diff --git a/compiler/src/dotty/tools/dotc/Run.scala b/compiler/src/dotty/tools/dotc/Run.scala
index 022ffbed5408..f7a08d1640ee 100644
--- a/compiler/src/dotty/tools/dotc/Run.scala
+++ b/compiler/src/dotty/tools/dotc/Run.scala
@@ -164,10 +164,15 @@ class Run(comp: Compiler, ictx: Context) extends ImplicitRunInfo with Constraint
   private var finalizeActions = mutable.ListBuffer[() => Unit]()
 
   /** Will be set to true if any of the compiled compilation units contains
-   *  a pureFunctions or captureChecking language import.
+   *  a pureFunctions language import.
    */
   var pureFunsImportEncountered = false
 
+  /** Will be set to true if any of the compiled compilation units contains
+   *  a captureChecking language import.
+   */
+  var ccImportEncountered = false
+
   def compile(files: List[AbstractFile]): Unit =
     try
       val sources = files.map(runContext.getSource(_))
@@ -229,6 +234,7 @@ class Run(comp: Compiler, ictx: Context) extends ImplicitRunInfo with Constraint
     def runPhases(using Context) = {
       var lastPrintedTree: PrintedTree = NoPrintedTree
       val profiler = ctx.profiler
+      var phasesWereAdjusted = false
 
       for (phase <- ctx.base.allPhases)
         if (phase.isRunnable)
@@ -247,6 +253,11 @@ class Run(comp: Compiler, ictx: Context) extends ImplicitRunInfo with Constraint
               Stats.record(s"retained typed trees at end of $phase", unit.tpdTree.treeSize)
             ctx.typerState.gc()
           }
+          if !phasesWereAdjusted then
+            phasesWereAdjusted = true
+            if !Feature.ccEnabledSomewhere then
+              ctx.base.unlinkPhaseAsDenotTransformer(Phases.checkCapturesPhase.prev)
+              ctx.base.unlinkPhaseAsDenotTransformer(Phases.checkCapturesPhase)
 
       profiler.finished()
     }
diff --git a/compiler/src/dotty/tools/dotc/cc/CaptureOps.scala b/compiler/src/dotty/tools/dotc/cc/CaptureOps.scala
index 3261cb1d90f8..0ede1825e611 100644
--- a/compiler/src/dotty/tools/dotc/cc/CaptureOps.scala
+++ b/compiler/src/dotty/tools/dotc/cc/CaptureOps.scala
@@ -166,8 +166,49 @@ extension (tp: Type)
       case CapturingType(_, _) => true
       case _ => false
 
+  /** Is type known to be always pure by its class structure,
+   *  so that adding a capture set to it would not make sense?
+   */
+  def isAlwaysPure(using Context): Boolean = tp.dealias match
+    case tp: (TypeRef | AppliedType) =>
+      val sym = tp.typeSymbol
+      if sym.isClass then sym.isPureClass
+      else tp.superType.isAlwaysPure
+    case CapturingType(parent, refs) =>
+      parent.isAlwaysPure || refs.isAlwaysEmpty
+    case tp: TypeProxy =>
+      tp.superType.isAlwaysPure
+    case tp: AndType =>
+      tp.tp1.isAlwaysPure || tp.tp2.isAlwaysPure
+    case tp: OrType =>
+      tp.tp1.isAlwaysPure && tp.tp2.isAlwaysPure
+    case _ =>
+      false
+
+extension (cls: ClassSymbol)
+
+  def pureBaseClass(using Context): Option[Symbol] =
+    cls.baseClasses.find(bc =>
+      defn.pureBaseClasses.contains(bc)
+      || {
+        val selfType = bc.givenSelfType
+        selfType.exists && selfType.captureSet.isAlwaysEmpty
+      })
+
 extension (sym: Symbol)
 
+  /** A class is pure if:
+   *   - one its base types has an explicitly declared self type with an empty capture set
+   *   - or it is a value class
+   *   - or it is an exception
+   *   - or it is one of Nothing, Null, or String
+   */
+  def isPureClass(using Context): Boolean = sym match
+    case cls: ClassSymbol =>
+      cls.pureBaseClass.isDefined || defn.pureSimpleClasses.contains(cls)
+    case _ =>
+      false
+
   /** Does this symbol allow results carrying the universal capability?
    *  Currently this is true only for function type applies (since their
    *  results are unboxed) and `erasedValue` since this function is magic in
diff --git a/compiler/src/dotty/tools/dotc/cc/CaptureSet.scala b/compiler/src/dotty/tools/dotc/cc/CaptureSet.scala
index d3e32ac538a4..6bf6d7770d8b 100644
--- a/compiler/src/dotty/tools/dotc/cc/CaptureSet.scala
+++ b/compiler/src/dotty/tools/dotc/cc/CaptureSet.scala
@@ -271,7 +271,7 @@ sealed abstract class CaptureSet extends Showable:
     map(Substituters.SubstParamsMap(tl, to))
 
   /** Invoke handler if this set has (or later aquires) the root capability `*` */
-  def disallowRootCapability(handler: () => Unit)(using Context): this.type =
+  def disallowRootCapability(handler: () => Context ?=> Unit)(using Context): this.type =
     if isUniversal then handler()
     this
 
@@ -373,7 +373,7 @@ object CaptureSet:
     def isAlwaysEmpty = false
 
     /** A handler to be invoked if the root reference `*` is added to this set */
-    var addRootHandler: () => Unit = () => ()
+    var rootAddedHandler: () => Context ?=> Unit = () => ()
 
     var description: String = ""
 
@@ -404,7 +404,7 @@ object CaptureSet:
     def addNewElems(newElems: Refs, origin: CaptureSet)(using Context, VarState): CompareResult =
       if !isConst && recordElemsState() then
         elems ++= newElems
-        if isUniversal then addRootHandler()
+        if isUniversal then rootAddedHandler()
         // assert(id != 2 || elems.size != 2, this)
         (CompareResult.OK /: deps) { (r, dep) =>
           r.andAlso(dep.tryInclude(newElems, this))
@@ -421,8 +421,8 @@ object CaptureSet:
       else
         CompareResult.fail(this)
 
-    override def disallowRootCapability(handler: () => Unit)(using Context): this.type =
-      addRootHandler = handler
+    override def disallowRootCapability(handler: () => Context ?=> Unit)(using Context): this.type =
+      rootAddedHandler = handler
       super.disallowRootCapability(handler)
 
     private var computingApprox = false
diff --git a/compiler/src/dotty/tools/dotc/cc/CheckCaptures.scala b/compiler/src/dotty/tools/dotc/cc/CheckCaptures.scala
index cf1d4266e89b..37a16a870f31 100644
--- a/compiler/src/dotty/tools/dotc/cc/CheckCaptures.scala
+++ b/compiler/src/dotty/tools/dotc/cc/CheckCaptures.scala
@@ -10,7 +10,8 @@ import config.Printers.{capt, recheckr}
 import config.{Config, Feature}
 import ast.{tpd, untpd, Trees}
 import Trees.*
-import typer.RefChecks.{checkAllOverrides, checkParents}
+import typer.RefChecks.{checkAllOverrides, checkSelfAgainstParents}
+import typer.Checking.{checkBounds, checkAppliedTypesIn}
 import util.{SimpleIdentitySet, EqHashMap, SrcPos}
 import transform.SymUtils.*
 import transform.{Recheck, PreRecheck}
@@ -18,6 +19,7 @@ import Recheck.*
 import scala.collection.mutable
 import CaptureSet.{withCaptureSetsExplained, IdempotentCaptRefMap}
 import StdNames.nme
+import NameKinds.DefaultGetterName
 import reporting.trace
 
 /** The capture checker */
@@ -335,12 +337,21 @@ class CheckCaptures extends Recheck, SymTransformer:
     override def recheckApply(tree: Apply, pt: Type)(using Context): Type =
       val meth = tree.fun.symbol
       includeCallCaptures(meth, tree.srcPos)
-      if meth == defn.Caps_unsafeBox || meth == defn.Caps_unsafeUnbox then
+      def mapArgUsing(f: Type => Type) =
         val arg :: Nil = tree.args: @unchecked
-        val argType0 = recheckStart(arg, pt)
-          .forceBoxStatus(boxed = meth == defn.Caps_unsafeBox)
+        val argType0 = f(recheckStart(arg, pt))
         val argType = super.recheckFinish(argType0, arg, pt)
         super.recheckFinish(argType, tree, pt)
+
+      if meth == defn.Caps_unsafeBox then
+        mapArgUsing(_.forceBoxStatus(true))
+      else if meth == defn.Caps_unsafeUnbox then
+        mapArgUsing(_.forceBoxStatus(false))
+      else if meth == defn.Caps_unsafeBoxFunArg then
+        mapArgUsing {
+          case defn.FunctionOf(paramtpe :: Nil, restpe, isContectual, isErased) =>
+            defn.FunctionOf(paramtpe.forceBoxStatus(true) :: Nil, restpe, isContectual, isErased)
+        }
       else
         super.recheckApply(tree, pt) match
           case appType @ CapturingType(appType1, refs) =>
@@ -432,7 +443,8 @@ class CheckCaptures extends Recheck, SymTransformer:
       block match
         case closureDef(mdef) =>
           pt.dealias match
-            case defn.FunctionOf(ptformals, _, _, _) if ptformals.forall(_.captureSet.isAlwaysEmpty) =>
+            case defn.FunctionOf(ptformals, _, _, _)
+            if ptformals.nonEmpty && ptformals.forall(_.captureSet.isAlwaysEmpty) =>
               // Redo setup of the anonymous function so that formal parameters don't
               // get capture sets. This is important to avoid false widenings to `*`
               // when taking the base type of the actual closures's dependent function
@@ -442,9 +454,10 @@ class CheckCaptures extends Recheck, SymTransformer:
               // First, undo the previous setup which installed a completer for `meth`.
               atPhase(preRecheckPhase.prev)(meth.denot.copySymDenotation())
                 .installAfter(preRecheckPhase)
+
               // Next, update all parameter symbols to match expected formals
               meth.paramSymss.head.lazyZip(ptformals).foreach { (psym, pformal) =>
-                psym.copySymDenotation(info = pformal).installAfter(preRecheckPhase)
+                psym.updateInfoBetween(preRecheckPhase, thisPhase, pformal.mapExprType)
               }
               // Next, update types of parameter ValDefs
               mdef.paramss.head.lazyZip(ptformals).foreach { (param, pformal) =>
@@ -452,36 +465,21 @@ class CheckCaptures extends Recheck, SymTransformer:
                 tpt.rememberTypeAlways(pformal)
               }
               // Next, install a new completer reflecting the new parameters for the anonymous method
+              val mt = meth.info.asInstanceOf[MethodType]
               val completer = new LazyType:
                 def complete(denot: SymDenotation)(using Context) =
-                  denot.info = MethodType(ptformals, mdef.tpt.knownType)
+                  denot.info = mt.companion(ptformals, mdef.tpt.knownType)
                     .showing(i"simplify info of $meth to $result", capt)
                   recheckDef(mdef, meth)
-              meth.copySymDenotation(info = completer, initFlags = meth.flags &~ Touched)
-                .installAfter(preRecheckPhase)
+              meth.updateInfoBetween(preRecheckPhase, thisPhase, completer)
             case _ =>
         case _ =>
       super.recheckBlock(block, pt)
 
-    /** If `rhsProto` has `*` as its capture set, wrap `rhs` in a `unsafeBox`.
-     *  Used to infer `unsafeBox` for expressions that get assigned to variables
-     *  that have universal capture set.
-     */
-    def maybeBox(rhs: Tree, rhsProto: Type)(using Context): Tree =
-      if rhsProto.captureSet.isUniversal then
-        ref(defn.Caps_unsafeBox).appliedToType(rhsProto).appliedTo(rhs)
-      else rhs
-
-    override def recheckAssign(tree: Assign)(using Context): Type =
-      val rhsProto = recheck(tree.lhs).widen
-      recheck(maybeBox(tree.rhs, rhsProto), rhsProto)
-      defn.UnitType
-
     override def recheckValDef(tree: ValDef, sym: Symbol)(using Context): Unit =
       try
         if !sym.is(Module) then // Modules are checked by checking the module class
-          if sym.is(Mutable) then recheck(maybeBox(tree.rhs, sym.info), sym.info)
-          else super.recheckValDef(tree, sym)
+          super.recheckValDef(tree, sym)
       finally
         if !sym.is(Param) then
           // Parameters with inferred types belong to anonymous methods. We need to wait
@@ -503,7 +501,8 @@ class CheckCaptures extends Recheck, SymTransformer:
     /** Class-specific capture set relations:
      *   1. The capture set of a class includes the capture sets of its parents.
      *   2. The capture set of the self type of a class includes the capture set of the class.
-     *   3. The capture set of the self type of a class includes the capture set of every class parameter.
+     *   3. The capture set of the self type of a class includes the capture set of every class parameter,
+     *      unless the parameter is marked @constructorOnly.
      */
     override def recheckClassDef(tree: TypeDef, impl: Template, cls: ClassSymbol)(using Context): Type =
       val saved = curEnv
@@ -515,7 +514,12 @@ class CheckCaptures extends Recheck, SymTransformer:
         val thisSet = cls.classInfo.selfType.captureSet.withDescription(i"of the self type of $cls")
         checkSubset(localSet, thisSet, tree.srcPos) // (2)
         for param <- cls.paramGetters do
-          checkSubset(param.termRef.captureSet, thisSet, param.srcPos) // (3)
+          if !param.hasAnnotation(defn.ConstructorOnlyAnnot) then
+            checkSubset(param.termRef.captureSet, thisSet, param.srcPos) // (3)
+        for pureBase <- cls.pureBaseClass do
+          checkSubset(thisSet,
+            CaptureSet.empty.withDescription(i"of pure base class $pureBase"),
+            tree.srcPos)
         super.recheckClassDef(tree, impl, cls)
       finally
         curEnv = saved
@@ -772,7 +776,8 @@ class CheckCaptures extends Recheck, SymTransformer:
               // We can't box/unbox the universal capability. Leave `actual` as it is
               // so we get an error in checkConforms. This tends to give better error
               // messages than disallowing the root capability in `criticalSet`.
-              capt.println(i"cannot box/unbox $actual vs $expected")
+              if ctx.settings.YccDebug.value then
+                println(i"cannot box/unbox $actual vs $expected")
               actual
             else
               // Disallow future addition of `*` to `criticalSet`.
@@ -845,13 +850,21 @@ class CheckCaptures extends Recheck, SymTransformer:
           cls => !parentTrees(cls).exists(ptree => parentTrees.contains(ptree.tpe.classSymbol))
         }
         assert(roots.nonEmpty)
-        for root <- roots do
-          checkParents(root, parentTrees(root))
+        for case root: ClassSymbol <- roots do
+          checkSelfAgainstParents(root, root.baseClasses)
           val selfType = root.asClass.classInfo.selfType
           interpolator(startingVariance = -1).traverse(selfType)
           if !root.isEffectivelySealed  then
+            def matchesExplicitRefsInBaseClass(refs: CaptureSet, cls: ClassSymbol): Boolean =
+              cls.baseClasses.tail.exists { psym =>
+                val selfType = psym.asClass.givenSelfType
+                selfType.exists && selfType.captureSet.elems == refs.elems
+              }
             selfType match
-              case CapturingType(_, refs: CaptureSet.Var) if !refs.isUniversal =>
+              case CapturingType(_, refs: CaptureSet.Var)
+              if !refs.isUniversal && !matchesExplicitRefsInBaseClass(refs, root) =>
+                // Forbid inferred self types unless they are already implied by an explicit
+                // self type in a parent.
                 report.error(
                   i"""$root needs an explicitly declared self type since its
                      |inferred self type $selfType
@@ -885,15 +898,23 @@ class CheckCaptures extends Recheck, SymTransformer:
           val isLocal =
             sym.owner.ownersIterator.exists(_.isTerm)
             || sym.accessBoundary(defn.RootClass).isContainedIn(sym.topLevelClass)
-
-          // The following classes of definitions need explicit capture types ...
-          if !isLocal                            // ... since external capture types are not inferred
-            || sym.owner.is(Trait)               // ... since we do OverridingPairs checking before capture inference
-            || sym.allOverriddenSymbols.nonEmpty // ... since we do override checking before capture inference
-          then
+          def canUseInferred =    // If canUseInferred is false, all capturing types in the type of `sym` need to be given explicitly
+            sym.is(Private)                   // private symbols can always have inferred types
+            || sym.name.is(DefaultGetterName) // default getters are exempted since otherwise it would be
+                                              // too annoying. This is a hole since a defualt getter's result type
+                                              // might leak into a type variable.
+            ||                                // non-local symbols cannot have inferred types since external capture types are not inferred
+              isLocal                         // local symbols still need explicit types if
+              && !sym.owner.is(Trait)         // they are defined in a trait, since we do OverridingPairs checking before capture inference
+          def isNotPureThis(ref: CaptureRef) = ref match {
+            case ref: ThisType => !ref.cls.isPureClass
+            case _ => true
+          }
+          if !canUseInferred then
             val inferred = t.tpt.knownType
             def checkPure(tp: Type) = tp match
-              case CapturingType(_, refs) if !refs.elems.isEmpty =>
+              case CapturingType(_, refs)
+              if !refs.elems.filter(isNotPureThis).isEmpty =>
                 val resultStr = if t.isInstanceOf[DefDef] then " result" else ""
                 report.error(
                   em"""Non-local $sym cannot have an inferred$resultStr type
@@ -902,8 +923,27 @@ class CheckCaptures extends Recheck, SymTransformer:
                       |The type needs to be declared explicitly.""", t.srcPos)
               case _ =>
             inferred.foreachPart(checkPure, StopAt.Static)
+        case t @ TypeApply(fun, args) =>
+          fun.knownType.widen match
+            case tl: PolyType =>
+              val normArgs = args.lazyZip(tl.paramInfos).map { (arg, bounds) =>
+                arg.withType(arg.knownType.forceBoxStatus(
+                  bounds.hi.isBoxedCapturing | bounds.lo.isBoxedCapturing))
+              }
+              checkBounds(normArgs, tl)
+            case _ =>
         case _ =>
       }
-
+      if !ctx.reporter.errorsReported then
+        // We dont report errors hre if previous errors were reported, because other
+        // errors often result in bad applied types, but flagging these bad types gives
+        // often worse error messages than the original errors.
+        val checkApplied = new TreeTraverser:
+          def traverse(t: Tree)(using Context) = t match
+            case tree: InferredTypeTree =>
+            case tree: New =>
+            case tree: TypeTree => checkAppliedTypesIn(tree.withKnownType)
+            case _ => traverseChildren(t)
+        checkApplied.traverse(unit)
   end CaptureChecker
 end CheckCaptures
diff --git a/compiler/src/dotty/tools/dotc/cc/Setup.scala b/compiler/src/dotty/tools/dotc/cc/Setup.scala
index 42c80e524a6e..95f2e71437a8 100644
--- a/compiler/src/dotty/tools/dotc/cc/Setup.scala
+++ b/compiler/src/dotty/tools/dotc/cc/Setup.scala
@@ -98,7 +98,10 @@ extends tpd.TreeTraverser:
     def addCaptureRefinements(tp: Type): Type = tp match
       case _: TypeRef | _: AppliedType if tp.typeParams.isEmpty =>
         tp.typeSymbol match
-          case cls: ClassSymbol if !defn.isFunctionClass(cls) =>
+          case cls: ClassSymbol
+          if !defn.isFunctionClass(cls) && !cls.is(JavaDefined) =>
+            // We assume that Java classes can refer to capturing Scala types only indirectly,
+            // using type parameters. Hence, no need to refine them.
             cls.paramGetters.foldLeft(tp) { (core, getter) =>
               if getter.termRef.isTracked then
                 val getterType = tp.memberInfo(getter).strippedDealias
@@ -117,14 +120,14 @@ extends tpd.TreeTraverser:
         case tp: (TypeRef | AppliedType) =>
           val sym = tp.typeSymbol
           if sym.isClass then
-            tp.typeSymbol == defn.AnyClass
+            sym == defn.AnyClass
               // we assume Any is a shorthand of {*} Any, so if Any is an upper
               // bound, the type is taken to be impure.
           else superTypeIsImpure(tp.superType)
         case tp: (RefinedOrRecType | MatchType) =>
           superTypeIsImpure(tp.underlying)
         case tp: AndType =>
-          superTypeIsImpure(tp.tp1) || canHaveInferredCapture(tp.tp2)
+          superTypeIsImpure(tp.tp1) || needsVariable(tp.tp2)
         case tp: OrType =>
           superTypeIsImpure(tp.tp1) && superTypeIsImpure(tp.tp2)
         case _ =>
@@ -132,23 +135,26 @@ extends tpd.TreeTraverser:
     }.showing(i"super type is impure $tp = $result", capt)
 
     /** Should a capture set variable be added on type `tp`? */
-    def canHaveInferredCapture(tp: Type): Boolean = {
+    def needsVariable(tp: Type): Boolean = {
       tp.typeParams.isEmpty && tp.match
         case tp: (TypeRef | AppliedType) =>
           val tp1 = tp.dealias
-          if tp1 ne tp then canHaveInferredCapture(tp1)
+          if tp1 ne tp then needsVariable(tp1)
           else
             val sym = tp1.typeSymbol
-            if sym.isClass then !sym.isValueClass && sym != defn.AnyClass
+            if sym.isClass then
+              !sym.isPureClass && sym != defn.AnyClass
             else superTypeIsImpure(tp1)
         case tp: (RefinedOrRecType | MatchType) =>
-          canHaveInferredCapture(tp.underlying)
+          needsVariable(tp.underlying)
         case tp: AndType =>
-          canHaveInferredCapture(tp.tp1) && canHaveInferredCapture(tp.tp2)
+          needsVariable(tp.tp1) && needsVariable(tp.tp2)
         case tp: OrType =>
-          canHaveInferredCapture(tp.tp1) || canHaveInferredCapture(tp.tp2)
-        case CapturingType(_, refs) =>
-          refs.isConst && !refs.isUniversal
+          needsVariable(tp.tp1) || needsVariable(tp.tp2)
+        case CapturingType(parent, refs) =>
+          needsVariable(parent)
+          && refs.isConst      // if refs is a variable, no need to add another
+          && !refs.isUniversal // if refs is {*}, an added variable would not change anything
         case _ =>
           false
     }.showing(i"can have inferred capture $tp = $result", capt)
@@ -181,7 +187,7 @@ extends tpd.TreeTraverser:
         CapturingType(OrType(parent1, tp2, tp.isSoft), refs1, tp1.isBoxed)
       case tp @ OrType(tp1, tp2 @ CapturingType(parent2, refs2)) =>
         CapturingType(OrType(tp1, parent2, tp.isSoft), refs2, tp2.isBoxed)
-      case _ if canHaveInferredCapture(tp) =>
+      case _ if needsVariable(tp) =>
         val cs = tp.dealias match
           case CapturingType(_, refs) => CaptureSet.Var(refs.elems)
           case _ => CaptureSet.Var()
@@ -382,20 +388,18 @@ extends tpd.TreeTraverser:
           return
         tree.tpt match
           case tpt: TypeTree if tree.symbol.allOverriddenSymbols.hasNext =>
+            tree.paramss.foreach(traverse)
             transformTT(tpt, boxed = false, exact = true)
+            traverse(tree.rhs)
             //println(i"TYPE of ${tree.symbol.showLocated} = ${tpt.knownType}")
           case _ =>
-        traverseChildren(tree)
+            traverseChildren(tree)
       case tree @ ValDef(_, tpt: TypeTree, _) =>
-        val isVar = tree.symbol.is(Mutable)
-        val overrides = tree.symbol.allOverriddenSymbols.hasNext
-        //if overrides then println(i"transforming overriding ${tree.symbol}")
-        if isVar || overrides then
-          transformTT(tpt,
-              boxed = isVar,    // types of mutable variables are boxed
-              exact = overrides // types of symbols that override a parent don't get a capture set
-            )
-        traverseChildren(tree)
+        transformTT(tpt,
+          boxed = tree.symbol.is(Mutable),    // types of mutable variables are boxed
+          exact = tree.symbol.allOverriddenSymbols.hasNext // types of symbols that override a parent don't get a capture set
+        )
+        traverse(tree.rhs)
       case tree @ TypeApply(fn, args) =>
         traverse(fn)
         for case arg: TypeTree <- args do
diff --git a/compiler/src/dotty/tools/dotc/cc/Synthetics.scala b/compiler/src/dotty/tools/dotc/cc/Synthetics.scala
index e8f7fd502baa..dacbd27e0f35 100644
--- a/compiler/src/dotty/tools/dotc/cc/Synthetics.scala
+++ b/compiler/src/dotty/tools/dotc/cc/Synthetics.scala
@@ -31,10 +31,12 @@ object Synthetics:
    *  The types of these symbols are transformed in a special way without
    *  looking at the definitions's RHS
    */
-  def needsTransform(sym: SymDenotation)(using Context): Boolean =
-    isSyntheticCopyMethod(sym)
-    || isSyntheticCompanionMethod(sym, nme.apply, nme.unapply)
-    || isSyntheticCopyDefaultGetterMethod(sym)
+  def needsTransform(symd: SymDenotation)(using Context): Boolean =
+    isSyntheticCopyMethod(symd)
+    || isSyntheticCompanionMethod(symd, nme.apply, nme.unapply)
+    || isSyntheticCopyDefaultGetterMethod(symd)
+    || (symd.symbol eq defn.Object_eq)
+    || (symd.symbol eq defn.Object_ne)
 
   /** Method is excluded from regular capture checking.
    *  Excluded are synthetic class members
@@ -141,13 +143,16 @@ object Synthetics:
   /** Drop added capture information from the type of an `unapply` */
   private def dropUnapplyCaptures(info: Type)(using Context): Type = info match
     case info: MethodType =>
-      val CapturingType(oldParamInfo, _) :: Nil = info.paramInfos: @unchecked
-      def oldResult(tp: Type): Type = tp match
-        case tp: MethodOrPoly =>
-          tp.derivedLambdaType(resType = oldResult(tp.resType))
-        case CapturingType(tp, _) =>
-          tp
-      info.derivedLambdaType(paramInfos = oldParamInfo :: Nil, resType = oldResult(info.resType))
+      info.paramInfos match
+        case CapturingType(oldParamInfo, _) :: Nil =>
+          def oldResult(tp: Type): Type = tp match
+            case tp: MethodOrPoly =>
+              tp.derivedLambdaType(resType = oldResult(tp.resType))
+            case CapturingType(tp, _) =>
+              tp
+          info.derivedLambdaType(paramInfos = oldParamInfo :: Nil, resType = oldResult(info.resType))
+        case _ =>
+          info
     case info: PolyType =>
       info.derivedLambdaType(resType = dropUnapplyCaptures(info.resType))
 
@@ -163,7 +168,9 @@ object Synthetics:
       sym.copySymDenotation(info = addUnapplyCaptures(sym.info))
     case nme.apply | nme.copy =>
       sym.copySymDenotation(info = addCaptureDeps(sym.info))
-
+    case n if n == nme.eq || n == nme.ne =>
+      sym.copySymDenotation(info =
+        MethodType(defn.ObjectType.capturing(CaptureSet.universal) :: Nil, defn.BooleanType))
 
   /** If `sym` refers to a synthetic apply, unapply, copy, or copy default getter method
    *  of a case class, transform it back to what it was before the CC phase.
@@ -176,5 +183,7 @@ object Synthetics:
       sym.copySymDenotation(info = dropUnapplyCaptures(sym.info))
     case nme.apply | nme.copy =>
       sym.copySymDenotation(info = dropCaptureDeps(sym.info))
+    case n if n == nme.eq || n == nme.ne =>
+      sym.copySymDenotation(info = defn.methOfAnyRef(defn.BooleanType))
 
 end Synthetics
\ No newline at end of file
diff --git a/compiler/src/dotty/tools/dotc/config/Feature.scala b/compiler/src/dotty/tools/dotc/config/Feature.scala
index d836716c3901..e7117f542384 100644
--- a/compiler/src/dotty/tools/dotc/config/Feature.scala
+++ b/compiler/src/dotty/tools/dotc/config/Feature.scala
@@ -79,19 +79,27 @@ object Feature:
 
   def scala2ExperimentalMacroEnabled(using Context) = enabled(scala2macros)
 
+  /** Is pureFunctions enabled for this compilation unit? */
   def pureFunsEnabled(using Context) =
     enabledBySetting(pureFunctions)
     || ctx.compilationUnit.knowsPureFuns
     || ccEnabled
 
+  /** Is captureChecking enabled for this compilation unit? */
   def ccEnabled(using Context) =
     enabledBySetting(captureChecking)
     || ctx.compilationUnit.needsCaptureChecking
 
+  /** Is pureFunctions enabled for any of the currently compiled compilation units? */
   def pureFunsEnabledSomewhere(using Context) =
     enabledBySetting(pureFunctions)
-    || enabledBySetting(captureChecking)
     || ctx.run != null && ctx.run.nn.pureFunsImportEncountered
+    || ccEnabledSomewhere
+
+  /** Is captureChecking enabled for any of the currently compiled compilation units? */
+  def ccEnabledSomewhere(using Context) =
+    enabledBySetting(captureChecking)
+    || ctx.run != null && ctx.run.nn.ccImportEncountered
 
   def sourceVersionSetting(using Context): SourceVersion =
     SourceVersion.valueOf(ctx.settings.source.value)
@@ -143,6 +151,11 @@ object Feature:
   def isExperimentalEnabled(using Context): Boolean =
     Properties.experimental && !ctx.settings.YnoExperimental.value
 
+  /** Handle language import `import language.<prefix>.<imported>` if it is one
+   *  of the global imports `pureFunctions` or `captureChecking`. In this case
+   *  make the compilation unit's and current run's fields accordingly.
+   *  @return true iff import that was handled
+   */
   def handleGlobalLanguageImport(prefix: TermName, imported: Name)(using Context): Boolean =
     val fullFeatureName = QualifiedName(prefix, imported.asTermName)
     if fullFeatureName == pureFunctions then
@@ -151,7 +164,7 @@ object Feature:
       true
     else if fullFeatureName == captureChecking then
       ctx.compilationUnit.needsCaptureChecking = true
-      if ctx.run != null then ctx.run.nn.pureFunsImportEncountered = true
+      if ctx.run != null then ctx.run.nn.ccImportEncountered = true
       true
     else
       false
diff --git a/compiler/src/dotty/tools/dotc/core/CheckRealizable.scala b/compiler/src/dotty/tools/dotc/core/CheckRealizable.scala
index 4b441d512dec..a61701eee2d7 100644
--- a/compiler/src/dotty/tools/dotc/core/CheckRealizable.scala
+++ b/compiler/src/dotty/tools/dotc/core/CheckRealizable.scala
@@ -149,7 +149,7 @@ class CheckRealizable(using Context) {
    */
   private def boundsRealizability(tp: Type) = {
 
-    val memberProblems = withMode(Mode.CheckBounds) {
+    val memberProblems = withMode(Mode.CheckBoundsOrSelfType) {
       for {
         mbr <- tp.nonClassTypeMembers
         if !(mbr.info.loBound <:< mbr.info.hiBound)
@@ -157,7 +157,7 @@ class CheckRealizable(using Context) {
       yield new HasProblemBounds(mbr.name, mbr.info)
     }
 
-    val refinementProblems = withMode(Mode.CheckBounds) {
+    val refinementProblems = withMode(Mode.CheckBoundsOrSelfType) {
       for {
         name <- refinedNames(tp)
         if (name.isTypeName)
diff --git a/compiler/src/dotty/tools/dotc/core/ConstraintHandling.scala b/compiler/src/dotty/tools/dotc/core/ConstraintHandling.scala
index 1dfa04822766..a3d8cabba971 100644
--- a/compiler/src/dotty/tools/dotc/core/ConstraintHandling.scala
+++ b/compiler/src/dotty/tools/dotc/core/ConstraintHandling.scala
@@ -58,6 +58,12 @@ trait ConstraintHandling {
    */
   protected var comparedTypeLambdas: Set[TypeLambda] = Set.empty
 
+  /** Used for match type reduction: If false, we don't recognize an abstract type
+   *  to be a subtype type of any of its base classes. This is in place only at the
+   *  toplevel; it is turned on again when we add parts of the scrutinee to the constraint.
+   */
+  protected var canWidenAbstract: Boolean = true
+
   protected var myNecessaryConstraintsOnly = false
   /** When collecting the constraints needed for a particular subtyping
    *  judgment to be true, we sometimes need to approximate the constraint
@@ -839,13 +845,17 @@ trait ConstraintHandling {
     //checkPropagated(s"adding $description")(true) // DEBUG in case following fails
     checkPropagated(s"added $description") {
       addConstraintInvocations += 1
+      val saved = canWidenAbstract
+      canWidenAbstract = true
       try bound match
         case bound: TypeParamRef if constraint contains bound =>
           addParamBound(bound)
         case _ =>
           val pbound = avoidLambdaParams(bound)
           kindCompatible(param, pbound) && addBoundTransitively(param, pbound, !fromBelow)
-      finally addConstraintInvocations -= 1
+      finally
+        canWidenAbstract = saved
+        addConstraintInvocations -= 1
     }
   end addConstraint
 
diff --git a/compiler/src/dotty/tools/dotc/core/Definitions.scala b/compiler/src/dotty/tools/dotc/core/Definitions.scala
index 174244b4a456..3373fee9fce6 100644
--- a/compiler/src/dotty/tools/dotc/core/Definitions.scala
+++ b/compiler/src/dotty/tools/dotc/core/Definitions.scala
@@ -961,9 +961,11 @@ class Definitions {
   def RuntimeTupleFunctionsModule(using Context): Symbol = requiredModule("scala.runtime.TupledFunctions")
 
   @tu lazy val CapsModule: Symbol = requiredModule("scala.caps")
-    @tu lazy val Caps_unsafeBox: Symbol = CapsModule.requiredMethod("unsafeBox")
-    @tu lazy val Caps_unsafeUnbox: Symbol = CapsModule.requiredMethod("unsafeUnbox")
     @tu lazy val captureRoot: TermSymbol = CapsModule.requiredValue("*")
+    @tu lazy val CapsUnsafeModule: Symbol = requiredModule("scala.caps.unsafe")
+    @tu lazy val Caps_unsafeBox: Symbol = CapsUnsafeModule.requiredMethod("unsafeBox")
+    @tu lazy val Caps_unsafeUnbox: Symbol = CapsUnsafeModule.requiredMethod("unsafeUnbox")
+    @tu lazy val Caps_unsafeBoxFunArg: Symbol = CapsUnsafeModule.requiredMethod("unsafeBoxFunArg")
 
   // Annotation base classes
   @tu lazy val AnnotationClass: ClassSymbol = requiredClass("scala.annotation.Annotation")
@@ -1347,6 +1349,15 @@ class Definitions {
 
   @tu lazy val untestableClasses: Set[Symbol] = Set(NothingClass, NullClass, SingletonClass)
 
+  /** Base classes that are assumed to be pure for the purposes of capture checking.
+   *  Every class inheriting from a pure baseclass is pure.
+   */
+  @tu lazy val pureBaseClasses = Set(defn.AnyValClass, defn.ThrowableClass)
+
+  /** Non-inheritable lasses that are assumed to be pure for the purposes of capture checking,
+   */
+  @tu lazy val pureSimpleClasses = Set(StringClass, NothingClass, NullClass)
+
   @tu lazy val AbstractFunctionType: Array[TypeRef] = mkArityArray("scala.runtime.AbstractFunction", MaxImplementedFunctionArity, 0).asInstanceOf[Array[TypeRef]]
   val AbstractFunctionClassPerRun: PerRun[Array[Symbol]] = new PerRun(AbstractFunctionType.map(_.symbol.asClass))
   def AbstractFunctionClass(n: Int)(using Context): Symbol = AbstractFunctionClassPerRun()(using ctx)(n)
diff --git a/compiler/src/dotty/tools/dotc/core/Mode.scala b/compiler/src/dotty/tools/dotc/core/Mode.scala
index 33ac3de70767..40a45b9f4678 100644
--- a/compiler/src/dotty/tools/dotc/core/Mode.scala
+++ b/compiler/src/dotty/tools/dotc/core/Mode.scala
@@ -70,10 +70,14 @@ object Mode {
   /** We are currently unpickling Scala2 info */
   val Scala2Unpickling: Mode = newMode(13, "Scala2Unpickling")
 
-  /** We are currently checking bounds to be non-empty, so we should not
-   *  do any widening when computing members of refined types.
+  /** Signifies one of two possible situations:
+   *   1. We are currently checking bounds to be non-empty, so we should not
+   *      do any widening when computing members of refined types.
+   *   2. We are currently checking self type conformance, so we should not
+   *      ignore capture sets added to otherwise pure classes (only needed
+   *      for capture checking).
    */
-  val CheckBounds: Mode = newMode(14, "CheckBounds")
+  val CheckBoundsOrSelfType: Mode = newMode(14, "CheckBoundsOrSelfType")
 
   /** Use Scala2 scheme for overloading and implicit resolution */
   val OldOverloadingResolution: Mode = newMode(15, "OldOverloadingResolution")
diff --git a/compiler/src/dotty/tools/dotc/core/Phases.scala b/compiler/src/dotty/tools/dotc/core/Phases.scala
index b4a2dcac1b85..205554e418ed 100644
--- a/compiler/src/dotty/tools/dotc/core/Phases.scala
+++ b/compiler/src/dotty/tools/dotc/core/Phases.scala
@@ -197,6 +197,14 @@ object Phases {
       config.println(s"nextDenotTransformerId = ${nextDenotTransformerId.toList}")
     }
 
+    /** Unlink `phase` from Denot transformer chain. This means that
+     *  any denotation transformer defined by the phase will not be executed.
+     */
+    def unlinkPhaseAsDenotTransformer(phase: Phase)(using Context) =
+      for i <- 0 until nextDenotTransformerId.length do
+        if nextDenotTransformerId(i) == phase.id then
+          nextDenotTransformerId(i) = nextDenotTransformerId(phase.id + 1)
+
     private var myParserPhase: Phase = _
     private var myTyperPhase: Phase = _
     private var myPostTyperPhase: Phase = _
diff --git a/compiler/src/dotty/tools/dotc/core/TypeComparer.scala b/compiler/src/dotty/tools/dotc/core/TypeComparer.scala
index 283a7e3a474e..e823e3c9a72f 100644
--- a/compiler/src/dotty/tools/dotc/core/TypeComparer.scala
+++ b/compiler/src/dotty/tools/dotc/core/TypeComparer.scala
@@ -23,7 +23,7 @@ import typer.ProtoTypes.constrained
 import typer.Applications.productSelectorTypes
 import reporting.trace
 import annotation.constructorOnly
-import cc.{CapturingType, derivedCapturingType, CaptureSet, stripCapturing, isBoxedCapturing, boxed, boxedUnlessFun, boxedIfTypeParam}
+import cc.{CapturingType, derivedCapturingType, CaptureSet, stripCapturing, isBoxedCapturing, boxed, boxedUnlessFun, boxedIfTypeParam, isAlwaysPure}
 
 /** Provides methods to compare types.
  */
@@ -60,8 +60,6 @@ class TypeComparer(@constructorOnly initctx: Context) extends ConstraintHandling
   /** Indicates whether the subtype check used GADT bounds */
   private var GADTused: Boolean = false
 
-  protected var canWidenAbstract: Boolean = true
-
   private var myInstance: TypeComparer = this
   def currentInstance: TypeComparer = myInstance
 
@@ -522,7 +520,9 @@ class TypeComparer(@constructorOnly initctx: Context) extends ConstraintHandling
         res
 
       case CapturingType(parent1, refs1) =>
-        if subCaptures(refs1, tp2.captureSet, frozenConstraint).isOK && sameBoxed(tp1, tp2, refs1)
+        if tp2.isAny then true
+        else if subCaptures(refs1, tp2.captureSet, frozenConstraint).isOK && sameBoxed(tp1, tp2, refs1)
+          || !ctx.mode.is(Mode.CheckBoundsOrSelfType) && tp1.isAlwaysPure
         then recur(parent1, tp2)
         else thirdTry
       case tp1: AnnotatedType if !tp1.isRefining =>
@@ -826,7 +826,11 @@ class TypeComparer(@constructorOnly initctx: Context) extends ConstraintHandling
             if refs1.isAlwaysEmpty then recur(tp1, parent2)
             else subCaptures(refs1, refs2, frozenConstraint).isOK
               && sameBoxed(tp1, tp2, refs1)
-              && recur(tp1.widen.stripCapturing, parent2)
+              && (recur(tp1.widen.stripCapturing, parent2)
+                 || tp1.isInstanceOf[SingletonType] && recur(tp1, parent2)
+                    // this alternative is needed in case the right hand side is a
+                    // capturing type that contains the lhs as an |-alternative.
+                 )
           catch case ex: AssertionError =>
             println(i"assertion failed while compare captured $tp1 <:< $tp2")
             throw ex
diff --git a/compiler/src/dotty/tools/dotc/core/TypeOps.scala b/compiler/src/dotty/tools/dotc/core/TypeOps.scala
index 3e3490b1f01b..9363b27b4dde 100644
--- a/compiler/src/dotty/tools/dotc/core/TypeOps.scala
+++ b/compiler/src/dotty/tools/dotc/core/TypeOps.scala
@@ -186,7 +186,7 @@ object TypeOps:
         if (normed.exists) normed else mapOver
       case tp: MethodicType =>
         // See documentation of `Types#simplified`
-        val addTypeVars = new TypeMap:
+        val addTypeVars = new TypeMap with IdempotentCaptRefMap:
           val constraint = ctx.typerState.constraint
           def apply(t: Type): Type = t match
             case t: TypeParamRef => constraint.typeVarOfParam(t).orElse(t)
@@ -615,7 +615,7 @@ object TypeOps:
       boundss: List[TypeBounds],
       instantiate: (Type, List[Type]) => Type,
       app: Type)(
-      using Context): List[BoundsViolation] = withMode(Mode.CheckBounds) {
+      using Context): List[BoundsViolation] = withMode(Mode.CheckBoundsOrSelfType) {
     val argTypes = args.tpes
 
     /** Replace all wildcards in `tps` with `<app>#<tparam>` where `<tparam>` is the
diff --git a/compiler/src/dotty/tools/dotc/core/Types.scala b/compiler/src/dotty/tools/dotc/core/Types.scala
index 4bcd6f0d8de7..2c59be445010 100644
--- a/compiler/src/dotty/tools/dotc/core/Types.scala
+++ b/compiler/src/dotty/tools/dotc/core/Types.scala
@@ -765,11 +765,11 @@ object Types {
         val rinfo = tp.refinedInfo
         if (name.isTypeName && !pinfo.isInstanceOf[ClassInfo]) { // simplified case that runs more efficiently
           val jointInfo =
-            if rinfo.isInstanceOf[TypeAlias] && !ctx.mode.is(Mode.CheckBounds) then
+            if rinfo.isInstanceOf[TypeAlias] && !ctx.mode.is(Mode.CheckBoundsOrSelfType) then
               // In normal situations, the only way to "improve" on rinfo is to return an empty type bounds
               // So, we do not lose anything essential in "widening" to rinfo.
               // We need to compute the precise info only when checking for empty bounds
-              // which is communicated by the CheckBounds mode.
+              // which is communicated by the CheckBoundsOrSelfType mode.
               rinfo
             else if ctx.base.pendingMemberSearches.contains(name) then
               pinfo safe_& rinfo
@@ -2338,7 +2338,8 @@ object Types {
       lastDenotation match {
         case lastd0: SingleDenotation =>
           val lastd = lastd0.skipRemoved
-          if (lastd.validFor.runId == ctx.runId && (checkedPeriod != Nowhere)) finish(lastd.current)
+          if lastd.validFor.runId == ctx.runId && checkedPeriod != Nowhere then
+            finish(lastd.current)
           else lastd match {
             case lastd: SymDenotation =>
               if (stillValid(lastd) && (checkedPeriod != Nowhere)) finish(lastd.current)
@@ -2443,6 +2444,8 @@ object Types {
     }
 
     private def checkDenot()(using Context) = {}
+      //if name.toString == "getConstructor" then
+      //  println(i"set denot of $this to ${denot.info}, ${denot.getClass}, ${Phases.phaseOf(denot.validFor.lastPhaseId)} at ${ctx.phase}")
 
     private def checkSymAssign(sym: Symbol)(using Context) = {
       def selfTypeOf(sym: Symbol) =
@@ -6032,14 +6035,10 @@ object Types {
   /** A range of possible types between lower bound `lo` and upper bound `hi`.
    *  Only used internally in `ApproximatingTypeMap`.
    */
-  case class Range(lo: Type, hi: Type) extends UncachedGroundType {
+  case class Range(lo: Type, hi: Type) extends UncachedGroundType:
     assert(!lo.isInstanceOf[Range])
     assert(!hi.isInstanceOf[Range])
 
-    override def toText(printer: Printer): Text =
-      lo.toText(printer) ~ ".." ~ hi.toText(printer)
-  }
-
   /** Approximate wildcards by their bounds */
   class AvoidWildcardsMap(using Context) extends ApproximatingTypeMap:
     protected def mapWild(t: WildcardType) =
diff --git a/compiler/src/dotty/tools/dotc/printing/PlainPrinter.scala b/compiler/src/dotty/tools/dotc/printing/PlainPrinter.scala
index 60a5c74eedbc..e0c940fd81aa 100644
--- a/compiler/src/dotty/tools/dotc/printing/PlainPrinter.scala
+++ b/compiler/src/dotty/tools/dotc/printing/PlainPrinter.scala
@@ -278,6 +278,8 @@ class PlainPrinter(_ctx: Context) extends Printer {
             case ex: Throwable => Str("...")
           }
         "LazyRef(" ~ refTxt ~ ")"
+      case Range(lo, hi) =>
+        toText(lo) ~ ".." ~ toText(hi)
       case _ =>
         tp.fallbackToText(this)
     }
diff --git a/compiler/src/dotty/tools/dotc/transform/Recheck.scala b/compiler/src/dotty/tools/dotc/transform/Recheck.scala
index 6d783854ae35..0ac9087a08c0 100644
--- a/compiler/src/dotty/tools/dotc/transform/Recheck.scala
+++ b/compiler/src/dotty/tools/dotc/transform/Recheck.scala
@@ -22,6 +22,7 @@ import StdNames.nme
 import reporting.trace
 import annotation.constructorOnly
 import cc.CaptureSet.IdempotentCaptRefMap
+import dotty.tools.dotc.core.Denotations.SingleDenotation
 
 object Recheck:
   import tpd.*
@@ -71,7 +72,7 @@ object Recheck:
       val symd = sym.denot
       symd.validFor.firstPhaseId == phase.id + 1 && (sym.originDenotation ne symd)
 
-  extension (tree: Tree)
+  extension [T <: Tree](tree: T)
 
     /** Remember `tpe` as the type of `tree`, which might be different from the
      *  type stored in the tree itself, unless a type was already remembered for `tree`.
@@ -86,11 +87,27 @@ object Recheck:
       if tpe ne tree.tpe then tree.putAttachment(RecheckedType, tpe)
 
     /** The remembered type of the tree, or if none was installed, the original type */
-    def knownType =
+    def knownType: Type =
       tree.attachmentOrElse(RecheckedType, tree.tpe)
 
     def hasRememberedType: Boolean = tree.hasAttachment(RecheckedType)
 
+    def withKnownType(using Context): T = tree.getAttachment(RecheckedType) match
+      case Some(tpe) => tree.withType(tpe).asInstanceOf[T]
+      case None => tree
+
+  extension (tpe: Type)
+
+    /** Map ExprType => T to () ?=> T (and analogously for pure versions).
+     *  Even though this phase runs after ElimByName, ExprTypes can still occur
+     *  as by-name arguments of applied types. See note in doc comment for
+     *  ElimByName phase. Test case is bynamefun.scala.
+     */
+    def mapExprType(using Context): Type = tpe match
+      case ExprType(rt) => defn.ByNameFunction(rt)
+      case _ => tpe
+
+
 /** A base class that runs a simplified typer pass over an already re-typed program. The pass
  *  does not transform trees but returns instead the re-typed type of each tree as it is
  *  traversed. The Recheck phase must be directly preceded by a phase of type PreRecheck.
@@ -116,7 +133,9 @@ abstract class Recheck extends Phase, SymTransformer:
     else sym
 
   def run(using Context): Unit =
-    newRechecker().checkUnit(ctx.compilationUnit)
+    val rechecker = newRechecker()
+    rechecker.checkUnit(ctx.compilationUnit)
+    rechecker.reset()
 
   def newRechecker()(using Context): Rechecker
 
@@ -136,6 +155,12 @@ abstract class Recheck extends Phase, SymTransformer:
      */
     def keepType(tree: Tree): Boolean = keepAllTypes
 
+    private val prevSelDenots = util.HashMap[NamedType, Denotation]()
+
+    def reset()(using Context): Unit =
+      for (ref, mbr) <- prevSelDenots.iterator do
+        ref.withDenot(mbr)
+
     /** Constant-folded rechecked type `tp` of tree `tree` */
     protected def constFold(tree: Tree, tp: Type)(using Context): Type =
       val tree1 = tree.withType(tp)
@@ -147,18 +172,42 @@ abstract class Recheck extends Phase, SymTransformer:
 
     def recheckSelect(tree: Select, pt: Type)(using Context): Type =
       val Select(qual, name) = tree
-      recheckSelection(tree, recheck(qual, AnySelectionProto).widenIfUnstable, name, pt)
+      val proto =
+        if tree.symbol == defn.Any_asInstanceOf then WildcardType
+        else AnySelectionProto
+      recheckSelection(tree, recheck(qual, proto).widenIfUnstable, name, pt)
+
+    /** When we select the `apply` of a function with type such as `(=> A) => B`,
+     *  we need to convert the parameter type `=> A` to `() ?=> A`. See doc comment
+     *  of `mapExprType`.
+     */
+    def normalizeByName(mbr: SingleDenotation)(using Context): SingleDenotation = mbr.info match
+      case mt: MethodType if mt.paramInfos.exists(_.isInstanceOf[ExprType]) =>
+        mbr.derivedSingleDenotation(mbr.symbol,
+          mt.derivedLambdaType(paramInfos = mt.paramInfos.map(_.mapExprType)))
+      case _ =>
+        mbr
 
     def recheckSelection(tree: Select, qualType: Type, name: Name,
         sharpen: Denotation => Denotation)(using Context): Type =
       if name.is(OuterSelectName) then tree.tpe
       else
         //val pre = ta.maybeSkolemizePrefix(qualType, name)
-        val mbr = sharpen(
+        val mbr = normalizeByName(
+          sharpen(
             qualType.findMember(name, qualType,
               excluded = if tree.symbol.is(Private) then EmptyFlags else Private
-          )).suchThat(tree.symbol == _)
-        constFold(tree, qualType.select(name, mbr))
+          )).suchThat(tree.symbol == _))
+        val newType = tree.tpe match
+          case prevType: NamedType =>
+            val prevDenot = prevType.denot
+            val newType = qualType.select(name, mbr)
+            if (newType eq prevType) && (mbr.info ne prevDenot.info) && !prevSelDenots.contains(prevType) then
+              prevSelDenots(prevType) = prevDenot
+            newType
+          case _ =>
+            qualType.select(name, mbr)
+        constFold(tree, newType)
           //.showing(i"recheck select $qualType . $name : ${mbr.info} = $result")
 
 
@@ -212,7 +261,8 @@ abstract class Recheck extends Phase, SymTransformer:
       mt.instantiate(argTypes)
 
     def recheckApply(tree: Apply, pt: Type)(using Context): Type =
-      recheck(tree.fun).widen match
+      val funtpe = recheck(tree.fun)
+      funtpe.widen match
         case fntpe: MethodType =>
           assert(fntpe.paramInfos.hasSameLengthAs(tree.args))
           val formals =
@@ -220,7 +270,7 @@ abstract class Recheck extends Phase, SymTransformer:
             else fntpe.paramInfos
           def recheckArgs(args: List[Tree], formals: List[Type], prefs: List[ParamRef]): List[Type] = args match
             case arg :: args1 =>
-              val argType = recheck(arg, formals.head)
+              val argType = recheck(arg, formals.head.mapExprType)
               val formals1 =
                 if fntpe.isParamDependent
                 then formals.tail.map(_.substParam(prefs.head, argType))
@@ -232,6 +282,8 @@ abstract class Recheck extends Phase, SymTransformer:
           val argTypes = recheckArgs(tree.args, formals, fntpe.paramRefs)
           constFold(tree, instantiate(fntpe, argTypes, tree.fun.symbol))
             //.showing(i"typed app $tree : $fntpe with ${tree.args}%, % : $argTypes%, % = $result")
+        case tp =>
+          assert(false, i"unexpected type of ${tree.fun}: $funtpe")
 
     def recheckTypeApply(tree: TypeApply, pt: Type)(using Context): Type =
       recheck(tree.fun).widen match
@@ -262,7 +314,7 @@ abstract class Recheck extends Phase, SymTransformer:
       recheckBlock(tree.stats, tree.expr, pt)
 
     def recheckInlined(tree: Inlined, pt: Type)(using Context): Type =
-      recheckBlock(tree.bindings, tree.expansion, pt)
+      recheckBlock(tree.bindings, tree.expansion, pt)(using inlineContext(tree.call))
 
     def recheckIf(tree: If, pt: Type)(using Context): Type =
       recheck(tree.cond, defn.BooleanType)
@@ -297,7 +349,20 @@ abstract class Recheck extends Phase, SymTransformer:
 
       val rawType = recheck(tree.expr)
       val ownType = avoidMap(rawType)
-      checkConforms(ownType, tree.from.symbol.returnProto, tree)
+
+      // The pattern matching translation, which runs before this phase
+      // sometimes instantiates return types with singleton type alternatives
+      // but the returned expression is widened. We compensate by widening the expected
+      // type as well. See also `widenSkolems` in `checkConformsExpr` which fixes
+      // a more general problem. It turns out that pattern matching returns
+      // are not checked by Ycheck, that's why these problems were allowed to slip
+      // through.
+      def widened(tp: Type): Type = tp match
+        case tp: SingletonType => tp.widen
+        case tp: AndOrType => tp.derivedAndOrType(widened(tp.tp1), widened(tp.tp2))
+        case tp @ AnnotatedType(tp1, ann) => tp.derivedAnnotatedType(widened(tp1), ann)
+        case _ => tp
+      checkConforms(ownType, widened(tree.from.symbol.returnProto), tree)
       defn.NothingType
     end recheckReturn
 
@@ -423,6 +488,27 @@ abstract class Recheck extends Phase, SymTransformer:
           throw ex
       }
 
+    /** Typing and previous transforms sometiems leaves skolem types in prefixes of
+     *  NamedTypes in `expected` that do not match the `actual` Type. -Ycheck does
+     *  not complain (need to find out why), but a full recheck does. We compensate
+     *  by de-skolemizing everywhere in `expected` except when variance is negative.
+     *  @return If `tp` contains SkolemTypes in covariant or invariant positions,
+     *          the type where these SkolemTypes are mapped to their underlying type.
+     *          Otherwise, `tp` itself
+     */
+    def widenSkolems(tp: Type)(using Context): Type =
+      object widenSkolems extends TypeMap, IdempotentCaptRefMap:
+        var didWiden: Boolean = false
+        def apply(t: Type): Type = t match
+          case t: SkolemType if variance >= 0 =>
+            didWiden = true
+            apply(t.underlying)
+          case t: LazyRef => t
+          case t @ AnnotatedType(t1, ann) => t.derivedAnnotatedType(apply(t1), ann)
+          case _ => mapOver(t)
+      val tp1 = widenSkolems(tp)
+      if widenSkolems.didWiden then tp1 else tp
+
     /** If true, print info for some successful checkConforms operations (failing ones give
      *  an error message in any case).
      */
@@ -438,11 +524,16 @@ abstract class Recheck extends Phase, SymTransformer:
 
     def checkConformsExpr(actual: Type, expected: Type, tree: Tree)(using Context): Unit =
       //println(i"check conforms $actual <:< $expected")
-      val isCompatible =
+
+      def isCompatible(expected: Type): Boolean =
         actual <:< expected
         || expected.isRepeatedParam
-            && actual <:< expected.translateFromRepeated(toArray = tree.tpe.isRef(defn.ArrayClass))
-      if !isCompatible then
+            && isCompatible(expected.translateFromRepeated(toArray = tree.tpe.isRef(defn.ArrayClass)))
+        || {
+          val widened = widenSkolems(expected)
+          (widened ne expected) && isCompatible(widened)
+        }
+      if !isCompatible(expected) then
         recheckr.println(i"conforms failed for ${tree}: $actual vs $expected")
         err.typeMismatch(tree.withType(actual), expected)
       else if debugSuccesses then
@@ -450,6 +541,7 @@ abstract class Recheck extends Phase, SymTransformer:
           case _: Ident =>
             println(i"SUCCESS $tree:\n${TypeComparer.explained(_.isSubType(actual, expected))}")
           case _ =>
+    end checkConformsExpr
 
     def checkUnit(unit: CompilationUnit)(using Context): Unit =
       recheck(unit.tpdTree)
diff --git a/compiler/src/dotty/tools/dotc/transform/TreeChecker.scala b/compiler/src/dotty/tools/dotc/transform/TreeChecker.scala
index 6ab0e7fc499f..dc8defa90eef 100644
--- a/compiler/src/dotty/tools/dotc/transform/TreeChecker.scala
+++ b/compiler/src/dotty/tools/dotc/transform/TreeChecker.scala
@@ -91,7 +91,7 @@ class TreeChecker extends Phase with SymTransformer {
     if (ctx.phaseId <= erasurePhase.id) {
       val initial = symd.initial
       assert(symd == initial || symd.signature == initial.signature,
-        i"""Signature of ${sym.showLocated} changed at phase ${ctx.phase.prevMega}
+        i"""Signature of ${sym} in ${sym.ownersIterator.toList}%, % changed at phase ${ctx.phase.prevMega}
            |Initial info: ${initial.info}
            |Initial sig : ${initial.signature}
            |Current info: ${symd.info}
diff --git a/compiler/src/dotty/tools/dotc/typer/Checking.scala b/compiler/src/dotty/tools/dotc/typer/Checking.scala
index c53213d7bd37..16499f6c1f3e 100644
--- a/compiler/src/dotty/tools/dotc/typer/Checking.scala
+++ b/compiler/src/dotty/tools/dotc/typer/Checking.scala
@@ -67,11 +67,12 @@ object Checking {
    */
   def checkBounds(args: List[tpd.Tree], boundss: List[TypeBounds],
     instantiate: (Type, List[Type]) => Type, app: Type = NoType, tpt: Tree = EmptyTree)(using Context): Unit =
-    args.lazyZip(boundss).foreach { (arg, bound) =>
-      if !bound.isLambdaSub && !arg.tpe.hasSimpleKind then
-        errorTree(arg,
-          showInferred(MissingTypeParameterInTypeApp(arg.tpe), app, tpt))
-    }
+    if ctx.phase != Phases.checkCapturesPhase then
+      args.lazyZip(boundss).foreach { (arg, bound) =>
+        if !bound.isLambdaSub && !arg.tpe.hasSimpleKind then
+          errorTree(arg,
+            showInferred(MissingTypeParameterInTypeApp(arg.tpe), app, tpt))
+      }
     for (arg, which, bound) <- TypeOps.boundsViolations(args, boundss, instantiate, app) do
       report.error(
         showInferred(DoesNotConformToBound(arg.tpe, which, bound), app, tpt),
diff --git a/compiler/src/dotty/tools/dotc/typer/CrossVersionChecks.scala b/compiler/src/dotty/tools/dotc/typer/CrossVersionChecks.scala
index 044dd7bb8528..00b037a4e259 100644
--- a/compiler/src/dotty/tools/dotc/typer/CrossVersionChecks.scala
+++ b/compiler/src/dotty/tools/dotc/typer/CrossVersionChecks.scala
@@ -117,7 +117,7 @@ class CrossVersionChecks extends MiniPhase:
 
   /** Check that classes extending experimental classes or nested in experimental classes have the @experimental annotation. */
   private def checkExperimentalInheritance(cls: ClassSymbol)(using Context): Unit =
-    if !cls.isAnonymousClass && !cls.hasAnnotation(defn.ExperimentalAnnot) then
+    if !cls.isAnonymousClass && !cls.isInExperimentalScope then
       cls.info.parents.find(_.typeSymbol.isExperimental) match
         case Some(parent) =>
           report.error(em"extension of experimental ${parent.typeSymbol} must have @experimental annotation", cls.srcPos)
diff --git a/compiler/src/dotty/tools/dotc/typer/RefChecks.scala b/compiler/src/dotty/tools/dotc/typer/RefChecks.scala
index 1aa53d866b5e..8afcec4dee63 100644
--- a/compiler/src/dotty/tools/dotc/typer/RefChecks.scala
+++ b/compiler/src/dotty/tools/dotc/typer/RefChecks.scala
@@ -91,24 +91,42 @@ object RefChecks {
       cls.thisType
   }
 
+  /**  - Check that self type of `cls` conforms to self types of all `parents` as seen from
+   *     `cls.thisType`
+   *   - If self type of `cls` is explicit, check that it conforms to the self types
+   *     of all its class symbols.
+   *  @param deep  If true and a self type of a parent is not given explicitly, recurse to
+   *               check against the parents of the parent. This is needed when capture checking,
+   *               since we assume (& check) that the capture set of an inferred self type
+   *               is the intersection of the capture sets of all its parents
+   */
+  def checkSelfAgainstParents(cls: ClassSymbol, parents: List[Symbol])(using Context): Unit =
+    withMode(Mode.CheckBoundsOrSelfType) {
+      val cinfo = cls.classInfo
+
+      def checkSelfConforms(other: ClassSymbol, category: String, relation: String) =
+        val otherSelf = other.declaredSelfTypeAsSeenFrom(cls.thisType)
+        if otherSelf.exists then
+          if !(cinfo.selfType <:< otherSelf) then
+            report.error(DoesNotConformToSelfType(category, cinfo.selfType, cls, otherSelf, relation, other),
+              cls.srcPos)
+
+      for psym <- parents do
+        checkSelfConforms(psym.asClass, "illegal inheritance", "parent")
+      for reqd <- cls.asClass.givenSelfType.classSymbols do
+        if reqd != cls then
+          checkSelfConforms(reqd, "missing requirement", "required")
+    }
+  end checkSelfAgainstParents
+
   /** Check that self type of this class conforms to self types of parents
    *  and required classes. Also check that only `enum` constructs extend
    *  `java.lang.Enum` and no user-written class extends ContextFunctionN.
    */
   def checkParents(cls: Symbol, parentTrees: List[Tree])(using Context): Unit = cls.info match {
     case cinfo: ClassInfo =>
-      def checkSelfConforms(other: ClassSymbol, category: String, relation: String) = {
-        val otherSelf = other.declaredSelfTypeAsSeenFrom(cls.thisType)
-        if otherSelf.exists && !(cinfo.selfType <:< otherSelf) then
-          report.error(DoesNotConformToSelfType(category, cinfo.selfType, cls, otherSelf, relation, other),
-            cls.srcPos)
-      }
       val psyms = cls.asClass.parentSyms
-      for (psym <- psyms)
-        checkSelfConforms(psym.asClass, "illegal inheritance", "parent")
-      for reqd <- cinfo.cls.givenSelfType.classSymbols do
-        if reqd != cls then
-          checkSelfConforms(reqd, "missing requirement", "required")
+      checkSelfAgainstParents(cls.asClass, psyms)
 
       def isClassExtendingJavaEnum =
         !cls.isOneOf(Enum | Trait) && psyms.contains(defn.JavaEnumClass)
@@ -774,17 +792,19 @@ object RefChecks {
 
         // For each member, check that the type of its symbol, as seen from `self`
         // can override the info of this member
-        for (name <- membersToCheck)
-          for (mbrd <- self.member(name).alternatives) {
-            val mbr = mbrd.symbol
-            val mbrType = mbr.info.asSeenFrom(self, mbr.owner)
-            if (!mbrType.overrides(mbrd.info, relaxedCheck = false, matchLoosely = true))
-              report.errorOrMigrationWarning(
-                em"""${mbr.showLocated} is not a legal implementation of `$name` in $clazz
-                    |  its type             $mbrType
-                    |  does not conform to  ${mbrd.info}""",
-                (if (mbr.owner == clazz) mbr else clazz).srcPos, from = `3.0`)
+        withMode(Mode.IgnoreCaptures) {
+          for (name <- membersToCheck)
+            for (mbrd <- self.member(name).alternatives) {
+              val mbr = mbrd.symbol
+              val mbrType = mbr.info.asSeenFrom(self, mbr.owner)
+              if (!mbrType.overrides(mbrd.info, relaxedCheck = false, matchLoosely = true))
+                report.errorOrMigrationWarning(
+                  em"""${mbr.showLocated} is not a legal implementation of `$name` in $clazz
+                      |  its type             $mbrType
+                      |  does not conform to  ${mbrd.info}""",
+                  (if (mbr.owner == clazz) mbr else clazz).srcPos, from = `3.0`)
           }
+        }
       }
 
       /** Check that inheriting a case class does not constitute a variant refinement
diff --git a/compiler/src/dotty/tools/package.scala b/compiler/src/dotty/tools/package.scala
index 57a58151acc7..4ec9ae40c421 100644
--- a/compiler/src/dotty/tools/package.scala
+++ b/compiler/src/dotty/tools/package.scala
@@ -18,7 +18,7 @@ package object tools {
      *  Flow-typing under explicit nulls will automatically insert many necessary
      *  occurrences of uncheckedNN.
      */
-    inline def uncheckedNN: T = x.asInstanceOf[T]
+    transparent inline def uncheckedNN: T = x.asInstanceOf[T]
 
     inline def toOption: Option[T] =
       if x == null then None else Some(x.asInstanceOf[T])
diff --git a/compiler/test/dotc/pos-test-pickling.blacklist b/compiler/test/dotc/pos-test-pickling.blacklist
index a7d8778d4c61..30126f07b49a 100644
--- a/compiler/test/dotc/pos-test-pickling.blacklist
+++ b/compiler/test/dotc/pos-test-pickling.blacklist
@@ -84,7 +84,6 @@ boxmap-paper.scala
 # Function types print differnt after unpickling since test mispredicts Feature.preFundsEnabled
 caps-universal.scala
 
-
 # GADT cast applied to singleton type difference
 i4176-gadt.scala
 
diff --git a/compiler/test/dotty/tools/dotc/BootstrappedOnlyCompilationTests.scala b/compiler/test/dotty/tools/dotc/BootstrappedOnlyCompilationTests.scala
index 7ea05c615e0d..e9d0e26f33b0 100644
--- a/compiler/test/dotty/tools/dotc/BootstrappedOnlyCompilationTests.scala
+++ b/compiler/test/dotty/tools/dotc/BootstrappedOnlyCompilationTests.scala
@@ -36,6 +36,12 @@ class BootstrappedOnlyCompilationTests {
     ).checkCompile()
   }
 
+  @Test def posWithCompilerCC: Unit =
+    implicit val testGroup: TestGroup = TestGroup("compilePosWithCompilerCC")
+    aggregateTests(
+      compileDir("tests/pos-with-compiler-cc/dotc", withCompilerOptions.and("-language:experimental.captureChecking"))
+    ).checkCompile()
+
   @Test def posWithCompiler: Unit = {
     implicit val testGroup: TestGroup = TestGroup("compilePosWithCompiler")
     aggregateTests(
diff --git a/compiler/test/dotty/tools/dotc/CompilationTests.scala b/compiler/test/dotty/tools/dotc/CompilationTests.scala
index 932acb90371c..c1b465ad4a88 100644
--- a/compiler/test/dotty/tools/dotc/CompilationTests.scala
+++ b/compiler/test/dotty/tools/dotc/CompilationTests.scala
@@ -242,7 +242,8 @@ class CompilationTests {
     ).checkCompile()
   }
 
-  @Test def recheck: Unit =
+  //@Test disabled in favor of posWithCompilerCC to save time.
+  def recheck: Unit =
     given TestGroup = TestGroup("recheck")
     aggregateTests(
       compileFilesInDir("tests/new", recheckOptions),
diff --git a/library/src/scala/caps.scala b/library/src/scala/caps.scala
index 21b2f7a4dece..fb1721f98b35 100644
--- a/library/src/scala/caps.scala
+++ b/library/src/scala/caps.scala
@@ -7,12 +7,26 @@ import annotation.experimental
   /** The universal capture reference */
   val `*`: Any = ()
 
-  /** If argument is of type `cs T`, converts to type `box cs T`. This
-   *  avoids the error that would be raised when boxing `*`.
-   */
-  extension [T](x: T) def unsafeBox: T = x
+  object unsafe:
+
+    /** If argument is of type `cs T`, converts to type `box cs T`. This
+     *  avoids the error that would be raised when boxing `*`.
+     */
+    extension [T](x: T) def unsafeBox: T = x
+
+    /** If argument is of type `box cs T`, converts to type `cs T`. This
+     *  avoids the error that would be raised when unboxing `*`.
+     */
+    extension [T](x: T) def unsafeUnbox: T = x
+
+    /** If argument is of type `box cs T`, converts to type `cs T`. This
+     *  avoids the error that would be raised when unboxing `*`.
+     */
+    extension [T, U](f: T => U) def unsafeBoxFunArg: T => U = f
+  end unsafe
 
-  /** If argument is of type `box cs T`, converts to type `cs T`. This
-   *  avoids the error that would be raised when unboxing `*`.
+  /** Mixing in this trait forces a trait or class to be pure, i.e.
+   *  have no capabilities retained in its self type.
    */
-  extension [T](x: T) def unsafeUnbox: T = x
+  trait Pure:
+    this: Pure =>
diff --git a/project/MiMaFilters.scala b/project/MiMaFilters.scala
index 81510d22d2c2..408930bbeee9 100644
--- a/project/MiMaFilters.scala
+++ b/project/MiMaFilters.scala
@@ -19,5 +19,7 @@ object MiMaFilters {
     ProblemFilters.exclude[MissingClassProblem]("scala.runtime.stdLibPatches.language$experimental$pureFunctions$"),
     ProblemFilters.exclude[MissingClassProblem]("scala.runtime.stdLibPatches.language$experimental$captureChecking$"),
     ProblemFilters.exclude[MissingClassProblem]("scala.caps"),
+    ProblemFilters.exclude[MissingClassProblem]("scala.caps$Pure"),
+    ProblemFilters.exclude[MissingClassProblem]("scala.caps$unsafe$"),
   )
 }
diff --git a/tests/neg-custom-args/captures/boundschecks.scala b/tests/neg-custom-args/captures/boundschecks.scala
new file mode 100644
index 000000000000..cf4eab28f19d
--- /dev/null
+++ b/tests/neg-custom-args/captures/boundschecks.scala
@@ -0,0 +1,18 @@
+object test {
+
+  class Tree
+
+  def f[X <: Tree](x: X): Unit = ()
+
+  class C[X <: Tree](x: X)
+
+  def foo(t: {*} Tree) =
+    f(t) // error
+    f[{*} Tree](t) // error
+    f[Tree](t)  // error
+    val c1 = C(t) // error
+    val c2 = C[{*} Tree](t) // error
+    val c3 = C[Tree](t)  // error
+
+    val foo: C[{*} Tree] = ???
+}
diff --git a/tests/neg-custom-args/captures/boundschecks2.scala b/tests/neg-custom-args/captures/boundschecks2.scala
new file mode 100644
index 000000000000..f6927b04931b
--- /dev/null
+++ b/tests/neg-custom-args/captures/boundschecks2.scala
@@ -0,0 +1,13 @@
+object test {
+
+  class Tree
+
+  def f[X <: Tree](x: X): Unit = ()
+
+  class C[X <: Tree](x: X)
+
+  val foo: C[{*} Tree] = ??? // error
+  type T = C[{*} Tree] // error
+  val bar: T -> T = ???
+  val baz: C[{*} Tree] -> Unit = ??? // error
+}
diff --git a/tests/neg-custom-args/captures/capt-depfun.scala b/tests/neg-custom-args/captures/capt-depfun.scala
index a74764f432c7..c01eed7c4b25 100644
--- a/tests/neg-custom-args/captures/capt-depfun.scala
+++ b/tests/neg-custom-args/captures/capt-depfun.scala
@@ -1,8 +1,9 @@
 import annotation.retains
 class C
 type Cap = C @retains(caps.*)
+class Str
 
 def f(y: Cap, z: Cap) =
   def g(): C @retains(y, z) = ???
-  val ac: ((x: Cap) => String @retains(x) => String @retains(x)) = ???
-  val dc: (({y, z} String) => {y, z} String) = ac(g()) // error
+  val ac: ((x: Cap) => Str @retains(x) => Str @retains(x)) = ???
+  val dc: (({y, z} Str) => {y, z} Str) = ac(g()) // error
diff --git a/tests/neg-custom-args/captures/capt-depfun2.scala b/tests/neg-custom-args/captures/capt-depfun2.scala
index 74b9441593c1..52dd74aabf9f 100644
--- a/tests/neg-custom-args/captures/capt-depfun2.scala
+++ b/tests/neg-custom-args/captures/capt-depfun2.scala
@@ -1,11 +1,12 @@
 import annotation.retains
 class C
 type Cap = C @retains(caps.*)
+class Str
 
 def f(y: Cap, z: Cap) =
   def g(): C @retains(y, z) = ???
-  val ac: ((x: Cap) => Array[String @retains(x)]) = ???
-  val dc = ac(g()) // error: Needs explicit type Array[? >: String <: {y, z} String]
+  val ac: ((x: Cap) => Array[Str @retains(x)]) = ???
+  val dc = ac(g()) // error: Needs explicit type Array[? >: Str <: {y, z} Str]
                    // This is a shortcoming of rechecking since the originally inferred
-                   // type is `Array[String]` and the actual type after rechecking
-                   // cannot be expressed as `Array[C String]` for any capture set C
\ No newline at end of file
+                   // type is `Array[Str]` and the actual type after rechecking
+                   // cannot be expressed as `Array[C Str]` for any capture set C
\ No newline at end of file
diff --git a/tests/neg-custom-args/captures/cc-this.check b/tests/neg-custom-args/captures/cc-this.check
index c492df15078f..0049f42a5db5 100644
--- a/tests/neg-custom-args/captures/cc-this.check
+++ b/tests/neg-custom-args/captures/cc-this.check
@@ -9,10 +9,7 @@
 10 |  class C2(val x: () => Int): // error
    |               ^
    |        reference (C2.this.x : () => Int) is not included in allowed capture set {} of the self type of class C2
--- [E058] Type Mismatch Error: tests/neg-custom-args/captures/cc-this.scala:17:8 ---------------------------------------
+-- Error: tests/neg-custom-args/captures/cc-this.scala:17:8 ------------------------------------------------------------
 17 |  class C4(val f: () => Int) extends C3 // error
-   |        ^
-   |        illegal inheritance: self type {C4.this.f} C4 of class C4 does not conform to self type C3
-   |        of parent class C3
-   |
-   | longer explanation available when compiling with `-explain`
+   |  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |  reference (C4.this.f : () => Int) is not included in allowed capture set {} of pure base class class C3
diff --git a/tests/neg-custom-args/captures/cc-this2.check b/tests/neg-custom-args/captures/cc-this2.check
index d10519636ca8..086524d307a2 100644
--- a/tests/neg-custom-args/captures/cc-this2.check
+++ b/tests/neg-custom-args/captures/cc-this2.check
@@ -1,8 +1,6 @@
 
--- [E058] Type Mismatch Error: tests/neg-custom-args/captures/cc-this2/D_2.scala:2:6 -----------------------------------
+-- Error: tests/neg-custom-args/captures/cc-this2/D_2.scala:2:6 --------------------------------------------------------
 2 |class D extends C: // error
-  |      ^
-  |      illegal inheritance: self type {*} D of class D does not conform to self type C
-  |      of parent class C
-  |
-  | longer explanation available when compiling with `-explain`
+  |^
+  |reference (scala.caps.* : Any) is not included in allowed capture set {} of pure base class class C
+3 |  this: {*} D =>
diff --git a/tests/neg-custom-args/captures/exception-definitions.check b/tests/neg-custom-args/captures/exception-definitions.check
new file mode 100644
index 000000000000..aca5d9217d64
--- /dev/null
+++ b/tests/neg-custom-args/captures/exception-definitions.check
@@ -0,0 +1,17 @@
+-- Error: tests/neg-custom-args/captures/exception-definitions.scala:2:6 -----------------------------------------------
+2 |class Err extends Exception: // error
+  |^
+  |reference (scala.caps.* : Any) is not included in allowed capture set {} of pure base class class Throwable
+3 |  self: {*} Err =>
+-- Error: tests/neg-custom-args/captures/exception-definitions.scala:10:6 ----------------------------------------------
+10 |class Err4(c: {*} Any) extends AnyVal // error
+   |^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |reference (Err4.this.c : {*} Any) is not included in allowed capture set {} of pure base class class AnyVal
+-- Error: tests/neg-custom-args/captures/exception-definitions.scala:7:12 ----------------------------------------------
+7 |    val x = c  // error
+  |            ^
+  |(c : {*} Any) cannot be referenced here; it is not included in the allowed capture set {} of pure base class class Throwable
+-- Error: tests/neg-custom-args/captures/exception-definitions.scala:8:8 -----------------------------------------------
+8 |  class Err3(c: {*} Any) extends Exception // error
+  |  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+  |  reference (Err3.this.c : {*} Any) is not included in allowed capture set {} of pure base class class Throwable
diff --git a/tests/neg-custom-args/captures/exception-definitions.scala b/tests/neg-custom-args/captures/exception-definitions.scala
new file mode 100644
index 000000000000..9f3539b7febf
--- /dev/null
+++ b/tests/neg-custom-args/captures/exception-definitions.scala
@@ -0,0 +1,12 @@
+
+class Err extends Exception: // error
+  self: {*} Err =>
+
+def test(c: {*} Any) =
+  class Err2 extends Exception:
+    val x = c  // error
+  class Err3(c: {*} Any) extends Exception // error
+
+class Err4(c: {*} Any) extends AnyVal // error
+
+
diff --git a/tests/neg-custom-args/captures/i15116.check b/tests/neg-custom-args/captures/i15116.check
index 83c552087646..8b8d2d2e091b 100644
--- a/tests/neg-custom-args/captures/i15116.check
+++ b/tests/neg-custom-args/captures/i15116.check
@@ -9,7 +9,7 @@
 5 |  val x = Foo(m)   // error
   |  ^^^^^^^^^^^^^^
   |  Non-local value x cannot have an inferred type
-  |  {Baz.this} Foo{m: {Baz.this} String}
+  |  {Baz.this} Foo{m: {*} String}
   |  with non-empty capture set {Baz.this}.
   |  The type needs to be declared explicitly.
 -- Error: tests/neg-custom-args/captures/i15116.scala:7:6 --------------------------------------------------------------
@@ -23,6 +23,6 @@
 9 |  val x = Foo(m)   // error
   |  ^^^^^^^^^^^^^^
   |  Non-local value x cannot have an inferred type
-  |  {Baz2.this} Foo{m: {Baz2.this} String}
+  |  {Baz2.this} Foo{m: {*} String}
   |  with non-empty capture set {Baz2.this}.
   |  The type needs to be declared explicitly.
diff --git a/tests/neg-custom-args/captures/lazylist.check b/tests/neg-custom-args/captures/lazylist.check
index e43538ad97f7..1ad705556b88 100644
--- a/tests/neg-custom-args/captures/lazylist.check
+++ b/tests/neg-custom-args/captures/lazylist.check
@@ -5,6 +5,13 @@
    |        method tail of type -> {*} lazylists.LazyList[Nothing] has incompatible type
    |
    | longer explanation available when compiling with `-explain`
+-- [E007] Type Mismatch Error: tests/neg-custom-args/captures/lazylist.scala:17:15 -------------------------------------
+17 |  def tail = xs() // error
+   |             ^^^^
+   |             Found:    {LazyCons.this.xs} lazylists.LazyList[T]
+   |             Required: lazylists.LazyList[T]
+   |
+   | longer explanation available when compiling with `-explain`
 -- [E007] Type Mismatch Error: tests/neg-custom-args/captures/lazylist.scala:35:29 -------------------------------------
 35 |  val ref1c: LazyList[Int] = ref1 // error
    |                             ^^^^
@@ -33,10 +40,3 @@
    |                                             Required: {cap1, ref3, cap3} lazylists.LazyList[Int]
    |
    | longer explanation available when compiling with `-explain`
--- Error: tests/neg-custom-args/captures/lazylist.scala:17:6 -----------------------------------------------------------
-17 |  def tail = xs() // error: cannot have an inferred type
-   |  ^^^^^^^^^^^^^^^
-   |  Non-local method tail cannot have an inferred result type
-   |  {LazyCons.this.xs} lazylists.LazyList[? T]
-   |  with non-empty capture set {LazyCons.this.xs}.
-   |  The type needs to be declared explicitly.
diff --git a/tests/neg-custom-args/captures/lazylist.scala b/tests/neg-custom-args/captures/lazylist.scala
index 56bfc3ea6da2..2674f15a0ee3 100644
--- a/tests/neg-custom-args/captures/lazylist.scala
+++ b/tests/neg-custom-args/captures/lazylist.scala
@@ -14,7 +14,7 @@ abstract class LazyList[+T]:
 class LazyCons[+T](val x: T, val xs: () => {*} LazyList[T]) extends LazyList[T]:
   def isEmpty = false
   def head = x
-  def tail = xs() // error: cannot have an inferred type
+  def tail = xs() // error
 
 object LazyNil extends LazyList[Nothing]:
   def isEmpty = true
diff --git a/tests/neg-custom-args/captures/selftype.scala b/tests/neg-custom-args/captures/selftype.scala
new file mode 100644
index 000000000000..21148f625a7a
--- /dev/null
+++ b/tests/neg-custom-args/captures/selftype.scala
@@ -0,0 +1,4 @@
+@annotation.experimental class C(x: () => Unit) extends caps.Pure // error
+
+@annotation.experimental class D(@annotation.constructorOnly x: () => Unit) extends caps.Pure // ok
+
diff --git a/tests/neg-custom-args/captures/try.check b/tests/neg-custom-args/captures/try.check
index 13aff2661b85..c9cc7f7c1b56 100644
--- a/tests/neg-custom-args/captures/try.check
+++ b/tests/neg-custom-args/captures/try.check
@@ -1,7 +1,7 @@
 -- [E007] Type Mismatch Error: tests/neg-custom-args/captures/try.scala:23:49 ------------------------------------------
 23 |  val a = handle[Exception, CanThrow[Exception]] { // error
    |                                                 ^
-   |                                                 Found:    ? ({*} CT[Exception]) -> CanThrow[? Exception]
+   |                                                 Found:    ? ({*} CT[Exception]) -> CanThrow[Exception]
    |                                                 Required: CanThrow[Exception] => box {*} CT[Exception]
 24 |    (x: CanThrow[Exception]) => x
 25 |  }{
@@ -10,7 +10,7 @@
 -- [E007] Type Mismatch Error: tests/neg-custom-args/captures/try.scala:29:43 ------------------------------------------
 29 |  val b = handle[Exception, () -> Nothing] {  // error
    |                                           ^
-   |                                           Found:    ? (x: {*} CT[Exception]) -> {x} () -> ? Nothing
+   |                                           Found:    ? (x: {*} CT[Exception]) -> {x} () -> Nothing
    |                                           Required: CanThrow[Exception] => () -> Nothing
 30 |    (x: CanThrow[Exception]) => () => raise(new Exception)(using x)
 31 |  } {
diff --git a/tests/neg-custom-args/captures/vars.check b/tests/neg-custom-args/captures/vars.check
index e4f28fd45e93..8fe72a76493a 100644
--- a/tests/neg-custom-args/captures/vars.check
+++ b/tests/neg-custom-args/captures/vars.check
@@ -9,7 +9,7 @@
 15 |  val u = a  // error
    |          ^
    |          Found:    (a : box {*} String -> String)
-   |          Required: {*} (x$0: ? String) -> ? String
+   |          Required: {*} (x$0: String) -> String
    |
    | longer explanation available when compiling with `-explain`
 -- Error: tests/neg-custom-args/captures/vars.scala:16:2 ---------------------------------------------------------------
@@ -25,7 +25,7 @@
 -- Error: tests/neg-custom-args/captures/vars.scala:32:8 ---------------------------------------------------------------
 32 |  local { cap3 => // error
    |  ^
-   |  The expression's type box {*} (x$0: ? String) -> ? String is not allowed to capture the root capability `*`.
+   |  The expression's type box {*} (x$0: String) -> String is not allowed to capture the root capability `*`.
    |  This usually means that a capability persists longer than its allowed lifetime.
 33 |    def g(x: String): String = if cap3 == cap3 then "" else "a"
 34 |    g
diff --git a/tests/pending/pos/i16268.scala b/tests/pending/pos/i16268.scala
new file mode 100644
index 000000000000..6b44e71a2247
--- /dev/null
+++ b/tests/pending/pos/i16268.scala
@@ -0,0 +1,25 @@
+import language.experimental.captureChecking
+class Tree
+case class Thicket(trees: List[Tree]) extends Tree
+
+def test1(segments: List[{*} Tree]) =
+  val elems = segments flatMap { (t: {*} Tree) => t match // error
+    case ts: Thicket => ts.trees.tail
+    case t => Nil
+  }
+  elems
+
+def test2(segments: List[{*} Tree]) =
+  val f = (t: {*} Tree) => t match
+    case ts: Thicket => ts.trees.tail
+    case t => Nil
+  val elems = segments.flatMap(f) // error
+  elems
+
+def test3(c: {*} Any)(segments: List[{c} Tree]) =
+  val elems = segments flatMap { (t: {c} Tree) => t match
+    case ts: Thicket => ts.trees.tail
+    case t => Nil
+  }
+  elems
+
diff --git a/tests/pos-custom-args/captures/bynamefun.scala b/tests/pos-custom-args/captures/bynamefun.scala
new file mode 100644
index 000000000000..86bad201ffc3
--- /dev/null
+++ b/tests/pos-custom-args/captures/bynamefun.scala
@@ -0,0 +1,11 @@
+object test:
+  class Plan(elem: Plan)
+  object SomePlan extends Plan(???)
+  def f1(expr: (-> Plan) -> Plan): Plan = expr(SomePlan)
+  f1 { onf => Plan(onf) }
+  def f2(expr: (=> Plan) -> Plan): Plan = ???
+  f2 { onf => Plan(onf) }
+  def f3(expr: (-> Plan) => Plan): Plan = ???
+  f1 { onf => Plan(onf) }
+  def f4(expr: (=> Plan) => Plan): Plan = ???
+  f2 { onf => Plan(onf) }
diff --git a/tests/pos-custom-args/captures/capt-test.scala b/tests/pos-custom-args/captures/capt-test.scala
index 6ee0d2a4d9f4..c61577e96eb1 100644
--- a/tests/pos-custom-args/captures/capt-test.scala
+++ b/tests/pos-custom-args/captures/capt-test.scala
@@ -21,6 +21,9 @@ def map[A, B](f: A => B)(xs: LIST[A]): LIST[B] =
 class C
 type Cap = {*} C
 
+class Foo(x: Cap):
+  this: {x} Foo =>
+
 def test(c: Cap, d: Cap) =
   def f(x: Cap): Unit = if c == x then ()
   def g(x: Cap): Unit = if d == x then ()
diff --git a/tests/pos-custom-args/captures/cmp-singleton-2.scala b/tests/pos-custom-args/captures/cmp-singleton-2.scala
new file mode 100644
index 000000000000..daaa4add3858
--- /dev/null
+++ b/tests/pos-custom-args/captures/cmp-singleton-2.scala
@@ -0,0 +1,11 @@
+class T
+class A extends T
+class B extends T
+
+def test(tp: T) =
+  val mapping: Map[A, String] = ???
+
+  tp match
+    case a: A => mapping(a) match
+      case s: String => B()
+      case null => a
diff --git a/tests/pos-custom-args/captures/cmp-singleton.scala b/tests/pos-custom-args/captures/cmp-singleton.scala
new file mode 100644
index 000000000000..45b4009f5e89
--- /dev/null
+++ b/tests/pos-custom-args/captures/cmp-singleton.scala
@@ -0,0 +1,10 @@
+class Denotation
+abstract class SingleDenotation extends Denotation
+def goRefined: Denotation =
+  val foo: Denotation = ???
+  val joint = foo
+  joint match
+    case joint: SingleDenotation =>
+      joint
+    case _ =>
+      joint
\ No newline at end of file
diff --git a/tests/pos-custom-args/captures/foreach.scala b/tests/pos-custom-args/captures/foreach.scala
new file mode 100644
index 000000000000..b7dfc49272a9
--- /dev/null
+++ b/tests/pos-custom-args/captures/foreach.scala
@@ -0,0 +1,4 @@
+import caps.unsafe.*
+def test =
+  val tasks = new collection.mutable.ArrayBuffer[() => Unit]
+  val _: Unit = tasks.foreach(((task: () => Unit) => task()).unsafeBoxFunArg)
diff --git a/tests/pos-custom-args/captures/gadt-ycheck.scala b/tests/pos-custom-args/captures/gadt-ycheck.scala
new file mode 100644
index 000000000000..946763b53e7e
--- /dev/null
+++ b/tests/pos-custom-args/captures/gadt-ycheck.scala
@@ -0,0 +1,14 @@
+package test
+
+import reflect.ClassTag
+import language.experimental.pureFunctions
+
+object Settings:
+  val OptionTag: ClassTag[Option[?]] = ClassTag(classOf[Option[?]])
+
+  class Setting[T: ClassTag](propertyClass: Option[Class[?]]):
+    def tryToSet() =
+      def update(value: Any): String = ???
+      implicitly[ClassTag[T]] match
+        case OptionTag =>
+          update(Some(propertyClass.get.getConstructor().newInstance()))
diff --git a/tests/pos-custom-args/captures/matchtypes.scala b/tests/pos-custom-args/captures/matchtypes.scala
new file mode 100644
index 000000000000..b2442277f1f7
--- /dev/null
+++ b/tests/pos-custom-args/captures/matchtypes.scala
@@ -0,0 +1,10 @@
+type HEAD[X <: NonEmptyTuple] = X match {
+  case x *: (_ <: NonEmptyTuple) => x
+}
+
+inline def head[A <: NonEmptyTuple](x: A): HEAD[A] = null.asInstanceOf[HEAD[A]]
+
+def show[A, T <: Tuple](x: A *: T) =
+  show1(head(x))
+  show1(x.head)
+def show1[A](x: A): String = ???
\ No newline at end of file
diff --git a/tests/pos-custom-args/captures/overrides.scala b/tests/pos-custom-args/captures/overrides.scala
index 66f19726ffa7..7e70afe7a327 100644
--- a/tests/pos-custom-args/captures/overrides.scala
+++ b/tests/pos-custom-args/captures/overrides.scala
@@ -12,15 +12,3 @@ class Bar extends Foo:
 class Baz extends Bar:
   override def foo = () => println("baz")
   override def bar = "baz"
-  //override def toString = bar
-
-abstract class Message:
-  protected def msg: String
-  override def toString = msg
-
-abstract class SyntaxMsg extends Message
-
-class CyclicInheritance extends SyntaxMsg:
-  def msg = "cyclic"
-
-
diff --git a/tests/pos-custom-args/captures/overrides/A.scala b/tests/pos-custom-args/captures/overrides/A.scala
new file mode 100644
index 000000000000..6a81f8562164
--- /dev/null
+++ b/tests/pos-custom-args/captures/overrides/A.scala
@@ -0,0 +1,4 @@
+abstract class Message:
+  lazy val message: String = ???
+  def rawMessage = message
+
diff --git a/tests/pos-custom-args/captures/overrides/B.scala b/tests/pos-custom-args/captures/overrides/B.scala
new file mode 100644
index 000000000000..ce4a3f20f1d2
--- /dev/null
+++ b/tests/pos-custom-args/captures/overrides/B.scala
@@ -0,0 +1,6 @@
+
+abstract class SyntaxMsg extends Message
+
+class CyclicInheritance extends SyntaxMsg
+
+
diff --git a/tests/pos-custom-args/captures/selftypes.scala b/tests/pos-custom-args/captures/selftypes.scala
new file mode 100644
index 000000000000..c1b8eefce506
--- /dev/null
+++ b/tests/pos-custom-args/captures/selftypes.scala
@@ -0,0 +1,15 @@
+  import annotation.constructorOnly
+  trait A:
+    self: A =>
+    def foo: Int
+
+  abstract class B extends A:
+    def foo: Int
+
+  class C extends B:
+    def foo = 1
+    def derived = this
+
+  class D(@constructorOnly op: Int => Int) extends C:
+    val x = 1//op(1)
+
diff --git a/tests/pos-custom-args/captures/unsafe-unbox.scala b/tests/pos-custom-args/captures/unsafe-unbox.scala
index e846a7db1b69..b228d8c07925 100644
--- a/tests/pos-custom-args/captures/unsafe-unbox.scala
+++ b/tests/pos-custom-args/captures/unsafe-unbox.scala
@@ -1,4 +1,4 @@
-import caps.*
+import caps.unsafe.*
 def test =
   var finalizeActions = collection.mutable.ListBuffer[() => Unit]()
   val action = finalizeActions.remove(0).unsafeUnbox
diff --git a/tests/pos-custom-args/captures/vars1.scala b/tests/pos-custom-args/captures/vars1.scala
index 8c2f2cb8b5d5..c008bac2e72f 100644
--- a/tests/pos-custom-args/captures/vars1.scala
+++ b/tests/pos-custom-args/captures/vars1.scala
@@ -1,4 +1,4 @@
-import caps.*
+import caps.unsafe.*
 
 object Test:
   type ErrorHandler = (Int, String) => Unit
@@ -11,15 +11,11 @@ object Test:
 
   def defaultIncompleteHandler1(): ErrorHandler = ???
   val defaultIncompleteHandler2: ErrorHandler = ???
-  var incompleteHandler1: ErrorHandler = defaultIncompleteHandler1()
-  var incompleteHandler2: ErrorHandler = defaultIncompleteHandler2
-  var incompleteHandler3: ErrorHandler = defaultIncompleteHandler1().unsafeBox
-  var incompleteHandler4: ErrorHandler = defaultIncompleteHandler2.unsafeBox
-  private var incompleteHandler5 = defaultIncompleteHandler1()
-  private var incompleteHandler6 = defaultIncompleteHandler2
+  var incompleteHandler1: ErrorHandler = defaultIncompleteHandler1().unsafeBox
+  var incompleteHandler2: ErrorHandler = defaultIncompleteHandler2.unsafeBox
   private var incompleteHandler7 = defaultIncompleteHandler1().unsafeBox
   private var incompleteHandler8 = defaultIncompleteHandler2.unsafeBox
 
-  incompleteHandler1 = defaultIncompleteHandler2
+  incompleteHandler1 = defaultIncompleteHandler2.unsafeBox
   incompleteHandler1 = defaultIncompleteHandler2.unsafeBox
   val saved = incompleteHandler1.unsafeUnbox
diff --git a/tests/pos-custom-args/no-experimental/dotty-experimental.scala b/tests/pos-custom-args/no-experimental/dotty-experimental.scala
index 74e79c85eaaa..320c68dbea50 100644
--- a/tests/pos-custom-args/no-experimental/dotty-experimental.scala
+++ b/tests/pos-custom-args/no-experimental/dotty-experimental.scala
@@ -1,6 +1,6 @@
 package dotty.tools
 object test {
 
-  val x = caps.unsafeBox
+  val x = caps.unsafe.unsafeBox
 
 }
diff --git a/tests/pos-with-compiler-cc/dotc/Bench.scala b/tests/pos-with-compiler-cc/dotc/Bench.scala
new file mode 100644
index 000000000000..c9c032b0ae7d
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/Bench.scala
@@ -0,0 +1,64 @@
+package dotty.tools
+package dotc
+
+import core.Contexts._
+import reporting.Reporter
+import io.AbstractFile
+
+import scala.annotation.internal.sharable
+
+/** A main class for running compiler benchmarks. Can instantiate a given
+ *  number of compilers and run each (sequentially) a given number of times
+ *  on the same sources.
+ */
+object Bench extends Driver:
+
+  @sharable private var numRuns = 1
+
+  private def ntimes(n: Int)(op: => Reporter): Reporter =
+    (0 until n).foldLeft(emptyReporter)((_, _) => op)
+
+  @sharable private var times: Array[Int] = _
+
+  override def doCompile(compiler: Compiler, files: List[AbstractFile])(using Context): Reporter =
+    times = new Array[Int](numRuns)
+    var reporter: Reporter = emptyReporter
+    for i <- 0 until numRuns do
+      val start = System.nanoTime()
+      reporter = super.doCompile(compiler, files)
+      times(i) = ((System.nanoTime - start) / 1000000).toInt
+      println(s"time elapsed: ${times(i)}ms")
+      if ctx.settings.Xprompt.value then
+        print("hit <return> to continue >")
+        System.in.nn.read()
+        println()
+    reporter
+
+  def extractNumArg(args: Array[String], name: String, default: Int = 1): (Int, Array[String]) = {
+    val pos = args indexOf name
+    if (pos < 0) (default, args)
+    else (args(pos + 1).toInt, (args take pos) ++ (args drop (pos + 2)))
+  }
+
+  def reportTimes() =
+    val best = times.sorted
+    val measured = numRuns / 3
+    val avgBest = best.take(measured).sum / measured
+    val avgLast = times.reverse.take(measured).sum / measured
+    println(s"best out of $numRuns runs: ${best(0)}")
+    println(s"average out of best $measured: $avgBest")
+    println(s"average out of last $measured: $avgLast")
+
+  override def process(args: Array[String], rootCtx: Context): Reporter =
+    val (numCompilers, args1) = extractNumArg(args, "#compilers")
+    val (numRuns, args2) = extractNumArg(args1, "#runs")
+    this.numRuns = numRuns
+    var reporter: Reporter = emptyReporter
+    for i <- 0 until numCompilers do
+      reporter = super.process(args2, rootCtx)
+    reportTimes()
+    reporter
+
+end Bench
+
+
diff --git a/tests/pos-with-compiler-cc/dotc/CompilationUnit.scala b/tests/pos-with-compiler-cc/dotc/CompilationUnit.scala
new file mode 100644
index 000000000000..44ca582c3c61
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/CompilationUnit.scala
@@ -0,0 +1,166 @@
+package dotty.tools
+package dotc
+
+import core._
+import Contexts._
+import SymDenotations.ClassDenotation
+import Symbols._
+import util.{FreshNameCreator, SourceFile, NoSource}
+import util.Spans.Span
+import ast.{tpd, untpd}
+import tpd.{Tree, TreeTraverser}
+import ast.Trees.{Import, Ident}
+import typer.Nullables
+import transform.SymUtils._
+import core.Decorators._
+import config.{SourceVersion, Feature}
+import StdNames.nme
+import scala.annotation.internal.sharable
+
+class CompilationUnit protected (val source: SourceFile) {
+
+  override def toString: String = source.toString
+
+  var untpdTree: untpd.Tree = untpd.EmptyTree
+
+  var tpdTree: tpd.Tree = tpd.EmptyTree
+
+  /** Is this the compilation unit of a Java file */
+  def isJava: Boolean = source.file.name.endsWith(".java")
+
+  /** The source version for this unit, as determined by a language import */
+  var sourceVersion: Option[SourceVersion] = None
+
+  /** Pickled TASTY binaries, indexed by class. */
+  var pickled: Map[ClassSymbol, () => Array[Byte]] = Map()
+
+  /** The fresh name creator for the current unit.
+   *  FIXME(#7661): This is not fine-grained enough to enable reproducible builds,
+   *  see https://github.com/scala/scala/commit/f50ec3c866263448d803139e119b33afb04ec2bc
+   */
+  val freshNames: FreshNameCreator = new FreshNameCreator.Default
+
+  /** Will be set to `true` if there are inline call that must be inlined after typer.
+   *  The information is used in phase `Inlining` in order to avoid traversing trees that need no transformations.
+   */
+  var needsInlining: Boolean = false
+
+  /** Set to `true` if inliner added anonymous mirrors that need to be completed */
+  var needsMirrorSupport: Boolean = false
+
+  /** Will be set to `true` if contains `Quote`.
+   *  The information is used in phase `Staging`/`Splicing`/`PickleQuotes` in order to avoid traversing trees that need no transformations.
+   */
+  var needsStaging: Boolean = false
+
+  /** Will be set to true if the unit contains a captureChecking language import */
+  var needsCaptureChecking: Boolean = false
+
+  /** Will be set to true if the unit contains a pureFunctions language import */
+  var knowsPureFuns: Boolean = false
+
+  var suspended: Boolean = false
+  var suspendedAtInliningPhase: Boolean = false
+
+  /** Can this compilation unit be suspended */
+  def isSuspendable: Boolean = true
+
+  /** Suspends the compilation unit by thowing a SuspendException
+   *  and recording the suspended compilation unit
+   */
+  def suspend()(using Context): Nothing =
+    assert(isSuspendable)
+    if !suspended then
+      if (ctx.settings.XprintSuspension.value)
+        report.echo(i"suspended: $this")
+      suspended = true
+      ctx.run.nn.suspendedUnits += this
+      if ctx.phase == Phases.inliningPhase then
+        suspendedAtInliningPhase = true
+    throw CompilationUnit.SuspendException()
+
+  private var myAssignmentSpans: Map[Int, List[Span]] | Null = null
+
+  /** A map from (name-) offsets of all local variables in this compilation unit
+   *  that can be tracked for being not null to the list of spans of assignments
+   *  to these variables.
+   */
+  def assignmentSpans(using Context): Map[Int, List[Span]] =
+    if myAssignmentSpans == null then myAssignmentSpans = Nullables.assignmentSpans
+    myAssignmentSpans.nn
+}
+
+@sharable object NoCompilationUnit extends CompilationUnit(NoSource) {
+
+  override def isJava: Boolean = false
+
+  override def suspend()(using Context): Nothing =
+    throw CompilationUnit.SuspendException()
+
+  override def assignmentSpans(using Context): Map[Int, List[Span]] = Map.empty
+}
+
+object CompilationUnit {
+
+  class SuspendException extends Exception
+
+  /** Make a compilation unit for top class `clsd` with the contents of the `unpickled` tree */
+  def apply(clsd: ClassDenotation, unpickled: Tree, forceTrees: Boolean)(using Context): CompilationUnit =
+    val file = clsd.symbol.associatedFile.nn
+    apply(SourceFile(file, Array.empty[Char]), unpickled, forceTrees)
+
+  /** Make a compilation unit, given picked bytes and unpickled tree */
+  def apply(source: SourceFile, unpickled: Tree, forceTrees: Boolean)(using Context): CompilationUnit = {
+    assert(!unpickled.isEmpty, unpickled)
+    val unit1 = new CompilationUnit(source)
+    unit1.tpdTree = unpickled
+    if (forceTrees) {
+      val force = new Force
+      force.traverse(unit1.tpdTree)
+      unit1.needsStaging = force.containsQuote
+      unit1.needsInlining = force.containsInline
+    }
+    unit1
+  }
+
+  /** Create a compilation unit corresponding to `source`.
+   *  If `mustExist` is true, this will fail if `source` does not exist.
+   */
+  def apply(source: SourceFile, mustExist: Boolean = true)(using Context): CompilationUnit = {
+    val src =
+      if (!mustExist)
+        source
+      else if (source.file.isDirectory) {
+        report.error(s"expected file, received directory '${source.file.path}'")
+        NoSource
+      }
+      else if (!source.file.exists) {
+        report.error(s"source file not found: ${source.file.path}")
+        NoSource
+      }
+      else source
+    new CompilationUnit(src)
+  }
+
+  /** Force the tree to be loaded */
+  private class Force extends TreeTraverser {
+    var containsQuote = false
+    var containsInline = false
+    var containsCaptureChecking = false
+    def traverse(tree: Tree)(using Context): Unit = {
+      if (tree.symbol.isQuote)
+        containsQuote = true
+      if tree.symbol.is(Flags.Inline) then
+        containsInline = true
+      tree match
+        case Import(qual, selectors) =>
+          tpd.languageImport(qual) match
+            case Some(prefix) =>
+              for case untpd.ImportSelector(untpd.Ident(imported), untpd.EmptyTree, _) <- selectors do
+                Feature.handleGlobalLanguageImport(prefix, imported)
+            case _ =>
+        case _ =>
+      traverseChildren(tree)
+    }
+  }
+}
diff --git a/tests/pos-with-compiler-cc/dotc/Compiler.scala b/tests/pos-with-compiler-cc/dotc/Compiler.scala
new file mode 100644
index 000000000000..b121a47781e1
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/Compiler.scala
@@ -0,0 +1,171 @@
+package dotty.tools
+package dotc
+
+import core._
+import Contexts._
+import typer.{TyperPhase, RefChecks}
+import cc.CheckCaptures
+import parsing.Parser
+import Phases.Phase
+import transform._
+import dotty.tools.backend
+import backend.jvm.{CollectSuperCalls, GenBCode}
+import localopt.StringInterpolatorOpt
+
+/** The central class of the dotc compiler. The job of a compiler is to create
+ *  runs, which process given `phases` in a given `rootContext`.
+ */
+class Compiler {
+
+  /** Meta-ordering constraint:
+   *
+   *  DenotTransformers that change the signature of their denotation's info must go
+   *  after erasure. The reason is that denotations are permanently referred to by
+   *  TermRefs which contain a signature. If the signature of a symbol would change,
+   *  all refs to it would become outdated - they could not be dereferenced in the
+   *  new phase.
+   *
+   *  After erasure, signature changing denot-transformers are OK because signatures
+   *  are never recomputed later than erasure.
+   */
+  def phases: List[List[Phase]] =
+    frontendPhases ::: picklerPhases ::: transformPhases ::: backendPhases
+
+  /** Phases dealing with the frontend up to trees ready for TASTY pickling */
+  protected def frontendPhases: List[List[Phase]] =
+    List(new Parser) ::             // Compiler frontend: scanner, parser
+    List(new TyperPhase) ::         // Compiler frontend: namer, typer
+    List(new YCheckPositions) ::    // YCheck positions
+    List(new sbt.ExtractDependencies) :: // Sends information on classes' dependencies to sbt via callbacks
+    List(new semanticdb.ExtractSemanticDB) :: // Extract info into .semanticdb files
+    List(new PostTyper) ::          // Additional checks and cleanups after type checking
+    List(new sjs.PrepJSInterop) ::  // Additional checks and transformations for Scala.js (Scala.js only)
+    List(new sbt.ExtractAPI) ::     // Sends a representation of the API of classes to sbt via callbacks
+    List(new SetRootTree) ::        // Set the `rootTreeOrProvider` on class symbols
+    Nil
+
+  /** Phases dealing with TASTY tree pickling and unpickling */
+  protected def picklerPhases: List[List[Phase]] =
+    List(new Pickler) ::            // Generate TASTY info
+    List(new Inlining) ::           // Inline and execute macros
+    List(new PostInlining) ::       // Add mirror support for inlined code
+    List(new Staging) ::            // Check staging levels and heal staged types
+    List(new Splicing) ::           // Replace level 1 splices with holes
+    List(new PickleQuotes) ::       // Turn quoted trees into explicit run-time data structures
+    Nil
+
+  /** Phases dealing with the transformation from pickled trees to backend trees */
+  protected def transformPhases: List[List[Phase]] =
+    List(new InstrumentCoverage) ::  // Perform instrumentation for code coverage (if -coverage-out is set)
+    List(new FirstTransform,         // Some transformations to put trees into a canonical form
+         new CheckReentrant,         // Internal use only: Check that compiled program has no data races involving global vars
+         new ElimPackagePrefixes,    // Eliminate references to package prefixes in Select nodes
+         new CookComments,           // Cook the comments: expand variables, doc, etc.
+         new CheckStatic,            // Check restrictions that apply to @static members
+         new CheckLoopingImplicits,  // Check that implicit defs do not call themselves in an infinite loop
+         new BetaReduce,             // Reduce closure applications
+         new InlineVals,             // Check right hand-sides of an `inline val`s
+         new ExpandSAMs,             // Expand single abstract method closures to anonymous classes
+         new ElimRepeated,           // Rewrite vararg parameters and arguments
+         new RefChecks) ::           // Various checks mostly related to abstract members and overriding
+    List(new init.Checker) ::        // Check initialization of objects
+    List(new CrossVersionChecks,     // Check issues related to deprecated and experimental
+         new ProtectedAccessors,     // Add accessors for protected members
+         new ExtensionMethods,       // Expand methods of value classes with extension methods
+         new UncacheGivenAliases,    // Avoid caching RHS of simple parameterless given aliases
+         new ElimByName,             // Map by-name parameters to functions
+         new HoistSuperArgs,         // Hoist complex arguments of supercalls to enclosing scope
+         new ForwardDepChecks,       // Check that there are no forward references to local vals
+         new SpecializeApplyMethods, // Adds specialized methods to FunctionN
+         new TryCatchPatterns,       // Compile cases in try/catch
+         new PatternMatcher) ::      // Compile pattern matches
+    List(new TestRecheck.Pre) ::     // Test only: run rechecker, enabled under -Yrecheck-test
+    List(new TestRecheck) ::         // Test only: run rechecker, enabled under -Yrecheck-test
+    List(new CheckCaptures.Pre) ::   // Preparations for check captures phase, enabled under captureChecking
+    List(new CheckCaptures) ::       // Check captures, enabled under captureChecking
+    List(new ElimOpaque,             // Turn opaque into normal aliases
+         new sjs.ExplicitJSClasses,  // Make all JS classes explicit (Scala.js only)
+         new ExplicitOuter,          // Add accessors to outer classes from nested ones.
+         new ExplicitSelf,           // Make references to non-trivial self types explicit as casts
+         new StringInterpolatorOpt) :: // Optimizes raw and s and f string interpolators by rewriting them to string concatenations or formats
+    List(new PruneErasedDefs,        // Drop erased definitions from scopes and simplify erased expressions
+         new UninitializedDefs,      // Replaces `compiletime.uninitialized` by `_`
+         new InlinePatterns,         // Remove placeholders of inlined patterns
+         new VCInlineMethods,        // Inlines calls to value class methods
+         new SeqLiterals,            // Express vararg arguments as arrays
+         new InterceptedMethods,     // Special handling of `==`, `|=`, `getClass` methods
+         new Getters,                // Replace non-private vals and vars with getter defs (fields are added later)
+         new SpecializeFunctions,    // Specialized Function{0,1,2} by replacing super with specialized super
+         new SpecializeTuples,       // Specializes Tuples by replacing tuple construction and selection trees
+         new LiftTry,                // Put try expressions that might execute on non-empty stacks into their own methods
+         new CollectNullableFields,  // Collect fields that can be nulled out after use in lazy initialization
+         new ElimOuterSelect,        // Expand outer selections
+         new ResolveSuper,           // Implement super accessors
+         new FunctionXXLForwarders,  // Add forwarders for FunctionXXL apply method
+         new ParamForwarding,        // Add forwarders for aliases of superclass parameters
+         new TupleOptimizations,     // Optimize generic operations on tuples
+         new LetOverApply,           // Lift blocks from receivers of applications
+         new ArrayConstructors) ::   // Intercept creation of (non-generic) arrays and intrinsify.
+    List(new Erasure) ::             // Rewrite types to JVM model, erasing all type parameters, abstract types and refinements.
+    List(new ElimErasedValueType,    // Expand erased value types to their underlying implmementation types
+         new PureStats,              // Remove pure stats from blocks
+         new VCElideAllocations,     // Peep-hole optimization to eliminate unnecessary value class allocations
+         new EtaReduce,              // Reduce eta expansions of pure paths to the underlying function reference
+         new ArrayApply,             // Optimize `scala.Array.apply([....])` and `scala.Array.apply(..., [....])` into `[...]`
+         new sjs.AddLocalJSFakeNews, // Adds fake new invocations to local JS classes in calls to `createLocalJSClass`
+         new ElimPolyFunction,       // Rewrite PolyFunction subclasses to FunctionN subclasses
+         new TailRec,                // Rewrite tail recursion to loops
+         new CompleteJavaEnums,      // Fill in constructors for Java enums
+         new Mixin,                  // Expand trait fields and trait initializers
+         new LazyVals,               // Expand lazy vals
+         new Memoize,                // Add private fields to getters and setters
+         new NonLocalReturns,        // Expand non-local returns
+         new CapturedVars) ::        // Represent vars captured by closures as heap objects
+    List(new Constructors,           // Collect initialization code in primary constructors
+                                        // Note: constructors changes decls in transformTemplate, no InfoTransformers should be added after it
+         new Instrumentation) ::     // Count calls and allocations under -Yinstrument
+    List(new LambdaLift,             // Lifts out nested functions to class scope, storing free variables in environments
+                                     // Note: in this mini-phase block scopes are incorrect. No phases that rely on scopes should be here
+         new ElimStaticThis,         // Replace `this` references to static objects by global identifiers
+         new CountOuterAccesses) ::  // Identify outer accessors that can be dropped
+    List(new DropOuterAccessors,     // Drop unused outer accessors
+         new CheckNoSuperThis,       // Check that supercalls don't contain references to `this`
+         new Flatten,                // Lift all inner classes to package scope
+         new TransformWildcards,     // Replace wildcards with default values
+         new MoveStatics,            // Move static methods from companion to the class itself
+         new ExpandPrivate,          // Widen private definitions accessed from nested classes
+         new RestoreScopes,          // Repair scopes rendered invalid by moving definitions in prior phases of the group
+         new SelectStatic,           // get rid of selects that would be compiled into GetStatic
+         new sjs.JUnitBootstrappers, // Generate JUnit-specific bootstrapper classes for Scala.js (not enabled by default)
+         new CollectEntryPoints,     // Collect all entry points and save them in the context
+         new CollectSuperCalls,      // Find classes that are called with super
+         new RepeatableAnnotations) :: // Aggregate repeatable annotations
+    Nil
+
+  /** Generate the output of the compilation */
+  protected def backendPhases: List[List[Phase]] =
+    List(new backend.sjs.GenSJSIR) :: // Generate .sjsir files for Scala.js (not enabled by default)
+    List(new GenBCode) ::             // Generate JVM bytecode
+    Nil
+
+  var runId: Int = 1
+  def nextRunId: Int = {
+    runId += 1; runId
+  }
+
+  def reset()(using Context): Unit = {
+    ctx.base.reset()
+    val run = ctx.run
+    if (run != null) run.reset()
+  }
+
+  def newRun(using Context): Run = {
+    reset()
+    val rctx =
+      if ctx.settings.Xsemanticdb.value then
+        ctx.addMode(Mode.ReadPositions)
+      else
+        ctx
+    new Run(this, rctx)
+  }
+}
diff --git a/tests/pos-with-compiler-cc/dotc/Driver.scala b/tests/pos-with-compiler-cc/dotc/Driver.scala
new file mode 100644
index 000000000000..14a71463c66d
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/Driver.scala
@@ -0,0 +1,207 @@
+package dotty.tools.dotc
+
+import dotty.tools.FatalError
+import config.CompilerCommand
+import core.Comments.{ContextDoc, ContextDocstrings}
+import core.Contexts._
+import core.{MacroClassLoader, TypeError}
+import dotty.tools.dotc.ast.Positioned
+import dotty.tools.io.AbstractFile
+import reporting._
+import core.Decorators._
+import config.Feature
+
+import scala.util.control.NonFatal
+import fromtasty.{TASTYCompiler, TastyFileUtil}
+
+/** Run the Dotty compiler.
+ *
+ *  Extending this class lets you customize many aspect of the compilation
+ *  process, but in most cases you only need to call [[process]] on the
+ *  existing object [[Main]].
+ */
+class Driver {
+
+  protected def newCompiler(using Context): Compiler =
+    if (ctx.settings.fromTasty.value) new TASTYCompiler
+    else new Compiler
+
+  protected def emptyReporter: Reporter = new StoreReporter(null)
+
+  protected def doCompile(compiler: Compiler, files: List[AbstractFile])(using Context): Reporter =
+    if files.nonEmpty then
+      try
+        val run = compiler.newRun
+        run.compile(files)
+        finish(compiler, run)
+      catch
+        case ex: FatalError =>
+          report.error(ex.getMessage.nn) // signals that we should fail compilation.
+        case ex: TypeError =>
+          println(s"${ex.toMessage} while compiling ${files.map(_.path).mkString(", ")}")
+          throw ex
+        case ex: Throwable =>
+          println(s"$ex while compiling ${files.map(_.path).mkString(", ")}")
+          throw ex
+    ctx.reporter
+
+  protected def finish(compiler: Compiler, run: Run)(using Context): Unit =
+    run.printSummary()
+    if !ctx.reporter.errorsReported && run.suspendedUnits.nonEmpty then
+      val suspendedUnits = run.suspendedUnits.toList
+      if (ctx.settings.XprintSuspension.value)
+        report.echo(i"compiling suspended $suspendedUnits%, %")
+      val run1 = compiler.newRun
+      for unit <- suspendedUnits do unit.suspended = false
+      run1.compileUnits(suspendedUnits)
+      finish(compiler, run1)(using MacroClassLoader.init(ctx.fresh))
+
+  protected def initCtx: Context = (new ContextBase).initialCtx
+
+  protected def sourcesRequired: Boolean = true
+
+  protected def command: CompilerCommand = ScalacCommand
+
+  /** Setup context with initialized settings from CLI arguments, then check if there are any settings that
+   *  would change the default behaviour of the compiler.
+   *
+   *  @return If there is no setting like `-help` preventing us from continuing compilation,
+   *  this method returns a list of files to compile and an updated Context.
+   *  If compilation should be interrupted, this method returns None.
+   */
+  def setup(args: Array[String], rootCtx: Context): Option[(List[AbstractFile], Context)] = {
+    val ictx = rootCtx.fresh
+    val summary = command.distill(args, ictx.settings)(ictx.settingsState)(using ictx)
+    ictx.setSettings(summary.sstate)
+    Feature.checkExperimentalSettings(using ictx)
+    MacroClassLoader.init(ictx)
+    Positioned.init(using ictx)
+
+    inContext(ictx) {
+      if !ctx.settings.YdropComments.value || ctx.settings.YreadComments.value then
+        ictx.setProperty(ContextDoc, new ContextDocstrings)
+      val fileNamesOrNone = command.checkUsage(summary, sourcesRequired)(using ctx.settings)(using ctx.settingsState)
+      fileNamesOrNone.map { fileNames =>
+        val files = fileNames.map(ctx.getFile)
+        (files, fromTastySetup(files))
+      }
+    }
+  }
+
+  /** Setup extra classpath of tasty and jar files */
+  protected def fromTastySetup(files: List[AbstractFile])(using Context): Context =
+    if ctx.settings.fromTasty.value then
+      val newEntries: List[String] = files
+        .flatMap { file =>
+          if !file.exists then
+            report.error(s"File does not exist: ${file.path}")
+            None
+          else file.extension match
+            case "jar" => Some(file.path)
+            case "tasty" =>
+              TastyFileUtil.getClassPath(file) match
+                case Some(classpath) => Some(classpath)
+                case _ =>
+                  report.error(s"Could not load classname from: ${file.path}")
+                  None
+            case _ =>
+              report.error(s"File extension is not `tasty` or `jar`: ${file.path}")
+              None
+        }
+        .distinct
+      val ctx1 = ctx.fresh
+      val fullClassPath =
+        (newEntries :+ ctx.settings.classpath.value).mkString(java.io.File.pathSeparator.nn)
+      ctx1.setSetting(ctx1.settings.classpath, fullClassPath)
+    else ctx
+
+  /** Entry point to the compiler that can be conveniently used with Java reflection.
+   *
+   *  This entry point can easily be used without depending on the `dotty` package,
+   *  you only need to depend on `dotty-interfaces` and call this method using
+   *  reflection. This allows you to write code that will work against multiple
+   *  versions of dotty without recompilation.
+   *
+   *  The trade-off is that you can only pass a SimpleReporter to this method
+   *  and not a normal Reporter which is more powerful.
+   *
+   *  Usage example: [[https://github.com/lampepfl/dotty/tree/master/compiler/test/dotty/tools/dotc/InterfaceEntryPointTest.scala]]
+   *
+   *  @param args       Arguments to pass to the compiler.
+   *  @param simple     Used to log errors, warnings, and info messages.
+   *                    The default reporter is used if this is `null`.
+   *  @param callback   Used to execute custom code during the compilation
+   *                    process. No callbacks will be executed if this is `null`.
+   *  @return
+   */
+  final def process(args: Array[String], simple: interfaces.SimpleReporter | Null,
+    callback: interfaces.CompilerCallback | Null): interfaces.ReporterResult = {
+    val reporter = if (simple == null) null else Reporter.fromSimpleReporter(simple)
+    process(args, reporter, callback)
+  }
+
+  /** Principal entry point to the compiler.
+   *
+   *  Usage example: [[https://github.com/lampepfl/dotty/tree/master/compiler/test/dotty/tools/dotc/EntryPointsTest.scala.disabled]]
+   *  in method `runCompiler`
+   *
+   *  @param args       Arguments to pass to the compiler.
+   *  @param reporter   Used to log errors, warnings, and info messages.
+   *                    The default reporter is used if this is `null`.
+   *  @param callback   Used to execute custom code during the compilation
+   *                    process. No callbacks will be executed if this is `null`.
+   *  @return           The `Reporter` used. Use `Reporter#hasErrors` to check
+   *                    if compilation succeeded.
+   */
+  final def process(args: Array[String], reporter: Reporter | Null = null,
+    callback: interfaces.CompilerCallback | Null = null): Reporter = {
+    val compileCtx = initCtx.fresh
+    if (reporter != null)
+      compileCtx.setReporter(reporter)
+    if (callback != null)
+      compileCtx.setCompilerCallback(callback)
+    process(args, compileCtx)
+  }
+
+  /** Entry point to the compiler with no optional arguments.
+   *
+   *  This overload is provided for compatibility reasons: the
+   *  `RawCompiler` of sbt expects this method to exist and calls
+   *  it using reflection. Keeping it means that we can change
+   *  the other overloads without worrying about breaking compatibility
+   *  with sbt.
+   */
+  final def process(args: Array[String]): Reporter =
+    process(args, null: Reporter | Null, null: interfaces.CompilerCallback | Null)
+
+  /** Entry point to the compiler using a custom `Context`.
+   *
+   *  In most cases, you do not need a custom `Context` and should
+   *  instead use one of the other overloads of `process`. However,
+   *  the other overloads cannot be overridden, instead you
+   *  should override this one which they call internally.
+   *
+   *  Usage example: [[https://github.com/lampepfl/dotty/tree/master/compiler/test/dotty/tools/dotc/EntryPointsTest.scala.disabled]]
+   *  in method `runCompilerWithContext`
+   *
+   *  @param args       Arguments to pass to the compiler.
+   *  @param rootCtx    The root Context to use.
+   *  @return           The `Reporter` used. Use `Reporter#hasErrors` to check
+   *                    if compilation succeeded.
+   */
+  def process(args: Array[String], rootCtx: Context): Reporter = {
+    setup(args, rootCtx) match
+      case Some((files, compileCtx)) =>
+        doCompile(newCompiler(using compileCtx), files)(using compileCtx)
+      case None =>
+        rootCtx.reporter
+  }
+
+  def main(args: Array[String]): Unit = {
+    // Preload scala.util.control.NonFatal. Otherwise, when trying to catch a StackOverflowError,
+    // we may try to load it but fail with another StackOverflowError and lose the original exception,
+    // see <https://groups.google.com/forum/#!topic/scala-user/kte6nak-zPM>.
+    val _ = NonFatal
+    sys.exit(if (process(args).hasErrors) 1 else 0)
+  }
+}
diff --git a/tests/pos-with-compiler-cc/dotc/Main.scala b/tests/pos-with-compiler-cc/dotc/Main.scala
new file mode 100644
index 000000000000..3288fded52a2
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/Main.scala
@@ -0,0 +1,5 @@
+package dotty.tools
+package dotc
+
+/** Main class of the `dotc` batch compiler. */
+object Main extends Driver
diff --git a/tests/pos-with-compiler-cc/dotc/MissingCoreLibraryException.scala b/tests/pos-with-compiler-cc/dotc/MissingCoreLibraryException.scala
new file mode 100644
index 000000000000..ae20d81226c9
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/MissingCoreLibraryException.scala
@@ -0,0 +1,9 @@
+package dotty.tools.dotc
+
+import dotty.tools.FatalError
+
+class MissingCoreLibraryException(rootPackage: String) extends FatalError(
+  s"""Could not find package $rootPackage from compiler core libraries.
+     |Make sure the compiler core libraries are on the classpath.
+   """.stripMargin
+)
diff --git a/tests/pos-with-compiler-cc/dotc/Resident.scala b/tests/pos-with-compiler-cc/dotc/Resident.scala
new file mode 100644
index 000000000000..0b9bca0dc75b
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/Resident.scala
@@ -0,0 +1,61 @@
+package dotty.tools
+package dotc
+
+import core.Contexts._
+import reporting.Reporter
+import java.io.EOFException
+import scala.annotation.tailrec
+
+/** A compiler which stays resident between runs. This is more of a PoC than
+ *  something that's expected to be used often
+ *
+ *  Usage:
+ *
+ *  > scala dotty.tools.dotc.Resident <options> <initial files>
+ *
+ *  dotc> "more options and files to compile"
+ *
+ *  ...
+ *
+ *  dotc> :reset  // reset all options to the ones passed on the command line
+ *
+ *  ...
+ *
+ *  dotc> :q     // quit
+ */
+class Resident extends Driver {
+
+  object residentCompiler extends Compiler
+
+  override def sourcesRequired: Boolean = false
+
+  private val quit = ":q"
+  private val reset = ":reset"
+  private val prompt = "dotc> "
+
+  private def getLine() = {
+    Console.print(prompt)
+    try scala.io.StdIn.readLine() catch { case _: EOFException => quit }
+  }
+
+  final override def process(args: Array[String], rootCtx: Context): Reporter = {
+    @tailrec def loop(args: Array[String], prevCtx: Context): Reporter = {
+      setup(args, prevCtx) match
+        case Some((files, ctx)) =>
+          inContext(ctx) {
+            doCompile(residentCompiler, files)
+          }
+          var nextCtx = ctx
+          var line = getLine()
+          while (line == reset) {
+            nextCtx = rootCtx
+            line = getLine()
+          }
+          if line.startsWith(quit) then ctx.reporter
+          else loop((line split "\\s+").asInstanceOf[Array[String]], nextCtx)
+        case None =>
+          prevCtx.reporter
+    }
+    loop(args, rootCtx)
+  }
+}
diff --git a/tests/pos-with-compiler-cc/dotc/Run.scala b/tests/pos-with-compiler-cc/dotc/Run.scala
new file mode 100644
index 000000000000..705664177507
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/Run.scala
@@ -0,0 +1,398 @@
+package dotty.tools
+package dotc
+
+import core._
+import Contexts._
+import Periods._
+import Symbols._
+import Scopes._
+import Names.Name
+import Denotations.Denotation
+import typer.Typer
+import typer.ImportInfo.withRootImports
+import Decorators._
+import io.AbstractFile
+import Phases.unfusedPhases
+
+import util._
+import reporting.{Suppression, Action, Profile, ActiveProfile, NoProfile}
+import reporting.Diagnostic
+import reporting.Diagnostic.Warning
+import rewrites.Rewrites
+import profile.Profiler
+import printing.XprintMode
+import typer.ImplicitRunInfo
+import config.Feature
+import StdNames.nme
+
+import java.io.{BufferedWriter, OutputStreamWriter}
+import java.nio.charset.StandardCharsets
+
+import scala.collection.mutable
+import scala.util.control.NonFatal
+import scala.io.Codec
+import caps.unsafe.unsafeUnbox
+
+/** A compiler run. Exports various methods to compile source files */
+class Run(comp: Compiler, ictx: Context) extends ImplicitRunInfo with ConstraintRunInfo {
+
+  /** Default timeout to stop looking for further implicit suggestions, in ms.
+   *  This is usually for the first import suggestion; subsequent suggestions
+   *  may get smaller timeouts. @see ImportSuggestions.reduceTimeBudget
+   */
+  private var myImportSuggestionBudget: Int =
+    Int.MinValue // sentinel value; means whatever is set in command line option
+
+  def importSuggestionBudget =
+    if myImportSuggestionBudget == Int.MinValue then ictx.settings.XimportSuggestionTimeout.value
+    else myImportSuggestionBudget
+
+  def importSuggestionBudget_=(x: Int) =
+    myImportSuggestionBudget = x
+
+  /** If this variable is set to `true`, some core typer operations will
+   *  return immediately. Currently these early abort operations are
+   *  `Typer.typed` and `Implicits.typedImplicit`.
+   */
+  @volatile var isCancelled = false
+
+  private var compiling = false
+
+  private var myUnits: List[CompilationUnit] = Nil
+  private var myUnitsCached: List[CompilationUnit] = Nil
+  private var myFiles: Set[AbstractFile] = _
+
+  // `@nowarn` annotations by source file, populated during typer
+  private val mySuppressions: mutable.LinkedHashMap[SourceFile, mutable.ListBuffer[Suppression]] = mutable.LinkedHashMap.empty
+  // source files whose `@nowarn` annotations are processed
+  private val mySuppressionsComplete: mutable.Set[SourceFile] = mutable.Set.empty
+  // warnings issued before a source file's `@nowarn` annotations are processed, suspended so that `@nowarn` can filter them
+  private val mySuspendedMessages: mutable.LinkedHashMap[SourceFile, mutable.LinkedHashSet[Warning]] = mutable.LinkedHashMap.empty
+
+  object suppressions:
+    // When the REPL creates a new run (ReplDriver.compile), parsing is already done in the old context, with the
+    // previous Run. Parser warnings were suspended in the old run and need to be copied over so they are not lost.
+    // Same as scala/scala/commit/79ca1408c7.
+    def initSuspendedMessages(oldRun: Run | Null) = if oldRun != null then
+      mySuspendedMessages.clear()
+      mySuspendedMessages ++= oldRun.mySuspendedMessages
+
+    def suppressionsComplete(source: SourceFile) = source == NoSource || mySuppressionsComplete(source)
+
+    def addSuspendedMessage(warning: Warning) =
+      mySuspendedMessages.getOrElseUpdate(warning.pos.source, mutable.LinkedHashSet.empty) += warning
+
+    def nowarnAction(dia: Diagnostic): Action.Warning.type | Action.Verbose.type | Action.Silent.type =
+      mySuppressions.getOrElse(dia.pos.source, Nil).find(_.matches(dia)) match {
+        case Some(s) =>
+          s.markUsed()
+          if (s.verbose) Action.Verbose
+          else Action.Silent
+        case _ =>
+          Action.Warning
+      }
+
+    def addSuppression(sup: Suppression): Unit =
+      val source = sup.annotPos.source
+      mySuppressions.getOrElseUpdate(source, mutable.ListBuffer.empty) += sup
+
+    def reportSuspendedMessages(source: SourceFile)(using Context): Unit = {
+      // sort suppressions. they are not added in any particular order because of lazy type completion
+      for (sups <- mySuppressions.get(source))
+        mySuppressions(source) = sups.sortBy(sup => 0 - sup.start)
+      mySuppressionsComplete += source
+      mySuspendedMessages.remove(source).foreach(_.foreach(ctx.reporter.issueIfNotSuppressed))
+    }
+
+    def runFinished(hasErrors: Boolean): Unit =
+      // report suspended messages (in case the run finished before typer)
+      mySuspendedMessages.keysIterator.toList.foreach(reportSuspendedMessages)
+      // report unused nowarns only if all all phases are done
+      if !hasErrors && ctx.settings.WunusedHas.nowarn then
+        for {
+          source <- mySuppressions.keysIterator.toList
+          sups   <- mySuppressions.remove(source)
+          sup    <- sups.reverse
+        } if (!sup.used)
+          report.warning("@nowarn annotation does not suppress any warnings", sup.annotPos)
+
+  /** The compilation units currently being compiled, this may return different
+   *  results over time.
+   */
+  def units: List[CompilationUnit] = myUnits
+
+  private def units_=(us: List[CompilationUnit]): Unit =
+    myUnits = us
+
+  var suspendedUnits: mutable.ListBuffer[CompilationUnit] = mutable.ListBuffer()
+
+  def checkSuspendedUnits(newUnits: List[CompilationUnit])(using Context): Unit =
+    if newUnits.isEmpty && suspendedUnits.nonEmpty && !ctx.reporter.errorsReported then
+      val where =
+        if suspendedUnits.size == 1 then i"in ${suspendedUnits.head}."
+        else i"""among
+                |
+                |  ${suspendedUnits.toList}%, %
+                |"""
+      val enableXprintSuspensionHint =
+        if ctx.settings.XprintSuspension.value then ""
+        else "\n\nCompiling with  -Xprint-suspension   gives more information."
+      report.error(em"""Cyclic macro dependencies $where
+                    |Compilation stopped since no further progress can be made.
+                    |
+                    |To fix this, place macros in one set of files and their callers in another.$enableXprintSuspensionHint""")
+
+  /** The files currently being compiled (active or suspended).
+   *  This may return different results over time.
+   *  These files do not have to be source files since it's possible to compile
+   *  from TASTY.
+   */
+  def files: Set[AbstractFile] = {
+    if (myUnits ne myUnitsCached) {
+      myUnitsCached = myUnits
+      myFiles = (myUnits ++ suspendedUnits).map(_.source.file).toSet
+    }
+    myFiles
+  }
+
+  /** The source files of all late entered symbols, as a set */
+  private var lateFiles = mutable.Set[AbstractFile]()
+
+  /** A cache for static references to packages and classes */
+  val staticRefs = util.EqHashMap[Name, Denotation](initialCapacity = 1024)
+
+  /** Actions that need to be performed at the end of the current compilation run */
+  private var finalizeActions = mutable.ListBuffer[() => Unit]()
+
+  /** Will be set to true if any of the compiled compilation units contains
+   *  a pureFunctions language import.
+   */
+  var pureFunsImportEncountered = false
+
+  /** Will be set to true if any of the compiled compilation units contains
+   *  a captureChecking language import.
+   */
+  var ccImportEncountered = false
+
+  def compile(files: List[AbstractFile]): Unit =
+    try
+      val sources = files.map(runContext.getSource(_))
+      compileSources(sources)
+    catch
+      case NonFatal(ex) =>
+        if units.nonEmpty then report.echo(i"exception occurred while compiling $units%, %")
+        else report.echo(s"exception occurred while compiling ${files.map(_.name).mkString(", ")}")
+        throw ex
+
+  /** TODO: There's a fundamental design problem here: We assemble phases using `fusePhases`
+   *  when we first build the compiler. But we modify them with -Yskip, -Ystop
+   *  on each run. That modification needs to either transform the tree structure,
+   *  or we need to assemble phases on each run, and take -Yskip, -Ystop into
+   *  account. I think the latter would be preferable.
+   */
+  def compileSources(sources: List[SourceFile]): Unit =
+    if (sources forall (_.exists)) {
+      units = sources.map(CompilationUnit(_))
+      compileUnits()
+    }
+
+
+  def compileUnits(us: List[CompilationUnit]): Unit = {
+    units = us
+    compileUnits()
+  }
+
+  def compileUnits(us: List[CompilationUnit], ctx: Context): Unit = {
+    units = us
+    compileUnits()(using ctx)
+  }
+
+  var profile: Profile = NoProfile
+
+  private def compileUnits()(using Context) = Stats.maybeMonitored {
+    if (!ctx.mode.is(Mode.Interactive)) // IDEs might have multi-threaded access, accesses are synchronized
+      ctx.base.checkSingleThreaded()
+
+    compiling = true
+
+    profile =
+      if ctx.settings.Vprofile.value
+        || !ctx.settings.VprofileSortedBy.value.isEmpty
+        || ctx.settings.VprofileDetails.value != 0
+      then ActiveProfile(ctx.settings.VprofileDetails.value.max(0).min(1000))
+      else NoProfile
+
+    // If testing pickler, make sure to stop after pickling phase:
+    val stopAfter =
+      if (ctx.settings.YtestPickler.value) List("pickler")
+      else ctx.settings.YstopAfter.value
+
+    val pluginPlan = ctx.base.addPluginPhases(ctx.base.phasePlan)
+    val phases = ctx.base.fusePhases(pluginPlan,
+      ctx.settings.Yskip.value, ctx.settings.YstopBefore.value, stopAfter, ctx.settings.Ycheck.value)
+    ctx.base.usePhases(phases)
+
+    def runPhases(using Context) = {
+      var lastPrintedTree: PrintedTree = NoPrintedTree
+      val profiler = ctx.profiler
+      var phasesWereAdjusted = false
+
+      for (phase <- ctx.base.allPhases)
+        if (phase.isRunnable)
+          Stats.trackTime(s"$phase ms ") {
+            val start = System.currentTimeMillis
+            val profileBefore = profiler.beforePhase(phase)
+            units = phase.runOn(units)
+            profiler.afterPhase(phase, profileBefore)
+            if (ctx.settings.Xprint.value.containsPhase(phase))
+              for (unit <- units)
+                lastPrintedTree =
+                  printTree(lastPrintedTree)(using ctx.fresh.setPhase(phase.next).setCompilationUnit(unit))
+            report.informTime(s"$phase ", start)
+            Stats.record(s"total trees at end of $phase", ast.Trees.ntrees)
+            for (unit <- units)
+              Stats.record(s"retained typed trees at end of $phase", unit.tpdTree.treeSize)
+            ctx.typerState.gc()
+          }
+          if !phasesWereAdjusted then
+            phasesWereAdjusted = true
+            if !Feature.ccEnabledSomewhere then
+              ctx.base.unlinkPhaseAsDenotTransformer(Phases.checkCapturesPhase.prev)
+              ctx.base.unlinkPhaseAsDenotTransformer(Phases.checkCapturesPhase)
+
+      profiler.finished()
+    }
+
+    val runCtx = ctx.fresh
+    runCtx.setProfiler(Profiler())
+    unfusedPhases.foreach(_.initContext(runCtx))
+    runPhases(using runCtx)
+    if (!ctx.reporter.hasErrors)
+      Rewrites.writeBack()
+    suppressions.runFinished(hasErrors = ctx.reporter.hasErrors)
+    while (finalizeActions.nonEmpty) {
+      val action = finalizeActions.remove(0).unsafeUnbox
+      action()
+    }
+    compiling = false
+  }
+
+  /** Enter top-level definitions of classes and objects contained in source file `file`.
+   *  The newly added symbols replace any previously entered symbols.
+   *  If `typeCheck = true`, also run typer on the compilation unit, and set
+   *  `rootTreeOrProvider`.
+   */
+  def lateCompile(file: AbstractFile, typeCheck: Boolean)(using Context): Unit =
+    if (!files.contains(file) && !lateFiles.contains(file)) {
+      lateFiles += file
+
+      val unit = CompilationUnit(ctx.getSource(file))
+      val unitCtx = runContext.fresh
+        .setCompilationUnit(unit)
+        .withRootImports
+
+      def process()(using Context) =
+        ctx.typer.lateEnterUnit(doTypeCheck =>
+          if typeCheck then
+            if compiling then finalizeActions += doTypeCheck
+            else doTypeCheck()
+        )
+
+      process()(using unitCtx)
+    }
+
+  private sealed trait PrintedTree
+  private /*final*/ case class SomePrintedTree(phase: String, tree: String) extends PrintedTree
+  private object NoPrintedTree extends PrintedTree
+
+  private def printTree(last: PrintedTree)(using Context): PrintedTree = {
+    val unit = ctx.compilationUnit
+    val fusedPhase = ctx.phase.prevMega
+    val echoHeader = f"[[syntax trees at end of $fusedPhase%25s]] // ${unit.source}"
+    val tree = if ctx.isAfterTyper then unit.tpdTree else unit.untpdTree
+    val treeString = fusedPhase.show(tree)
+
+    last match {
+      case SomePrintedTree(phase, lastTreeString) if lastTreeString == treeString =>
+        report.echo(s"$echoHeader: unchanged since $phase")
+        last
+
+      case SomePrintedTree(phase, lastTreeString) if ctx.settings.XprintDiff.value || ctx.settings.XprintDiffDel.value =>
+        val diff = DiffUtil.mkColoredCodeDiff(treeString, lastTreeString, ctx.settings.XprintDiffDel.value)
+        report.echo(s"$echoHeader\n$diff\n")
+        SomePrintedTree(fusedPhase.phaseName, treeString)
+
+      case _ =>
+        report.echo(s"$echoHeader\n$treeString\n")
+        SomePrintedTree(fusedPhase.phaseName, treeString)
+    }
+  }
+
+  def compileFromStrings(scalaSources: List[String], javaSources: List[String] = Nil): Unit = {
+    def sourceFile(source: String, isJava: Boolean): SourceFile = {
+      val uuid = java.util.UUID.randomUUID().toString
+      val ext = if (isJava) "java" else "scala"
+      val name = s"compileFromString-$uuid.$ext"
+      SourceFile.virtual(name, source)
+    }
+    val sources =
+      scalaSources.map(sourceFile(_, isJava = false)) ++
+       javaSources.map(sourceFile(_, isJava = true))
+
+    compileSources(sources)
+  }
+
+  /** Print summary of warnings and errors encountered */
+  def printSummary(): Unit = {
+    printMaxConstraint()
+    val r = runContext.reporter
+    if !r.errorsReported then
+      profile.printSummary()
+    r.summarizeUnreportedWarnings()
+    r.printSummary()
+  }
+
+  override def reset(): Unit = {
+    super[ImplicitRunInfo].reset()
+    super[ConstraintRunInfo].reset()
+    myCtx = null
+    myUnits = Nil
+    myUnitsCached = Nil
+  }
+
+  /** Produces the following contexts, from outermost to innermost
+   *
+   *    bootStrap:   A context with next available runId and a scope consisting of
+   *                 the RootPackage _root_
+   *    start        A context with RootClass as owner and the necessary initializations
+   *                 for type checking.
+   *    imports      For each element of RootImports, an import context
+   */
+  protected def rootContext(using Context): Context = {
+    ctx.initialize()
+    ctx.base.setPhasePlan(comp.phases)
+    val rootScope = new MutableScope(0)
+    val bootstrap = ctx.fresh
+      .setPeriod(Period(comp.nextRunId, FirstPhaseId))
+      .setScope(rootScope)
+    rootScope.enter(ctx.definitions.RootPackage)(using bootstrap)
+    var start = bootstrap.fresh
+      .setOwner(defn.RootClass)
+      .setTyper(new Typer)
+      .addMode(Mode.ImplicitsEnabled)
+      .setTyperState(ctx.typerState.fresh(ctx.reporter))
+    if ctx.settings.YexplicitNulls.value && !Feature.enabledBySetting(nme.unsafeNulls) then
+      start = start.addMode(Mode.SafeNulls)
+    ctx.initialize()(using start) // re-initialize the base context with start
+
+    // `this` must be unchecked for safe initialization because by being passed to setRun during
+    // initialization, it is not yet considered fully initialized by the initialization checker
+    start.setRun(this: @unchecked)
+  }
+
+  private var myCtx: Context | Null = rootContext(using ictx)
+
+  /** The context created for this run */
+  given runContext[Dummy_so_its_a_def]: Context = myCtx.nn
+  assert(runContext.runId <= Periods.MaxPossibleRunId)
+}
diff --git a/tests/pos-with-compiler-cc/dotc/ScalacCommand.scala b/tests/pos-with-compiler-cc/dotc/ScalacCommand.scala
new file mode 100644
index 000000000000..2e0d9a08f25d
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/ScalacCommand.scala
@@ -0,0 +1,9 @@
+package dotty.tools.dotc
+
+import config.Properties._
+import config.CompilerCommand
+
+object ScalacCommand extends CompilerCommand:
+  override def cmdName: String = "scalac"
+  override def versionMsg: String = s"Scala compiler $versionString -- $copyrightString"
+  override def ifErrorsMsg: String = "  scalac -help  gives more information"
diff --git a/tests/pos-with-compiler-cc/dotc/ast/CheckTrees.scala.disabled b/tests/pos-with-compiler-cc/dotc/ast/CheckTrees.scala.disabled
new file mode 100644
index 000000000000..6bf7530faf24
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/ast/CheckTrees.scala.disabled
@@ -0,0 +1,258 @@
+package dotty.tools
+package dotc
+package ast
+
+import core._
+import util.Spans._, Types._, Contexts._, Constants._, Names._, Flags._
+import SymDenotations._, Symbols._, StdNames._, Annotations._, Trees._
+
+// TODO: revise, integrate in a checking phase.
+object CheckTrees {
+
+  import tpd._
+
+  def check(p: Boolean, msg: => String = "")(using Context): Unit = assert(p, msg)
+
+  def checkTypeArg(arg: Tree, bounds: TypeBounds)(using Context): Unit = {
+    check(arg.isValueType)
+    check(bounds contains arg.tpe)
+  }
+
+  def escapingRefs(block: Block)(using Context): collection.Set[NamedType] = {
+    var hoisted: Set[Symbol] = Set()
+    lazy val locals = ctx.typeAssigner.localSyms(block.stats).toSet
+    def isLocal(sym: Symbol): Boolean =
+      (locals contains sym) && !isHoistableClass(sym)
+    def isHoistableClass(sym: Symbol) =
+      sym.isClass && {
+        (hoisted contains sym) || {
+          hoisted += sym
+          !classLeaks(sym.asClass)
+        }
+      }
+    def leakingTypes(tp: Type): collection.Set[NamedType] =
+      tp namedPartsWith (tp => isLocal(tp.symbol))
+    def typeLeaks(tp: Type): Boolean = leakingTypes(tp).nonEmpty
+    def classLeaks(sym: ClassSymbol): Boolean =
+      (ctx.owner is Method) || // can't hoist classes out of method bodies
+      (sym.info.parents exists typeLeaks) ||
+      (sym.decls.toList exists (t => typeLeaks(t.info)))
+    leakingTypes(block.tpe)
+  }
+
+  def checkType(tree: Tree)(using Context): Unit = tree match {
+    case Ident(name) =>
+    case Select(qualifier, name) =>
+      check(qualifier.isValue)
+      check(qualifier.tpe =:= tree.tpe.normalizedPrefix)
+      val denot = qualifier.tpe.member(name)
+      check(denot.exists)
+      check(denot.hasAltWith(_.symbol == tree.symbol))
+    case This(cls) =>
+    case Super(qual, mixin) =>
+      check(qual.isValue)
+      val cls = qual.tpe.typeSymbol
+      check(cls.isClass)
+    case Apply(fn, args) =>
+      def checkArg(arg: Tree, name: Name, formal: Type): Unit = {
+        arg match {
+          case NamedArg(argName, _) =>
+            check(argName == name)
+          case _ =>
+            check(arg.isValue)
+        }
+        check(arg.tpe <:< formal)
+      }
+      val MethodType(paramNames, paramTypes) = fn.tpe.widen // checked already at construction
+      args.lazyZip(paramNames).lazyZip(paramTypes) foreach checkArg
+    case TypeApply(fn, args) =>
+      val pt @ PolyType(_) = fn.tpe.widen // checked already at construction
+      args.lazyZip(pt.instantiateBounds(args map (_.tpe))) foreach checkTypeArg
+    case Literal(const: Constant) =>
+    case New(tpt) =>
+      check(tpt.isValueType)
+      val cls = tpt.tpe.typeSymbol
+      check(cls.isClass)
+      check(!(cls is AbstractOrTrait))
+    case Pair(left, right) =>
+      check(left.isValue)
+      check(right.isValue)
+    case Typed(expr, tpt) =>
+      check(tpt.isValueType)
+      expr.tpe.widen match {
+        case tp: MethodType =>
+          val cls = tpt.tpe.typeSymbol
+          check(cls.isClass)
+          check((cls is Trait) ||
+                cls.primaryConstructor.info.paramTypess.flatten.isEmpty)
+          val absMembers = tpt.tpe.abstractTermMembers
+          check(absMembers.size == 1)
+          check(tp <:< absMembers.head.info)
+        case _ =>
+          check(expr.isValueOrPattern)
+          check(expr.tpe <:< tpt.tpe.translateParameterized(defn.RepeatedParamClass, defn.SeqClass))
+      }
+    case NamedArg(name, arg) =>
+    case Assign(lhs, rhs) =>
+      check(lhs.isValue); check(rhs.isValue)
+      lhs.tpe match {
+        case ltpe: TermRef =>
+          check(ltpe.symbol is Mutable)
+        case _ =>
+          check(false)
+      }
+      check(rhs.tpe <:< lhs.tpe.widen)
+    case tree @ Block(stats, expr) =>
+      check(expr.isValue)
+      check(escapingRefs(tree).isEmpty)
+    case If(cond, thenp, elsep) =>
+      check(cond.isValue); check(thenp.isValue); check(elsep.isValue)
+      check(cond.tpe isRef defn.BooleanClass)
+    case Closure(env, meth, target) =>
+   	  meth.tpe.widen match {
+   	    case mt @ MethodType(_, paramTypes) =>
+   	      if (target.isEmpty) {
+   	        check(env.length < paramTypes.length)
+   	        for ((arg, formal) <- env zip paramTypes)
+   	          check(arg.tpe <:< formal)
+   	      }
+   	      else
+   	        // env is stored in class, not method
+   	        target.tpe match {
+   	          case SAMType(targetMeth) =>
+   	            check(mt <:< targetMeth.info)
+   	        }
+   	  }
+    case Match(selector, cases) =>
+      check(selector.isValue)
+      // are any checks that relate selector and patterns desirable?
+    case CaseDef(pat, guard, body) =>
+      check(pat.isValueOrPattern); check(guard.isValue); check(body.isValue)
+      check(guard.tpe.derivesFrom(defn.BooleanClass))
+    case Return(expr, from) =>
+      check(expr.isValue); check(from.isTerm)
+      check(from.tpe.termSymbol.isRealMethod)
+    case Try(block, handler, finalizer) =>
+      check(block.isTerm)
+      check(finalizer.isTerm)
+      check(handler.isTerm)
+      check(handler.tpe derivesFrom defn.FunctionClass(1))
+      check(handler.tpe.baseArgInfos(defn.FunctionClass(1)).head <:< defn.ThrowableType)
+    case Throw(expr) =>
+      check(expr.isValue)
+      check(expr.tpe.derivesFrom(defn.ThrowableClass))
+    case SeqLiteral(elems) =>
+      val elemtp = tree.tpe.elemType
+      for (elem <- elems) {
+        check(elem.isValue)
+        check(elem.tpe <:< elemtp)
+      }
+    case TypeTree(original) =>
+      if (!original.isEmpty) {
+        check(original.isValueType)
+        check(original.tpe == tree.tpe)
+      }
+    case SingletonTypeTree(ref) =>
+      check(ref.isValue)
+      check(ref.symbol.isStable)
+    case SelectFromTypeTree(qualifier, name) =>
+      check(qualifier.isValueType)
+      check(qualifier.tpe =:= tree.tpe.normalizedPrefix)
+      val denot = qualifier.tpe.member(name)
+      check(denot.exists)
+      check(denot.symbol == tree.symbol)
+    case AndTypeTree(left, right) =>
+      check(left.isValueType); check(right.isValueType)
+    case OrTypeTree(left, right) =>
+      check(left.isValueType); check(right.isValueType)
+    case RefinedTypeTree(tpt, refinements) =>
+      check(tpt.isValueType)
+      def checkRefinements(forbidden: Set[Symbol], rs: List[Tree]): Unit = rs match {
+        case r :: rs1 =>
+          val rsym = r.symbol
+          check(rsym.isTerm || rsym.isAbstractOrAliasType)
+          if (rsym.isAbstractType) check(tpt.tpe.member(rsym.name).exists)
+          check(rsym.info forallParts {
+            case nt: NamedType => !(forbidden contains nt.symbol)
+            case _ => true
+          })
+          checkRefinements(forbidden - rsym, rs1)
+        case nil =>
+      }
+      checkRefinements(ctx.typeAssigner.localSyms(refinements).toSet, refinements)
+    case AppliedTypeTree(tpt, args) =>
+      check(tpt.isValueType)
+      val tparams = tpt.tpe.typeParams
+      check(sameLength(tparams, args))
+      args.lazyZip(tparams map (_.info.bounds)) foreach checkTypeArg
+    case TypeBoundsTree(lo, hi) =>
+      check(lo.isValueType); check(hi.isValueType)
+      check(lo.tpe <:< hi.tpe)
+    case Bind(sym, body) =>
+      check(body.isValueOrPattern)
+      check(!(tree.symbol is Method))
+      body match {
+        case Ident(nme.WILDCARD) =>
+        case _ => check(body.tpe.widen =:= tree.symbol.info)
+      }
+    case Alternative(alts) =>
+      for (alt <- alts) check(alt.isValueOrPattern)
+    case UnApply(fun, implicits, args) => // todo: review
+      check(fun.isTerm)
+      for (arg <- args) check(arg.isValueOrPattern)
+      val funtpe @ MethodType(_, _) = fun.tpe.widen
+      fun.symbol.name match { // check arg arity
+        case nme.unapplySeq =>
+          // args need to be wrapped in (...: _*)
+          check(args.length == 1)
+          check(args.head.isInstanceOf[SeqLiteral])
+        case nme.unapply =>
+          val rtp = funtpe.resultType
+          if (rtp isRef defn.BooleanClass)
+            check(args.isEmpty)
+          else {
+            check(rtp isRef defn.OptionClass)
+            val normArgs = rtp.argTypesHi match {
+              case optionArg :: Nil =>
+                optionArg.argTypesHi match {
+                  case Nil =>
+                    optionArg :: Nil
+                  case tupleArgs if defn.isTupleNType(optionArg) =>
+                    tupleArgs
+                }
+              case _ =>
+                check(false)
+                Nil
+            }
+            check(sameLength(normArgs, args))
+          }
+      }
+    case ValDef(mods, name, tpt, rhs) =>
+      check(!(tree.symbol is Method))
+      if (!rhs.isEmpty) {
+        check(rhs.isValue)
+        check(rhs.tpe <:< tpt.tpe)
+      }
+    case DefDef(mods, name, tparams, vparamss, tpt, rhs) =>
+      check(tree.symbol is Method)
+      if (!rhs.isEmpty) {
+        check(rhs.isValue)
+        check(rhs.tpe <:< tpt.tpe)
+      }
+    case TypeDef(mods, name, tpt) =>
+      check(tpt.isInstanceOf[Template] || tpt.tpe.isInstanceOf[TypeBounds])
+    case Template(constr, parents, selfType, body) =>
+    case Import(expr, selectors) =>
+      check(expr.isValue)
+      check(expr.tpe.termSymbol.isStable)
+    case PackageDef(pid, stats) =>
+      check(pid.isTerm)
+      check(pid.symbol is Package)
+    case Annotated(annot, arg) =>
+      check(annot.isInstantiation)
+      check(annot.symbol.owner.isSubClass(defn.AnnotationClass))
+      check(arg.isValueType || arg.isValue)
+    case EmptyTree =>
+  }
+}
+
diff --git a/tests/pos-with-compiler-cc/dotc/ast/Desugar.scala b/tests/pos-with-compiler-cc/dotc/ast/Desugar.scala
new file mode 100644
index 000000000000..ba2c8f5f43e6
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/ast/Desugar.scala
@@ -0,0 +1,1968 @@
+package dotty.tools
+package dotc
+package ast
+
+import core._
+import util.Spans._, Types._, Contexts._, Constants._, Names._, NameOps._, Flags._
+import Symbols._, StdNames._, Trees._, ContextOps._
+import Decorators._, transform.SymUtils._
+import NameKinds.{UniqueName, EvidenceParamName, DefaultGetterName, WildcardParamName}
+import typer.{Namer, Checking}
+import util.{Property, SourceFile, SourcePosition, Chars}
+import config.Feature.{sourceVersion, migrateTo3, enabled}
+import config.SourceVersion._
+import collection.mutable.ListBuffer
+import reporting._
+import annotation.constructorOnly
+import printing.Formatting.hl
+import config.Printers
+
+import scala.annotation.internal.sharable
+
+object desugar {
+  import untpd._
+  import DesugarEnums._
+
+  /** An attachment for companion modules of classes that have a `derives` clause.
+   *  The position value indicates the start position of the template of the
+   *  deriving class.
+   */
+  val DerivingCompanion: Property.Key[SourcePosition] = Property.Key()
+
+  /** An attachment for match expressions generated from a PatDef or GenFrom.
+   *  Value of key == one of IrrefutablePatDef, IrrefutableGenFrom
+   */
+  val CheckIrrefutable: Property.Key[MatchCheck] = Property.StickyKey()
+
+  /** A multi-line infix operation with the infix operator starting a new line.
+   *  Used for explaining potential errors.
+   */
+  val MultiLineInfix: Property.Key[Unit] = Property.StickyKey()
+
+  /** An attachment key to indicate that a ValDef originated from parameter untupling.
+   */
+  val UntupledParam: Property.Key[Unit] = Property.StickyKey()
+
+  /** What static check should be applied to a Match? */
+  enum MatchCheck {
+    case None, Exhaustive, IrrefutablePatDef, IrrefutableGenFrom
+  }
+
+  /** Is `name` the name of a method that can be invalidated as a compiler-generated
+   *  case class method if it clashes with a user-defined method?
+   */
+  def isRetractableCaseClassMethodName(name: Name)(using Context): Boolean = name match {
+    case nme.apply | nme.unapply | nme.unapplySeq | nme.copy => true
+    case DefaultGetterName(nme.copy, _) => true
+    case _ => false
+  }
+
+  /** Is `name` the name of a method that is added unconditionally to case classes? */
+  def isDesugaredCaseClassMethodName(name: Name)(using Context): Boolean =
+    isRetractableCaseClassMethodName(name) || name.isSelectorName
+
+// ----- DerivedTypeTrees -----------------------------------
+
+  class SetterParamTree(implicit @constructorOnly src: SourceFile) extends DerivedTypeTree {
+    def derivedTree(sym: Symbol)(using Context): tpd.TypeTree = tpd.TypeTree(sym.info.resultType)
+  }
+
+  class TypeRefTree(implicit @constructorOnly src: SourceFile) extends DerivedTypeTree {
+    def derivedTree(sym: Symbol)(using Context): tpd.TypeTree = tpd.TypeTree(sym.typeRef)
+  }
+
+  class TermRefTree(implicit @constructorOnly src: SourceFile) extends DerivedTypeTree {
+    def derivedTree(sym: Symbol)(using Context): tpd.Tree = tpd.ref(sym)
+  }
+
+  /** A type tree that computes its type from an existing parameter. */
+  class DerivedFromParamTree()(implicit @constructorOnly src: SourceFile) extends DerivedTypeTree {
+
+    /** Complete the appropriate constructors so that OriginalSymbol attachments are
+     *  pushed to DerivedTypeTrees.
+     */
+    override def ensureCompletions(using Context): Unit = {
+      def completeConstructor(sym: Symbol) =
+        sym.infoOrCompleter match {
+          case completer: Namer#ClassCompleter =>
+            completer.completeConstructor(sym)
+          case _ =>
+        }
+
+      if (!ctx.owner.is(Package))
+        if (ctx.owner.isClass) {
+          completeConstructor(ctx.owner)
+          if (ctx.owner.is(ModuleClass))
+            completeConstructor(ctx.owner.linkedClass)
+        }
+        else ensureCompletions(using ctx.outer)
+    }
+
+    /** Return info of original symbol, where all references to siblings of the
+     *  original symbol (i.e. sibling and original symbol have the same owner)
+     *  are rewired to same-named parameters or accessors in the scope enclosing
+     *  the current scope. The current scope is the scope owned by the defined symbol
+     *  itself, that's why we have to look one scope further out. If the resulting
+     *  type is an alias type, dealias it. This is necessary because the
+     *  accessor of a type parameter is a private type alias that cannot be accessed
+     *  from subclasses.
+     */
+    def derivedTree(sym: Symbol)(using Context): tpd.TypeTree = {
+      val relocate = new TypeMap {
+        val originalOwner = sym.owner
+        def apply(tp: Type) = tp match {
+          case tp: NamedType if tp.symbol.exists && (tp.symbol.owner eq originalOwner) =>
+            val defctx = mapCtx.outersIterator.dropWhile(_.scope eq mapCtx.scope).next()
+            var local = defctx.denotNamed(tp.name).suchThat(_.isParamOrAccessor).symbol
+            if (local.exists) (defctx.owner.thisType select local).dealiasKeepAnnots
+            else {
+              def msg =
+                s"no matching symbol for ${tp.symbol.showLocated} in ${defctx.owner} / ${defctx.effectiveScope.toList}"
+              ErrorType(msg).assertingErrorsReported(msg)
+            }
+          case _ =>
+            mapOver(tp)
+        }
+      }
+      tpd.TypeTree(relocate(sym.info))
+    }
+  }
+
+  /** A type definition copied from `tdef` with a rhs typetree derived from it */
+  def derivedTypeParam(tdef: TypeDef)(using Context): TypeDef =
+    cpy.TypeDef(tdef)(
+      rhs = DerivedFromParamTree().withSpan(tdef.rhs.span).watching(tdef)
+    )
+
+  /** A derived type definition watching `sym` */
+  def derivedTypeParamWithVariance(sym: TypeSymbol)(using Context): TypeDef =
+    val variance = VarianceFlags & sym.flags
+    TypeDef(sym.name, DerivedFromParamTree().watching(sym)).withFlags(TypeParam | Synthetic | variance)
+
+  /** A value definition copied from `vdef` with a tpt typetree derived from it */
+  def derivedTermParam(vdef: ValDef)(using Context): ValDef =
+    cpy.ValDef(vdef)(
+      tpt = DerivedFromParamTree().withSpan(vdef.tpt.span).watching(vdef))
+
+// ----- Desugar methods -------------------------------------------------
+
+  /** Setter generation is needed for:
+   *    - non-private class members
+   *    - all trait members
+   *    - all package object members
+   */
+  def isSetterNeeded(valDef: ValDef)(using Context): Boolean = {
+    val mods = valDef.mods
+    mods.is(Mutable)
+      && ctx.owner.isClass
+      && (!mods.is(Private) || ctx.owner.is(Trait) || ctx.owner.isPackageObject)
+  }
+
+  /**   var x: Int = expr
+   *  ==>
+   *    def x: Int = expr
+   *    def x_=($1: <TypeTree()>): Unit = ()
+   *
+   *  Generate setter where needed
+   */
+  def valDef(vdef0: ValDef)(using Context): Tree = {
+    val vdef @ ValDef(_, tpt, rhs) = vdef0
+    val mods = vdef.mods
+
+    val valName = normalizeName(vdef, tpt).asTermName
+    val vdef1 = cpy.ValDef(vdef)(name = valName)
+
+    if (isSetterNeeded(vdef)) {
+      // TODO: copy of vdef as getter needed?
+      // val getter = ValDef(mods, name, tpt, rhs) withPos vdef.pos?
+      // right now vdef maps via expandedTree to a thicket which concerns itself.
+      // I don't see a problem with that but if there is one we can avoid it by making a copy here.
+      val setterParam = makeSyntheticParameter(tpt = SetterParamTree().watching(vdef))
+      // The rhs gets filled in later, when field is generated and getter has parameters (see Memoize miniphase)
+      val setterRhs = if (vdef.rhs.isEmpty) EmptyTree else unitLiteral
+      val setter = cpy.DefDef(vdef)(
+        name    = valName.setterName,
+        paramss = (setterParam :: Nil) :: Nil,
+        tpt     = TypeTree(defn.UnitType),
+        rhs     = setterRhs
+      ).withMods((mods | Accessor) &~ (CaseAccessor | GivenOrImplicit | Lazy))
+       .dropEndMarker() // the end marker should only appear on the getter definition
+      Thicket(vdef1, setter)
+    }
+    else vdef1
+  }
+
+  def makeImplicitParameters(tpts: List[Tree], implicitFlag: FlagSet, forPrimaryConstructor: Boolean = false)(using Context): List[ValDef] =
+    for (tpt <- tpts) yield {
+       val paramFlags: FlagSet = if (forPrimaryConstructor) LocalParamAccessor else Param
+       val epname = EvidenceParamName.fresh()
+       ValDef(epname, tpt, EmptyTree).withFlags(paramFlags | implicitFlag)
+    }
+
+  def mapParamss(paramss: List[ParamClause])
+                (mapTypeParam: TypeDef => TypeDef)
+                (mapTermParam: ValDef => ValDef)(using Context): List[ParamClause] =
+    paramss.mapConserve {
+      case TypeDefs(tparams) => tparams.mapConserve(mapTypeParam)
+      case ValDefs(vparams) => vparams.mapConserve(mapTermParam)
+      case _ => unreachable()
+    }
+
+  /** 1. Expand context bounds to evidence params. E.g.,
+   *
+   *      def f[T >: L <: H : B](params)
+   *  ==>
+   *      def f[T >: L <: H](params)(implicit evidence$0: B[T])
+   *
+   *  2. Expand default arguments to default getters. E.g,
+   *
+   *      def f[T: B](x: Int = 1)(y: String = x + "m") = ...
+   *  ==>
+   *      def f[T](x: Int)(y: String)(implicit evidence$0: B[T]) = ...
+   *      def f$default$1[T] = 1
+   *      def f$default$2[T](x: Int) = x + "m"
+   */
+  private def defDef(meth: DefDef, isPrimaryConstructor: Boolean = false)(using Context): Tree =
+    addDefaultGetters(elimContextBounds(meth, isPrimaryConstructor))
+
+  private def elimContextBounds(meth: DefDef, isPrimaryConstructor: Boolean)(using Context): DefDef =
+    val DefDef(_, paramss, tpt, rhs) = meth
+    val evidenceParamBuf = ListBuffer[ValDef]()
+
+    def desugarContextBounds(rhs: Tree): Tree = rhs match
+      case ContextBounds(tbounds, cxbounds) =>
+        val iflag = if sourceVersion.isAtLeast(`future`) then Given else Implicit
+        evidenceParamBuf ++= makeImplicitParameters(
+          cxbounds, iflag, forPrimaryConstructor = isPrimaryConstructor)
+        tbounds
+      case LambdaTypeTree(tparams, body) =>
+        cpy.LambdaTypeTree(rhs)(tparams, desugarContextBounds(body))
+      case _ =>
+        rhs
+
+    val paramssNoContextBounds =
+      mapParamss(paramss) {
+        tparam => cpy.TypeDef(tparam)(rhs = desugarContextBounds(tparam.rhs))
+      }(identity)
+
+    rhs match
+      case MacroTree(call) =>
+        cpy.DefDef(meth)(rhs = call).withMods(meth.mods | Macro | Erased)
+      case _ =>
+        addEvidenceParams(
+          cpy.DefDef(meth)(
+            name = normalizeName(meth, tpt).asTermName,
+            paramss = paramssNoContextBounds),
+          evidenceParamBuf.toList)
+  end elimContextBounds
+
+  def addDefaultGetters(meth: DefDef)(using Context): Tree =
+
+    /** The longest prefix of parameter lists in paramss whose total number of
+     *  ValDefs does not exceed `n`
+     */
+    def takeUpTo(paramss: List[ParamClause], n: Int): List[ParamClause] = paramss match
+      case ValDefs(vparams) :: paramss1 =>
+        val len = vparams.length
+        if len <= n then vparams :: takeUpTo(paramss1, n - len) else Nil
+      case TypeDefs(tparams) :: paramss1 =>
+        tparams :: takeUpTo(paramss1, n)
+      case _ =>
+        Nil
+
+    def dropContextBounds(tparam: TypeDef): TypeDef =
+      def dropInRhs(rhs: Tree): Tree = rhs match
+        case ContextBounds(tbounds, _) =>
+          tbounds
+        case rhs @ LambdaTypeTree(tparams, body) =>
+          cpy.LambdaTypeTree(rhs)(tparams, dropInRhs(body))
+        case _ =>
+          rhs
+      cpy.TypeDef(tparam)(rhs = dropInRhs(tparam.rhs))
+
+    def paramssNoRHS = mapParamss(meth.paramss)(identity) {
+      vparam =>
+        if vparam.rhs.isEmpty then vparam
+        else cpy.ValDef(vparam)(rhs = EmptyTree).withMods(vparam.mods | HasDefault)
+    }
+
+    def getterParamss(n: Int): List[ParamClause] =
+      mapParamss(takeUpTo(paramssNoRHS, n)) {
+        tparam => dropContextBounds(toDefParam(tparam, keepAnnotations = true))
+      } {
+        vparam => toDefParam(vparam, keepAnnotations = true, keepDefault = false)
+      }
+
+    def defaultGetters(paramss: List[ParamClause], n: Int): List[DefDef] = paramss match
+      case ValDefs(vparam :: vparams) :: paramss1 =>
+        def defaultGetter: DefDef =
+          DefDef(
+            name = DefaultGetterName(meth.name, n),
+            paramss = getterParamss(n),
+            tpt = TypeTree(),
+            rhs = vparam.rhs
+          )
+          .withMods(Modifiers(
+            meth.mods.flags & (AccessFlags | Synthetic) | (vparam.mods.flags & Inline),
+            meth.mods.privateWithin))
+        val rest = defaultGetters(vparams :: paramss1, n + 1)
+        if vparam.rhs.isEmpty then rest else defaultGetter :: rest
+      case _ :: paramss1 =>  // skip empty parameter lists and type parameters
+        defaultGetters(paramss1, n)
+      case Nil =>
+        Nil
+
+    val defGetters = defaultGetters(meth.paramss, 0)
+    if defGetters.isEmpty then meth
+    else Thicket(cpy.DefDef(meth)(paramss = paramssNoRHS) :: defGetters)
+  end addDefaultGetters
+
+  /** Add an explicit ascription to the `expectedTpt` to every tail splice.
+   *
+   *  - `'{ x }` -> `'{ x }`
+   *  - `'{ $x }` -> `'{ $x: T }`
+   *  - `'{ if (...) $x else $y }` -> `'{ if (...) ($x: T) else ($y: T) }`
+   *
+   *  Note that the splice `$t: T` will be typed as `${t: Expr[T]}`
+   */
+  def quotedPattern(tree: untpd.Tree, expectedTpt: untpd.Tree)(using Context): untpd.Tree = {
+    def adaptToExpectedTpt(tree: untpd.Tree): untpd.Tree = tree match {
+      // Add the expected type as an ascription
+      case _: untpd.Splice =>
+        untpd.Typed(tree, expectedTpt).withSpan(tree.span)
+      case Typed(expr: untpd.Splice, tpt) =>
+        cpy.Typed(tree)(expr, untpd.makeAndType(tpt, expectedTpt).withSpan(tpt.span))
+
+      // Propagate down the expected type to the leafs of the expression
+      case Block(stats, expr) =>
+        cpy.Block(tree)(stats, adaptToExpectedTpt(expr))
+      case If(cond, thenp, elsep) =>
+        cpy.If(tree)(cond, adaptToExpectedTpt(thenp), adaptToExpectedTpt(elsep))
+      case untpd.Parens(expr) =>
+        cpy.Parens(tree)(adaptToExpectedTpt(expr))
+      case Match(selector, cases) =>
+        val newCases = cases.map(cdef => cpy.CaseDef(cdef)(body = adaptToExpectedTpt(cdef.body)))
+        cpy.Match(tree)(selector, newCases)
+      case untpd.ParsedTry(expr, handler, finalizer) =>
+        cpy.ParsedTry(tree)(adaptToExpectedTpt(expr), adaptToExpectedTpt(handler), finalizer)
+
+      // Tree does not need to be ascribed
+      case _ =>
+        tree
+    }
+    adaptToExpectedTpt(tree)
+  }
+
+  /**  Add all evidence parameters in `params` as implicit parameters to `meth`.
+   *   If the parameters of `meth` end in an implicit parameter list or using clause,
+   *   evidence parameters are added in front of that list. Otherwise they are added
+   *   as a separate parameter clause.
+   */
+  private def addEvidenceParams(meth: DefDef, params: List[ValDef])(using Context): DefDef =
+    params match
+      case Nil =>
+        meth
+      case evidenceParams =>
+        val paramss1 = meth.paramss.reverse match
+          case ValDefs(vparams @ (vparam :: _)) :: rparamss if vparam.mods.isOneOf(GivenOrImplicit) =>
+            ((evidenceParams ++ vparams) :: rparamss).reverse
+          case _ =>
+            meth.paramss :+ evidenceParams
+        cpy.DefDef(meth)(paramss = paramss1)
+
+  /** The implicit evidence parameters of `meth`, as generated by `desugar.defDef` */
+  private def evidenceParams(meth: DefDef)(using Context): List[ValDef] =
+    meth.paramss.reverse match {
+      case ValDefs(vparams @ (vparam :: _)) :: _ if vparam.mods.isOneOf(GivenOrImplicit) =>
+        vparams.takeWhile(_.name.is(EvidenceParamName))
+      case _ =>
+        Nil
+    }
+
+  @sharable private val synthetic = Modifiers(Synthetic)
+
+  private def toDefParam(tparam: TypeDef, keepAnnotations: Boolean): TypeDef = {
+    var mods = tparam.rawMods
+    if (!keepAnnotations) mods = mods.withAnnotations(Nil)
+    tparam.withMods(mods & EmptyFlags | Param)
+  }
+  private def toDefParam(vparam: ValDef, keepAnnotations: Boolean, keepDefault: Boolean): ValDef = {
+    var mods = vparam.rawMods
+    if (!keepAnnotations) mods = mods.withAnnotations(Nil)
+    val hasDefault = if keepDefault then HasDefault else EmptyFlags
+    vparam.withMods(mods & (GivenOrImplicit | Erased | hasDefault) | Param)
+  }
+
+  def mkApply(fn: Tree, paramss: List[ParamClause])(using Context): Tree =
+    paramss.foldLeft(fn) { (fn, params) => params match
+      case TypeDefs(params) =>
+        TypeApply(fn, params.map(refOfDef))
+      case (vparam: ValDef) :: _ if vparam.mods.is(Given) =>
+        Apply(fn, params.map(refOfDef)).setApplyKind(ApplyKind.Using)
+      case _ =>
+        Apply(fn, params.map(refOfDef))
+    }
+
+  /** The expansion of a class definition. See inline comments for what is involved */
+  def classDef(cdef: TypeDef)(using Context): Tree = {
+    val impl @ Template(constr0, _, self, _) = cdef.rhs: @unchecked
+    val className = normalizeName(cdef, impl).asTypeName
+    val parents = impl.parents
+    val mods = cdef.mods
+    val companionMods = mods
+        .withFlags((mods.flags & (AccessFlags | Final)).toCommonFlags)
+        .withMods(Nil)
+        .withAnnotations(Nil)
+
+    var defaultGetters: List[Tree] = Nil
+
+    def decompose(ddef: Tree): DefDef = ddef match {
+      case meth: DefDef => meth
+      case Thicket((meth: DefDef) :: defaults) =>
+        defaultGetters = defaults
+        meth
+    }
+
+    val constr1 = decompose(defDef(impl.constr, isPrimaryConstructor = true))
+
+    // The original type and value parameters in the constructor already have the flags
+    // needed to be type members (i.e. param, and possibly also private and local unless
+    // prefixed by type or val). `tparams` and `vparamss` are the type parameters that
+    // go in `constr`, the constructor after desugaring.
+
+    /** Does `tree' look like a reference to AnyVal? Temporary test before we have inline classes */
+    def isAnyVal(tree: Tree): Boolean = tree match {
+      case Ident(tpnme.AnyVal) => true
+      case Select(qual, tpnme.AnyVal) => isScala(qual)
+      case _ => false
+    }
+    def isScala(tree: Tree): Boolean = tree match {
+      case Ident(nme.scala) => true
+      case Select(Ident(nme.ROOTPKG), nme.scala) => true
+      case _ => false
+    }
+
+    def namePos = cdef.sourcePos.withSpan(cdef.nameSpan)
+
+    val isObject = mods.is(Module)
+    val isCaseClass  = mods.is(Case) && !isObject
+    val isCaseObject = mods.is(Case) && isObject
+    val isEnum = mods.isEnumClass && !mods.is(Module)
+    def isEnumCase = mods.isEnumCase
+    def isNonEnumCase = !isEnumCase && (isCaseClass || isCaseObject)
+    val isValueClass = parents.nonEmpty && isAnyVal(parents.head)
+      // This is not watertight, but `extends AnyVal` will be replaced by `inline` later.
+
+    val originalTparams = constr1.leadingTypeParams
+    val originalVparamss = asTermOnly(constr1.trailingParamss)
+    lazy val derivedEnumParams = enumClass.typeParams.map(derivedTypeParamWithVariance)
+    val impliedTparams =
+      if (isEnumCase) {
+        val tparamReferenced = typeParamIsReferenced(
+            enumClass.typeParams, originalTparams, originalVparamss, parents)
+        if (originalTparams.isEmpty && (parents.isEmpty || tparamReferenced))
+          derivedEnumParams.map(tdef => tdef.withFlags(tdef.mods.flags | PrivateLocal))
+        else originalTparams
+      }
+      else originalTparams
+
+    if mods.is(Trait) then
+      for vparams <- originalVparamss; vparam <- vparams do
+        if isByNameType(vparam.tpt) then
+          report.error(em"implementation restriction: traits cannot have by name parameters", vparam.srcPos)
+
+    // Annotations on class _type_ parameters are set on the derived parameters
+    // but not on the constructor parameters. The reverse is true for
+    // annotations on class _value_ parameters.
+    val constrTparams = impliedTparams.map(toDefParam(_, keepAnnotations = false))
+    val constrVparamss =
+      if (originalVparamss.isEmpty) { // ensure parameter list is non-empty
+        if (isCaseClass)
+          report.error(CaseClassMissingParamList(cdef), namePos)
+        ListOfNil
+      }
+      else if (isCaseClass && originalVparamss.head.exists(_.mods.isOneOf(GivenOrImplicit))) {
+        report.error(CaseClassMissingNonImplicitParamList(cdef), namePos)
+        ListOfNil
+      }
+      else originalVparamss.nestedMap(toDefParam(_, keepAnnotations = true, keepDefault = true))
+    val derivedTparams =
+      constrTparams.zipWithConserve(impliedTparams)((tparam, impliedParam) =>
+        derivedTypeParam(tparam).withAnnotations(impliedParam.mods.annotations))
+    val derivedVparamss =
+      constrVparamss.nestedMap(vparam =>
+        derivedTermParam(vparam).withAnnotations(Nil))
+
+    val constr = cpy.DefDef(constr1)(paramss = joinParams(constrTparams, constrVparamss))
+
+    val (normalizedBody, enumCases, enumCompanionRef) = {
+      // Add constructor type parameters and evidence implicit parameters
+      // to auxiliary constructors; set defaultGetters as a side effect.
+      def expandConstructor(tree: Tree) = tree match {
+        case ddef: DefDef if ddef.name.isConstructorName =>
+          decompose(
+            defDef(
+              addEvidenceParams(
+                cpy.DefDef(ddef)(paramss = joinParams(constrTparams, ddef.paramss)),
+                evidenceParams(constr1).map(toDefParam(_, keepAnnotations = false, keepDefault = false)))))
+        case stat =>
+          stat
+      }
+      // The Identifiers defined by a case
+      def caseIds(tree: Tree): List[Ident] = tree match {
+        case tree: MemberDef => Ident(tree.name.toTermName) :: Nil
+        case PatDef(_, ids: List[Ident] @ unchecked, _, _) => ids
+      }
+
+      val stats0 = impl.body.map(expandConstructor)
+      val stats =
+        if (ctx.owner eq defn.ScalaPackageClass) && defn.hasProblematicGetClass(className) then
+          stats0.filterConserve {
+            case ddef: DefDef =>
+              ddef.name ne nme.getClass_
+            case _ =>
+              true
+          }
+        else
+          stats0
+
+      if (isEnum) {
+        val (enumCases, enumStats) = stats.partition(DesugarEnums.isEnumCase)
+        if (enumCases.isEmpty)
+          report.error(EnumerationsShouldNotBeEmpty(cdef), namePos)
+        else
+          enumCases.last.pushAttachment(DesugarEnums.DefinesEnumLookupMethods, ())
+        val enumCompanionRef = TermRefTree()
+        val enumImport =
+          Import(enumCompanionRef, enumCases.flatMap(caseIds).map(
+            enumCase =>
+              ImportSelector(enumCase.withSpan(enumCase.span.startPos))
+            )
+          )
+        (enumImport :: enumStats, enumCases, enumCompanionRef)
+      }
+      else (stats, Nil, EmptyTree)
+    }
+
+    def anyRef = ref(defn.AnyRefAlias.typeRef)
+
+    val arity = constrVparamss.head.length
+
+    val classTycon: Tree = TypeRefTree() // watching is set at end of method
+
+    def appliedTypeTree(tycon: Tree, args: List[Tree]) =
+      (if (args.isEmpty) tycon else AppliedTypeTree(tycon, args))
+        .withSpan(cdef.span.startPos)
+
+    def isHK(tparam: Tree): Boolean = tparam match {
+      case TypeDef(_, LambdaTypeTree(tparams, body)) => true
+      case TypeDef(_, rhs: DerivedTypeTree) => isHK(rhs.watched)
+      case _ => false
+    }
+
+    def appliedRef(tycon: Tree, tparams: List[TypeDef] = constrTparams, widenHK: Boolean = false) = {
+      val targs = for (tparam <- tparams) yield {
+        val targ = refOfDef(tparam)
+        def fullyApplied(tparam: Tree): Tree = tparam match {
+          case TypeDef(_, LambdaTypeTree(tparams, body)) =>
+            AppliedTypeTree(targ, tparams.map(_ => WildcardTypeBoundsTree()))
+          case TypeDef(_, rhs: DerivedTypeTree) =>
+            fullyApplied(rhs.watched)
+          case _ =>
+            targ
+        }
+        if (widenHK) fullyApplied(tparam) else targ
+      }
+      appliedTypeTree(tycon, targs)
+    }
+
+    def isRepeated(tree: Tree): Boolean = stripByNameType(tree) match {
+      case PostfixOp(_, Ident(tpnme.raw.STAR)) => true
+      case _ => false
+    }
+
+    // a reference to the class type bound by `cdef`, with type parameters coming from the constructor
+    val classTypeRef = appliedRef(classTycon)
+
+    // a reference to `enumClass`, with type parameters coming from the case constructor
+    lazy val enumClassTypeRef =
+      if (enumClass.typeParams.isEmpty)
+        enumClassRef
+      else if (originalTparams.isEmpty)
+        appliedRef(enumClassRef)
+      else {
+        report.error(TypedCaseDoesNotExplicitlyExtendTypedEnum(enumClass, cdef)
+            , cdef.srcPos.startPos)
+        appliedTypeTree(enumClassRef, constrTparams map (_ => anyRef))
+      }
+
+    // new C[Ts](paramss)
+    lazy val creatorExpr =
+      val vparamss = constrVparamss match
+        case (vparam :: _) :: _ if vparam.mods.is(Implicit) => // add a leading () to match class parameters
+          Nil :: constrVparamss
+        case _ =>
+          if constrVparamss.nonEmpty && constrVparamss.forall {
+            case vparam :: _ => vparam.mods.is(Given)
+            case _ => false
+          }
+          then constrVparamss :+ Nil // add a trailing () to match class parameters
+          else constrVparamss
+      val nu = vparamss.foldLeft(makeNew(classTypeRef)) { (nu, vparams) =>
+        val app = Apply(nu, vparams.map(refOfDef))
+        vparams match {
+          case vparam :: _ if vparam.mods.is(Given) => app.setApplyKind(ApplyKind.Using)
+          case _ => app
+        }
+      }
+      ensureApplied(nu)
+
+    val copiedAccessFlags = if migrateTo3 then EmptyFlags else AccessFlags
+
+    // Methods to add to a case class C[..](p1: T1, ..., pN: Tn)(moreParams)
+    //     def _1: T1 = this.p1
+    //     ...
+    //     def _N: TN = this.pN (unless already given as valdef or parameterless defdef)
+    //     def copy(p1: T1 = p1..., pN: TN = pN)(moreParams) =
+    //       new C[...](p1, ..., pN)(moreParams)
+    val (caseClassMeths, enumScaffolding) = {
+      def syntheticProperty(name: TermName, tpt: Tree, rhs: Tree) =
+        DefDef(name, Nil, tpt, rhs).withMods(synthetic)
+
+      def productElemMeths =
+        val caseParams = derivedVparamss.head.toArray
+        val selectorNamesInBody = normalizedBody.collect {
+          case vdef: ValDef if vdef.name.isSelectorName =>
+            vdef.name
+          case ddef: DefDef if ddef.name.isSelectorName && ddef.paramss.isEmpty =>
+            ddef.name
+        }
+        for i <- List.range(0, arity)
+            selName = nme.selectorName(i)
+            if (selName ne caseParams(i).name) && !selectorNamesInBody.contains(selName)
+        yield syntheticProperty(selName, caseParams(i).tpt,
+          Select(This(EmptyTypeIdent), caseParams(i).name))
+
+      def enumCaseMeths =
+        if isEnumCase then
+          val (ordinal, scaffolding) = nextOrdinal(className, CaseKind.Class, definesEnumLookupMethods(cdef))
+          (ordinalMethLit(ordinal) :: Nil, scaffolding)
+        else (Nil, Nil)
+      def copyMeths = {
+        val hasRepeatedParam = constrVparamss.nestedExists {
+          case ValDef(_, tpt, _) => isRepeated(tpt)
+        }
+        if (mods.is(Abstract) || hasRepeatedParam) Nil  // cannot have default arguments for repeated parameters, hence copy method is not issued
+        else {
+          val copyFirstParams = derivedVparamss.head.map(vparam =>
+            cpy.ValDef(vparam)(rhs = refOfDef(vparam)))
+          val copyRestParamss = derivedVparamss.tail.nestedMap(vparam =>
+            cpy.ValDef(vparam)(rhs = EmptyTree))
+          DefDef(
+            nme.copy,
+            joinParams(derivedTparams, copyFirstParams :: copyRestParamss),
+            TypeTree(),
+            creatorExpr
+          ).withMods(Modifiers(Synthetic | constr1.mods.flags & copiedAccessFlags, constr1.mods.privateWithin)) :: Nil
+        }
+      }
+
+      if isCaseClass then
+        val (enumMeths, enumScaffolding) = enumCaseMeths
+        (copyMeths ::: enumMeths ::: productElemMeths, enumScaffolding)
+      else (Nil, Nil)
+    }
+
+    var parents1: List[untpd.Tree] = parents // !cc! need explicit type to make capture checking pass
+    if (isEnumCase && parents.isEmpty)
+      parents1 = enumClassTypeRef :: Nil
+    if (isNonEnumCase)
+      parents1 = parents1 :+ scalaDot(str.Product.toTypeName) :+ scalaDot(nme.Serializable.toTypeName)
+    if (isEnum)
+      parents1 = parents1 :+ ref(defn.EnumClass)
+
+    // derived type classes of non-module classes go to their companions
+    val (clsDerived, companionDerived) =
+      if (mods.is(Module)) (impl.derived, Nil) else (Nil, impl.derived)
+
+    // The thicket which is the desugared version of the companion object
+    //     synthetic object C extends parentTpt derives class-derived { defs }
+    def companionDefs(parentTpt: Tree, defs: List[Tree]) = {
+      val mdefs = moduleDef(
+        ModuleDef(
+          className.toTermName, Template(emptyConstructor, parentTpt :: Nil, companionDerived, EmptyValDef, defs))
+            .withMods(companionMods | Synthetic))
+        .withSpan(cdef.span).toList
+      if (companionDerived.nonEmpty)
+        for (case modClsDef @ TypeDef(_, _) <- mdefs)
+          modClsDef.putAttachment(DerivingCompanion, impl.srcPos.startPos)
+      mdefs
+    }
+
+    val companionMembers = defaultGetters ::: enumCases
+
+    // The companion object definitions, if a companion is needed, Nil otherwise.
+    // companion definitions include:
+    // 1. If class is a case class case class C[Ts](p1: T1, ..., pN: TN)(moreParams):
+    //     def apply[Ts](p1: T1, ..., pN: TN)(moreParams) = new C[Ts](p1, ..., pN)(moreParams)  (unless C is abstract)
+    //     def unapply[Ts]($1: C[Ts]) = $1        // if not repeated
+    //     def unapplySeq[Ts]($1: C[Ts]) = $1     // if repeated
+    // 2. The default getters of the constructor
+    // The parent of the companion object of a non-parameterized case class
+    //     (T11, ..., T1N) => ... => (TM1, ..., TMN) => C
+    // For all other classes, the parent is AnyRef.
+    val companions =
+      if (isCaseClass) {
+        val applyMeths =
+          if (mods.is(Abstract)) Nil
+          else {
+            val appMods =
+              Modifiers(Synthetic | constr1.mods.flags & copiedAccessFlags).withPrivateWithin(constr1.mods.privateWithin)
+            val appParamss =
+              derivedVparamss.nestedZipWithConserve(constrVparamss)((ap, cp) =>
+                ap.withMods(ap.mods | (cp.mods.flags & HasDefault)))
+            DefDef(nme.apply, joinParams(derivedTparams, appParamss), TypeTree(), creatorExpr)
+              .withMods(appMods) :: Nil
+          }
+        val unapplyMeth = {
+          val hasRepeatedParam = constrVparamss.head.exists {
+            case ValDef(_, tpt, _) => isRepeated(tpt)
+          }
+          val methName = if (hasRepeatedParam) nme.unapplySeq else nme.unapply
+          val unapplyParam = makeSyntheticParameter(tpt = classTypeRef)
+          val unapplyRHS = if (arity == 0) Literal(Constant(true)) else Ident(unapplyParam.name)
+          val unapplyResTp = if (arity == 0) Literal(Constant(true)) else TypeTree()
+          DefDef(
+            methName,
+            joinParams(derivedTparams, (unapplyParam :: Nil) :: Nil),
+            unapplyResTp,
+            unapplyRHS
+          ).withMods(synthetic)
+        }
+        val toStringMeth =
+          DefDef(nme.toString_, Nil, TypeTree(), Literal(Constant(className.toString))).withMods(Modifiers(Override | Synthetic))
+
+        companionDefs(anyRef, applyMeths ::: unapplyMeth :: toStringMeth :: companionMembers)
+      }
+      else if (companionMembers.nonEmpty || companionDerived.nonEmpty || isEnum)
+        companionDefs(anyRef, companionMembers)
+      else if (isValueClass)
+        companionDefs(anyRef, Nil)
+      else Nil
+
+    enumCompanionRef match {
+      case ref: TermRefTree => // have the enum import watch the companion object
+        val (modVal: ValDef) :: _ = companions: @unchecked
+        ref.watching(modVal)
+      case _ =>
+    }
+
+    // For an implicit class C[Ts](p11: T11, ..., p1N: T1N) ... (pM1: TM1, .., pMN: TMN), the method
+    //     synthetic implicit C[Ts](p11: T11, ..., p1N: T1N) ... (pM1: TM1, ..., pMN: TMN): C[Ts] =
+    //       new C[Ts](p11, ..., p1N) ... (pM1, ..., pMN) =
+    val implicitWrappers =
+      if (!mods.isOneOf(GivenOrImplicit))
+        Nil
+      else if (ctx.owner.is(Package)) {
+        report.error(TopLevelImplicitClass(cdef), cdef.srcPos)
+        Nil
+      }
+      else if (mods.is(Trait)) {
+        report.error(TypesAndTraitsCantBeImplicit(), cdef.srcPos)
+        Nil
+      }
+      else if (isCaseClass) {
+        report.error(ImplicitCaseClass(cdef), cdef.srcPos)
+        Nil
+      }
+      else if (arity != 1 && !mods.is(Given)) {
+        report.error(ImplicitClassPrimaryConstructorArity(), cdef.srcPos)
+        Nil
+      }
+      else {
+        val defParamss = constrVparamss match {
+          case Nil :: paramss =>
+            paramss // drop leading () that got inserted by class
+                    // TODO: drop this once we do not silently insert empty class parameters anymore
+          case paramss => paramss
+        }
+        // implicit wrapper is typechecked in same scope as constructor, so
+        // we can reuse the constructor parameters; no derived params are needed.
+        DefDef(
+          className.toTermName, joinParams(constrTparams, defParamss),
+          classTypeRef, creatorExpr)
+          .withMods(companionMods | mods.flags.toTermFlags & (GivenOrImplicit | Inline) | Final)
+          .withSpan(cdef.span) :: Nil
+      }
+
+    val self1 = {
+      val selfType = if (self.tpt.isEmpty) classTypeRef else self.tpt
+      if (self.isEmpty) self
+      else cpy.ValDef(self)(tpt = selfType).withMods(self.mods | SelfName)
+    }
+
+    val cdef1 = addEnumFlags {
+      val tparamAccessors = {
+        val impliedTparamsIt = impliedTparams.iterator
+        derivedTparams.map(_.withMods(impliedTparamsIt.next().mods))
+      }
+      val caseAccessor = if (isCaseClass) CaseAccessor else EmptyFlags
+      val vparamAccessors = {
+        val originalVparamsIt = originalVparamss.iterator.flatten
+        derivedVparamss match {
+          case first :: rest =>
+            first.map(_.withMods(originalVparamsIt.next().mods | caseAccessor)) ++
+            rest.flatten.map(_.withMods(originalVparamsIt.next().mods))
+          case _ =>
+            Nil
+        }
+      }
+      if mods.isAllOf(Given | Inline | Transparent) then
+        report.error("inline given instances cannot be trasparent", cdef)
+      val classMods = if mods.is(Given) then mods &~ (Inline | Transparent) | Synthetic else mods
+      cpy.TypeDef(cdef: TypeDef)(
+        name = className,
+        rhs = cpy.Template(impl)(constr, parents1, clsDerived, self1,
+          tparamAccessors ::: vparamAccessors ::: normalizedBody ::: caseClassMeths)
+      ).withMods(classMods)
+    }
+
+    // install the watch on classTycon
+    classTycon match {
+      case tycon: DerivedTypeTree => tycon.watching(cdef1)
+      case _ =>
+    }
+
+    flatTree(cdef1 :: companions ::: implicitWrappers ::: enumScaffolding)
+  }.showing(i"desugared: $cdef --> $result", Printers.desugar)
+
+  /** Expand
+   *
+   *    package object name { body }
+   *
+   *  to:
+   *
+   *    package name {
+   *      object `package` { body }
+   *    }
+   */
+  def packageModuleDef(mdef: ModuleDef)(using Context): Tree =
+    val impl = mdef.impl
+    val mods = mdef.mods
+    val moduleName = normalizeName(mdef, impl).asTermName
+    if mods.is(Package) then
+      checkPackageName(mdef)
+      PackageDef(Ident(moduleName),
+        cpy.ModuleDef(mdef)(nme.PACKAGE, impl).withMods(mods &~ Package) :: Nil)
+    else
+      mdef
+
+  /** Expand
+   *
+   *    object name extends parents { self => body }
+   *
+   *  to:
+   *
+   *    <module> val name: name$ = New(name$)
+   *    <module> final class name$ extends parents { self: name.type => body }
+   */
+  def moduleDef(mdef: ModuleDef)(using Context): Tree = {
+    val impl = mdef.impl
+    val mods = mdef.mods
+    val moduleName = normalizeName(mdef, impl).asTermName
+    def isEnumCase = mods.isEnumCase
+    Checking.checkWellFormedModule(mdef)
+
+    if (mods.is(Package))
+      packageModuleDef(mdef)
+    else if (isEnumCase) {
+      typeParamIsReferenced(enumClass.typeParams, Nil, Nil, impl.parents)
+        // used to check there are no illegal references to enum's type parameters in parents
+      expandEnumModule(moduleName, impl, mods, definesEnumLookupMethods(mdef), mdef.span)
+    }
+    else {
+      val clsName = moduleName.moduleClassName
+      val clsRef = Ident(clsName)
+      val modul = ValDef(moduleName, clsRef, New(clsRef, Nil))
+        .withMods(mods.toTermFlags & RetainedModuleValFlags | ModuleValCreationFlags)
+        .withSpan(mdef.span.startPos)
+      val ValDef(selfName, selfTpt, _) = impl.self
+      val selfMods = impl.self.mods
+      if (!selfTpt.isEmpty) report.error(ObjectMayNotHaveSelfType(mdef), impl.self.srcPos)
+      val clsSelf = ValDef(selfName, SingletonTypeTree(Ident(moduleName)), impl.self.rhs)
+        .withMods(selfMods)
+        .withSpan(impl.self.span.orElse(impl.span.startPos))
+      val clsTmpl = cpy.Template(impl)(self = clsSelf, body = impl.body)
+      val cls = TypeDef(clsName, clsTmpl)
+        .withMods(mods.toTypeFlags & RetainedModuleClassFlags | ModuleClassCreationFlags)
+        .withEndMarker(copyFrom = mdef) // copy over the end marker position to the module class def
+      Thicket(modul, classDef(cls).withSpan(mdef.span))
+    }
+  }
+
+  def extMethod(mdef: DefDef, extParamss: List[ParamClause])(using Context): DefDef =
+    cpy.DefDef(mdef)(
+      name = normalizeName(mdef, mdef.tpt).asTermName,
+      paramss =
+        if mdef.name.isRightAssocOperatorName then
+          val (typaramss, paramss) = mdef.paramss.span(isTypeParamClause) // first extract type parameters
+
+          paramss match
+            case params :: paramss1 => // `params` must have a single parameter and without `given` flag
+
+              def badRightAssoc(problem: String) =
+                report.error(i"right-associative extension method $problem", mdef.srcPos)
+                extParamss ++ mdef.paramss
+
+              params match
+                case ValDefs(vparam :: Nil) =>
+                  if !vparam.mods.is(Given) then
+                    // we merge the extension parameters with the method parameters,
+                    // swapping the operator arguments:
+                    // e.g.
+                    //   extension [A](using B)(c: C)(using D)
+                    //     def %:[E](f: F)(g: G)(using H): Res = ???
+                    // will be encoded as
+                    //   def %:[A](using B)[E](f: F)(c: C)(using D)(g: G)(using H): Res = ???
+                    val (leadingUsing, otherExtParamss) = extParamss.span(isUsingOrTypeParamClause)
+                    leadingUsing ::: typaramss ::: params :: otherExtParamss ::: paramss1
+                  else
+                    badRightAssoc("cannot start with using clause")
+                case _ =>
+                  badRightAssoc("must start with a single parameter")
+            case _ =>
+              // no value parameters, so not an infix operator.
+              extParamss ++ mdef.paramss
+        else
+          extParamss ++ mdef.paramss
+    ).withMods(mdef.mods | ExtensionMethod)
+
+  /** Transform extension construct to list of extension methods */
+  def extMethods(ext: ExtMethods)(using Context): Tree = flatTree {
+    ext.methods map {
+      case exp: Export => exp
+      case mdef: DefDef => defDef(extMethod(mdef, ext.paramss))
+    }
+  }
+  /** Transforms
+   *
+   *    <mods> type t >: Low <: Hi
+   *  to
+   *
+   *    @patternType <mods> type $T >: Low <: Hi
+   *
+   *  if the type has a pattern variable name
+   */
+  def quotedPatternTypeDef(tree: TypeDef)(using Context): TypeDef = {
+    assert(ctx.mode.is(Mode.QuotedPattern))
+    if tree.name.isVarPattern && !tree.isBackquoted then
+      val patternTypeAnnot = New(ref(defn.QuotedRuntimePatterns_patternTypeAnnot.typeRef)).withSpan(tree.span)
+      val mods = tree.mods.withAddedAnnotation(patternTypeAnnot)
+      tree.withMods(mods)
+    else if tree.name.startsWith("$") && !tree.isBackquoted then
+      report.error(
+        """Quoted pattern variable names starting with $ are not supported anymore.
+          |Use lower cases type pattern name instead.
+          |""".stripMargin,
+        tree.srcPos)
+      tree
+    else tree
+  }
+
+  def checkPackageName(mdef: ModuleDef | PackageDef)(using Context): Unit =
+
+    def check(name: Name, errSpan: Span): Unit = name match
+      case name: SimpleName if !errSpan.isSynthetic && name.exists(Chars.willBeEncoded) =>
+        report.warning(em"The package name `$name` will be encoded on the classpath, and can lead to undefined behaviour.", mdef.source.atSpan(errSpan))
+      case _ =>
+
+    def loop(part: RefTree): Unit = part match
+      case part @ Ident(name) => check(name, part.span)
+      case part @ Select(qual: RefTree, name) =>
+        check(name, part.nameSpan)
+        loop(qual)
+      case _ =>
+
+    mdef match
+      case pdef: PackageDef => loop(pdef.pid)
+      case mdef: ModuleDef if mdef.mods.is(Package) => check(mdef.name, mdef.nameSpan)
+      case _ =>
+  end checkPackageName
+
+  /** The normalized name of `mdef`. This means
+   *   1. Check that the name does not redefine a Scala core class.
+   *      If it does redefine, issue an error and return a mangled name instead
+   *      of the original one.
+   *   2. If the name is missing (this can be the case for instance definitions),
+   *      invent one instead.
+   */
+  def normalizeName(mdef: MemberDef, impl: Tree)(using Context): Name = {
+    var name = mdef.name
+    if (name.isEmpty) name = name.likeSpaced(inventGivenOrExtensionName(impl))
+    def errPos = mdef.source.atSpan(mdef.nameSpan)
+    if (ctx.owner == defn.ScalaPackageClass && defn.reservedScalaClassNames.contains(name.toTypeName)) {
+      val kind = if (name.isTypeName) "class" else "object"
+      report.error(IllegalRedefinitionOfStandardKind(kind, name), errPos)
+      name = name.errorName
+    }
+    name
+  }
+
+  /** Invent a name for an anonympus given of type or template `impl`. */
+  def inventGivenOrExtensionName(impl: Tree)(using Context): SimpleName =
+    val str = impl match
+      case impl: Template =>
+        if impl.parents.isEmpty then
+          report.error(AnonymousInstanceCannotBeEmpty(impl), impl.srcPos)
+          nme.ERROR.toString
+        else
+          impl.parents.map(inventTypeName(_)).mkString("given_", "_", "")
+      case impl: Tree =>
+        "given_" ++ inventTypeName(impl)
+    str.toTermName.asSimpleName
+
+  private class NameExtractor(followArgs: Boolean) extends UntypedTreeAccumulator[String] {
+    private def extractArgs(args: List[Tree])(using Context): String =
+      args.map(argNameExtractor.apply("", _)).mkString("_")
+    override def apply(x: String, tree: Tree)(using Context): String =
+      if (x.isEmpty)
+        tree match {
+          case Select(pre, nme.CONSTRUCTOR) => foldOver(x, pre)
+          case tree: RefTree =>
+            if tree.name.isTypeName then tree.name.toString
+            else s"${tree.name}_type"
+          case tree: TypeDef => tree.name.toString
+          case tree: AppliedTypeTree if followArgs && tree.args.nonEmpty =>
+            s"${apply(x, tree.tpt)}_${extractArgs(tree.args)}"
+          case InfixOp(left, op, right) =>
+            if followArgs then s"${op.name}_${extractArgs(List(left, right))}"
+            else op.name.toString
+          case tree: LambdaTypeTree =>
+            apply(x, tree.body)
+          case tree: Tuple =>
+            extractArgs(tree.trees)
+          case tree: Function if tree.args.nonEmpty =>
+            if followArgs then s"${extractArgs(tree.args)}_to_${apply("", tree.body)}"
+            else "Function"
+          case _ => foldOver(x, tree)
+        }
+      else x
+  }
+  private val typeNameExtractor = NameExtractor(followArgs = true)
+  private val argNameExtractor = NameExtractor(followArgs = false)
+
+  private def inventTypeName(tree: Tree)(using Context): String = typeNameExtractor("", tree)
+
+  /**This will check if this def tree is marked to define enum lookup methods,
+   * this is not recommended to call more than once per tree
+   */
+  private def definesEnumLookupMethods(ddef: DefTree): Boolean =
+    ddef.removeAttachment(DefinesEnumLookupMethods).isDefined
+
+  /**     val p1, ..., pN: T = E
+   *  ==>
+   *      makePatDef[[val p1: T1 = E]]; ...; makePatDef[[val pN: TN = E]]
+   *
+   *      case e1, ..., eN
+   *  ==>
+   *      expandSimpleEnumCase([case e1]); ...; expandSimpleEnumCase([case eN])
+   */
+  def patDef(pdef: PatDef)(using Context): Tree = flatTree {
+    val PatDef(mods, pats, tpt, rhs) = pdef
+    if mods.isEnumCase then
+      def expand(id: Ident, definesLookups: Boolean) =
+        expandSimpleEnumCase(id.name.asTermName, mods, definesLookups,
+            Span(id.span.start, id.span.end, id.span.start))
+
+      val ids = pats.asInstanceOf[List[Ident]]
+      if definesEnumLookupMethods(pdef) then
+        ids.init.map(expand(_, false)) ::: expand(ids.last, true) :: Nil
+      else
+        ids.map(expand(_, false))
+    else {
+      val pats1 = if (tpt.isEmpty) pats else pats map (Typed(_, tpt))
+      pats1 map (makePatDef(pdef, mods, _, rhs))
+    }
+  }
+
+  /** The selector of a match, which depends of the given `checkMode`.
+   *  @param  sel  the original selector
+   *  @return if `checkMode` is
+   *           - None              :  sel @unchecked
+   *           - Exhaustive        :  sel
+   *           - IrrefutablePatDef,
+   *             IrrefutableGenFrom:  sel with attachment `CheckIrrefutable -> checkMode`
+   */
+  def makeSelector(sel: Tree, checkMode: MatchCheck)(using Context): Tree =
+    checkMode match
+    case MatchCheck.None =>
+      Annotated(sel, New(ref(defn.UncheckedAnnot.typeRef)))
+
+    case MatchCheck.Exhaustive =>
+      sel
+
+    case MatchCheck.IrrefutablePatDef | MatchCheck.IrrefutableGenFrom =>
+      // TODO: use `pushAttachment` and investigate duplicate attachment
+      sel.withAttachment(CheckIrrefutable, checkMode)
+      sel
+    end match
+
+  /** If `pat` is a variable pattern,
+   *
+   *    val/var/lazy val p = e
+   *
+   *  Otherwise, in case there is exactly one variable x_1 in pattern
+   *   val/var/lazy val p = e  ==>  val/var/lazy val x_1 = (e: @unchecked) match (case p => (x_1))
+   *
+   *   in case there are zero or more than one variables in pattern
+   *   val/var/lazy p = e  ==>  private[this] synthetic [lazy] val t$ = (e: @unchecked) match (case p => (x_1, ..., x_N))
+   *                   val/var/def x_1 = t$._1
+   *                   ...
+   *                   val/var/def x_N = t$._N
+   *  If the original pattern variable carries a type annotation, so does the corresponding
+   *  ValDef or DefDef.
+   */
+  def makePatDef(original: Tree, mods: Modifiers, pat: Tree, rhs: Tree)(using Context): Tree = pat match {
+    case IdPattern(id, tpt) =>
+      val id1 =
+        if id.name == nme.WILDCARD
+        then cpy.Ident(id)(WildcardParamName.fresh())
+        else id
+      derivedValDef(original, id1, tpt, rhs, mods)
+    case _ =>
+
+      def filterWildcardGivenBinding(givenPat: Bind): Boolean =
+        givenPat.name != nme.WILDCARD
+
+      def errorOnGivenBinding(bind: Bind)(using Context): Boolean =
+        report.error(
+          em"""${hl("given")} patterns are not allowed in a ${hl("val")} definition,
+              |please bind to an identifier and use an alias given.""".stripMargin, bind)
+        false
+
+      def isTuplePattern(arity: Int): Boolean = pat match {
+        case Tuple(pats) if pats.size == arity =>
+          pats.forall(isVarPattern)
+        case _ => false
+      }
+      val isMatchingTuple: Tree => Boolean = {
+        case Tuple(es) => isTuplePattern(es.length)
+        case _ => false
+      }
+
+      // We can only optimize `val pat = if (...) e1 else e2` if:
+      // - `e1` and `e2` are both tuples of arity N
+      // - `pat` is a tuple of N variables or wildcard patterns like `(x1, x2, ..., xN)`
+      val tupleOptimizable = forallResults(rhs, isMatchingTuple)
+
+      val inAliasGenerator = original match
+        case _: GenAlias => true
+        case _ => false
+
+      val vars =
+        if (tupleOptimizable) // include `_`
+          pat match
+            case Tuple(pats) => pats.map { case id: Ident => id -> TypeTree() }
+        else
+          getVariables(
+            tree = pat,
+            shouldAddGiven =
+              if inAliasGenerator then
+                filterWildcardGivenBinding
+              else
+                errorOnGivenBinding
+          ) // no `_`
+
+      val ids = for ((named, _) <- vars) yield Ident(named.name)
+      val matchExpr =
+        if (tupleOptimizable) rhs
+        else
+          val caseDef = CaseDef(pat, EmptyTree, makeTuple(ids))
+          Match(makeSelector(rhs, MatchCheck.IrrefutablePatDef), caseDef :: Nil)
+      vars match {
+        case Nil if !mods.is(Lazy) =>
+          matchExpr
+        case (named, tpt) :: Nil =>
+          derivedValDef(original, named, tpt, matchExpr, mods)
+        case _ =>
+          val tmpName = UniqueName.fresh()
+          val patMods =
+            mods & Lazy | Synthetic | (if (ctx.owner.isClass) PrivateLocal else EmptyFlags)
+          val firstDef =
+            ValDef(tmpName, TypeTree(), matchExpr)
+              .withSpan(pat.span.union(rhs.span)).withMods(patMods)
+          val useSelectors = vars.length <= 22
+          def selector(n: Int) =
+            if useSelectors then Select(Ident(tmpName), nme.selectorName(n))
+            else Apply(Select(Ident(tmpName), nme.apply), Literal(Constant(n)) :: Nil)
+          val restDefs =
+            for (((named, tpt), n) <- vars.zipWithIndex if named.name != nme.WILDCARD)
+            yield
+              if mods.is(Lazy) then
+                DefDef(named.name.asTermName, Nil, tpt, selector(n))
+                  .withMods(mods &~ Lazy)
+                  .withSpan(named.span)
+              else
+                valDef(
+                  ValDef(named.name.asTermName, tpt, selector(n))
+                    .withMods(mods)
+                    .withSpan(named.span)
+                )
+          flatTree(firstDef :: restDefs)
+      }
+  }
+
+  /** Expand variable identifier x to x @ _ */
+  def patternVar(tree: Tree)(using Context): Bind = {
+    val Ident(name) = unsplice(tree): @unchecked
+    Bind(name, Ident(nme.WILDCARD)).withSpan(tree.span)
+  }
+
+  /** The type of tests that check whether a MemberDef is OK for some flag.
+   *  The test succeeds if the partial function is defined and returns true.
+   */
+  type MemberDefTest = PartialFunction[MemberDef, Boolean]
+
+  val legalOpaque: MemberDefTest = {
+    case TypeDef(_, rhs) =>
+      def rhsOK(tree: Tree): Boolean = tree match {
+        case bounds: TypeBoundsTree => !bounds.alias.isEmpty
+        case _: Template | _: MatchTypeTree => false
+        case LambdaTypeTree(_, body) => rhsOK(body)
+        case _ => true
+      }
+      rhsOK(rhs)
+  }
+
+  def checkOpaqueAlias(tree: MemberDef)(using Context): MemberDef =
+    def check(rhs: Tree): MemberDef = rhs match
+      case bounds: TypeBoundsTree if bounds.alias.isEmpty =>
+        report.error(i"opaque type must have a right-hand side", tree.srcPos)
+        tree.withMods(tree.mods.withoutFlags(Opaque))
+      case LambdaTypeTree(_, body) => check(body)
+      case _ => tree
+    if !tree.mods.is(Opaque) then tree
+    else tree match
+      case TypeDef(_, rhs) => check(rhs)
+      case _ => tree
+
+  /** Check that modifiers are legal for the definition `tree`.
+   *  Right now, we only check for `opaque`. TODO: Move other modifier checks here.
+   */
+  def checkModifiers(tree: Tree)(using Context): Tree = tree match {
+    case tree: MemberDef =>
+      var tested: MemberDef = tree
+      def checkApplicable(flag: Flag, test: MemberDefTest): MemberDef =
+        if (tested.mods.is(flag) && !test.applyOrElse(tree, (md: MemberDef) => false)) {
+          report.error(ModifierNotAllowedForDefinition(flag), tree.srcPos)
+           tested.withMods(tested.mods.withoutFlags(flag))
+        } else tested
+      tested = checkOpaqueAlias(tested)
+      tested = checkApplicable(Opaque, legalOpaque)
+      tested
+    case _ =>
+      tree
+  }
+
+  def defTree(tree: Tree)(using Context): Tree =
+    checkModifiers(tree) match {
+      case tree: ValDef => valDef(tree)
+      case tree: TypeDef =>
+        if (tree.isClassDef) classDef(tree)
+        else if (ctx.mode.is(Mode.QuotedPattern)) quotedPatternTypeDef(tree)
+        else tree
+      case tree: DefDef =>
+        if (tree.name.isConstructorName) tree // was already handled by enclosing classDef
+        else defDef(tree)
+      case tree: ModuleDef => moduleDef(tree)
+      case tree: PatDef => patDef(tree)
+    }
+
+  /**     { stats; <empty > }
+   *  ==>
+   *      { stats; () }
+   */
+  def block(tree: Block)(using Context): Block = tree.expr match {
+    case EmptyTree =>
+      cpy.Block(tree)(tree.stats,
+        unitLiteral.withSpan(if (tree.stats.isEmpty) tree.span else tree.span.endPos))
+    case _ =>
+      tree
+  }
+
+  /** Translate infix operation expression
+    *
+    *     l op r     ==>    l.op(r)  if op is left-associative
+    *                ==>    r.op(l)  if op is right-associative
+    */
+  def binop(left: Tree, op: Ident, right: Tree)(using Context): Apply = {
+    def assignToNamedArg(arg: Tree) = arg match {
+      case Assign(Ident(name), rhs) => cpy.NamedArg(arg)(name, rhs)
+      case _ => arg
+    }
+    def makeOp(fn: Tree, arg: Tree, selectPos: Span) =
+      val sel = Select(fn, op.name).withSpan(selectPos)
+      if (left.sourcePos.endLine < op.sourcePos.startLine)
+        sel.pushAttachment(MultiLineInfix, ())
+      arg match
+        case Parens(arg) =>
+          Apply(sel, assignToNamedArg(arg) :: Nil)
+        case Tuple(args) if args.exists(_.isInstanceOf[Assign]) =>
+          Apply(sel, args.mapConserve(assignToNamedArg))
+        case Tuple(args) =>
+          Apply(sel, arg :: Nil).setApplyKind(ApplyKind.InfixTuple)
+        case _ =>
+          Apply(sel, arg :: Nil)
+
+    if op.name.isRightAssocOperatorName then
+      makeOp(right, left, Span(op.span.start, right.span.end))
+    else
+      makeOp(left, right, Span(left.span.start, op.span.end, op.span.start))
+  }
+
+  /** Translate throws type `A throws E1 | ... | En` to
+   *  $throws[... $throws[A, E1] ... , En].
+   */
+  def throws(tpt: Tree, op: Ident, excepts: Tree)(using Context): AppliedTypeTree = excepts match
+    case Parens(excepts1) =>
+      throws(tpt, op, excepts1)
+    case InfixOp(l, bar @ Ident(tpnme.raw.BAR), r) =>
+      throws(throws(tpt, op, l), bar, r)
+    case e =>
+      AppliedTypeTree(
+        TypeTree(defn.throwsAlias.typeRef).withSpan(op.span), tpt :: excepts :: Nil)
+
+  /** Translate tuple expressions of arity <= 22
+   *
+   *     ()             ==>   ()
+   *     (t)            ==>   t
+   *     (t1, ..., tN)  ==>   TupleN(t1, ..., tN)
+   */
+  def smallTuple(tree: Tuple)(using Context): Tree = {
+    val ts = tree.trees
+    val arity = ts.length
+    assert(arity <= Definitions.MaxTupleArity)
+    def tupleTypeRef = defn.TupleType(arity).nn
+    if (arity == 0)
+      if (ctx.mode is Mode.Type) TypeTree(defn.UnitType) else unitLiteral
+    else if (ctx.mode is Mode.Type) AppliedTypeTree(ref(tupleTypeRef), ts)
+    else Apply(ref(tupleTypeRef.classSymbol.companionModule.termRef), ts)
+  }
+
+  private def isTopLevelDef(stat: Tree)(using Context): Boolean = stat match
+    case _: ValDef | _: PatDef | _: DefDef | _: Export | _: ExtMethods => true
+    case stat: ModuleDef =>
+      stat.mods.isOneOf(GivenOrImplicit)
+    case stat: TypeDef =>
+      !stat.isClassDef || stat.mods.isOneOf(GivenOrImplicit)
+    case _ =>
+      false
+
+  /** Assuming `src` contains top-level definition, returns the name that should
+   *  be using for the package object that will wrap them.
+   */
+  def packageObjectName(src: SourceFile): TermName =
+    val fileName = src.file.name
+    val sourceName = fileName.take(fileName.lastIndexOf('.'))
+    (sourceName ++ str.TOPLEVEL_SUFFIX).toTermName
+
+  /** Group all definitions that can't be at the toplevel in
+   *  an object named `<source>$package` where `<source>` is the name of the source file.
+   *  Definitions that can't be at the toplevel are:
+   *
+   *   - all pattern, value and method definitions
+   *   - non-class type definitions
+   *   - implicit classes and objects
+   *   - "companion objects" of wrapped type definitions
+   *     (i.e. objects having the same name as a wrapped type)
+   */
+  def packageDef(pdef: PackageDef)(using Context): PackageDef = {
+    checkPackageName(pdef)
+    val wrappedTypeNames = pdef.stats.collect {
+      case stat: TypeDef if isTopLevelDef(stat) => stat.name
+    }
+    def inPackageObject(stat: Tree) =
+      isTopLevelDef(stat) || {
+        stat match
+          case stat: ModuleDef =>
+            wrappedTypeNames.contains(stat.name.stripModuleClassSuffix.toTypeName)
+          case _ =>
+            false
+      }
+    val (nestedStats, topStats) = pdef.stats.partition(inPackageObject)
+    if (nestedStats.isEmpty) pdef
+    else {
+      val name = packageObjectName(ctx.source)
+      val grouped =
+        ModuleDef(name, Template(emptyConstructor, Nil, Nil, EmptyValDef, nestedStats))
+          .withMods(Modifiers(Synthetic))
+      cpy.PackageDef(pdef)(pdef.pid, topStats :+ grouped)
+    }
+  }
+
+  /** Make closure corresponding to function.
+   *      params => body
+   *  ==>
+   *      def $anonfun(params) = body
+   *      Closure($anonfun)
+   */
+  def makeClosure(params: List[ValDef], body: Tree, tpt: Tree | Null = null, isContextual: Boolean, span: Span)(using Context): Block =
+    Block(
+      DefDef(nme.ANON_FUN, params :: Nil, if (tpt == null) TypeTree() else tpt, body)
+        .withSpan(span)
+        .withMods(synthetic | Artifact),
+      Closure(Nil, Ident(nme.ANON_FUN), if (isContextual) ContextualEmptyTree else EmptyTree))
+
+  /** If `nparams` == 1, expand partial function
+   *
+   *       { cases }
+   *  ==>
+   *       x$1 => (x$1 @unchecked?) match { cases }
+   *
+   *  If `nparams` != 1, expand instead to
+   *
+   *       (x$1, ..., x$n) => (x$0, ..., x${n-1} @unchecked?) match { cases }
+   */
+  def makeCaseLambda(cases: List[CaseDef], checkMode: MatchCheck, nparams: Int = 1)(using Context): Function = {
+    val params = (1 to nparams).toList.map(makeSyntheticParameter(_))
+    val selector = makeTuple(params.map(p => Ident(p.name)))
+    Function(params, Match(makeSelector(selector, checkMode), cases))
+  }
+
+  /** Map n-ary function `(x1: T1, ..., xn: Tn) => body` where n != 1 to unary function as follows:
+   *
+   *    (x$1: (T1, ..., Tn)) => {
+   *      def x1: T1 = x$1._1
+   *      ...
+   *      def xn: Tn = x$1._n
+   *      body
+   *    }
+   *
+   *  or if `isGenericTuple`
+   *
+   *    (x$1: (T1, ... Tn) => {
+   *      def x1: T1 = x$1.apply(0)
+   *      ...
+   *      def xn: Tn = x$1.apply(n-1)
+   *      body
+   *    }
+   *
+   *  If some of the Ti's are absent, omit the : (T1, ..., Tn) type ascription
+   *  in the selector.
+   */
+  def makeTupledFunction(params: List[ValDef], body: Tree, isGenericTuple: Boolean)(using Context): Tree = {
+    val param = makeSyntheticParameter(
+      tpt =
+        if params.exists(_.tpt.isEmpty) then TypeTree()
+        else Tuple(params.map(_.tpt)))
+    def selector(n: Int) =
+      if (isGenericTuple) Apply(Select(refOfDef(param), nme.apply), Literal(Constant(n)))
+      else Select(refOfDef(param), nme.selectorName(n))
+    val vdefs =
+      params.zipWithIndex.map {
+        case (param, idx) =>
+          ValDef(param.name, param.tpt, selector(idx))
+            .withSpan(param.span)
+            .withAttachment(UntupledParam, ())
+            .withFlags(Synthetic)
+      }
+    Function(param :: Nil, Block(vdefs, body))
+  }
+
+  /** Convert a tuple pattern with given `elems` to a sequence of `ValDefs`,
+   *  skipping elements that are not convertible.
+   */
+  def patternsToParams(elems: List[Tree])(using Context): List[ValDef] =
+    def toParam(elem: Tree, tpt: Tree): Tree =
+      elem match
+        case Annotated(elem1, _) => toParam(elem1, tpt)
+        case Typed(elem1, tpt1) => toParam(elem1, tpt1)
+        case Ident(id: TermName) => ValDef(id, tpt, EmptyTree).withFlags(Param)
+        case _ => EmptyTree
+    elems.map(param => toParam(param, TypeTree()).withSpan(param.span)).collect {
+      case vd: ValDef => vd
+    }
+
+  def makeContextualFunction(formals: List[Tree], body: Tree, isErased: Boolean)(using Context): Function = {
+    val mods = if (isErased) Given | Erased else Given
+    val params = makeImplicitParameters(formals, mods)
+    FunctionWithMods(params, body, Modifiers(mods))
+  }
+
+  private def derivedValDef(original: Tree, named: NameTree, tpt: Tree, rhs: Tree, mods: Modifiers)(using Context) = {
+    val vdef = ValDef(named.name.asTermName, tpt, rhs)
+      .withMods(mods)
+      .withSpan(original.span.withPoint(named.span.start))
+    val mayNeedSetter = valDef(vdef)
+    mayNeedSetter
+  }
+
+  private def derivedDefDef(original: Tree, named: NameTree, tpt: Tree, rhs: Tree, mods: Modifiers)(implicit src: SourceFile) =
+    DefDef(named.name.asTermName, Nil, tpt, rhs)
+      .withMods(mods)
+      .withSpan(original.span.withPoint(named.span.start))
+
+  /** Main desugaring method */
+  def apply(tree: Tree, pt: Type = NoType)(using Context): Tree = {
+
+    /** Create tree for for-comprehension `<for (enums) do body>` or
+     *   `<for (enums) yield body>` where mapName and flatMapName are chosen
+     *  corresponding to whether this is a for-do or a for-yield.
+     *  The creation performs the following rewrite rules:
+     *
+     *  1.
+     *
+     *    for (P <- G) E   ==>   G.foreach (P => E)
+     *
+     *     Here and in the following (P => E) is interpreted as the function (P => E)
+     *     if P is a variable pattern and as the partial function { case P => E } otherwise.
+     *
+     *  2.
+     *
+     *    for (P <- G) yield E  ==>  G.map (P => E)
+     *
+     *  3.
+     *
+     *    for (P_1 <- G_1; P_2 <- G_2; ...) ...
+     *      ==>
+     *    G_1.flatMap (P_1 => for (P_2 <- G_2; ...) ...)
+     *
+     *  4.
+     *
+     *    for (P <- G; E; ...) ...
+     *      =>
+     *    for (P <- G.filter (P => E); ...) ...
+     *
+     *  5. For any N:
+     *
+     *    for (P_1 <- G; P_2 = E_2; val P_N = E_N; ...)
+     *      ==>
+     *    for (TupleN(P_1, P_2, ... P_N) <-
+     *      for (x_1 @ P_1 <- G) yield {
+     *        val x_2 @ P_2 = E_2
+     *        ...
+     *        val x_N & P_N = E_N
+     *        TupleN(x_1, ..., x_N)
+     *      } ...)
+     *
+     *    If any of the P_i are variable patterns, the corresponding `x_i @ P_i` is not generated
+     *    and the variable constituting P_i is used instead of x_i
+     *
+     *  @param mapName      The name to be used for maps (either map or foreach)
+     *  @param flatMapName  The name to be used for flatMaps (either flatMap or foreach)
+     *  @param enums        The enumerators in the for expression
+     *  @param body         The body of the for expression
+     */
+    def makeFor(mapName: TermName, flatMapName: TermName, enums: List[Tree], body: Tree): Tree = trace(i"make for ${ForYield(enums, body)}", show = true) {
+
+      /** Let `pat` be `gen`'s pattern. Make a function value `pat => body`.
+       *  If `pat` is a var pattern `id: T` then this gives `(id: T) => body`.
+       *  Otherwise this gives `{ case pat => body }`, where `pat` is checked to be
+       *  irrefutable if `gen`'s checkMode is GenCheckMode.Check.
+       */
+      def makeLambda(gen: GenFrom, body: Tree): Tree = gen.pat match {
+        case IdPattern(named, tpt) if gen.checkMode != GenCheckMode.FilterAlways =>
+          Function(derivedValDef(gen.pat, named, tpt, EmptyTree, Modifiers(Param)) :: Nil, body)
+        case _ =>
+          val matchCheckMode =
+            if (gen.checkMode == GenCheckMode.Check || gen.checkMode == GenCheckMode.CheckAndFilter) MatchCheck.IrrefutableGenFrom
+            else MatchCheck.None
+          makeCaseLambda(CaseDef(gen.pat, EmptyTree, body) :: Nil, matchCheckMode)
+      }
+
+      /** If `pat` is not an Identifier, a Typed(Ident, _), or a Bind, wrap
+       *  it in a Bind with a fresh name. Return the transformed pattern, and the identifier
+       *  that refers to the bound variable for the pattern. Wildcard Binds are
+       *  also replaced by Binds with fresh names.
+       */
+      def makeIdPat(pat: Tree): (Tree, Ident) = pat match {
+        case bind @ Bind(name, pat1) =>
+          if name == nme.WILDCARD then
+            val name = UniqueName.fresh()
+            (cpy.Bind(pat)(name, pat1).withMods(bind.mods), Ident(name))
+          else (pat, Ident(name))
+        case id: Ident if isVarPattern(id) && id.name != nme.WILDCARD => (id, id)
+        case Typed(id: Ident, _) if isVarPattern(id) && id.name != nme.WILDCARD => (pat, id)
+        case _ =>
+          val name = UniqueName.fresh()
+          (Bind(name, pat), Ident(name))
+      }
+
+      /** Make a pattern filter:
+       *    rhs.withFilter { case pat => true case _ => false }
+       *
+       *  On handling irrefutable patterns:
+       *  The idea is to wait until the pattern matcher sees a call
+       *
+       *      xs withFilter { cases }
+       *
+       *  where cases can be proven to be refutable i.e. cases would be
+       *  equivalent to  { case _ => true }
+       *
+       *  In that case, compile to
+       *
+       *      xs withFilter alwaysTrue
+       *
+       *  where `alwaysTrue` is a predefined function value:
+       *
+       *      val alwaysTrue: Any => Boolean = true
+       *
+       *  In the libraries operations can take advantage of alwaysTrue to shortcircuit the
+       *  withFilter call.
+       *
+       *  def withFilter(f: Elem => Boolean) =
+       *    if (f eq alwaysTrue) this // or rather identity filter monadic applied to this
+       *    else real withFilter
+       */
+      def makePatFilter(rhs: Tree, pat: Tree): Tree = {
+        val cases = List(
+          CaseDef(pat, EmptyTree, Literal(Constant(true))),
+          CaseDef(Ident(nme.WILDCARD), EmptyTree, Literal(Constant(false))))
+        Apply(Select(rhs, nme.withFilter), makeCaseLambda(cases, MatchCheck.None))
+      }
+
+      /** Is pattern `pat` irrefutable when matched against `rhs`?
+       *  We only can do a simple syntactic check here; a more refined check
+       *  is done later in the pattern matcher (see discussion in @makePatFilter).
+       */
+      def isIrrefutable(pat: Tree, rhs: Tree): Boolean = {
+        def matchesTuple(pats: List[Tree], rhs: Tree): Boolean = rhs match {
+          case Tuple(trees) => (pats corresponds trees)(isIrrefutable)
+          case Parens(rhs1) => matchesTuple(pats, rhs1)
+          case Block(_, rhs1) => matchesTuple(pats, rhs1)
+          case If(_, thenp, elsep) => matchesTuple(pats, thenp) && matchesTuple(pats, elsep)
+          case Match(_, cases) => cases forall (matchesTuple(pats, _))
+          case CaseDef(_, _, rhs1) => matchesTuple(pats, rhs1)
+          case Throw(_) => true
+          case _ => false
+        }
+        pat match {
+          case Bind(_, pat1) => isIrrefutable(pat1, rhs)
+          case Parens(pat1) => isIrrefutable(pat1, rhs)
+          case Tuple(pats) => matchesTuple(pats, rhs)
+          case _ => isVarPattern(pat)
+        }
+      }
+
+      /** Is `pat` of the form `x`, `x T`, or `given T`? when used as the lhs of a generator,
+       *  these are all considered irrefutable.
+       */
+      def isVarBinding(pat: Tree): Boolean = pat match
+        case pat @ Bind(_, pat1) if pat.mods.is(Given) => isVarBinding(pat1)
+        case IdPattern(_) => true
+        case _ => false
+
+      def needsNoFilter(gen: GenFrom): Boolean = gen.checkMode match
+        case GenCheckMode.FilterAlways => false  // pattern was prefixed by `case`
+        case GenCheckMode.FilterNow | GenCheckMode.CheckAndFilter => isVarBinding(gen.pat) || isIrrefutable(gen.pat, gen.expr)
+        case GenCheckMode.Check => true
+        case GenCheckMode.Ignore => true
+
+      /** rhs.name with a pattern filter on rhs unless `pat` is irrefutable when
+       *  matched against `rhs`.
+       */
+      def rhsSelect(gen: GenFrom, name: TermName) = {
+        val rhs = if (needsNoFilter(gen)) gen.expr else makePatFilter(gen.expr, gen.pat)
+        Select(rhs, name)
+      }
+
+      enums match {
+        case (gen: GenFrom) :: Nil =>
+          Apply(rhsSelect(gen, mapName), makeLambda(gen, body))
+        case (gen: GenFrom) :: (rest @ (GenFrom(_, _, _) :: _)) =>
+          val cont = makeFor(mapName, flatMapName, rest, body)
+          Apply(rhsSelect(gen, flatMapName), makeLambda(gen, cont))
+        case (gen: GenFrom) :: (rest @ GenAlias(_, _) :: _) =>
+          val (valeqs, rest1) = rest.span(_.isInstanceOf[GenAlias])
+          val pats = valeqs map { case GenAlias(pat, _) => pat }
+          val rhss = valeqs map { case GenAlias(_, rhs) => rhs }
+          val (defpat0, id0) = makeIdPat(gen.pat)
+          val (defpats, ids) = (pats map makeIdPat).unzip
+          val pdefs = valeqs.lazyZip(defpats).lazyZip(rhss).map { (valeq, defpat, rhs) =>
+            val mods = defpat match
+              case defTree: DefTree => defTree.mods
+              case _ => Modifiers()
+            makePatDef(valeq, mods, defpat, rhs)
+          }
+          val rhs1 = makeFor(nme.map, nme.flatMap, GenFrom(defpat0, gen.expr, gen.checkMode) :: Nil, Block(pdefs, makeTuple(id0 :: ids)))
+          val allpats = gen.pat :: pats
+          val vfrom1 = GenFrom(makeTuple(allpats), rhs1, GenCheckMode.Ignore)
+          makeFor(mapName, flatMapName, vfrom1 :: rest1, body)
+        case (gen: GenFrom) :: test :: rest =>
+          val filtered = Apply(rhsSelect(gen, nme.withFilter), makeLambda(gen, test))
+          val genFrom = GenFrom(gen.pat, filtered, GenCheckMode.Ignore)
+          makeFor(mapName, flatMapName, genFrom :: rest, body)
+        case _ =>
+          EmptyTree //may happen for erroneous input
+      }
+    }
+
+    def makePolyFunction(targs: List[Tree], body: Tree, pt: Type): Tree = body match {
+      case Parens(body1) =>
+        makePolyFunction(targs, body1, pt)
+      case Block(Nil, body1) =>
+        makePolyFunction(targs, body1, pt)
+      case Function(vargs, res) =>
+        assert(targs.nonEmpty)
+        // TODO: Figure out if we need a `PolyFunctionWithMods` instead.
+        val mods = body match {
+          case body: FunctionWithMods => body.mods
+          case _ => untpd.EmptyModifiers
+        }
+        val polyFunctionTpt = ref(defn.PolyFunctionType)
+        val applyTParams = targs.asInstanceOf[List[TypeDef]]
+        if (ctx.mode.is(Mode.Type)) {
+          // Desugar [T_1, ..., T_M] -> (P_1, ..., P_N) => R
+          // Into    scala.PolyFunction { def apply[T_1, ..., T_M](x$1: P_1, ..., x$N: P_N): R }
+
+          val applyVParams = vargs.zipWithIndex.map {
+            case (p: ValDef, _) => p.withAddedFlags(mods.flags)
+            case (p, n) => makeSyntheticParameter(n + 1, p).withAddedFlags(mods.flags)
+          }
+          RefinedTypeTree(polyFunctionTpt, List(
+            DefDef(nme.apply, applyTParams :: applyVParams :: Nil, res, EmptyTree).withFlags(Synthetic)
+          ))
+        }
+        else {
+          // Desugar [T_1, ..., T_M] -> (x_1: P_1, ..., x_N: P_N) => body
+          // with pt [S_1, ..., S_M] -> (O_1, ..., O_N) => R
+          // Into    new scala.PolyFunction { def apply[T_1, ..., T_M](x_1: P_1, ..., x_N: P_N): R2 = body }
+          // where R2 is R, with all references to S_1..S_M replaced with T1..T_M.
+
+          def typeTree(tp: Type) = tp match
+            case RefinedType(parent, nme.apply, PolyType(_, mt)) if parent.typeSymbol eq defn.PolyFunctionClass =>
+              var bail = false
+              def mapper(tp: Type, topLevel: Boolean = false): Tree = tp match
+                case tp: TypeRef              => ref(tp)
+                case tp: TypeParamRef         => Ident(applyTParams(tp.paramNum).name)
+                case AppliedType(tycon, args) => AppliedTypeTree(mapper(tycon), args.map(mapper(_)))
+                case _                        => if topLevel then TypeTree() else { bail = true; genericEmptyTree }
+              val mapped = mapper(mt.resultType, topLevel = true)
+              if bail then TypeTree() else mapped
+            case _ => TypeTree()
+
+          val applyVParams = vargs.asInstanceOf[List[ValDef]]
+            .map(varg => varg.withAddedFlags(mods.flags | Param))
+            New(Template(emptyConstructor, List(polyFunctionTpt), Nil, EmptyValDef,
+              List(DefDef(nme.apply, applyTParams :: applyVParams :: Nil, typeTree(pt), res))
+              ))
+        }
+      case _ =>
+        // may happen for erroneous input. An error will already have been reported.
+        assert(ctx.reporter.errorsReported)
+        EmptyTree
+    }
+
+    // begin desugar
+
+    // Special case for `Parens` desugaring: unlike all the desugarings below,
+    // its output is not a new tree but an existing one whose position should
+    // be preserved, so we shouldn't call `withPos` on it.
+    tree match {
+      case Parens(t) =>
+        return t
+      case _ =>
+    }
+
+    val desugared = tree match {
+      case PolyFunction(targs, body) =>
+        makePolyFunction(targs, body, pt) orElse tree
+      case SymbolLit(str) =>
+        Apply(
+          ref(defn.ScalaSymbolClass.companionModule.termRef),
+          Literal(Constant(str)) :: Nil)
+      case InterpolatedString(id, segments) =>
+        val strs = segments map {
+          case ts: Thicket => ts.trees.head
+          case t => t
+        }
+        val elems = segments flatMap {
+          case ts: Thicket => ts.trees.tail
+          case t => Nil
+        } map { (t: Tree) => t match
+            // !cc! explicitly typed parameter (t: Tree) is needed since otherwise
+            // we get an error similar to #16268. (The explicit type constrains the type of `segments`
+            // which is otherwise List[{*} tree])
+          case Block(Nil, EmptyTree) => Literal(Constant(())) // for s"... ${} ..."
+          case Block(Nil, expr) => expr // important for interpolated string as patterns, see i1773.scala
+          case t => t
+        }
+        // This is a deliberate departure from scalac, where StringContext is not rooted (See #4732)
+        Apply(Select(Apply(scalaDot(nme.StringContext), strs), id).withSpan(tree.span), elems)
+      case PostfixOp(t, op) =>
+        if (ctx.mode is Mode.Type) && !isBackquoted(op) && op.name == tpnme.raw.STAR then
+          if ctx.isJava then
+            AppliedTypeTree(ref(defn.RepeatedParamType), t)
+          else
+            Annotated(
+              AppliedTypeTree(ref(defn.SeqType), t),
+              New(ref(defn.RepeatedAnnot.typeRef), Nil :: Nil))
+        else
+          assert(ctx.mode.isExpr || ctx.reporter.errorsReported || ctx.mode.is(Mode.Interactive), ctx.mode)
+          Select(t, op.name)
+      case PrefixOp(op, t) =>
+        val nspace = if (ctx.mode.is(Mode.Type)) tpnme else nme
+        Select(t, nspace.UNARY_PREFIX ++ op.name)
+      case ForDo(enums, body) =>
+        makeFor(nme.foreach, nme.foreach, enums, body) orElse tree
+      case ForYield(enums, body) =>
+        makeFor(nme.map, nme.flatMap, enums, body) orElse tree
+      case PatDef(mods, pats, tpt, rhs) =>
+        val pats1 = if (tpt.isEmpty) pats else pats map (Typed(_, tpt))
+        flatTree(pats1 map (makePatDef(tree, mods, _, rhs)))
+      case ext: ExtMethods =>
+        Block(List(ext), Literal(Constant(())).withSpan(ext.span))
+      case CapturingTypeTree(refs, parent) =>
+        // convert   `{refs} T`   to `T @retains refs`
+        //           `{refs}-> T` to `-> (T @retainsByName refs)`
+        def annotate(annotName: TypeName, tp: Tree) =
+          Annotated(tp, New(scalaAnnotationDot(annotName), List(refs)))
+        parent match
+          case ByNameTypeTree(restpt) =>
+            cpy.ByNameTypeTree(parent)(annotate(tpnme.retainsByName, restpt))
+          case _ =>
+            annotate(tpnme.retains, parent)
+    }
+    desugared.withSpan(tree.span)
+  }
+
+  /** Turn a fucntion value `handlerFun` into a catch case for a try.
+   *  If `handlerFun` is a partial function, translate to
+   *
+   *    case ex =>
+   *      val ev$1 = handlerFun
+   *      if ev$1.isDefinedAt(ex) then ev$1.apply(ex) else throw ex
+   *
+   *  Otherwise translate to
+   *
+   *     case ex => handlerFun.apply(ex)
+   */
+  def makeTryCase(handlerFun: tpd.Tree)(using Context): CaseDef =
+    val handler = TypedSplice(handlerFun)
+    val excId = Ident(nme.DEFAULT_EXCEPTION_NAME)
+    val rhs =
+      if handlerFun.tpe.widen.isRef(defn.PartialFunctionClass) then
+        val tmpName = UniqueName.fresh()
+        val tmpId = Ident(tmpName)
+        val init = ValDef(tmpName, TypeTree(), handler)
+        val test = If(
+          Apply(Select(tmpId, nme.isDefinedAt), excId),
+          Apply(Select(tmpId, nme.apply), excId),
+          Throw(excId))
+        Block(init :: Nil, test)
+      else
+        Apply(Select(handler, nme.apply), excId)
+    CaseDef(excId, EmptyTree, rhs)
+
+  /** Create a class definition with the same info as the refined type given by `parent`
+   *  and `refinements`.
+   *
+   *      parent { refinements }
+   *  ==>
+   *      trait <refinement> extends core { this: self => refinements }
+   *
+   *  Here, `core` is the (possibly parameterized) class part of `parent`.
+   *  If `parent` is the same as `core`, self is empty. Otherwise `self` is `parent`.
+   *
+   *  Example: Given
+   *
+   *      class C
+   *      type T1 = C { type T <: A }
+   *
+   *  the refined type
+   *
+   *      T1 { type T <: B }
+   *
+   *  is expanded to
+   *
+   *      trait <refinement> extends C { this: T1 => type T <: A }
+   *
+   *  The result of this method is used for validity checking, is thrown away afterwards.
+   *  @param parent  The type of `parent`
+   */
+  def refinedTypeToClass(parent: tpd.Tree, refinements: List[Tree])(using Context): TypeDef = {
+    def stripToCore(tp: Type): List[Type] = tp match {
+      case tp: AppliedType => tp :: Nil
+      case tp: TypeRef if tp.symbol.isClass => tp :: Nil     // monomorphic class type
+      case tp: TypeProxy => stripToCore(tp.underlying)
+      case AndType(tp1, tp2) => stripToCore(tp1) ::: stripToCore(tp2)
+      case _ => defn.AnyType :: Nil
+    }
+    val parentCores = stripToCore(parent.tpe)
+    val untpdParent = TypedSplice(parent)
+    val (classParents, self) =
+      if (parentCores.length == 1 && (parent.tpe eq parentCores.head)) (untpdParent :: Nil, EmptyValDef)
+      else (parentCores map TypeTree, ValDef(nme.WILDCARD, untpdParent, EmptyTree))
+    val impl = Template(emptyConstructor, classParents, Nil, self, refinements)
+    TypeDef(tpnme.REFINE_CLASS, impl).withFlags(Trait)
+  }
+
+  /** Returns list of all pattern variables, possibly with their types,
+   *  without duplicates
+   */
+  private def getVariables(tree: Tree, shouldAddGiven: Context ?=> Bind => Boolean)(using Context): List[VarInfo] = {
+    val buf = ListBuffer[VarInfo]()
+    def seenName(name: Name) = buf exists (_._1.name == name)
+    def add(named: NameTree, t: Tree): Unit =
+      if (!seenName(named.name) && named.name.isTermName) buf += ((named, t))
+    def collect(tree: Tree): Unit = tree match {
+      case tree @ Bind(nme.WILDCARD, tree1) =>
+        if tree.mods.is(Given) then
+          val Typed(_, tpt) = tree1: @unchecked
+          if shouldAddGiven(tree) then
+            add(tree, tpt)
+        collect(tree1)
+      case tree @ Bind(_, Typed(tree1, tpt)) =>
+        if !(tree.mods.is(Given) && !shouldAddGiven(tree)) then
+          add(tree, tpt)
+        collect(tree1)
+      case tree @ Bind(_, tree1) =>
+        add(tree, TypeTree())
+        collect(tree1)
+      case Typed(id: Ident, t) if isVarPattern(id) && id.name != nme.WILDCARD && !isWildcardStarArg(tree) =>
+        add(id, t)
+      case id: Ident if isVarPattern(id) && id.name != nme.WILDCARD =>
+        add(id, TypeTree())
+      case Apply(_, args) =>
+        args foreach collect
+      case Typed(expr, _) =>
+        collect(expr)
+      case NamedArg(_, arg) =>
+        collect(arg)
+      case SeqLiteral(elems, _) =>
+        elems foreach collect
+      case Alternative(trees) =>
+        for (tree <- trees; (vble, _) <- getVariables(tree, shouldAddGiven))
+          report.error(IllegalVariableInPatternAlternative(vble.symbol.name), vble.srcPos)
+      case Annotated(arg, _) =>
+        collect(arg)
+      case InterpolatedString(_, segments) =>
+        segments foreach collect
+      case InfixOp(left, _, right) =>
+        collect(left)
+        collect(right)
+      case PrefixOp(_, od) =>
+        collect(od)
+      case Parens(tree) =>
+        collect(tree)
+      case Tuple(trees) =>
+        trees foreach collect
+      case Thicket(trees) =>
+        trees foreach collect
+      case Block(Nil, expr) =>
+        collect(expr)
+      case Quote(expr) =>
+        new UntypedTreeTraverser {
+          def traverse(tree: untpd.Tree)(using Context): Unit = tree match {
+            case Splice(expr) => collect(expr)
+            case _ => traverseChildren(tree)
+          }
+        }.traverse(expr)
+      case CapturingTypeTree(refs, parent) =>
+        collect(parent)
+      case _ =>
+    }
+    collect(tree)
+    buf.toList
+  }
+}
diff --git a/tests/pos-with-compiler-cc/dotc/ast/DesugarEnums.scala b/tests/pos-with-compiler-cc/dotc/ast/DesugarEnums.scala
new file mode 100644
index 000000000000..096a885dcf32
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/ast/DesugarEnums.scala
@@ -0,0 +1,310 @@
+package dotty.tools
+package dotc
+package ast
+
+import core._
+import util.Spans._, Types._, Contexts._, Constants._, Names._, Flags._
+import Symbols._, StdNames._, Trees._
+import Decorators._
+import util.{Property, SourceFile}
+import typer.ErrorReporting._
+import transform.SyntheticMembers.ExtendsSingletonMirror
+
+import scala.annotation.internal.sharable
+
+/** Helper methods to desugar enums */
+object DesugarEnums {
+  import untpd._
+
+  enum CaseKind:
+    case Simple, Object, Class
+
+  final case class EnumConstraints(minKind: CaseKind, maxKind: CaseKind, enumCases: List[(Int, RefTree)]):
+    require(minKind.ordinal <= maxKind.ordinal && !(cached && enumCases.isEmpty))
+    def requiresCreator = minKind == CaseKind.Simple
+    def isEnumeration   = maxKind.ordinal < CaseKind.Class.ordinal
+    def cached          = minKind.ordinal < CaseKind.Class.ordinal
+  end EnumConstraints
+
+  /** Attachment containing the number of enum cases, the smallest kind that was seen so far,
+   *  and a list of all the value cases with their ordinals.
+   */
+  val EnumCaseCount: Property.Key[(Int, CaseKind, CaseKind, List[(Int, TermName)])] = Property.Key()
+
+  /** Attachment signalling that when this definition is desugared, it should add any additional
+   *  lookup methods for enums.
+   */
+  val DefinesEnumLookupMethods: Property.Key[Unit] = Property.Key()
+
+  /** The enumeration class that belongs to an enum case. This works no matter
+   *  whether the case is still in the enum class or it has been transferred to the
+   *  companion object.
+   */
+  def enumClass(using Context): Symbol = {
+    val cls = ctx.owner
+    if (cls.is(Module)) cls.linkedClass else cls
+  }
+
+  def enumCompanion(using Context): Symbol = {
+    val cls = ctx.owner
+    if (cls.is(Module)) cls.sourceModule else cls.linkedClass.sourceModule
+  }
+
+  /** Is `tree` an (untyped) enum case? */
+  def isEnumCase(tree: Tree)(using Context): Boolean = tree match {
+    case tree: MemberDef => tree.mods.isEnumCase
+    case PatDef(mods, _, _, _) => mods.isEnumCase
+    case _ => false
+  }
+
+  /** A reference to the enum class `E`, possibly followed by type arguments.
+   *  Each covariant type parameter is approximated by its lower bound.
+   *  Each contravariant type parameter is approximated by its upper bound.
+   *  It is an error if a type parameter is non-variant, or if its approximation
+   *  refers to pther type parameters.
+   */
+  def interpolatedEnumParent(span: Span)(using Context): Tree = {
+    val tparams = enumClass.typeParams
+    def isGround(tp: Type) = tp.subst(tparams, tparams.map(_ => NoType)) eq tp
+    val targs = tparams map { tparam =>
+      if (tparam.is(Covariant) && isGround(tparam.info.bounds.lo))
+        tparam.info.bounds.lo
+      else if (tparam.is(Contravariant) && isGround(tparam.info.bounds.hi))
+        tparam.info.bounds.hi
+      else {
+        def problem =
+          if (!tparam.isOneOf(VarianceFlags)) "is invariant"
+          else "has bounds that depend on a type parameter in the same parameter list"
+        errorType(i"""cannot determine type argument for enum parent $enumClass,
+                     |type parameter $tparam $problem""", ctx.source.atSpan(span))
+      }
+    }
+    TypeTree(enumClass.typeRef.appliedTo(targs)).withSpan(span)
+  }
+
+  /** A type tree referring to `enumClass` */
+  def enumClassRef(using Context): Tree =
+    if (enumClass.exists) TypeTree(enumClass.typeRef) else TypeTree()
+
+  /** Add implied flags to an enum class or an enum case */
+  def addEnumFlags(cdef: TypeDef)(using Context): TypeDef =
+    if (cdef.mods.isEnumClass) cdef.withMods(cdef.mods.withAddedFlags(Abstract | Sealed, cdef.span))
+    else if (isEnumCase(cdef)) cdef.withMods(cdef.mods.withAddedFlags(Final, cdef.span))
+    else cdef
+
+  private def valuesDot(name: PreName)(implicit src: SourceFile) =
+    Select(Ident(nme.DOLLAR_VALUES), name.toTermName)
+
+  private def ArrayLiteral(values: List[Tree], tpt: Tree)(using Context): Tree =
+    val clazzOf = TypeApply(ref(defn.Predef_classOf.termRef), tpt :: Nil)
+    val ctag    = Apply(TypeApply(ref(defn.ClassTagModule_apply.termRef), tpt :: Nil), clazzOf :: Nil)
+    val apply   = Select(ref(defn.ArrayModule.termRef), nme.apply)
+    Apply(Apply(TypeApply(apply, tpt :: Nil), values), ctag :: Nil)
+
+  /**  The following lists of definitions for an enum type E and known value cases e_0, ..., e_n:
+   *
+   *   private val $values = Array[E](this.e_0,...,this.e_n)(ClassTag[E](classOf[E]))
+   *   def values = $values.clone
+   *   def valueOf($name: String) = $name match {
+   *     case "e_0" => this.e_0
+   *     ...
+   *     case "e_n" => this.e_n
+   *     case _ => throw new IllegalArgumentException("case not found: " + $name)
+   *   }
+   */
+  private def enumScaffolding(enumValues: List[RefTree])(using Context): List[Tree] = {
+    val rawEnumClassRef = rawRef(enumClass.typeRef)
+    extension (tpe: NamedType) def ofRawEnum = AppliedTypeTree(ref(tpe), rawEnumClassRef)
+
+    val privateValuesDef =
+      ValDef(nme.DOLLAR_VALUES, TypeTree(), ArrayLiteral(enumValues, rawEnumClassRef))
+        .withFlags(Private | Synthetic)
+
+    val valuesDef =
+      DefDef(nme.values, Nil, defn.ArrayType.ofRawEnum, valuesDot(nme.clone_))
+        .withFlags(Synthetic)
+
+    val valuesOfBody: Tree =
+      val defaultCase =
+        val msg = Apply(Select(Literal(Constant("enum case not found: ")), nme.PLUS), Ident(nme.nameDollar))
+        CaseDef(Ident(nme.WILDCARD), EmptyTree,
+          Throw(New(TypeTree(defn.IllegalArgumentExceptionType), List(msg :: Nil))))
+      val stringCases = enumValues.map(enumValue =>
+        CaseDef(Literal(Constant(enumValue.name.toString)), EmptyTree, enumValue)
+      ) ::: defaultCase :: Nil
+      Match(Ident(nme.nameDollar), stringCases)
+    val valueOfDef = DefDef(nme.valueOf, List(param(nme.nameDollar, defn.StringType) :: Nil),
+      TypeTree(), valuesOfBody)
+        .withFlags(Synthetic)
+
+    privateValuesDef ::
+    valuesDef ::
+    valueOfDef :: Nil
+  }
+
+  private def enumLookupMethods(constraints: EnumConstraints)(using Context): List[Tree] =
+    def scaffolding: List[Tree] =
+      if constraints.isEnumeration then enumScaffolding(constraints.enumCases.map(_._2)) else Nil
+    def valueCtor: List[Tree] = if constraints.requiresCreator then enumValueCreator :: Nil else Nil
+    def fromOrdinal: Tree =
+      def throwArg(ordinal: Tree) =
+        Throw(New(TypeTree(defn.NoSuchElementExceptionType), List(Select(ordinal, nme.toString_) :: Nil)))
+      if !constraints.cached then
+        fromOrdinalMeth(throwArg)
+      else
+        def default(ordinal: Tree) =
+          CaseDef(Ident(nme.WILDCARD), EmptyTree, throwArg(ordinal))
+        if constraints.isEnumeration then
+          fromOrdinalMeth(ordinal =>
+            Try(Apply(valuesDot(nme.apply), ordinal), default(ordinal) :: Nil, EmptyTree))
+        else
+          fromOrdinalMeth(ordinal =>
+            Match(ordinal,
+              constraints.enumCases.map((i, enumValue) => CaseDef(Literal(Constant(i)), EmptyTree, enumValue))
+              :+ default(ordinal)))
+
+    if !enumClass.exists then
+      // in the case of a double definition of an enum that only defines class cases (see tests/neg/i4470c.scala)
+      // it seems `enumClass` might be `NoSymbol`; in this case we provide no scaffolding.
+      Nil
+    else
+      scaffolding ::: valueCtor ::: fromOrdinal :: Nil
+  end enumLookupMethods
+
+  /** A creation method for a value of enum type `E`, which is defined as follows:
+   *
+   *   private def $new(_$ordinal: Int, $name: String) = new E with scala.runtime.EnumValue {
+   *     def ordinal = _$ordinal // if `E` does not derive from `java.lang.Enum`
+   *   }
+   */
+  private def enumValueCreator(using Context) = {
+    val creator = New(Template(
+      constr = emptyConstructor,
+      parents = enumClassRef :: scalaRuntimeDot(tpnme.EnumValue) :: Nil,
+      derived = Nil,
+      self = EmptyValDef,
+      body = Nil
+    ).withAttachment(ExtendsSingletonMirror, ()))
+    DefDef(nme.DOLLAR_NEW,
+        List(List(param(nme.ordinalDollar_, defn.IntType), param(nme.nameDollar, defn.StringType))),
+        TypeTree(), creator).withFlags(Private | Synthetic)
+  }
+
+  /** Is a type parameter in `enumTypeParams` referenced from an enum class case that has
+   *  given type parameters `caseTypeParams`, value parameters `vparamss` and parents `parents`?
+   *  Issues an error if that is the case but the reference is illegal.
+   *  The reference could be illegal for two reasons:
+   *   - explicit type parameters are given
+   *   - it's a value case, i.e. no value parameters are given
+   */
+  def typeParamIsReferenced(
+    enumTypeParams: List[TypeSymbol],
+    caseTypeParams: List[TypeDef],
+    vparamss: List[List[ValDef]],
+    parents: List[Tree])(using Context): Boolean = {
+
+    object searchRef extends UntypedTreeAccumulator[Boolean] {
+      var tparamNames = enumTypeParams.map(_.name).toSet[Name]
+      def underBinders(binders: List[MemberDef], op: => Boolean): Boolean = {
+        val saved = tparamNames
+        tparamNames = tparamNames -- binders.map(_.name)
+        try op
+        finally tparamNames = saved
+      }
+      def apply(x: Boolean, tree: Tree)(using Context): Boolean = x || {
+        tree match {
+          case Ident(name) =>
+            val matches = tparamNames.contains(name)
+            if (matches && (caseTypeParams.nonEmpty || vparamss.isEmpty))
+              report.error(i"illegal reference to type parameter $name from enum case", tree.srcPos)
+            matches
+          case LambdaTypeTree(lambdaParams, body) =>
+            underBinders(lambdaParams, foldOver(x, tree))
+          case RefinedTypeTree(parent, refinements) =>
+            val refinementDefs = refinements collect { case r: MemberDef => r }
+            underBinders(refinementDefs, foldOver(x, tree))
+          case _ => foldOver(x, tree)
+        }
+      }
+      def apply(tree: Tree)(using Context): Boolean =
+        underBinders(caseTypeParams, apply(false, tree))
+    }
+
+    def typeHasRef(tpt: Tree) = searchRef(tpt)
+    def valDefHasRef(vd: ValDef) = typeHasRef(vd.tpt)
+    def parentHasRef(parent: Tree): Boolean = parent match {
+      case Apply(fn, _) => parentHasRef(fn)
+      case TypeApply(_, targs) => targs.exists(typeHasRef)
+      case Select(nu, nme.CONSTRUCTOR) => parentHasRef(nu)
+      case New(tpt) => typeHasRef(tpt)
+      case parent => parent.isType && typeHasRef(parent)
+    }
+
+    vparamss.nestedExists(valDefHasRef) || parents.exists(parentHasRef)
+  }
+
+  /** A pair consisting of
+   *   - the next enum tag
+   *   - scaffolding containing the necessary definitions for singleton enum cases
+   *     unless that scaffolding was already generated by a previous call to `nextEnumKind`.
+   */
+  def nextOrdinal(name: Name, kind: CaseKind, definesLookups: Boolean)(using Context): (Int, List[Tree]) = {
+    val (ordinal, seenMinKind, seenMaxKind, seenCases) =
+      ctx.tree.removeAttachment(EnumCaseCount).getOrElse((0, CaseKind.Class, CaseKind.Simple, Nil))
+    val minKind = if kind.ordinal < seenMinKind.ordinal then kind else seenMinKind
+    val maxKind = if kind.ordinal > seenMaxKind.ordinal then kind else seenMaxKind
+    val cases = name match
+      case name: TermName => (ordinal, name) :: seenCases
+      case _              => seenCases
+    if definesLookups then
+      val thisRef = This(EmptyTypeIdent)
+      val cachedValues = cases.reverse.map((i, name) => (i, Select(thisRef, name)))
+      (ordinal, enumLookupMethods(EnumConstraints(minKind, maxKind, cachedValues)))
+    else
+      ctx.tree.pushAttachment(EnumCaseCount, (ordinal + 1, minKind, maxKind, cases))
+      (ordinal, Nil)
+  }
+
+  def param(name: TermName, typ: Type)(using Context): ValDef = param(name, TypeTree(typ))
+  def param(name: TermName, tpt: Tree)(using Context): ValDef = ValDef(name, tpt, EmptyTree).withFlags(Param)
+
+  def ordinalMeth(body: Tree)(using Context): DefDef =
+    DefDef(nme.ordinal, Nil, TypeTree(defn.IntType), body).withAddedFlags(Synthetic)
+
+  def ordinalMethLit(ord: Int)(using Context): DefDef =
+    ordinalMeth(Literal(Constant(ord)))
+
+  def fromOrdinalMeth(body: Tree => Tree)(using Context): DefDef =
+    DefDef(nme.fromOrdinal, (param(nme.ordinal, defn.IntType) :: Nil) :: Nil,
+      rawRef(enumClass.typeRef), body(Ident(nme.ordinal))).withFlags(Synthetic)
+
+  /** Expand a module definition representing a parameterless enum case */
+  def expandEnumModule(name: TermName, impl: Template, mods: Modifiers, definesLookups: Boolean, span: Span)(using Context): Tree = {
+    assert(impl.body.isEmpty)
+    if (!enumClass.exists) EmptyTree
+    else if (impl.parents.isEmpty)
+      expandSimpleEnumCase(name, mods, definesLookups, span)
+    else {
+      val (tag, scaffolding) = nextOrdinal(name, CaseKind.Object, definesLookups)
+      val impl1 = cpy.Template(impl)(parents = impl.parents :+ scalaRuntimeDot(tpnme.EnumValue), body = Nil)
+        .withAttachment(ExtendsSingletonMirror, ())
+      val vdef = ValDef(name, TypeTree(), New(impl1)).withMods(mods.withAddedFlags(EnumValue, span))
+      flatTree(vdef :: scaffolding).withSpan(span)
+    }
+  }
+
+  /** Expand a simple enum case */
+  def expandSimpleEnumCase(name: TermName, mods: Modifiers, definesLookups: Boolean, span: Span)(using Context): Tree =
+    if (!enumClass.exists) EmptyTree
+    else if (enumClass.typeParams.nonEmpty) {
+      val parent = interpolatedEnumParent(span)
+      val impl = Template(emptyConstructor, parent :: Nil, Nil, EmptyValDef, Nil)
+      expandEnumModule(name, impl, mods, definesLookups, span)
+    }
+    else {
+      val (tag, scaffolding) = nextOrdinal(name, CaseKind.Simple, definesLookups)
+      val creator = Apply(Ident(nme.DOLLAR_NEW), List(Literal(Constant(tag)), Literal(Constant(name.toString))))
+      val vdef = ValDef(name, enumClassRef, creator).withMods(mods.withAddedFlags(EnumValue, span))
+      flatTree(vdef :: scaffolding).withSpan(span)
+    }
+}
diff --git a/tests/pos-with-compiler-cc/dotc/ast/MainProxies.scala b/tests/pos-with-compiler-cc/dotc/ast/MainProxies.scala
new file mode 100644
index 000000000000..040582476e96
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/ast/MainProxies.scala
@@ -0,0 +1,449 @@
+package dotty.tools.dotc
+package ast
+
+import core._
+import Symbols._, Types._, Contexts._, Decorators._, util.Spans._, Flags._, Constants._
+import StdNames.{nme, tpnme}
+import ast.Trees._
+import Names.Name
+import Comments.Comment
+import NameKinds.DefaultGetterName
+import Annotations.Annotation
+
+object MainProxies {
+
+  /** Generate proxy classes for @main functions and @myMain functions where myMain <:< MainAnnotation */
+  def proxies(stats: List[tpd.Tree])(using Context): List[untpd.Tree] = {
+    mainAnnotationProxies(stats) ++ mainProxies(stats)
+  }
+
+  /** Generate proxy classes for @main functions.
+   *  A function like
+   *
+   *     @main def f(x: S, ys: T*) = ...
+   *
+   *  would be translated to something like
+   *
+   *     import CommandLineParser._
+   *     class f {
+   *       @static def main(args: Array[String]): Unit =
+   *         try
+   *           f(
+   *             parseArgument[S](args, 0),
+   *             parseRemainingArguments[T](args, 1): _*
+   *           )
+   *         catch case err: ParseError => showError(err)
+   *       }
+   */
+  private def mainProxies(stats: List[tpd.Tree])(using Context): List[untpd.Tree] = {
+    import tpd._
+    def mainMethods(stats: List[Tree]): List[Symbol] = stats.flatMap {
+      case stat: DefDef if stat.symbol.hasAnnotation(defn.MainAnnot) =>
+        stat.symbol :: Nil
+      case stat @ TypeDef(name, impl: Template) if stat.symbol.is(Module) =>
+        mainMethods(impl.body)
+      case _ =>
+        Nil
+    }
+    mainMethods(stats).flatMap(mainProxy)
+  }
+
+  import untpd._
+  private def mainProxy(mainFun: Symbol)(using Context): List[TypeDef] = {
+    val mainAnnotSpan = mainFun.getAnnotation(defn.MainAnnot).get.tree.span
+    def pos = mainFun.sourcePos
+    val argsRef = Ident(nme.args)
+
+    def addArgs(call: untpd.Tree, mt: MethodType, idx: Int): untpd.Tree =
+      if (mt.isImplicitMethod) {
+        report.error(s"@main method cannot have implicit parameters", pos)
+        call
+      }
+      else {
+        val args = mt.paramInfos.zipWithIndex map {
+          (formal, n) =>
+            val (parserSym, formalElem) =
+              if (formal.isRepeatedParam) (defn.CLP_parseRemainingArguments, formal.argTypes.head)
+              else (defn.CLP_parseArgument, formal)
+            val arg = Apply(
+              TypeApply(ref(parserSym.termRef), TypeTree(formalElem) :: Nil),
+              argsRef :: Literal(Constant(idx + n)) :: Nil)
+            if (formal.isRepeatedParam) repeated(arg) else arg
+        }
+        val call1 = Apply(call, args)
+        mt.resType match {
+          case restpe: MethodType =>
+            if (mt.paramInfos.lastOption.getOrElse(NoType).isRepeatedParam)
+              report.error(s"varargs parameter of @main method must come last", pos)
+            addArgs(call1, restpe, idx + args.length)
+          case _ =>
+            call1
+        }
+      }
+
+    var result: List[TypeDef] = Nil
+    if (!mainFun.owner.isStaticOwner)
+      report.error(s"@main method is not statically accessible", pos)
+    else {
+      var call = ref(mainFun.termRef)
+      mainFun.info match {
+        case _: ExprType =>
+        case mt: MethodType =>
+          call = addArgs(call, mt, 0)
+        case _: PolyType =>
+          report.error(s"@main method cannot have type parameters", pos)
+        case _ =>
+          report.error(s"@main can only annotate a method", pos)
+      }
+      val errVar = Ident(nme.error)
+      val handler = CaseDef(
+        Typed(errVar, TypeTree(defn.CLP_ParseError.typeRef)),
+        EmptyTree,
+        Apply(ref(defn.CLP_showError.termRef), errVar :: Nil))
+      val body = Try(call, handler :: Nil, EmptyTree)
+      val mainArg = ValDef(nme.args, TypeTree(defn.ArrayType.appliedTo(defn.StringType)), EmptyTree)
+        .withFlags(Param)
+      /** Replace typed `Ident`s that have been typed with a TypeSplice with the reference to the symbol.
+       *  The annotations will be retype-checked in another scope that may not have the same imports.
+       */
+      def insertTypeSplices = new TreeMap {
+          override def transform(tree: Tree)(using Context): Tree = tree match
+            case tree: tpd.Ident @unchecked => TypedSplice(tree)
+            case tree => super.transform(tree)
+      }
+      val annots = mainFun.annotations
+        .filterNot(_.matches(defn.MainAnnot))
+        .map(annot => insertTypeSplices.transform(annot.tree))
+      val mainMeth = DefDef(nme.main, (mainArg :: Nil) :: Nil, TypeTree(defn.UnitType), body)
+        .withFlags(JavaStatic | Synthetic)
+        .withAnnotations(annots)
+      val mainTempl = Template(emptyConstructor, Nil, Nil, EmptyValDef, mainMeth :: Nil)
+      val mainCls = TypeDef(mainFun.name.toTypeName, mainTempl)
+        .withFlags(Final | Invisible)
+
+      if (!ctx.reporter.hasErrors)
+        result = mainCls.withSpan(mainAnnotSpan.toSynthetic) :: Nil
+    }
+    result
+  }
+
+  private type DefaultValueSymbols = Map[Int, Symbol]
+  private type ParameterAnnotationss = Seq[Seq[Annotation]]
+
+  /**
+   * Generate proxy classes for main functions.
+   * A function like
+   *
+   *     /**
+   *       * Lorem ipsum dolor sit amet
+   *       * consectetur adipiscing elit.
+   *       *
+   *       * @param x my param x
+   *       * @param ys all my params y
+   *       */
+   *     @myMain(80) def f(
+   *       @myMain.Alias("myX") x: S,
+   *       y: S,
+   *       ys: T*
+   *     ) = ...
+   *
+   *  would be translated to something like
+   *
+   *     final class f {
+   *       static def main(args: Array[String]): Unit = {
+   *         val annotation = new myMain(80)
+   *         val info = new Info(
+   *           name = "f",
+   *           documentation = "Lorem ipsum dolor sit amet consectetur adipiscing elit.",
+   *           parameters = Seq(
+   *             new scala.annotation.MainAnnotation.Parameter("x", "S", false, false, "my param x", Seq(new scala.main.Alias("myX"))),
+   *             new scala.annotation.MainAnnotation.Parameter("y", "S", true, false, "", Seq()),
+   *             new scala.annotation.MainAnnotation.Parameter("ys", "T", false, true, "all my params y", Seq())
+   *           )
+   *         ),
+   *         val command = annotation.command(info, args)
+   *         if command.isDefined then
+   *           val cmd = command.get
+   *           val args0: () => S = annotation.argGetter[S](info.parameters(0), cmd(0), None)
+   *           val args1: () => S = annotation.argGetter[S](info.parameters(1), mainArgs(1), Some(() => sum$default$1()))
+   *           val args2: () => Seq[T] = annotation.varargGetter[T](info.parameters(2), cmd.drop(2))
+   *           annotation.run(() => f(args0(), args1(), args2()*))
+   *       }
+   *     }
+   */
+  private def mainAnnotationProxies(stats: List[tpd.Tree])(using Context): List[untpd.Tree] = {
+    import tpd._
+
+    /**
+      * Computes the symbols of the default values of the function. Since they cannot be inferred anymore at this
+      * point of the compilation, they must be explicitly passed by [[mainProxy]].
+      */
+    def defaultValueSymbols(scope: Tree, funSymbol: Symbol): DefaultValueSymbols =
+      scope match {
+        case TypeDef(_, template: Template) =>
+          template.body.flatMap((_: Tree) match {
+            case dd: DefDef if dd.name.is(DefaultGetterName) && dd.name.firstPart == funSymbol.name =>
+              val DefaultGetterName.NumberedInfo(index) = dd.name.info: @unchecked
+              List(index -> dd.symbol)
+            case _ => Nil
+          }).toMap
+        case _ => Map.empty
+      }
+
+    /** Computes the list of main methods present in the code. */
+    def mainMethods(scope: Tree, stats: List[Tree]): List[(Symbol, ParameterAnnotationss, DefaultValueSymbols, Option[Comment])] = stats.flatMap {
+      case stat: DefDef =>
+        val sym = stat.symbol
+        sym.annotations.filter(_.matches(defn.MainAnnotationClass)) match {
+          case Nil =>
+            Nil
+          case _ :: Nil =>
+            val paramAnnotations = stat.paramss.flatMap(_.map(
+              valdef => valdef.symbol.annotations.filter(_.matches(defn.MainAnnotationParameterAnnotation))
+            ))
+            (sym, paramAnnotations.toVector, defaultValueSymbols(scope, sym), stat.rawComment) :: Nil
+          case mainAnnot :: others =>
+            report.error(s"method cannot have multiple main annotations", mainAnnot.tree)
+            Nil
+        }
+      case stat @ TypeDef(_, impl: Template) if stat.symbol.is(Module) =>
+        mainMethods(stat, impl.body)
+      case _ =>
+        Nil
+    }
+
+    // Assuming that the top-level object was already generated, all main methods will have a scope
+    mainMethods(EmptyTree, stats).flatMap(mainAnnotationProxy)
+  }
+
+  private def mainAnnotationProxy(mainFun: Symbol, paramAnnotations: ParameterAnnotationss, defaultValueSymbols: DefaultValueSymbols, docComment: Option[Comment])(using Context): Option[TypeDef] = {
+    val mainAnnot = mainFun.getAnnotation(defn.MainAnnotationClass).get
+    def pos = mainFun.sourcePos
+
+    val documentation = new Documentation(docComment)
+
+    /** () => value */
+    def unitToValue(value: Tree): Tree =
+      val defDef = DefDef(nme.ANON_FUN, List(Nil), TypeTree(), value)
+      Block(defDef, Closure(Nil, Ident(nme.ANON_FUN), EmptyTree))
+
+    /** Generate a list of trees containing the ParamInfo instantiations.
+     *
+     *  A ParamInfo has the following shape
+     *  ```
+     *  new scala.annotation.MainAnnotation.Parameter("x", "S", false, false, "my param x", Seq(new scala.main.Alias("myX")))
+     *  ```
+     */
+    def parameterInfos(mt: MethodType): List[Tree] =
+      extension (tree: Tree) def withProperty(sym: Symbol, args: List[Tree]) =
+        Apply(Select(tree, sym.name), args)
+
+      for ((formal, paramName), idx) <- mt.paramInfos.zip(mt.paramNames).zipWithIndex yield
+        val param = paramName.toString
+        val paramType0 = if formal.isRepeatedParam then formal.argTypes.head.dealias else formal.dealias
+        val paramType = paramType0.dealias
+        val paramTypeOwner = paramType.typeSymbol.owner
+        val paramTypeStr =
+          if paramTypeOwner == defn.EmptyPackageClass then paramType.show
+          else paramTypeOwner.showFullName + "." + paramType.show
+        val hasDefault = defaultValueSymbols.contains(idx)
+        val isRepeated = formal.isRepeatedParam
+        val paramDoc = documentation.argDocs.getOrElse(param, "")
+        val paramAnnots =
+          val annotationTrees = paramAnnotations(idx).map(instantiateAnnotation).toList
+          Apply(ref(defn.SeqModule.termRef), annotationTrees)
+
+        val constructorArgs = List(param, paramTypeStr, hasDefault, isRepeated, paramDoc)
+          .map(value => Literal(Constant(value)))
+
+        New(TypeTree(defn.MainAnnotationParameter.typeRef), List(constructorArgs :+ paramAnnots))
+
+    end parameterInfos
+
+    /**
+      * Creates a list of references and definitions of arguments.
+      * The goal is to create the
+      *   `val args0: () => S = annotation.argGetter[S](0, cmd(0), None)`
+      * part of the code.
+      */
+    def argValDefs(mt: MethodType): List[ValDef] =
+      for ((formal, paramName), idx) <- mt.paramInfos.zip(mt.paramNames).zipWithIndex yield
+        val argName = nme.args ++ idx.toString
+        val isRepeated = formal.isRepeatedParam
+        val formalType = if isRepeated then formal.argTypes.head else formal
+        val getterName = if isRepeated then nme.varargGetter else nme.argGetter
+        val defaultValueGetterOpt = defaultValueSymbols.get(idx) match
+          case None => ref(defn.NoneModule.termRef)
+          case Some(dvSym) =>
+              val value = unitToValue(ref(dvSym.termRef))
+              Apply(ref(defn.SomeClass.companionModule.termRef), value)
+        val argGetter0 = TypeApply(Select(Ident(nme.annotation), getterName), TypeTree(formalType) :: Nil)
+        val index = Literal(Constant(idx))
+        val paramInfo = Apply(Select(Ident(nme.info), nme.parameters), index)
+        val argGetter =
+          if isRepeated then Apply(argGetter0, List(paramInfo, Apply(Select(Ident(nme.cmd), nme.drop), List(index))))
+          else Apply(argGetter0, List(paramInfo, Apply(Ident(nme.cmd), List(index)), defaultValueGetterOpt))
+        ValDef(argName, TypeTree(), argGetter)
+    end argValDefs
+
+
+    /** Create a list of argument references that will be passed as argument to the main method.
+     *  `args0`, ...`argn*`
+     */
+    def argRefs(mt: MethodType): List[Tree] =
+      for ((formal, paramName), idx) <- mt.paramInfos.zip(mt.paramNames).zipWithIndex yield
+        val argRef = Apply(Ident(nme.args ++ idx.toString), Nil)
+        if formal.isRepeatedParam then repeated(argRef) else argRef
+    end argRefs
+
+
+    /** Turns an annotation (e.g. `@main(40)`) into an instance of the class (e.g. `new scala.main(40)`). */
+    def instantiateAnnotation(annot: Annotation): Tree =
+      val argss = {
+        def recurse(t: tpd.Tree, acc: List[List[Tree]]): List[List[Tree]] = t match {
+          case Apply(t, args: List[tpd.Tree]) => recurse(t, extractArgs(args) :: acc)
+          case _ => acc
+        }
+
+        def extractArgs(args: List[tpd.Tree]): List[Tree] =
+          args.flatMap {
+            case Typed(SeqLiteral(varargs, _), _) => varargs.map(arg => TypedSplice(arg))
+            case arg: Select if arg.name.is(DefaultGetterName) => Nil  // Ignore default values, they will be added later by the compiler
+            case arg => List(TypedSplice(arg))
+          }
+
+        recurse(annot.tree, Nil)
+      }
+
+      New(TypeTree(annot.symbol.typeRef), argss)
+    end instantiateAnnotation
+
+    def generateMainClass(mainCall: Tree, args: List[Tree], parameterInfos: List[Tree]): TypeDef =
+      val cmdInfo =
+        val nameTree = Literal(Constant(mainFun.showName))
+        val docTree = Literal(Constant(documentation.mainDoc))
+        val paramInfos = Apply(ref(defn.SeqModule.termRef), parameterInfos)
+        New(TypeTree(defn.MainAnnotationInfo.typeRef), List(List(nameTree, docTree, paramInfos)))
+
+      val annotVal = ValDef(
+        nme.annotation,
+        TypeTree(),
+        instantiateAnnotation(mainAnnot)
+      )
+      val infoVal = ValDef(
+        nme.info,
+        TypeTree(),
+        cmdInfo
+      )
+      val command = ValDef(
+        nme.command,
+        TypeTree(),
+        Apply(
+          Select(Ident(nme.annotation), nme.command),
+          List(Ident(nme.info), Ident(nme.args))
+        )
+      )
+      val argsVal = ValDef(
+        nme.cmd,
+        TypeTree(),
+        Select(Ident(nme.command), nme.get)
+      )
+      val run = Apply(Select(Ident(nme.annotation), nme.run), mainCall)
+      val body0 = If(
+        Select(Ident(nme.command), nme.isDefined),
+        Block(argsVal :: args, run),
+        EmptyTree
+      )
+      val body = Block(List(annotVal, infoVal, command), body0) // TODO add `if (cmd.nonEmpty)`
+
+      val mainArg = ValDef(nme.args, TypeTree(defn.ArrayType.appliedTo(defn.StringType)), EmptyTree)
+        .withFlags(Param)
+      /** Replace typed `Ident`s that have been typed with a TypeSplice with the reference to the symbol.
+       *  The annotations will be retype-checked in another scope that may not have the same imports.
+       */
+      def insertTypeSplices = new TreeMap {
+          override def transform(tree: Tree)(using Context): Tree = tree match
+            case tree: tpd.Ident @unchecked => TypedSplice(tree)
+            case tree => super.transform(tree)
+      }
+      val annots = mainFun.annotations
+        .filterNot(_.matches(defn.MainAnnotationClass))
+        .map(annot => insertTypeSplices.transform(annot.tree))
+      val mainMeth = DefDef(nme.main, (mainArg :: Nil) :: Nil, TypeTree(defn.UnitType), body)
+        .withFlags(JavaStatic)
+        .withAnnotations(annots)
+      val mainTempl = Template(emptyConstructor, Nil, Nil, EmptyValDef, mainMeth :: Nil)
+      val mainCls = TypeDef(mainFun.name.toTypeName, mainTempl)
+        .withFlags(Final | Invisible)
+      mainCls.withSpan(mainAnnot.tree.span.toSynthetic)
+    end generateMainClass
+
+    if (!mainFun.owner.isStaticOwner)
+      report.error(s"main method is not statically accessible", pos)
+      None
+    else mainFun.info match {
+      case _: ExprType =>
+        Some(generateMainClass(unitToValue(ref(mainFun.termRef)), Nil, Nil))
+      case mt: MethodType =>
+        if (mt.isImplicitMethod)
+          report.error(s"main method cannot have implicit parameters", pos)
+          None
+        else mt.resType match
+          case restpe: MethodType =>
+            report.error(s"main method cannot be curried", pos)
+            None
+          case _ =>
+            Some(generateMainClass(unitToValue(Apply(ref(mainFun.termRef), argRefs(mt))), argValDefs(mt), parameterInfos(mt)))
+      case _: PolyType =>
+        report.error(s"main method cannot have type parameters", pos)
+        None
+      case _ =>
+        report.error(s"main can only annotate a method", pos)
+        None
+    }
+  }
+
+  /** A class responsible for extracting the docstrings of a method. */
+  private class Documentation(docComment: Option[Comment]):
+    import util.CommentParsing._
+
+    /** The main part of the documentation. */
+    lazy val mainDoc: String = _mainDoc
+    /** The parameters identified by @param. Maps from parameter name to its documentation. */
+    lazy val argDocs: Map[String, String] = _argDocs
+
+    private var _mainDoc: String = ""
+    private var _argDocs: Map[String, String] = Map()
+
+    docComment match {
+      case Some(comment) => if comment.isDocComment then parseDocComment(comment.raw) else _mainDoc = comment.raw
+      case None =>
+    }
+
+    private def cleanComment(raw: String): String =
+      var lines: Seq[String] = raw.trim.nn.split('\n').nn.toSeq
+      lines = lines.map(l => l.substring(skipLineLead(l, -1), l.length).nn.trim.nn)
+      var s = lines.foldLeft("") {
+        case ("", s2) => s2
+        case (s1, "") if s1.last == '\n' => s1 // Multiple newlines are kept as single newlines
+        case (s1, "") => s1 + '\n'
+        case (s1, s2) if s1.last == '\n' => s1 + s2
+        case (s1, s2) => s1 + ' ' + s2
+      }
+      s.replaceAll(raw"\[\[", "").nn.replaceAll(raw"\]\]", "").nn.trim.nn
+
+    private def parseDocComment(raw: String): Unit =
+      // Positions of the sections (@) in the docstring
+      val tidx: List[(Int, Int)] = tagIndex(raw)
+
+      // Parse main comment
+      var mainComment: String = raw.substring(skipLineLead(raw, 0), startTag(raw, tidx)).nn
+      _mainDoc = cleanComment(mainComment)
+
+      // Parse arguments comments
+      val argsCommentsSpans: Map[String, (Int, Int)] = paramDocs(raw, "@param", tidx)
+      val argsCommentsTextSpans = argsCommentsSpans.view.mapValues(extractSectionText(raw, _))
+      val argsCommentsTexts = argsCommentsTextSpans.mapValues({ case (beg, end) => raw.substring(beg, end).nn })
+      _argDocs = argsCommentsTexts.mapValues(cleanComment(_)).toMap
+  end Documentation
+}
diff --git a/tests/pos-with-compiler-cc/dotc/ast/NavigateAST.scala b/tests/pos-with-compiler-cc/dotc/ast/NavigateAST.scala
new file mode 100644
index 000000000000..054ffe66f323
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/ast/NavigateAST.scala
@@ -0,0 +1,129 @@
+package dotty.tools.dotc
+package ast
+
+import core.Contexts._
+import core.Decorators._
+import util.Spans._
+import Trees.{MemberDef, DefTree, WithLazyField}
+import dotty.tools.dotc.core.Types.AnnotatedType
+import dotty.tools.dotc.core.Types.ImportType
+import dotty.tools.dotc.core.Types.Type
+
+/** Utility functions to go from typed to untyped ASTs */
+// TODO: Handle trees with mixed source files
+object NavigateAST {
+
+  /** The untyped tree corresponding to typed tree `tree` in the compilation
+   *  unit specified by `ctx`
+   */
+  def toUntyped(tree: tpd.Tree)(using Context): untpd.Tree =
+    untypedPath(tree, exactMatch = true) match {
+      case (utree: untpd.Tree) :: _ =>
+        utree
+      case _ =>
+        val loosePath = untypedPath(tree, exactMatch = false)
+        throw new
+          Error(i"""no untyped tree for $tree, pos = ${tree.sourcePos}
+                   |best matching path =\n$loosePath%\n====\n%
+                   |path positions = ${loosePath.map(_.sourcePos)}""")
+    }
+
+  /** The reverse path of untyped trees starting with a tree that closest matches
+   *  `tree` and ending in the untyped tree at the root of the compilation unit
+   *  specified by `ctx`.
+   *  @param exactMatch    If `true`, the path must start with a node that exactly
+   *                       matches `tree`, or `Nil` is returned.
+   *                       If `false` the path might start with a node enclosing
+   *                       the logical position of `tree`.
+   *  Note: A complication concerns member definitions. ValDefs and DefDefs
+   *  have after desugaring a position that spans just the name of the symbol being
+   *  defined and nothing else. So we look instead for an untyped tree approximating the
+   *  envelope of the definition, and declare success if we find another DefTree.
+   */
+  def untypedPath(tree: tpd.Tree, exactMatch: Boolean = false)(using Context): List[Positioned] =
+    tree match {
+      case tree: MemberDef[?] =>
+        untypedPath(tree.span) match {
+          case path @ (last: DefTree[?]) :: _ => path
+          case path if !exactMatch => path
+          case _ => Nil
+        }
+      case _ =>
+        untypedPath(tree.span) match {
+          case (path @ last :: _) if last.span == tree.span || !exactMatch => path
+          case _ => Nil
+        }
+    }
+
+  /** The reverse part of the untyped root of the compilation unit of `ctx` to
+   *  the given `span`.
+   */
+  def untypedPath(span: Span)(using Context): List[Positioned] =
+    pathTo(span, List(ctx.compilationUnit.untpdTree))
+
+
+  /** The reverse path from any node in `from` to the node that closest encloses `span`,
+   *  or `Nil` if no such path exists. If a non-empty path is returned it starts with
+   *  the node closest enclosing `span` and ends with one of the nodes in `from`.
+   *
+   *  @param skipZeroExtent  If true, skip over zero-extent nodes in the search. These nodes
+   *                         do not correspond to code the user wrote since their start and
+   *                         end point are the same, so this is useful when trying to reconcile
+   *                         nodes with source code.
+   */
+  def pathTo(span: Span, from: List[Positioned], skipZeroExtent: Boolean = false)(using Context): List[Positioned] = {
+    def childPath(it: Iterator[Any], path: List[Positioned]): List[Positioned] = {
+      var bestFit: List[Positioned] = path
+      while (it.hasNext) {
+        val path1 = it.next() match {
+          case p: Positioned => singlePath(p, path)
+          case m: untpd.Modifiers => childPath(m.productIterator, path)
+          case xs: List[?] => childPath(xs.iterator, path)
+          case _ => path
+        }
+        if ((path1 ne path) &&
+            ((bestFit eq path) ||
+             bestFit.head.span != path1.head.span &&
+             bestFit.head.span.contains(path1.head.span)))
+          bestFit = path1
+      }
+      bestFit
+    }
+    /*
+     * Annotations trees are located in the Type
+     */
+    def unpackAnnotations(t: Type, path: List[Positioned]): List[Positioned] =
+      t match {
+        case ann: AnnotatedType =>
+            unpackAnnotations(ann.parent, childPath(ann.annot.tree.productIterator, path))
+        case imp: ImportType =>
+          childPath(imp.expr.productIterator, path)
+        case other =>
+          path
+    }
+    def singlePath(p: Positioned, path: List[Positioned]): List[Positioned] =
+      if (p.span.exists && !(skipZeroExtent && p.span.isZeroExtent) && p.span.contains(span)) {
+        // FIXME: We shouldn't be manually forcing trees here, we should replace
+        // our usage of `productIterator` by something in `Positioned` that takes
+        // care of low-level details like this for us.
+        p match {
+          case p: WithLazyField[?] =>
+            p.forceIfLazy
+          case _ =>
+        }
+        val iterator = p match
+          case defdef: DefTree[?] =>
+            p.productIterator ++ defdef.mods.productIterator
+          case _ =>
+            p.productIterator 
+        childPath(iterator, p :: path)
+      }
+      else {
+        p match {
+          case t: untpd.TypeTree => unpackAnnotations(t.typeOpt, path)
+          case _ => path
+        }
+      }
+    childPath(from.iterator, Nil)
+  }
+}
diff --git a/tests/pos-with-compiler-cc/dotc/ast/Positioned.scala b/tests/pos-with-compiler-cc/dotc/ast/Positioned.scala
new file mode 100644
index 000000000000..fd30d441a6ee
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/ast/Positioned.scala
@@ -0,0 +1,246 @@
+package dotty.tools
+package dotc
+package ast
+
+import util.Spans._
+import util.{SourceFile, SourcePosition, SrcPos}
+import core.Contexts._
+import core.Decorators._
+import core.NameOps._
+import core.Flags.{JavaDefined, ExtensionMethod}
+import core.StdNames.nme
+import ast.Trees.mods
+import annotation.constructorOnly
+import annotation.internal.sharable
+
+/** A base class for things that have positions (currently: modifiers and trees)
+ */
+abstract class Positioned(implicit @constructorOnly src: SourceFile) extends SrcPos, Product, Cloneable, caps.Pure {
+  import Positioned.{ids, nextId, debugId}
+
+  private var mySpan: Span = _
+
+  private var mySource: SourceFile = src
+
+  /** A unique identifier in case -Yshow-tree-ids, or -Ydebug-tree-with-id
+   *  is set, -1 otherwise.
+   */
+  def uniqueId: Int =
+    if ids != null && ids.nn.containsKey(this) then ids.nn.get(this).nn else -1
+
+  private def allocateId() =
+    if ids != null then
+      val ownId = nextId
+      nextId += 1
+      ids.nn.put(this: @unchecked, ownId)
+      if ownId == debugId then
+        println(s"Debug tree (id=$debugId) creation \n${this: @unchecked}\n")
+        Thread.dumpStack()
+
+  allocateId()
+
+  /** The span part of the item's position */
+  def span: Span = mySpan
+
+  def span_=(span: Span): Unit =
+    mySpan = span
+
+  span = envelope(src)
+
+  def source: SourceFile = mySource
+
+  def sourcePos(using Context): SourcePosition = source.atSpan(span)
+
+  /** This positioned item, widened to `SrcPos`. Used to make clear we only need the
+   *  position, typically for error reporting.
+   */
+  final def srcPos: SrcPos = this
+
+  /** A positioned item like this one with given `span`.
+   *  If the positioned item is source-derived, a clone is returned.
+   *  If the positioned item is synthetic, the position is updated
+   *  destructively and the item itself is returned.
+   */
+  def withSpan(span: Span): this.type =
+    if (span == mySpan) this
+    else {
+      val newpd: this.type =
+        if !mySpan.exists then
+          if span.exists then envelope(source, span.startPos) // fill in children spans
+          this
+        else
+          cloneIn(source)
+      newpd.span = span
+      newpd
+    }
+
+  /** The union of startSpan and the spans of all positioned children that
+   *  have the same source as this node, except that Inlined nodes only
+   *  consider their `call` child.
+   *
+   *  Side effect: Any descendants without spans have but with the same source as this
+   *  node have their span set to the end position of the envelope of all children to
+   *  the left, or, if that one does not exist, to the start position of the envelope
+   *  of all children to the right.
+   */
+  def envelope(src: SourceFile, startSpan: Span = NoSpan): Span = (this: @unchecked) match {
+    case Trees.Inlined(call, _, _) =>
+      call.span
+    case _ =>
+      def include(span: Span, x: Any): Span = x match {
+        case p: Positioned =>
+          if (p.source != src) span
+          else if (p.span.exists) span.union(p.span)
+          else if (span.exists) {
+            if (span.end != MaxOffset)
+              p.span = p.envelope(src, span.endPos)
+            span
+          }
+          else // No span available to assign yet, signal this by returning a span with MaxOffset end
+            Span(MaxOffset, MaxOffset)
+        case m: untpd.Modifiers =>
+          include(include(span, m.mods), m.annotations)
+        case y :: ys =>
+          include(include(span, y), ys)
+        case _ => span
+      }
+      val limit = productArity
+      def includeChildren(span: Span, n: Int): Span =
+        if (n < limit) includeChildren(include(span, productElement(n): @unchecked), n + 1)
+        else span
+      val span1 = includeChildren(startSpan, 0)
+      val span2 =
+        if (!span1.exists || span1.end != MaxOffset)
+          span1
+        else if (span1.start == MaxOffset)
+          // No positioned child was found
+          NoSpan
+        else
+          ///println(s"revisit $uniqueId with $span1")
+          // We have some children left whose span could not be assigned.
+          // Go through it again with the known start position.
+          includeChildren(span1.startPos, 0)
+      span2.toSynthetic
+  }
+
+  /** Clone this node but assign it a fresh id which marks it as a node in `file`. */
+  def cloneIn(src: SourceFile): this.type = {
+    val newpd: this.type = clone.asInstanceOf[this.type]
+    newpd.allocateId()
+    newpd.mySource = src
+    newpd
+  }
+
+  def contains(that: Positioned): Boolean = {
+    def isParent(x: Any): Boolean = x match {
+      case x: Positioned =>
+        x.contains(that)
+      case m: untpd.Modifiers =>
+        m.mods.exists(isParent) || m.annotations.exists(isParent)
+      case xs: List[?] =>
+        xs.exists(isParent)
+      case _ =>
+        false
+    }
+    (this eq that) ||
+      (this.span contains that.span) && {
+        var n = productArity
+        var found = false
+        while (!found && n > 0) {
+          n -= 1
+          found = isParent(productElement(n))
+        }
+        found
+    }
+  }
+
+  /** Check that all positioned items in this tree satisfy the following conditions:
+   *  - Parent spans contain child spans
+   *  - If item is a non-empty tree, it has a position
+   */
+  def checkPos(nonOverlapping: Boolean)(using Context): Unit = try {
+    import untpd._
+    var lastPositioned: Positioned | Null = null
+    var lastSpan = NoSpan
+    def check(p: Any): Unit = p match {
+      case p: Positioned =>
+        assert(span contains p.span,
+          i"""position error, parent span does not contain child span
+             |parent      = $this # $uniqueId,
+             |parent span = $span,
+             |child       = $p # ${p.uniqueId},
+             |child span  = ${p.span}""".stripMargin)
+        p match {
+          case tree: Tree if !tree.isEmpty =>
+            assert(tree.span.exists,
+              s"position error: position not set for $tree # ${tree.uniqueId}")
+          case _ =>
+        }
+        if nonOverlapping then
+          this match {
+            case _: XMLBlock =>
+              // FIXME: Trees generated by the XML parser do not satisfy `checkPos`
+            case _: WildcardFunction
+            if lastPositioned.isInstanceOf[ValDef] && !p.isInstanceOf[ValDef] =>
+              // ignore transition from last wildcard parameter to body
+            case _ =>
+              assert(!lastSpan.exists || !p.span.exists || lastSpan.end <= p.span.start,
+                i"""position error, child positions overlap or in wrong order
+                   |parent         = $this
+                   |1st child      = $lastPositioned
+                   |1st child span = $lastSpan
+                   |2nd child      = $p
+                   |2nd child span = ${p.span}""".stripMargin)
+          }
+          lastPositioned = p
+          lastSpan = p.span
+        p.checkPos(nonOverlapping)
+      case m: untpd.Modifiers =>
+        m.annotations.foreach(check)
+        m.mods.foreach(check)
+      case xs: List[?] =>
+        xs.foreach(check)
+      case _ =>
+    }
+    this match {
+      case tree: DefDef if tree.name == nme.CONSTRUCTOR && tree.mods.is(JavaDefined) =>
+        // Special treatment for constructors coming from Java:
+        // Leave out leading type params, they are copied with wrong positions from parent class
+        check(tree.mods)
+        check(tree.trailingParamss)
+      case tree: DefDef if tree.mods.is(ExtensionMethod) =>
+        tree.paramss match
+          case vparams1 :: vparams2 :: rest if tree.name.isRightAssocOperatorName =>
+            // omit check for right-associatiove extension methods; their parameters were swapped
+          case _ =>
+            check(tree.paramss)
+        check(tree.tpt)
+        check(tree.rhs)
+      case _ =>
+        val end = productArity
+        var n = 0
+        while (n < end) {
+          check(productElement(n))
+          n += 1
+        }
+    }
+  }
+  catch {
+    case ex: AssertionError =>
+      println(i"error while checking $this")
+      throw ex
+  }
+}
+
+object Positioned {
+  @sharable private var debugId = Int.MinValue
+  @sharable private var ids: java.util.WeakHashMap[Positioned, Int] | Null = null
+  @sharable private var nextId: Int = 0
+
+  def init(using Context): Unit =
+    debugId = ctx.settings.YdebugTreeWithId.value
+    if ids == null && ctx.settings.YshowTreeIds.value
+       || debugId != ctx.settings.YdebugTreeWithId.default
+    then
+      ids = java.util.WeakHashMap()
+}
diff --git a/tests/pos-with-compiler-cc/dotc/ast/TreeInfo.scala b/tests/pos-with-compiler-cc/dotc/ast/TreeInfo.scala
new file mode 100644
index 000000000000..ff59a795d818
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/ast/TreeInfo.scala
@@ -0,0 +1,1075 @@
+package dotty.tools
+package dotc
+package ast
+
+import core._
+import Flags._, Trees._, Types._, Contexts._
+import Names._, StdNames._, NameOps._, Symbols._
+import typer.ConstFold
+import reporting.trace
+import dotty.tools.dotc.transform.SymUtils._
+import Decorators._
+import Constants.Constant
+import scala.collection.mutable
+
+import scala.annotation.tailrec
+
+trait TreeInfo[T >: Untyped <: Type] { self: Trees.Instance[T] =>
+
+  // Note: the <: Type constraint looks necessary (and is needed to make the file compile in dotc).
+  // But Scalac accepts the program happily without it. Need to find out why.
+
+  def unsplice(tree: Trees.Tree[T]): Trees.Tree[T] = tree
+
+  def isDeclarationOrTypeDef(tree: Tree): Boolean = unsplice(tree) match {
+    case DefDef(_, _, _, EmptyTree)
+      | ValDef(_, _, EmptyTree)
+      | TypeDef(_, _) => true
+    case _ => false
+  }
+
+  def isOpAssign(tree: Tree): Boolean = unsplice(tree) match {
+    case Apply(fn, _ :: _) =>
+      unsplice(fn) match {
+        case Select(_, name) if name.isOpAssignmentName => true
+        case _ => false
+      }
+    case _ => false
+  }
+
+  class MatchingArgs(params: List[Symbol], args: List[Tree])(using Context) {
+    def foreach(f: (Symbol, Tree) => Unit): Boolean = {
+      def recur(params: List[Symbol], args: List[Tree]): Boolean = params match {
+        case Nil => args.isEmpty
+        case param :: params1 =>
+          if (param.info.isRepeatedParam) {
+            for (arg <- args) f(param, arg)
+            true
+          }
+          else args match {
+            case Nil => false
+            case arg :: args1 =>
+              f(param, args.head)
+              recur(params1, args1)
+          }
+      }
+      recur(params, args)
+    }
+    def zipped: List[(Symbol, Tree)] = map((_, _))
+    def map[R](f: (Symbol, Tree) => R): List[R] = {
+      val b = List.newBuilder[R]
+      foreach(b += f(_, _))
+      b.result()
+    }
+  }
+
+  /** The method part of an application node, possibly enclosed in a block
+   *  with only valdefs as statements. the reason for also considering blocks
+   *  is that named arguments can transform a call into a block, e.g.
+   *   <init>(b = foo, a = bar)
+   * is transformed to
+   *   { val x$1 = foo
+   *     val x$2 = bar
+   *     <init>(x$2, x$1)
+   *   }
+   */
+  def methPart(tree: Tree): Tree = stripApply(tree) match {
+    case TypeApply(fn, _) => methPart(fn)
+    case AppliedTypeTree(fn, _) => methPart(fn) // !!! should not be needed
+    case Block(stats, expr) => methPart(expr)
+    case mp => mp
+  }
+
+  /** If this is an application, its function part, stripping all
+   *  Apply nodes (but leaving TypeApply nodes in). Otherwise the tree itself.
+   */
+  def stripApply(tree: Tree): Tree = unsplice(tree) match {
+    case Apply(fn, _) => stripApply(fn)
+    case _ => tree
+  }
+
+  /** If this is a block, its expression part */
+  def stripBlock(tree: Tree): Tree = unsplice(tree) match {
+    case Block(_, expr) => stripBlock(expr)
+    case Inlined(_, _, expr) => stripBlock(expr)
+    case _ => tree
+  }
+
+  def stripInlined(tree: Tree): Tree = unsplice(tree) match {
+    case Inlined(_, _, expr) => stripInlined(expr)
+    case _ => tree
+  }
+
+  def stripAnnotated(tree: Tree): Tree = tree match {
+    case Annotated(arg, _) => arg
+    case _ => tree
+  }
+
+  /** The number of arguments in an application */
+  def numArgs(tree: Tree): Int = unsplice(tree) match {
+    case Apply(fn, args) => numArgs(fn) + args.length
+    case TypeApply(fn, _) => numArgs(fn)
+    case Block(_, expr) => numArgs(expr)
+    case _ => 0
+  }
+
+  /** All term arguments of an application in a single flattened list */
+  def allArguments(tree: Tree): List[Tree] = unsplice(tree) match {
+    case Apply(fn, args) => allArguments(fn) ::: args
+    case TypeApply(fn, _) => allArguments(fn)
+    case Block(_, expr) => allArguments(expr)
+    case _ => Nil
+  }
+
+  /** Is tree explicitly parameterized with type arguments? */
+  def hasExplicitTypeArgs(tree: Tree): Boolean = tree match
+    case TypeApply(tycon, args) =>
+      args.exists(arg => !arg.span.isZeroExtent && !tycon.span.contains(arg.span))
+    case _ => false
+
+  /** Is tree a path? */
+  def isPath(tree: Tree): Boolean = unsplice(tree) match {
+    case Ident(_) | This(_) | Super(_, _) => true
+    case Select(qual, _) => isPath(qual)
+    case _ => false
+  }
+
+  /** Is tree a self constructor call this(...)? I.e. a call to a constructor of the
+   *  same object?
+   */
+  def isSelfConstrCall(tree: Tree): Boolean = methPart(tree) match {
+    case Ident(nme.CONSTRUCTOR) | Select(This(_), nme.CONSTRUCTOR) => true
+    case _ => false
+  }
+
+  /** Is tree a super constructor call?
+   */
+  def isSuperConstrCall(tree: Tree): Boolean = methPart(tree) match {
+    case Select(Super(_, _), nme.CONSTRUCTOR) => true
+    case _ => false
+  }
+
+  def isSuperSelection(tree: Tree): Boolean = unsplice(tree) match {
+    case Select(Super(_, _), _) => true
+    case _ => false
+  }
+
+  def isSelfOrSuperConstrCall(tree: Tree): Boolean = methPart(tree) match {
+    case Ident(nme.CONSTRUCTOR)
+       | Select(This(_), nme.CONSTRUCTOR)
+       | Select(Super(_, _), nme.CONSTRUCTOR) => true
+    case _ => false
+  }
+
+  /** Is tree a backquoted identifier or definition */
+  def isBackquoted(tree: Tree): Boolean = tree.hasAttachment(Backquoted)
+
+  /** Is tree a variable pattern? */
+  def isVarPattern(pat: Tree): Boolean = unsplice(pat) match {
+    case x: Ident => x.name.isVarPattern && !isBackquoted(x)
+    case _  => false
+  }
+
+  /** The first constructor definition in `stats` */
+  def firstConstructor(stats: List[Tree]): Tree = stats match {
+    case (meth: DefDef) :: _ if meth.name.isConstructorName => meth
+    case stat :: stats => firstConstructor(stats)
+    case nil => EmptyTree
+  }
+
+  /** Is tpt a vararg type of the form T* or => T*? */
+  def isRepeatedParamType(tpt: Tree)(using Context): Boolean = stripByNameType(tpt) match {
+    case tpt: TypeTree => tpt.typeOpt.isRepeatedParam
+    case AppliedTypeTree(Select(_, tpnme.REPEATED_PARAM_CLASS), _) => true
+    case _ => false
+  }
+
+  /** Is this argument node of the form <expr> *, or is it a reference to
+   *  such an argument ? The latter case can happen when an argument is lifted.
+   */
+  def isWildcardStarArg(tree: Tree)(using Context): Boolean = unbind(tree) match {
+    case Typed(Ident(nme.WILDCARD_STAR), _) => true
+    case Typed(_, Ident(tpnme.WILDCARD_STAR)) => true
+    case Typed(_, tpt: TypeTree) => tpt.typeOpt.isRepeatedParam
+    case NamedArg(_, arg) => isWildcardStarArg(arg)
+    case arg => arg.typeOpt.widen.isRepeatedParam
+  }
+
+  /** Is tree a type tree of the form `=> T` or (under pureFunctions) `{refs}-> T`? */
+  def isByNameType(tree: Tree)(using Context): Boolean =
+    stripByNameType(tree) ne tree
+
+  /** Strip `=> T` to `T` and (under pureFunctions) `{refs}-> T` to `T` */
+  def stripByNameType(tree: Tree)(using Context): Tree = unsplice(tree) match
+    case ByNameTypeTree(t1) => t1
+    case untpd.CapturingTypeTree(_, parent) =>
+      val parent1 = stripByNameType(parent)
+      if parent1 eq parent then tree else parent1
+    case _ => tree
+
+  /** All type and value parameter symbols of this DefDef */
+  def allParamSyms(ddef: DefDef)(using Context): List[Symbol] =
+    ddef.paramss.flatten.map(_.symbol)
+
+  /** Does this argument list end with an argument of the form <expr> : _* ? */
+  def isWildcardStarArgList(trees: List[Tree])(using Context): Boolean =
+    trees.nonEmpty && isWildcardStarArg(trees.last)
+
+  /** Is the argument a wildcard argument of the form `_` or `x @ _`?
+   */
+  def isWildcardArg(tree: Tree): Boolean = unbind(tree) match {
+    case Ident(nme.WILDCARD) => true
+    case _                   => false
+  }
+
+  /** Does this list contain a named argument tree? */
+  def hasNamedArg(args: List[Any]): Boolean = args exists isNamedArg
+  val isNamedArg: Any => Boolean = (arg: Any) => arg.isInstanceOf[Trees.NamedArg[_]]
+
+  /** Is this pattern node a catch-all (wildcard or variable) pattern? */
+  def isDefaultCase(cdef: CaseDef): Boolean = cdef match {
+    case CaseDef(pat, EmptyTree, _) => isWildcardArg(pat)
+    case _                            => false
+  }
+
+  /** Does this CaseDef catch Throwable? */
+  def catchesThrowable(cdef: CaseDef)(using Context): Boolean =
+    catchesAllOf(cdef, defn.ThrowableType)
+
+  /** Does this CaseDef catch everything of a certain Type? */
+  def catchesAllOf(cdef: CaseDef, threshold: Type)(using Context): Boolean =
+    isDefaultCase(cdef) ||
+    cdef.guard.isEmpty && {
+      unbind(cdef.pat) match {
+        case Typed(Ident(nme.WILDCARD), tpt) => threshold <:< tpt.typeOpt
+        case _                               => false
+      }
+    }
+
+  /** Is this case guarded? */
+  def isGuardedCase(cdef: CaseDef): Boolean = cdef.guard ne EmptyTree
+
+  /** Is this parameter list a using clause? */
+  def isUsingClause(params: ParamClause)(using Context): Boolean = params match
+    case ValDefs(vparam :: _) =>
+      val sym = vparam.symbol
+      if sym.exists then sym.is(Given) else vparam.mods.is(Given)
+    case _ =>
+      false
+
+  def isUsingOrTypeParamClause(params: ParamClause)(using Context): Boolean = params match
+    case TypeDefs(_) => true
+    case _ => isUsingClause(params)
+
+  def isTypeParamClause(params: ParamClause)(using Context): Boolean = params match
+    case TypeDefs(_) => true
+    case _ => false
+
+  private val languageSubCategories = Set(nme.experimental, nme.deprecated)
+
+  /** If `path` looks like a language import, `Some(name)` where name
+   *  is `experimental` if that sub-module is imported, and the empty
+   *  term name otherwise.
+   */
+  def languageImport(path: Tree): Option[TermName] = path match
+    case Select(p1, name: TermName) if languageSubCategories.contains(name) =>
+      languageImport(p1) match
+        case Some(EmptyTermName) => Some(name)
+        case _ => None
+    case p1: RefTree if p1.name == nme.language =>
+      p1.qualifier match
+        case EmptyTree => Some(EmptyTermName)
+        case p2: RefTree if p2.name == nme.scala =>
+          p2.qualifier match
+            case EmptyTree => Some(EmptyTermName)
+            case Ident(nme.ROOTPKG) => Some(EmptyTermName)
+            case _ => None
+        case _ => None
+    case _ => None
+
+  /** The underlying pattern ignoring any bindings */
+  def unbind(x: Tree): Tree = unsplice(x) match {
+    case Bind(_, y) => unbind(y)
+    case y          => y
+  }
+
+  /**  The largest subset of {NoInits, PureInterface} that a
+   *   trait or class with these parents can have as flags.
+   */
+  def parentsKind(parents: List[Tree])(using Context): FlagSet = parents match {
+    case Nil => NoInitsInterface
+    case Apply(_, _ :: _) :: _ => EmptyFlags
+    case _ :: parents1 => parentsKind(parents1)
+  }
+
+  /** Checks whether predicate `p` is true for all result parts of this expression,
+   *  where we zoom into Ifs, Matches, and Blocks.
+   */
+  def forallResults(tree: Tree, p: Tree => Boolean): Boolean = tree match {
+    case If(_, thenp, elsep) => forallResults(thenp, p) && forallResults(elsep, p)
+    case Match(_, cases) => cases forall (c => forallResults(c.body, p))
+    case Block(_, expr) => forallResults(expr, p)
+    case _ => p(tree)
+  }
+}
+
+trait UntypedTreeInfo extends TreeInfo[Untyped] { self: Trees.Instance[Untyped] =>
+  import untpd._
+
+  /** The underlying tree when stripping any TypedSplice or Parens nodes */
+  override def unsplice(tree: Tree): Tree = tree match {
+    case TypedSplice(tree1) => tree1
+    case Parens(tree1) => unsplice(tree1)
+    case _ => tree
+  }
+
+  def functionWithUnknownParamType(tree: Tree): Option[Tree] = tree match {
+    case Function(args, _) =>
+      if (args.exists {
+        case ValDef(_, tpt, _) => tpt.isEmpty
+        case _ => false
+      }) Some(tree)
+      else None
+    case Match(EmptyTree, _) =>
+      Some(tree)
+    case Block(Nil, expr) =>
+      functionWithUnknownParamType(expr)
+    case _ =>
+      None
+  }
+
+  def isFunctionWithUnknownParamType(tree: Tree): Boolean =
+    functionWithUnknownParamType(tree).isDefined
+
+  def isFunction(tree: Tree): Boolean = tree match
+    case Function(_, _) | Match(EmptyTree, _) => true
+    case Block(Nil, expr) => isFunction(expr)
+    case _ => false
+
+  /** Is `tree` an context function or closure, possibly nested in a block? */
+  def isContextualClosure(tree: Tree)(using Context): Boolean = unsplice(tree) match {
+    case tree: FunctionWithMods => tree.mods.is(Given)
+    case Function((param: untpd.ValDef) :: _, _) => param.mods.is(Given)
+    case Closure(_, meth, _) => true
+    case Block(Nil, expr) => isContextualClosure(expr)
+    case Block(DefDef(nme.ANON_FUN, params :: _, _, _) :: Nil, cl: Closure) =>
+      if params.isEmpty then
+        cl.tpt.eq(untpd.ContextualEmptyTree) || defn.isContextFunctionType(cl.tpt.typeOpt)
+      else
+        isUsingClause(params)
+    case _ => false
+  }
+
+  /**  The largest subset of {NoInits, PureInterface} that a
+   *   trait or class enclosing this statement can have as flags.
+   */
+  private def defKind(tree: Tree)(using Context): FlagSet = unsplice(tree) match {
+    case EmptyTree | _: Import => NoInitsInterface
+    case tree: TypeDef => if (tree.isClassDef) NoInits else NoInitsInterface
+    case tree: DefDef =>
+      if tree.unforcedRhs == EmptyTree
+         && tree.paramss.forall {
+              case ValDefs(vparams) => vparams.forall(_.rhs.isEmpty)
+              case _ => true
+            }
+      then
+        NoInitsInterface
+      else if tree.mods.is(Given) && tree.paramss.isEmpty then
+        EmptyFlags // might become a lazy val: TODO: check whether we need to suppress NoInits once we have new lazy val impl
+      else
+        NoInits
+    case tree: ValDef => if (tree.unforcedRhs == EmptyTree) NoInitsInterface else EmptyFlags
+    case _ => EmptyFlags
+  }
+
+  /**  The largest subset of {NoInits, PureInterface} that a
+   *   trait or class with this body can have as flags.
+   */
+  def bodyKind(body: List[Tree])(using Context): FlagSet =
+    body.foldLeft(NoInitsInterface)((fs, stat) => fs & defKind(stat))
+
+  /** Info of a variable in a pattern: The named tree and its type */
+  type VarInfo = (NameTree, Tree)
+
+  /** An extractor for trees of the form `id` or `id: T` */
+  object IdPattern {
+    def unapply(tree: Tree)(using Context): Option[VarInfo] = tree match {
+      case id: Ident if id.name != nme.WILDCARD => Some(id, TypeTree())
+      case Typed(id: Ident, tpt) => Some((id, tpt))
+      case _ => None
+    }
+  }
+
+  /** Under pureFunctions: A builder and extractor for `=> T`, which is an alias for `{*}-> T`.
+   *  Only trees of the form `=> T` are matched; trees written directly as `{*}-> T`
+   *  are ignored by the extractor.
+   */
+  object ImpureByNameTypeTree:
+
+    def apply(tp: ByNameTypeTree)(using Context): untpd.CapturingTypeTree =
+      untpd.CapturingTypeTree(
+        untpd.captureRoot.withSpan(tp.span.startPos) :: Nil, tp)
+
+    def unapply(tp: Tree)(using Context): Option[ByNameTypeTree] = tp match
+      case untpd.CapturingTypeTree(id @ Select(_, nme.CAPTURE_ROOT) :: Nil, bntp: ByNameTypeTree)
+      if id.span == bntp.span.startPos => Some(bntp)
+      case _ => None
+  end ImpureByNameTypeTree
+}
+
+trait TypedTreeInfo extends TreeInfo[Type] { self: Trees.Instance[Type] =>
+  import TreeInfo._
+  import tpd._
+
+  /** The purity level of this statement.
+   *  @return   Pure        if statement has no side effects
+   *            Idempotent  if running the statement a second time has no side effects
+   *            Impure      otherwise
+   */
+  def statPurity(tree: Tree)(using Context): PurityLevel = unsplice(tree) match {
+    case EmptyTree
+       | TypeDef(_, _)
+       | Import(_, _)
+       | DefDef(_, _, _, _) =>
+      Pure
+    case vdef @ ValDef(_, _, _) =>
+      if (vdef.symbol.flags is Mutable) Impure else exprPurity(vdef.rhs) `min` Pure
+    case _ =>
+      Impure
+      // TODO: It seem like this should be exprPurity(tree)
+      // But if we do that the repl/vars test break. Need to figure out why that's the case.
+  }
+
+  /** The purity level of this expression. See docs for PurityLevel for what that means
+   *
+   *  Note that purity and idempotency are treated differently.
+   *  References to modules and lazy vals are impure (side-effecting) both because
+   *  side-effecting code may be executed and because the first reference
+   *  takes a different code path than all to follow; but they are idempotent
+   *  because running the expression a second time gives the cached result.
+   */
+  def exprPurity(tree: Tree)(using Context): PurityLevel = unsplice(tree) match {
+    case EmptyTree
+       | This(_)
+       | Super(_, _)
+       | Literal(_) =>
+      PurePath
+    case Ident(_) =>
+      refPurity(tree)
+    case Select(qual, _) =>
+      if (tree.symbol.is(Erased)) Pure
+      else refPurity(tree) `min` exprPurity(qual)
+    case New(_) | Closure(_, _, _) =>
+      Pure
+    case TypeApply(fn, _) =>
+      if (fn.symbol.is(Erased) || fn.symbol == defn.QuotedTypeModule_of || fn.symbol == defn.Predef_classOf) Pure else exprPurity(fn)
+    case Apply(fn, args) =>
+      if isPureApply(tree, fn) then
+        minOf(exprPurity(fn), args.map(exprPurity)) `min` Pure
+      else if fn.symbol.is(Erased) then
+        Pure
+      else if fn.symbol.isStableMember /* && fn.symbol.is(Lazy) */ then
+        minOf(exprPurity(fn), args.map(exprPurity)) `min` Idempotent
+      else
+        Impure
+    case Typed(expr, _) =>
+      exprPurity(expr)
+    case Block(stats, expr) =>
+      minOf(exprPurity(expr), stats.map(statPurity))
+    case Inlined(_, bindings, expr) =>
+      minOf(exprPurity(expr), bindings.map(statPurity))
+    case NamedArg(_, expr) =>
+      exprPurity(expr)
+    case _ =>
+      Impure
+  }
+
+  private def minOf(l0: PurityLevel, ls: List[PurityLevel]) = ls.foldLeft(l0)(_ `min` _)
+
+  def isPurePath(tree: Tree)(using Context): Boolean = tree.tpe match {
+    case tpe: ConstantType => exprPurity(tree) >= Pure
+    case _ => exprPurity(tree) == PurePath
+  }
+
+  def isPureExpr(tree: Tree)(using Context): Boolean =
+    exprPurity(tree) >= Pure
+
+  def isIdempotentPath(tree: Tree)(using Context): Boolean = tree.tpe match {
+    case tpe: ConstantType => exprPurity(tree) >= Idempotent
+    case _ => exprPurity(tree) >= IdempotentPath
+  }
+
+  def isIdempotentExpr(tree: Tree)(using Context): Boolean =
+    exprPurity(tree) >= Idempotent
+
+  def isPureBinding(tree: Tree)(using Context): Boolean = statPurity(tree) >= Pure
+
+  /** Is the application `tree` with function part `fn` known to be pure?
+   *  Function value and arguments can still be impure.
+   */
+  def isPureApply(tree: Tree, fn: Tree)(using Context): Boolean =
+    def isKnownPureOp(sym: Symbol) =
+      sym.owner.isPrimitiveValueClass
+      || sym.owner == defn.StringClass
+      || defn.pureMethods.contains(sym)
+    tree.tpe.isInstanceOf[ConstantType] && tree.symbol != NoSymbol && isKnownPureOp(tree.symbol) // A constant expression with pure arguments is pure.
+    || fn.symbol.isStableMember && !fn.symbol.is(Lazy)  // constructors of no-inits classes are stable
+
+  /** The purity level of this reference.
+   *  @return
+   *    PurePath        if reference is (nonlazy and stable)
+   *                    or to a parameterized function
+   *                    or its type is a constant type
+   *    IdempotentPath  if reference is lazy and stable
+   *    Impure          otherwise
+   *  @DarkDimius: need to make sure that lazy accessor methods have Lazy and Stable
+   *               flags set.
+   */
+  def refPurity(tree: Tree)(using Context): PurityLevel = {
+    val sym = tree.symbol
+    if (!tree.hasType) Impure
+    else if !tree.tpe.widen.isParameterless then PurePath
+    else if sym.is(Erased) then PurePath
+    else if tree.tpe.isInstanceOf[ConstantType] then PurePath
+    else if (!sym.isStableMember) Impure
+    else if (sym.is(Module))
+      if (sym.moduleClass.isNoInitsRealClass) PurePath else IdempotentPath
+    else if (sym.is(Lazy)) IdempotentPath
+    else if sym.isAllOf(InlineParam) then Impure
+    else PurePath
+  }
+
+  def isPureRef(tree: Tree)(using Context): Boolean =
+    refPurity(tree) == PurePath
+  def isIdempotentRef(tree: Tree)(using Context): Boolean =
+    refPurity(tree) >= IdempotentPath
+
+  /** (1) If `tree` is a constant expression, its value as a Literal,
+   *  or `tree` itself otherwise.
+   *
+   *  Note: Demanding idempotency instead of purity in literalize is strictly speaking too loose.
+   *  Example
+   *
+   *    object O { final val x = 42; println("43") }
+   *    O.x
+   *
+   *  Strictly speaking we can't replace `O.x` with `42`.  But this would make
+   *  most expressions non-constant. Maybe we can change the spec to accept this
+   *  kind of eliding behavior. Or else enforce true purity in the compiler.
+   *  The choice will be affected by what we will do with `inline` and with
+   *  Singleton type bounds (see SIP 23). Presumably
+   *
+   *     object O1 { val x: Singleton = 42; println("43") }
+   *     object O2 { inline val x = 42; println("43") }
+   *
+   *  should behave differently.
+   *
+   *     O1.x  should have the same effect as   { println("43"); 42 }
+   *
+   *  whereas
+   *
+   *     O2.x = 42
+   *
+   *  Revisit this issue once we have standardized on `inline`. Then we can demand
+   *  purity of the prefix unless the selection goes to a inline val.
+   *
+   *  Note: This method should be applied to all term tree nodes that are not literals,
+   *        that can be idempotent, and that can have constant types. So far, only nodes
+   *        of the following classes qualify:
+   *
+   *        Ident
+   *        Select
+   *        TypeApply
+   *
+   *  (2) A primitive unary operator expression `pre.op` where `op` is one of `+`, `-`, `~`, `!`
+   *  that has a constant type `ConstantType(v)` but that is not a constant expression
+   *  (i.e. `pre` has side-effects) is translated to
+   *
+   *     { pre; v }
+   *
+   *  (3) An expression `pre.getClass[..]()` that has a constant type `ConstantType(v)` but where
+   *  `pre` has side-effects is translated to:
+   *
+   *     { pre; v }
+   *
+   *  This avoids the situation where we have a Select node that does not have a symbol.
+   */
+  def constToLiteral(tree: Tree)(using Context): Tree = {
+    assert(!tree.isType)
+    val tree1 = ConstFold(tree)
+    tree1.tpe.widenTermRefExpr.dealias.normalized match {
+      case ConstantType(Constant(_: Type)) if tree.isInstanceOf[Block] =>
+        // We can't rewrite `{ class A; classOf[A] }` to `classOf[A]`, so we leave
+        // blocks returning a class literal alone, even if they're idempotent.
+        tree1
+      case ConstantType(value) =>
+        def dropOp(t: Tree): Tree = t match
+          case Select(pre, _) if t.tpe.isInstanceOf[ConstantType] =>
+            // it's a primitive unary operator
+            pre
+          case Apply(TypeApply(Select(pre, nme.getClass_), _), Nil) =>
+            pre
+          case _ =>
+            tree1
+
+        val countsAsPure =
+          if dropOp(tree1).symbol.isInlineVal
+          then isIdempotentExpr(tree1)
+          else isPureExpr(tree1)
+
+        if countsAsPure then Literal(value).withSpan(tree.span)
+        else
+          val pre = dropOp(tree1)
+          if pre eq tree1 then tree1
+          else
+            // it's a primitive unary operator or getClass call;
+            // Simplify `pre.op` to `{ pre; v }` where `v` is the value of `pre.op`
+            Block(pre :: Nil, Literal(value)).withSpan(tree.span)
+      case _ => tree1
+    }
+  }
+
+  def isExtMethodApply(tree: Tree)(using Context): Boolean = methPart(tree) match
+    case Inlined(call, _, _) => isExtMethodApply(call)
+    case tree @ Select(qual, nme.apply) => tree.symbol.is(ExtensionMethod) || isExtMethodApply(qual)
+    case tree => tree.symbol.is(ExtensionMethod)
+
+  /** Is symbol potentially a getter of a mutable variable?
+   */
+  def mayBeVarGetter(sym: Symbol)(using Context): Boolean = {
+    def maybeGetterType(tpe: Type): Boolean = tpe match {
+      case _: ExprType => true
+      case tpe: MethodType => tpe.isImplicitMethod
+      case tpe: PolyType => maybeGetterType(tpe.resultType)
+      case _ => false
+    }
+    sym.owner.isClass && !sym.isStableMember && maybeGetterType(sym.info)
+  }
+
+  /** Is tree a reference to a mutable variable, or to a potential getter
+   *  that has a setter in the same class?
+   */
+  def isVariableOrGetter(tree: Tree)(using Context): Boolean = {
+    def sym = tree.symbol
+    def isVar = sym.is(Mutable)
+    def isGetter =
+      mayBeVarGetter(sym) && sym.owner.info.member(sym.name.asTermName.setterName).exists
+
+    unsplice(tree) match {
+      case Ident(_) => isVar
+      case Select(_, _) => isVar || isGetter
+      case Apply(_, _) =>
+        methPart(tree) match {
+          case Select(qual, nme.apply) => qual.tpe.member(nme.update).exists
+          case _ => false
+        }
+      case _ => false
+    }
+  }
+
+  /** Is tree a `this` node which belongs to `enclClass`? */
+  def isSelf(tree: Tree, enclClass: Symbol)(using Context): Boolean = unsplice(tree) match {
+    case This(_) => tree.symbol == enclClass
+    case _ => false
+  }
+
+  /** Strips layers of `.asInstanceOf[T]` / `_.$asInstanceOf[T]()` from an expression */
+  def stripCast(tree: Tree)(using Context): Tree = {
+    def isCast(sel: Tree) = sel.symbol.isTypeCast
+    unsplice(tree) match {
+      case TypeApply(sel @ Select(inner, _), _) if isCast(sel) =>
+        stripCast(inner)
+      case Apply(TypeApply(sel @ Select(inner, _), _), Nil) if isCast(sel) =>
+        stripCast(inner)
+      case t =>
+        t
+    }
+  }
+
+  /** The type arguments of a possibly curried call */
+  def typeArgss(tree: Tree): List[List[Tree]] =
+    @tailrec
+    def loop(tree: Tree, argss: List[List[Tree]]): List[List[Tree]] = tree match
+      case TypeApply(fn, args) => loop(fn, args :: argss)
+      case Apply(fn, args) => loop(fn, argss)
+      case _ => argss
+    loop(tree, Nil)
+
+  /** The term arguments of a possibly curried call */
+  def termArgss(tree: Tree): List[List[Tree]] =
+    @tailrec
+    def loop(tree: Tree, argss: List[List[Tree]]): List[List[Tree]] = tree match
+      case Apply(fn, args) => loop(fn, args :: argss)
+      case TypeApply(fn, args) => loop(fn, argss)
+      case _ => argss
+    loop(tree, Nil)
+
+  /** The type and term arguments of a possibly curried call, in the order they are given */
+  def allArgss(tree: Tree): List[List[Tree]] =
+    @tailrec
+    def loop(tree: Tree, argss: List[List[Tree]]): List[List[Tree]] = tree match
+      case tree: GenericApply => loop(tree.fun, tree.args :: argss)
+      case _ => argss
+    loop(tree, Nil)
+
+  /** The function part of a possibly curried call. Unlike `methPart` this one does
+   *  not decompose blocks
+   */
+  def funPart(tree: Tree): Tree = tree match
+    case tree: GenericApply => funPart(tree.fun)
+    case tree => tree
+
+  /** Decompose a template body into parameters and other statements */
+  def decomposeTemplateBody(body: List[Tree])(using Context): (List[Tree], List[Tree]) =
+    body.partition {
+      case stat: TypeDef => stat.symbol is Flags.Param
+      case stat: ValOrDefDef =>
+        stat.symbol.is(Flags.ParamAccessor) && !stat.symbol.isSetter
+      case _ => false
+    }
+
+  /** An extractor for closures, either contained in a block or standalone.
+   */
+  object closure {
+    def unapply(tree: Tree): Option[(List[Tree], Tree, Tree)] = tree match {
+      case Block(_, expr) => unapply(expr)
+      case Closure(env, meth, tpt) => Some(env, meth, tpt)
+      case Typed(expr, _)  => unapply(expr)
+      case _ => None
+    }
+  }
+
+  /** An extractor for def of a closure contained the block of the closure. */
+  object closureDef {
+    def unapply(tree: Tree)(using Context): Option[DefDef] = tree match {
+      case Block((meth : DefDef) :: Nil, closure: Closure) if meth.symbol == closure.meth.symbol =>
+        Some(meth)
+      case Block(Nil, expr) =>
+        unapply(expr)
+      case Inlined(_, bindings, expr) if bindings.forall(isPureBinding) =>
+        unapply(expr)
+      case _ =>
+        None
+    }
+  }
+
+  /** If tree is a closure, its body, otherwise tree itself */
+  def closureBody(tree: Tree)(using Context): Tree = tree match {
+    case closureDef(meth) => meth.rhs
+    case _ => tree
+  }
+
+  /** The variables defined by a pattern, in reverse order of their appearance. */
+  def patVars(tree: Tree)(using Context): List[Symbol] = {
+    val acc = new TreeAccumulator[List[Symbol]] {
+      def apply(syms: List[Symbol], tree: Tree)(using Context) = tree match {
+        case Bind(_, body) => apply(tree.symbol :: syms, body)
+        case Annotated(tree, id @ Ident(tpnme.BOUNDTYPE_ANNOT)) => apply(id.symbol :: syms, tree)
+        case _ => foldOver(syms, tree)
+      }
+    }
+    acc(Nil, tree)
+  }
+
+  /** Is this pattern node a catch-all or type-test pattern? */
+  def isCatchCase(cdef: CaseDef)(using Context): Boolean = cdef match {
+    case CaseDef(Typed(Ident(nme.WILDCARD), tpt), EmptyTree, _) =>
+      isSimpleThrowable(tpt.tpe)
+    case CaseDef(Bind(_, Typed(Ident(nme.WILDCARD), tpt)), EmptyTree, _) =>
+      isSimpleThrowable(tpt.tpe)
+    case _ =>
+      isDefaultCase(cdef)
+  }
+
+  private def isSimpleThrowable(tp: Type)(using Context): Boolean = tp match {
+    case tp @ TypeRef(pre, _) =>
+      (pre == NoPrefix || pre.typeSymbol.isStatic) &&
+      (tp.symbol derivesFrom defn.ThrowableClass) && !tp.symbol.is(Trait)
+    case _ =>
+      false
+  }
+
+  /** The symbols defined locally in a statement list */
+  def localSyms(stats: List[Tree])(using Context): List[Symbol] =
+    val locals = new mutable.ListBuffer[Symbol]
+    for stat <- stats do
+      if stat.isDef && stat.symbol.exists then locals += stat.symbol
+    locals.toList
+
+  /** If `tree` is a DefTree, the symbol defined by it, otherwise NoSymbol */
+  def definedSym(tree: Tree)(using Context): Symbol =
+    if (tree.isDef) tree.symbol else NoSymbol
+
+  /** Going from child to parent, the path of tree nodes that starts
+   *  with a definition of symbol `sym` and ends with `root`, or Nil
+   *  if no such path exists.
+   *  Pre: `sym` must have a position.
+   */
+  def defPath(sym: Symbol, root: Tree)(using Context): List[Tree] = trace.onDebug(s"defpath($sym with position ${sym.span}, ${root.show})") {
+    require(sym.span.exists, sym)
+    object accum extends TreeAccumulator[List[Tree]] {
+      def apply(x: List[Tree], tree: Tree)(using Context): List[Tree] =
+        if (tree.span.contains(sym.span))
+          if (definedSym(tree) == sym) tree :: x
+          else {
+            val x1 = foldOver(x, tree)
+            if (x1 ne x) tree :: x1 else x1
+          }
+        else x
+    }
+    accum(Nil, root)
+  }
+
+  /** The top level classes in this tree, including only those module classes that
+   *  are not a linked class of some other class in the result.
+   */
+  def topLevelClasses(tree: Tree)(using Context): List[ClassSymbol] = tree match {
+    case PackageDef(_, stats) => stats.flatMap(topLevelClasses)
+    case tdef: TypeDef if tdef.symbol.isClass => tdef.symbol.asClass :: Nil
+    case _ => Nil
+  }
+
+  /** The tree containing only the top-level classes and objects matching either `cls` or its companion object */
+  def sliceTopLevel(tree: Tree, cls: ClassSymbol)(using Context): List[Tree] = tree match {
+    case PackageDef(pid, stats) =>
+      val slicedStats = stats.flatMap(sliceTopLevel(_, cls))
+      val isEffectivelyEmpty = slicedStats.forall(_.isInstanceOf[Import])
+      if isEffectivelyEmpty then Nil
+      else cpy.PackageDef(tree)(pid, slicedStats) :: Nil
+    case tdef: TypeDef =>
+      val sym = tdef.symbol
+      assert(sym.isClass)
+      if (cls == sym || cls == sym.linkedClass) tdef :: Nil
+      else Nil
+    case vdef: ValDef =>
+      val sym = vdef.symbol
+      assert(sym.is(Module))
+      if (cls == sym.companionClass || cls == sym.moduleClass) vdef :: Nil
+      else Nil
+    case tree =>
+      tree :: Nil
+  }
+
+  /** The statement sequence that contains a definition of `sym`, or Nil
+   *  if none was found.
+   *  For a tree to be found, The symbol must have a position and its definition
+   *  tree must be reachable from come tree stored in an enclosing context.
+   */
+  def definingStats(sym: Symbol)(using Context): List[Tree] =
+    if (!sym.span.exists || (ctx eq NoContext) || (ctx.compilationUnit eq NoCompilationUnit)) Nil
+    else defPath(sym, ctx.compilationUnit.tpdTree) match {
+      case defn :: encl :: _ =>
+        def verify(stats: List[Tree]) =
+          if (stats exists (definedSym(_) == sym)) stats else Nil
+        encl match {
+          case Block(stats, _) => verify(stats)
+          case encl: Template => verify(encl.body)
+          case PackageDef(_, stats) => verify(stats)
+          case _ => Nil
+        }
+      case nil =>
+        Nil
+    }
+
+  /** If `tree` is an instance of `TupleN[...](e1, ..., eN)`, the arguments `e1, ..., eN`
+   *  otherwise the empty list.
+   */
+  def tupleArgs(tree: Tree)(using Context): List[Tree] = tree match {
+    case Block(Nil, expr) => tupleArgs(expr)
+    case Inlined(_, Nil, expr) => tupleArgs(expr)
+    case Apply(fn: NameTree, args)
+    if fn.name == nme.apply &&
+        fn.symbol.owner.is(Module) &&
+        defn.isTupleClass(fn.symbol.owner.companionClass) => args
+    case _ => Nil
+  }
+
+  /** The qualifier part of a Select or Ident.
+   *  For an Ident, this is the `This` of the current class.
+   */
+  def qualifier(tree: Tree)(using Context): Tree = tree match {
+    case Select(qual, _) => qual
+    case tree: Ident => desugarIdentPrefix(tree)
+    case _ => This(ctx.owner.enclosingClass.asClass)
+  }
+
+  /** Is this a (potentially applied) selection of a member of a structural type
+   *  that is not a member of an underlying class or trait?
+   */
+  def isStructuralTermSelectOrApply(tree: Tree)(using Context): Boolean = {
+    def isStructuralTermSelect(tree: Select) =
+      def hasRefinement(qualtpe: Type): Boolean = qualtpe.dealias match
+        case RefinedType(parent, rname, rinfo) =>
+          rname == tree.name || hasRefinement(parent)
+        case tp: TypeProxy =>
+          hasRefinement(tp.superType)
+        case tp: AndType =>
+          hasRefinement(tp.tp1) || hasRefinement(tp.tp2)
+        case tp: OrType =>
+          hasRefinement(tp.tp1) || hasRefinement(tp.tp2)
+        case _ =>
+          false
+      !tree.symbol.exists
+      && tree.isTerm
+      && {
+        val qualType = tree.qualifier.tpe
+        hasRefinement(qualType) && !qualType.derivesFrom(defn.PolyFunctionClass)
+      }
+    def loop(tree: Tree): Boolean = tree match
+      case TypeApply(fun, _) =>
+        loop(fun)
+      case Apply(fun, _) =>
+        loop(fun)
+      case tree: Select =>
+        isStructuralTermSelect(tree)
+      case _ =>
+        false
+    loop(tree)
+  }
+
+  /** Return a pair consisting of (supercall, rest)
+   *
+   *  - supercall: the superclass call, excluding trait constr calls
+   *
+   *  The supercall is always the first statement (if it exists)
+   */
+  final def splitAtSuper(constrStats: List[Tree])(implicit ctx: Context): (List[Tree], List[Tree]) =
+    constrStats.toList match {
+      case (sc: Apply) :: rest if sc.symbol.isConstructor => (sc :: Nil, rest)
+      case (block @ Block(_, sc: Apply)) :: rest if sc.symbol.isConstructor => (block :: Nil, rest)
+      case stats => (Nil, stats)
+    }
+
+  /** Structural tree comparison (since == on trees is reference equality).
+   *  For the moment, only Ident, Select, Literal, Apply and TypeApply are supported
+   */
+  extension (t1: Tree) {
+    def === (t2: Tree)(using Context): Boolean = (t1, t2) match {
+      case (t1: Ident, t2: Ident) =>
+        t1.symbol == t2.symbol
+      case (t1 @ Select(q1, _), t2 @ Select(q2, _)) =>
+        t1.symbol == t2.symbol && q1 === q2
+      case (Literal(c1), Literal(c2)) =>
+        c1 == c2
+      case (Apply(f1, as1), Apply(f2, as2)) =>
+        f1 === f2 && as1.corresponds(as2)(_ === _)
+      case (TypeApply(f1, ts1), TypeApply(f2, ts2)) =>
+        f1 === f2 && ts1.tpes.corresponds(ts2.tpes)(_ =:= _)
+      case _ =>
+        false
+    }
+    def hash(using Context): Int =
+      t1.getClass.hashCode * 37 + {
+        t1 match {
+          case t1: Ident => t1.symbol.hashCode
+          case t1 @ Select(q1, _) => t1.symbol.hashCode * 41 + q1.hash
+          case Literal(c1) => c1.hashCode
+          case Apply(f1, as1) => as1.foldLeft(f1.hash)((h, arg) => h * 41 + arg.hash)
+          case TypeApply(f1, ts1) => ts1.foldLeft(f1.hash)((h, arg) => h * 41 + arg.tpe.hash)
+          case _ => t1.hashCode
+        }
+      }
+  }
+
+  def assertAllPositioned(tree: Tree)(using Context): Unit =
+    tree.foreachSubTree {
+      case t: WithoutTypeOrPos[_] =>
+      case t => assert(t.span.exists, i"$t")
+    }
+
+  /** Extractors for quotes */
+  object Quoted {
+    /** Extracts the content of a quoted tree.
+     *  The result can be the contents of a term or type quote, which
+     *  will return a term or type tree respectively.
+     */
+    def unapply(tree: tpd.Apply)(using Context): Option[tpd.Tree] =
+      if tree.symbol == defn.QuotedRuntime_exprQuote then
+        // quoted.runtime.Expr.quote[T](<body>)
+        Some(tree.args.head)
+      else if tree.symbol == defn.QuotedTypeModule_of then
+        // quoted.Type.of[<body>](quotes)
+        val TypeApply(_, body :: _) = tree.fun: @unchecked
+        Some(body)
+      else None
+  }
+
+  /** Extractors for splices */
+  object Spliced {
+    /** Extracts the content of a spliced expression tree.
+     *  The result can be the contents of a term splice, which
+     *  will return a term tree.
+     */
+    def unapply(tree: tpd.Apply)(using Context): Option[tpd.Tree] =
+      if tree.symbol.isExprSplice then Some(tree.args.head) else None
+  }
+
+  /** Extractors for type splices */
+  object SplicedType {
+    /** Extracts the content of a spliced type tree.
+      *  The result can be the contents of a type splice, which
+      *  will return a type tree.
+      */
+    def unapply(tree: tpd.Select)(using Context): Option[tpd.Tree] =
+      if tree.symbol.isTypeSplice then Some(tree.qualifier) else None
+  }
+
+  /** Extractor for not-null assertions.
+   *  A not-null assertion for reference `x` has the form `x.$asInstanceOf$[x.type & T]`.
+   */
+  object AssertNotNull :
+    def apply(tree: tpd.Tree, tpnn: Type)(using Context): tpd.Tree =
+      tree.select(defn.Any_typeCast).appliedToType(AndType(tree.tpe, tpnn))
+
+    def unapply(tree: tpd.TypeApply)(using Context): Option[tpd.Tree] = tree match
+      case TypeApply(Select(qual: RefTree, nme.asInstanceOfPM), arg :: Nil) =>
+        arg.tpe match
+          case AndType(ref, nn1) if qual.tpe eq ref =>
+            qual.tpe.widen match
+              case OrNull(nn2) if nn1 eq nn2 =>
+              	Some(qual)
+              case _ => None
+          case _ => None
+      case _ => None
+  end AssertNotNull
+
+  object ConstantValue {
+    def unapply(tree: Tree)(using Context): Option[Any] =
+      tree match
+        case Typed(expr, _) => unapply(expr)
+        case Inlined(_, Nil, expr) => unapply(expr)
+        case Block(Nil, expr) => unapply(expr)
+        case _ =>
+          tree.tpe.widenTermRefExpr.normalized match
+            case ConstantType(Constant(x)) => Some(x)
+            case _ => None
+  }
+}
+
+object TreeInfo {
+  /** A purity level is represented as a bitset (expressed as an Int) */
+  class PurityLevel(val x: Int) extends AnyVal {
+    /** `this` contains the bits of `that` */
+    def >= (that: PurityLevel): Boolean = (x & that.x) == that.x
+
+    /** The intersection of the bits of `this` and `that` */
+    def min(that: PurityLevel): PurityLevel = new PurityLevel(x & that.x)
+  }
+
+  /** An expression is a stable path. Requires that expression is at least idempotent */
+  val Path: PurityLevel = new PurityLevel(4)
+
+  /** The expression has no side effects */
+  val Pure: PurityLevel = new PurityLevel(3)
+
+  /** Running the expression a second time has no side effects. Implied by `Pure`. */
+  val Idempotent: PurityLevel = new PurityLevel(1)
+
+  val Impure: PurityLevel = new PurityLevel(0)
+
+  /** A stable path that is evaluated without side effects */
+  val PurePath: PurityLevel = new PurityLevel(Pure.x | Path.x)
+
+  /** A stable path that is also idempotent */
+  val IdempotentPath: PurityLevel = new PurityLevel(Idempotent.x | Path.x)
+}
diff --git a/tests/pos-with-compiler-cc/dotc/ast/TreeMapWithImplicits.scala b/tests/pos-with-compiler-cc/dotc/ast/TreeMapWithImplicits.scala
new file mode 100644
index 000000000000..caf8d68442f6
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/ast/TreeMapWithImplicits.scala
@@ -0,0 +1,82 @@
+package dotty.tools.dotc
+package ast
+
+import Trees._
+import core.Contexts._
+import core.ContextOps.enter
+import core.Flags._
+import core.Symbols._
+import core.TypeError
+
+/** A TreeMap that maintains the necessary infrastructure to support
+ *  contextual implicit searches (type-scope implicits are supported anyway).
+ *
+ *  This incudes implicits defined in scope as well as imported implicits.
+ */
+class TreeMapWithImplicits extends tpd.TreeMapWithPreciseStatContexts {
+  import tpd._
+
+  def transformSelf(vd: ValDef)(using Context): ValDef =
+    cpy.ValDef(vd)(tpt = transform(vd.tpt))
+
+  private def nestedScopeCtx(defs: List[Tree])(using Context): Context = {
+    val nestedCtx = ctx.fresh.setNewScope
+    defs foreach {
+      case d: DefTree if d.symbol.isOneOf(GivenOrImplicitVal) => nestedCtx.enter(d.symbol)
+      case _ =>
+    }
+    nestedCtx
+  }
+
+  private def patternScopeCtx(pattern: Tree)(using Context): Context = {
+    val nestedCtx = ctx.fresh.setNewScope
+    new TreeTraverser {
+      def traverse(tree: Tree)(using Context): Unit = {
+        tree match {
+          case d: DefTree if d.symbol.isOneOf(GivenOrImplicitVal) =>
+            nestedCtx.enter(d.symbol)
+          case _ =>
+        }
+        traverseChildren(tree)
+      }
+    }.traverse(pattern)
+    nestedCtx
+  }
+
+  override def transform(tree: Tree)(using Context): Tree = {
+    try tree match {
+      case Block(stats, expr) =>
+        super.transform(tree)(using nestedScopeCtx(stats))
+      case tree: DefDef =>
+        inContext(localCtx(tree)) {
+          cpy.DefDef(tree)(
+            tree.name,
+            transformParamss(tree.paramss),
+            transform(tree.tpt),
+            transform(tree.rhs)(using nestedScopeCtx(tree.paramss.flatten)))
+        }
+      case impl @ Template(constr, parents, self, _) =>
+        cpy.Template(tree)(
+          transformSub(constr),
+          transform(parents)(using ctx.superCallContext),
+          Nil,
+          transformSelf(self),
+          transformStats(impl.body, tree.symbol))
+      case tree: CaseDef =>
+        val patCtx = patternScopeCtx(tree.pat)(using ctx)
+        cpy.CaseDef(tree)(
+          transform(tree.pat),
+          transform(tree.guard)(using patCtx),
+          transform(tree.body)(using patCtx)
+        )
+      case _ =>
+        super.transform(tree)
+    }
+    catch {
+      case ex: TypeError =>
+        report.error(ex, tree.srcPos)
+        tree
+    }
+  }
+}
+
diff --git a/tests/pos-with-compiler-cc/dotc/ast/TreeTypeMap.scala b/tests/pos-with-compiler-cc/dotc/ast/TreeTypeMap.scala
new file mode 100644
index 000000000000..5139a46d6352
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/ast/TreeTypeMap.scala
@@ -0,0 +1,232 @@
+package dotty.tools
+package dotc
+package ast
+
+import core._
+import Types._, Contexts._, Flags._
+import Symbols._, Annotations._, Trees._, Symbols._, Constants.Constant
+import Decorators._
+import dotty.tools.dotc.transform.SymUtils._
+import language.experimental.pureFunctions
+
+/** A map that applies three functions and a substitution together to a tree and
+ *  makes sure they are coordinated so that the result is well-typed. The functions are
+ *  @param typeMap   A function from Type to Type that gets applied to the
+ *                   type of every tree node and to all locally defined symbols,
+ *                   followed by the substitution [substFrom := substTo].
+ *  @param treeMap   A transformer that translates all encountered subtrees in
+ *                   prefix traversal orders
+ *  @param oldOwners Previous owners. If a top-level local symbol in the mapped tree
+ *                   has one of these as an owner, the owner is replaced by the corresponding
+ *                   symbol in `newOwners`.
+ *  @param newOwners New owners, replacing previous owners.
+ *  @param substFrom The symbols that need to be substituted.
+ *  @param substTo   The substitution targets.
+ *
+ *  The reason the substitution is broken out from the rest of the type map is
+ *  that all symbols have to be substituted at the same time. If we do not do this,
+ *  we risk data races on named types. Example: Say we have `outer#1.inner#2` and we
+ *  have two substitutions S1 = [outer#1 := outer#3], S2 = [inner#2 := inner#4] where
+ *  hashtags precede symbol ids. If we do S1 first, we get outer#2.inner#3. If we then
+ *  do S2 we get outer#2.inner#4. But that means that the named type outer#2.inner
+ *  gets two different denotations in the same period. Hence, if -Yno-double-bindings is
+ *  set, we would get a data race assertion error.
+ */
+class TreeTypeMap(
+  val typeMap: Type -> Type = IdentityTypeMap,
+  val treeMap: tpd.Tree -> tpd.Tree = identity[tpd.Tree](_), // !cc! need explicit instantiation of default argument
+  val oldOwners: List[Symbol] = Nil,
+  val newOwners: List[Symbol] = Nil,
+  val substFrom: List[Symbol] = Nil,
+  val substTo: List[Symbol] = Nil,
+  cpy: tpd.TreeCopier = tpd.cpy)(using Context) extends tpd.TreeMap(cpy) {
+  import tpd._
+
+  def copy(
+      typeMap: Type -> Type,
+      treeMap: tpd.Tree -> tpd.Tree,
+      oldOwners: List[Symbol],
+      newOwners: List[Symbol],
+      substFrom: List[Symbol],
+      substTo: List[Symbol])(using Context): TreeTypeMap =
+    new TreeTypeMap(typeMap, treeMap, oldOwners, newOwners, substFrom, substTo)
+
+  /** If `sym` is one of `oldOwners`, replace by corresponding symbol in `newOwners` */
+  def mapOwner(sym: Symbol): Symbol = sym.subst(oldOwners, newOwners)
+
+  /** Replace occurrences of `This(oldOwner)` in some prefix of a type
+   *  by the corresponding `This(newOwner)`.
+   */
+  private val mapOwnerThis = new TypeMap with cc.CaptureSet.IdempotentCaptRefMap {
+    private def mapPrefix(from: List[Symbol], to: List[Symbol], tp: Type): Type = from match {
+      case Nil => tp
+      case (cls: ClassSymbol) :: from1 => mapPrefix(from1, to.tail, tp.substThis(cls, to.head.thisType))
+      case _ :: from1 => mapPrefix(from1, to.tail, tp)
+    }
+    def apply(tp: Type): Type = tp match {
+      case tp: NamedType => tp.derivedSelect(mapPrefix(oldOwners, newOwners, tp.prefix))
+      case _ => mapOver(tp)
+    }
+  }
+
+  def mapType(tp: Type): Type =
+    mapOwnerThis(typeMap(tp).substSym(substFrom, substTo))
+
+  private def updateDecls(prevStats: List[Tree], newStats: List[Tree]): Unit =
+    if (prevStats.isEmpty) assert(newStats.isEmpty)
+    else {
+      prevStats.head match {
+        case pdef: MemberDef =>
+          val prevSym = pdef.symbol
+          val newSym = newStats.head.symbol
+          val newCls = newSym.owner.asClass
+          if (prevSym != newSym) newCls.replace(prevSym, newSym)
+        case _ =>
+      }
+      updateDecls(prevStats.tail, newStats.tail)
+    }
+
+  def transformInlined(tree: tpd.Inlined)(using Context): tpd.Tree =
+    val Inlined(call, bindings, expanded) = tree
+    val (tmap1, bindings1) = transformDefs(bindings)
+    val expanded1 = tmap1.transform(expanded)
+    cpy.Inlined(tree)(call, bindings1, expanded1)
+
+  override def transform(tree: tpd.Tree)(using Context): tpd.Tree = treeMap(tree) match {
+    case impl @ Template(constr, parents, self, _) =>
+      val tmap = withMappedSyms(localSyms(impl :: self :: Nil))
+      cpy.Template(impl)(
+          constr = tmap.transformSub(constr),
+          parents = parents.mapconserve(transform),
+          self = tmap.transformSub(self),
+          body = impl.body mapconserve
+            (tmap.transform(_)(using ctx.withOwner(mapOwner(impl.symbol.owner))))
+        ).withType(tmap.mapType(impl.tpe))
+    case tree1 =>
+      tree1.withType(mapType(tree1.tpe)) match {
+        case id: Ident if tpd.needsSelect(id.tpe) =>
+          ref(id.tpe.asInstanceOf[TermRef]).withSpan(id.span)
+        case ddef @ DefDef(name, paramss, tpt, _) =>
+          val (tmap1, paramss1) = transformAllParamss(paramss)
+          val res = cpy.DefDef(ddef)(name, paramss1, tmap1.transform(tpt), tmap1.transform(ddef.rhs))
+          res.symbol.setParamssFromDefs(paramss1)
+          res.symbol.transformAnnotations {
+            case ann: BodyAnnotation => ann.derivedAnnotation(transform(ann.tree))
+            case ann => ann
+          }
+          res
+        case tdef @ LambdaTypeTree(tparams, body) =>
+          val (tmap1, tparams1) = transformDefs(tparams)
+          cpy.LambdaTypeTree(tdef)(tparams1, tmap1.transform(body))
+        case blk @ Block(stats, expr) =>
+          val (tmap1, stats1) = transformDefs(stats)
+          val expr1 = tmap1.transform(expr)
+          cpy.Block(blk)(stats1, expr1)
+        case inlined: Inlined =>
+          transformInlined(inlined)
+        case cdef @ CaseDef(pat, guard, rhs) =>
+          val tmap = withMappedSyms(patVars(pat))
+          val pat1 = tmap.transform(pat)
+          val guard1 = tmap.transform(guard)
+          val rhs1 = tmap.transform(rhs)
+          cpy.CaseDef(cdef)(pat1, guard1, rhs1)
+        case labeled @ Labeled(bind, expr) =>
+          val tmap = withMappedSyms(bind.symbol :: Nil)
+          val bind1 = tmap.transformSub(bind)
+          val expr1 = tmap.transform(expr)
+          cpy.Labeled(labeled)(bind1, expr1)
+        case tree @ Hole(_, _, args, content, tpt) =>
+          val args1 = args.mapConserve(transform)
+          val content1 = transform(content)
+          val tpt1 = transform(tpt)
+          cpy.Hole(tree)(args = args1, content = content1, tpt = tpt1)
+        case lit @ Literal(Constant(tpe: Type)) =>
+          cpy.Literal(lit)(Constant(mapType(tpe)))
+        case tree1 =>
+          super.transform(tree1)
+      }
+  }
+
+  override def transformStats(trees: List[tpd.Tree], exprOwner: Symbol)(using Context): List[Tree] =
+    transformDefs(trees)._2
+
+  def transformDefs[TT <: tpd.Tree](trees: List[TT])(using Context): (TreeTypeMap, List[TT]) = {
+    val tmap = withMappedSyms(tpd.localSyms(trees))
+    (tmap, tmap.transformSub(trees))
+  }
+
+  private def transformAllParamss(paramss: List[ParamClause]): (TreeTypeMap, List[ParamClause]) = paramss match
+    case params :: paramss1 =>
+      val (tmap1, params1: ParamClause) = ((params: @unchecked) match
+        case ValDefs(vparams) => transformDefs(vparams)
+        case TypeDefs(tparams) => transformDefs(tparams)
+      ): @unchecked
+      val (tmap2, paramss2) = tmap1.transformAllParamss(paramss1)
+      (tmap2, params1 :: paramss2)
+    case nil =>
+      (this, paramss)
+
+  def apply[ThisTree <: tpd.Tree](tree: ThisTree): ThisTree = transform(tree).asInstanceOf[ThisTree]
+
+  def apply(annot: Annotation): Annotation = annot.derivedAnnotation(apply(annot.tree))
+
+  /** The current tree map composed with a substitution [from -> to] */
+  def withSubstitution(from: List[Symbol], to: List[Symbol]): TreeTypeMap =
+    if (from eq to) this
+    else {
+      // assert that substitution stays idempotent, assuming its parts are
+      // TODO: It might be better to cater for the asserted-away conditions, by
+      // setting up a proper substitution abstraction with a compose operator that
+      // guarantees idempotence. But this might be too inefficient in some cases.
+      // We'll cross that bridge when we need to.
+      assert(!from.exists(substTo contains _))
+      assert(!to.exists(substFrom contains _))
+      assert(!from.exists(newOwners contains _))
+      assert(!to.exists(oldOwners contains _))
+      copy(
+        typeMap,
+        treeMap,
+        from ++ oldOwners,
+        to ++ newOwners,
+        from ++ substFrom,
+        to ++ substTo)
+    }
+
+  /** Apply `typeMap` and `ownerMap` to given symbols `syms`
+   *  and return a treemap that contains the substitution
+   *  between original and mapped symbols.
+   */
+  def withMappedSyms(syms: List[Symbol]): TreeTypeMap =
+    withMappedSyms(syms, mapSymbols(syms, this))
+
+  /** The tree map with the substitution between originals `syms`
+   *  and mapped symbols `mapped`. Also goes into mapped classes
+   *  and substitutes their declarations.
+   */
+  def withMappedSyms(syms: List[Symbol], mapped: List[Symbol]): TreeTypeMap =
+    if syms eq mapped then this
+    else
+      val substMap = withSubstitution(syms, mapped)
+      lazy val origCls = mapped.zip(syms).filter(_._1.isClass).toMap
+      mapped.filter(_.isClass).foldLeft(substMap) { (tmap, cls) =>
+        val origDcls = cls.info.decls.toList.filterNot(_.is(TypeParam))
+        val tmap0 = tmap.withSubstitution(origCls(cls).typeParams, cls.typeParams)
+        val mappedDcls = mapSymbols(origDcls, tmap0, mapAlways = true)
+        val tmap1 = tmap.withMappedSyms(
+          origCls(cls).typeParams ::: origDcls,
+          cls.typeParams ::: mappedDcls)
+        origDcls.lazyZip(mappedDcls).foreach(cls.asClass.replace)
+        tmap1
+      }
+
+  override def toString =
+    def showSyms(syms: List[Symbol]) =
+      syms.map(sym => s"$sym#${sym.id}").mkString(", ")
+    s"""TreeTypeMap(
+       |typeMap   = $typeMap
+       |treeMap   = $treeMap
+       |oldOwners = ${showSyms(oldOwners)}
+       |newOwners = ${showSyms(newOwners)}
+       |substFrom = ${showSyms(substFrom)}
+       |substTo   = ${showSyms(substTo)}""".stripMargin
+}
diff --git a/tests/pos-with-compiler-cc/dotc/ast/Trees.scala b/tests/pos-with-compiler-cc/dotc/ast/Trees.scala
new file mode 100644
index 000000000000..82b027b0231a
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/ast/Trees.scala
@@ -0,0 +1,1789 @@
+package dotty.tools
+package dotc
+package ast
+
+import core._
+import Types._, Names._, NameOps._, Flags._, util.Spans._, Contexts._, Constants._
+import typer.{ ConstFold, ProtoTypes }
+import SymDenotations._, Symbols._, Denotations._, StdNames._, Comments._
+import collection.mutable.ListBuffer
+import printing.Printer
+import printing.Texts.Text
+import util.{Stats, Attachment, Property, SourceFile, NoSource, SrcPos, SourcePosition}
+import config.Config
+import config.Printers.overload
+import annotation.internal.sharable
+import annotation.unchecked.uncheckedVariance
+import annotation.constructorOnly
+import Decorators._
+import annotation.retains
+import language.experimental.pureFunctions
+
+object Trees {
+
+  type Untyped = Nothing
+
+  /** The total number of created tree nodes, maintained if Stats.enabled */
+  @sharable var ntrees: Int = 0
+
+  /** Property key for trees with documentation strings attached */
+  val DocComment: Property.StickyKey[Comments.Comment] = Property.StickyKey()
+
+  /** Property key for backquoted identifiers and definitions */
+  val Backquoted: Property.StickyKey[Unit] = Property.StickyKey()
+
+  /** Trees take a parameter indicating what the type of their `tpe` field
+   *  is. Two choices: `Type` or `Untyped`.
+   *  Untyped trees have type `Tree[Untyped]`.
+   *
+   *  Tree typing uses a copy-on-write implementation:
+   *
+   *   - You can never observe a `tpe` which is `null` (throws an exception)
+   *   - So when creating a typed tree with `withType` we can re-use
+   *     the existing tree transparently, assigning its `tpe` field.
+   *   - It is impossible to embed untyped trees in typed ones.
+   *   - Typed trees can be embedded in untyped ones provided they are rooted
+   *     in a TypedSplice node.
+   *   - Type checking an untyped tree should remove all embedded `TypedSplice`
+   *     nodes.
+   */
+  abstract class Tree[-T >: Untyped](implicit @constructorOnly src: SourceFile)
+  extends Positioned, SrcPos, Product, Attachment.Container, printing.Showable, caps.Pure {
+
+    if (Stats.enabled) ntrees += 1
+
+    /** The type  constructor at the root of the tree */
+    type ThisTree[T >: Untyped] <: Tree[T]
+
+    protected var myTpe: T @uncheckedVariance = _
+
+    /** Destructively set the type of the tree. This should be called only when it is known that
+     *  it is safe under sharing to do so. One use-case is in the withType method below
+     *  which implements copy-on-write. Another use-case is in method interpolateAndAdapt in Typer,
+     *  where we overwrite with a simplified version of the type itself.
+     */
+    private[dotc] def overwriteType(tpe: T): Unit =
+      myTpe = tpe
+
+    /** The type of the tree. In case of an untyped tree,
+     *   an UnAssignedTypeException is thrown. (Overridden by empty trees)
+     */
+    final def tpe: T @uncheckedVariance = {
+      if (myTpe == null)
+        throw UnAssignedTypeException(this)
+      myTpe
+    }
+
+    /** Copy `tpe` attribute from tree `from` into this tree, independently
+     *  whether it is null or not.
+    final def copyAttr[U >: Untyped](from: Tree[U]): ThisTree[T] = {
+      val t1 = this.withSpan(from.span)
+      val t2 =
+        if (from.myTpe != null) t1.withType(from.myTpe.asInstanceOf[Type])
+        else t1
+      t2.asInstanceOf[ThisTree[T]]
+    }
+     */
+
+    /** Return a typed tree that's isomorphic to this tree, but has given
+     *  type. (Overridden by empty trees)
+     */
+    def withType(tpe: Type)(using Context): ThisTree[Type] = {
+      if (tpe.isInstanceOf[ErrorType])
+        assert(!Config.checkUnreportedErrors ||
+               ctx.reporter.errorsReported ||
+               ctx.settings.YshowPrintErrors.value
+                 // under -Yshow-print-errors, errors might arise during printing, but they do not count as reported
+              )
+      else if (Config.checkTreesConsistent)
+        checkChildrenTyped(productIterator)
+      withTypeUnchecked(tpe)
+    }
+
+    /** Check that typed trees don't refer to untyped ones, except if
+     *   - the parent tree is an import, or
+     *   - the child tree is an identifier, or
+     *   - errors were reported
+     */
+    private def checkChildrenTyped(it: Iterator[Any])(using Context): Unit =
+      if (!this.isInstanceOf[Import[?]])
+        while (it.hasNext)
+          it.next() match {
+            case x: Ident[?] => // untyped idents are used in a number of places in typed trees
+            case x: Tree[?] =>
+              assert(x.hasType || ctx.reporter.errorsReported,
+                     s"$this has untyped child $x")
+            case xs: List[?] => checkChildrenTyped(xs.iterator)
+            case _ =>
+          }
+
+    def withTypeUnchecked(tpe: Type): ThisTree[Type] = {
+      val tree =
+        (if (myTpe == null ||
+          (myTpe.asInstanceOf[AnyRef] eq tpe.asInstanceOf[AnyRef])) this
+         else cloneIn(source)).asInstanceOf[Tree[Type]]
+      tree overwriteType tpe
+      tree.asInstanceOf[ThisTree[Type]]
+    }
+
+    /** Does the tree have its type field set? Note: this operation is not
+     *  referentially transparent, because it can observe the withType
+     *  modifications. Should be used only in special circumstances (we
+     *  need it for printing trees with optional type info).
+     */
+    final def hasType: Boolean = myTpe != null
+
+    final def typeOpt: Type = myTpe match {
+      case tp: Type => tp
+      case _ => NoType
+    }
+
+    /** The denotation referred to by this tree.
+     *  Defined for `DenotingTree`s and `ProxyTree`s, NoDenotation for other
+     *  kinds of trees
+     */
+    def denot(using Context): Denotation = NoDenotation
+
+    /** Shorthand for `denot.symbol`. */
+    final def symbol(using Context): Symbol = denot.symbol
+
+    /** Does this tree represent a type? */
+    def isType: Boolean = false
+
+    /** Does this tree represent a term? */
+    def isTerm: Boolean = false
+
+    /** Is this a legal part of a pattern which is not at the same time a term? */
+    def isPattern: Boolean = false
+
+    /** Does this tree define a new symbol that is not defined elsewhere? */
+    def isDef: Boolean = false
+
+    /** Is this tree either the empty tree or the empty ValDef or an empty type ident? */
+    def isEmpty: Boolean = false
+
+    /** Convert tree to a list. Gives a singleton list, except
+     *  for thickets which return their element trees.
+     */
+    def toList: List[Tree[T]] = this :: Nil
+
+    /** if this tree is the empty tree, the alternative, else this tree */
+    inline def orElse[U >: Untyped <: T](inline that: Tree[U]): Tree[U] =
+      if (this eq genericEmptyTree) that else this
+
+    /** The number of nodes in this tree */
+    def treeSize: Int = {
+      var s = 1
+      def addSize(elem: Any): Unit = elem match {
+        case t: Tree[?] => s += t.treeSize
+        case ts: List[?] => ts foreach addSize
+        case _ =>
+      }
+      productIterator foreach addSize
+      s
+    }
+
+    /** If this is a thicket, perform `op` on each of its trees
+     *  otherwise, perform `op` ion tree itself.
+     */
+    def foreachInThicket(op: Tree[T] => Unit): Unit = op(this)
+
+    override def toText(printer: Printer): Text = printer.toText(this)
+
+    def sameTree(that: Tree[?]): Boolean = {
+      def isSame(x: Any, y: Any): Boolean =
+        x.asInstanceOf[AnyRef].eq(y.asInstanceOf[AnyRef]) || {
+          x match {
+            case x: Tree[?] =>
+              y match {
+                case y: Tree[?] => x.sameTree(y)
+                case _ => false
+              }
+            case x: List[?] =>
+              y match {
+                case y: List[?] => x.corresponds(y)(isSame)
+                case _ => false
+              }
+            case _ =>
+              false
+          }
+        }
+      this.getClass == that.getClass && {
+        val it1 = this.productIterator
+        val it2 = that.productIterator
+        it1.corresponds(it2)(isSame)
+      }
+    }
+
+    override def hashCode(): Int = System.identityHashCode(this)
+    override def equals(that: Any): Boolean = this eq that.asInstanceOf[AnyRef]
+  }
+
+  class UnAssignedTypeException[T >: Untyped](tree: Tree[T]) extends RuntimeException {
+    override def getMessage: String = s"type of $tree is not assigned"
+  }
+
+  type LazyTree[-T >: Untyped] = Tree[T] | Lazy[Tree[T]]
+  type LazyTreeList[-T >: Untyped] = List[Tree[T]] | Lazy[List[Tree[T]]]
+
+  // ------ Categories of trees -----------------------------------
+
+  /** Instances of this class are trees for which isType is definitely true.
+   *  Note that some trees have isType = true without being TypTrees (e.g. Ident, Annotated)
+   */
+  trait TypTree[-T >: Untyped] extends Tree[T] {
+    type ThisTree[-T >: Untyped] <: TypTree[T]
+    override def isType: Boolean = true
+  }
+
+  /** Instances of this class are trees for which isTerm is definitely true.
+   *  Note that some trees have isTerm = true without being TermTrees (e.g. Ident, Annotated)
+   */
+  trait TermTree[-T >: Untyped] extends Tree[T] {
+    type ThisTree[-T >: Untyped] <: TermTree[T]
+    override def isTerm: Boolean = true
+  }
+
+  /** Instances of this class are trees which are not terms but are legal
+   *  parts of patterns.
+   */
+  trait PatternTree[-T >: Untyped] extends Tree[T] {
+    type ThisTree[-T >: Untyped] <: PatternTree[T]
+    override def isPattern: Boolean = true
+  }
+
+  /** Tree's denotation can be derived from its type */
+  abstract class DenotingTree[-T >: Untyped](implicit @constructorOnly src: SourceFile) extends Tree[T] {
+    type ThisTree[-T >: Untyped] <: DenotingTree[T]
+    override def denot(using Context): Denotation = typeOpt.stripped match
+      case tpe: NamedType => tpe.denot
+      case tpe: ThisType => tpe.cls.denot
+      case _ => NoDenotation
+  }
+
+  /** Tree's denot/isType/isTerm properties come from a subtree
+   *  identified by `forwardTo`.
+   */
+  abstract class ProxyTree[-T >: Untyped](implicit @constructorOnly src: SourceFile)  extends Tree[T] {
+    type ThisTree[-T >: Untyped] <: ProxyTree[T]
+    def forwardTo: Tree[T]
+    override def denot(using Context): Denotation = forwardTo.denot
+    override def isTerm: Boolean = forwardTo.isTerm
+    override def isType: Boolean = forwardTo.isType
+  }
+
+  /** Tree has a name */
+  abstract class NameTree[-T >: Untyped](implicit @constructorOnly src: SourceFile) extends DenotingTree[T] {
+    type ThisTree[-T >: Untyped] <: NameTree[T]
+    def name: Name
+  }
+
+  /** Tree refers by name to a denotation */
+  abstract class RefTree[-T >: Untyped](implicit @constructorOnly src: SourceFile) extends NameTree[T] {
+    type ThisTree[-T >: Untyped] <: RefTree[T]
+    def qualifier: Tree[T]
+    override def isType: Boolean = name.isTypeName
+    override def isTerm: Boolean = name.isTermName
+  }
+
+  /** Tree defines a new symbol */
+  trait DefTree[-T >: Untyped] extends DenotingTree[T] {
+    type ThisTree[-T >: Untyped] <: DefTree[T]
+
+    private var myMods: untpd.Modifiers | Null = _
+
+    private[dotc] def rawMods: untpd.Modifiers =
+      if (myMods == null) untpd.EmptyModifiers else myMods.uncheckedNN
+
+    def withAnnotations(annots: List[untpd.Tree]): ThisTree[Untyped] = withMods(rawMods.withAnnotations(annots))
+
+    def withMods(mods: untpd.Modifiers): ThisTree[Untyped] = {
+      val tree = if (myMods == null || (myMods == mods)) this else cloneIn(source)
+      tree.setMods(mods)
+      tree.asInstanceOf[ThisTree[Untyped]]
+    }
+
+    def withFlags(flags: FlagSet): ThisTree[Untyped] = withMods(untpd.Modifiers(flags))
+    def withAddedFlags(flags: FlagSet): ThisTree[Untyped] = withMods(rawMods | flags)
+
+    /** Destructively update modifiers. To be used with care. */
+    def setMods(mods: untpd.Modifiers): Unit = myMods = mods
+
+    override def isDef: Boolean = true
+    def namedType: NamedType = tpe.asInstanceOf[NamedType]
+  }
+
+  extension (mdef: untpd.DefTree) def mods: untpd.Modifiers = mdef.rawMods
+
+  sealed trait WithEndMarker[-T >: Untyped]:
+    self: PackageDef[T] | NamedDefTree[T] =>
+
+    import WithEndMarker.*
+
+    final def endSpan(using Context): Span =
+      if hasEndMarker then
+        val realName = srcName.stripModuleClassSuffix.lastPart
+        span.withStart(span.end - realName.length)
+      else
+        NoSpan
+
+    /** The name in source code that represents this construct,
+     *  and is the name that the user must write to create a valid
+     *  end marker.
+     *  e.g. a constructor definition is terminated in the source
+     *  code by `end this`, so it's `srcName` should return `this`.
+     */
+    protected def srcName(using Context): Name
+
+    final def withEndMarker(): self.type =
+      self.withAttachment(HasEndMarker, ())
+
+    final def withEndMarker(copyFrom: WithEndMarker[?]): self.type =
+      if copyFrom.hasEndMarker then
+        this.withEndMarker()
+      else
+        this
+
+    final def dropEndMarker(): self.type =
+      self.removeAttachment(HasEndMarker)
+      this
+
+    protected def hasEndMarker: Boolean = self.hasAttachment(HasEndMarker)
+
+  object WithEndMarker:
+    /** Property key that signals the tree was terminated
+     *  with an `end` marker in the source code
+     */
+    private val HasEndMarker: Property.StickyKey[Unit] = Property.StickyKey()
+
+  end WithEndMarker
+
+  abstract class NamedDefTree[-T >: Untyped](implicit @constructorOnly src: SourceFile)
+  extends NameTree[T] with DefTree[T] with WithEndMarker[T] {
+    type ThisTree[-T >: Untyped] <: NamedDefTree[T]
+
+    protected def srcName(using Context): Name =
+      if name == nme.CONSTRUCTOR then nme.this_
+      else if symbol.isPackageObject then symbol.owner.name
+      else name
+
+    /** The position of the name defined by this definition.
+     *  This is a point position if the definition is synthetic, or a range position
+     *  if the definition comes from source.
+     *  It might also be that the definition does not have a position (for instance when synthesized by
+     *  a calling chain from `viewExists`), in that case the return position is NoSpan.
+     *  Overridden in Bind
+     */
+    def nameSpan(using Context): Span =
+      if (span.exists) {
+        val point = span.point
+        if (rawMods.is(Synthetic) || span.isSynthetic || name.toTermName == nme.ERROR) Span(point)
+        else {
+          val realName = srcName.stripModuleClassSuffix.lastPart
+          Span(point, point + realName.length, point)
+        }
+      }
+      else span
+
+    /** The source position of the name defined by this definition.
+     *  This is a point position if the definition is synthetic, or a range position
+     *  if the definition comes from source.
+     */
+    def namePos(using Context): SourcePosition = source.atSpan(nameSpan)
+  }
+
+  /** Tree defines a new symbol and carries modifiers.
+   *  The position of a MemberDef contains only the defined identifier or pattern.
+   *  The envelope of a MemberDef contains the whole definition and has its point
+   *  on the opening keyword (or the next token after that if keyword is missing).
+   */
+  abstract class MemberDef[-T >: Untyped](implicit @constructorOnly src: SourceFile) extends NamedDefTree[T] {
+    type ThisTree[-T >: Untyped] <: MemberDef[T]
+
+    def rawComment: Option[Comment] = getAttachment(DocComment)
+
+    def setComment(comment: Option[Comment]): this.type = {
+      comment.map(putAttachment(DocComment, _))
+      this
+    }
+
+    def name: Name
+  }
+
+  /** A ValDef or DefDef tree */
+  abstract class ValOrDefDef[-T >: Untyped](implicit @constructorOnly src: SourceFile) extends MemberDef[T] with WithLazyField[Tree[T]] {
+    type ThisTree[-T >: Untyped] <: ValOrDefDef[T]
+    def name: TermName
+    def tpt: Tree[T]
+    def unforcedRhs: LazyTree[T] = unforced
+    def rhs(using Context): Tree[T] = forceIfLazy
+  }
+
+  trait ValOrTypeDef[-T >: Untyped] extends MemberDef[T]:
+    type ThisTree[-T >: Untyped] <: ValOrTypeDef[T]
+
+  type ParamClause[T >: Untyped] = List[ValDef[T]] | List[TypeDef[T]]
+
+  // ----------- Tree case classes ------------------------------------
+
+  /** name */
+  case class Ident[-T >: Untyped] private[ast] (name: Name)(implicit @constructorOnly src: SourceFile)
+    extends RefTree[T] {
+    type ThisTree[-T >: Untyped] = Ident[T]
+    def qualifier: Tree[T] = genericEmptyTree
+
+    def isBackquoted: Boolean = hasAttachment(Backquoted)
+  }
+
+  class SearchFailureIdent[-T >: Untyped] private[ast] (name: Name, expl: -> String)(implicit @constructorOnly src: SourceFile)
+    extends Ident[T](name) {
+    def explanation = expl
+    override def toString: String = s"SearchFailureIdent($explanation)"
+  }
+
+  /** qualifier.name, or qualifier#name, if qualifier is a type */
+  case class Select[-T >: Untyped] private[ast] (qualifier: Tree[T], name: Name)(implicit @constructorOnly src: SourceFile)
+    extends RefTree[T] {
+    type ThisTree[-T >: Untyped] = Select[T]
+
+    override def denot(using Context): Denotation = typeOpt match
+      case ConstantType(_) if ConstFold.foldedUnops.contains(name) =>
+        // Recover the denotation of a constant-folded selection
+        qualifier.typeOpt.member(name).atSignature(Signature.NotAMethod, name)
+      case _ =>
+        super.denot
+
+    def nameSpan(using Context): Span =
+      if span.exists then
+        val point = span.point
+        if name.toTermName == nme.ERROR then
+          Span(point)
+        else if qualifier.span.start > span.start then // right associative
+          val realName = name.stripModuleClassSuffix.lastPart
+          Span(span.start, span.start + realName.length, point)
+        else
+          Span(point, span.end, point)
+      else span
+  }
+
+  class SelectWithSig[-T >: Untyped] private[ast] (qualifier: Tree[T], name: Name, val sig: Signature)(implicit @constructorOnly src: SourceFile)
+    extends Select[T](qualifier, name) {
+    override def toString: String = s"SelectWithSig($qualifier, $name, $sig)"
+  }
+
+  /** qual.this */
+  case class This[-T >: Untyped] private[ast] (qual: untpd.Ident)(implicit @constructorOnly src: SourceFile)
+    extends DenotingTree[T] with TermTree[T] {
+    type ThisTree[-T >: Untyped] = This[T]
+    // Denotation of a This tree is always the underlying class; needs correction for modules.
+    override def denot(using Context): Denotation =
+      typeOpt match {
+        case tpe @ TermRef(pre, _) if tpe.symbol.is(Module) =>
+          tpe.symbol.moduleClass.denot.asSeenFrom(pre)
+        case _ =>
+          super.denot
+      }
+  }
+
+  /** C.super[mix], where qual = C.this */
+  case class Super[-T >: Untyped] private[ast] (qual: Tree[T], mix: untpd.Ident)(implicit @constructorOnly src: SourceFile)
+    extends ProxyTree[T] with TermTree[T] {
+    type ThisTree[-T >: Untyped] = Super[T]
+    def forwardTo: Tree[T] = qual
+  }
+
+  abstract class GenericApply[-T >: Untyped](implicit @constructorOnly src: SourceFile) extends ProxyTree[T] with TermTree[T] {
+    type ThisTree[-T >: Untyped] <: GenericApply[T]
+    val fun: Tree[T]
+    val args: List[Tree[T]]
+    def forwardTo: Tree[T] = fun
+  }
+
+  object GenericApply:
+    def unapply[T >: Untyped](tree: Tree[T]): Option[(Tree[T], List[Tree[T]])] = tree match
+      case tree: GenericApply[T] => Some((tree.fun, tree.args))
+      case _ => None
+
+  /** The kind of application */
+  enum ApplyKind:
+    case Regular      // r.f(x)
+    case Using        // r.f(using x)
+    case InfixTuple   // r f (x1, ..., xN) where N != 1;  needs to be treated specially for an error message in typedApply
+
+  /** fun(args) */
+  case class Apply[-T >: Untyped] private[ast] (fun: Tree[T], args: List[Tree[T]])(implicit @constructorOnly src: SourceFile)
+    extends GenericApply[T] {
+    type ThisTree[-T >: Untyped] = Apply[T]
+
+    def setApplyKind(kind: ApplyKind) =
+      putAttachment(untpd.KindOfApply, kind)
+      this
+
+    /** The kind of this application. Works reliably only for untyped trees; typed trees
+     *  are under no obligation to update it correctly.
+     */
+    def applyKind: ApplyKind =
+      attachmentOrElse(untpd.KindOfApply, ApplyKind.Regular)
+  }
+
+  /** fun[args] */
+  case class TypeApply[-T >: Untyped] private[ast] (fun: Tree[T], args: List[Tree[T]])(implicit @constructorOnly src: SourceFile)
+    extends GenericApply[T] {
+    type ThisTree[-T >: Untyped] = TypeApply[T]
+  }
+
+  /** const */
+  case class Literal[-T >: Untyped] private[ast] (const: Constant)(implicit @constructorOnly src: SourceFile)
+    extends Tree[T] with TermTree[T] {
+    type ThisTree[-T >: Untyped] = Literal[T]
+  }
+
+  /** new tpt, but no constructor call */
+  case class New[-T >: Untyped] private[ast] (tpt: Tree[T])(implicit @constructorOnly src: SourceFile)
+    extends Tree[T] with TermTree[T] {
+    type ThisTree[-T >: Untyped] = New[T]
+  }
+
+  /** expr : tpt */
+  case class Typed[-T >: Untyped] private[ast] (expr: Tree[T], tpt: Tree[T])(implicit @constructorOnly src: SourceFile)
+    extends ProxyTree[T] with TermTree[T] {
+    type ThisTree[-T >: Untyped] = Typed[T]
+    def forwardTo: Tree[T] = expr
+  }
+
+  /** name = arg, in a parameter list */
+  case class NamedArg[-T >: Untyped] private[ast] (name: Name, arg: Tree[T])(implicit @constructorOnly src: SourceFile)
+    extends Tree[T] {
+    type ThisTree[-T >: Untyped] = NamedArg[T]
+  }
+
+  /** name = arg, outside a parameter list */
+  case class Assign[-T >: Untyped] private[ast] (lhs: Tree[T], rhs: Tree[T])(implicit @constructorOnly src: SourceFile)
+    extends TermTree[T] {
+    type ThisTree[-T >: Untyped] = Assign[T]
+  }
+
+  /** { stats; expr } */
+  case class Block[-T >: Untyped] private[ast] (stats: List[Tree[T]], expr: Tree[T])(implicit @constructorOnly src: SourceFile)
+    extends Tree[T] {
+    type ThisTree[-T >: Untyped] = Block[T]
+    override def isType: Boolean = expr.isType
+    override def isTerm: Boolean = !isType // this will classify empty trees as terms, which is necessary
+  }
+
+  /** if cond then thenp else elsep */
+  case class If[-T >: Untyped] private[ast] (cond: Tree[T], thenp: Tree[T], elsep: Tree[T])(implicit @constructorOnly src: SourceFile)
+    extends TermTree[T] {
+    type ThisTree[-T >: Untyped] = If[T]
+    def isInline = false
+  }
+  class InlineIf[-T >: Untyped] private[ast] (cond: Tree[T], thenp: Tree[T], elsep: Tree[T])(implicit @constructorOnly src: SourceFile)
+    extends If(cond, thenp, elsep) {
+    override def isInline = true
+    override def toString = s"InlineIf($cond, $thenp, $elsep)"
+  }
+
+  /** A closure with an environment and a reference to a method.
+   *  @param env    The captured parameters of the closure
+   *  @param meth   A ref tree that refers to the method of the closure.
+   *                The first (env.length) parameters of that method are filled
+   *                with env values.
+   *  @param tpt    Either EmptyTree or a TypeTree. If tpt is EmptyTree the type
+   *                of the closure is a function type, otherwise it is the type
+   *                given in `tpt`, which must be a SAM type.
+   */
+  case class Closure[-T >: Untyped] private[ast] (env: List[Tree[T]], meth: Tree[T], tpt: Tree[T])(implicit @constructorOnly src: SourceFile)
+    extends TermTree[T] {
+    type ThisTree[-T >: Untyped] = Closure[T]
+  }
+
+  /** selector match { cases } */
+  case class Match[-T >: Untyped] private[ast] (selector: Tree[T], cases: List[CaseDef[T]])(implicit @constructorOnly src: SourceFile)
+    extends TermTree[T] {
+    type ThisTree[-T >: Untyped] = Match[T]
+    def isInline = false
+  }
+  class InlineMatch[-T >: Untyped] private[ast] (selector: Tree[T], cases: List[CaseDef[T]])(implicit @constructorOnly src: SourceFile)
+    extends Match(selector, cases) {
+    override def isInline = true
+    override def toString = s"InlineMatch($selector, $cases)"
+  }
+
+  /** case pat if guard => body */
+  case class CaseDef[-T >: Untyped] private[ast] (pat: Tree[T], guard: Tree[T], body: Tree[T])(implicit @constructorOnly src: SourceFile)
+    extends Tree[T] {
+    type ThisTree[-T >: Untyped] = CaseDef[T]
+  }
+
+  /** label[tpt]: { expr } */
+  case class Labeled[-T >: Untyped] private[ast] (bind: Bind[T], expr: Tree[T])(implicit @constructorOnly src: SourceFile)
+    extends NameTree[T] {
+    type ThisTree[-T >: Untyped] = Labeled[T]
+    def name: Name = bind.name
+  }
+
+  /** return expr
+   *  where `from` refers to the method or label from which the return takes place
+   *  After program transformations this is not necessarily the enclosing method, because
+   *  closures can intervene.
+   */
+  case class Return[-T >: Untyped] private[ast] (expr: Tree[T], from: Tree[T] = genericEmptyTree)(implicit @constructorOnly src: SourceFile)
+    extends TermTree[T] {
+    type ThisTree[-T >: Untyped] = Return[T]
+  }
+
+  /** while (cond) { body } */
+  case class WhileDo[-T >: Untyped] private[ast] (cond: Tree[T], body: Tree[T])(implicit @constructorOnly src: SourceFile)
+    extends TermTree[T] {
+    type ThisTree[-T >: Untyped] = WhileDo[T]
+  }
+
+  /** try block catch cases finally finalizer */
+  case class Try[-T >: Untyped] private[ast] (expr: Tree[T], cases: List[CaseDef[T]], finalizer: Tree[T])(implicit @constructorOnly src: SourceFile)
+    extends TermTree[T] {
+    type ThisTree[-T >: Untyped] = Try[T]
+  }
+
+  /** Seq(elems)
+   *  @param  tpt  The element type of the sequence.
+   */
+  case class SeqLiteral[-T >: Untyped] private[ast] (elems: List[Tree[T]], elemtpt: Tree[T])(implicit @constructorOnly src: SourceFile)
+    extends Tree[T] {
+    type ThisTree[-T >: Untyped] = SeqLiteral[T]
+  }
+
+  /** Array(elems) */
+  class JavaSeqLiteral[-T >: Untyped] private[ast] (elems: List[Tree[T]], elemtpt: Tree[T])(implicit @constructorOnly src: SourceFile)
+    extends SeqLiteral(elems, elemtpt) {
+    override def toString: String = s"JavaSeqLiteral($elems, $elemtpt)"
+  }
+
+  /** A tree representing inlined code.
+   *
+   *  @param  call      Info about the original call that was inlined
+   *                    Until PostTyper, this is the full call, afterwards only
+   *                    a reference to the toplevel class from which the call was inlined.
+   *  @param  bindings  Bindings for proxies to be used in the inlined code
+   *  @param  expansion The inlined tree, minus bindings.
+   *
+   *  The full inlined code is equivalent to
+   *
+   *      { bindings; expansion }
+   *
+   *  The reason to keep `bindings` separate is because they are typed in a
+   *  different context: `bindings` represent the arguments to the inlined
+   *  call, whereas `expansion` represents the body of the inlined function.
+   */
+  case class Inlined[-T >: Untyped] private[ast] (call: tpd.Tree, bindings: List[MemberDef[T]], expansion: Tree[T])(implicit @constructorOnly src: SourceFile)
+    extends Tree[T] {
+    type ThisTree[-T >: Untyped] = Inlined[T]
+    override def isTerm = expansion.isTerm
+    override def isType = expansion.isType
+  }
+
+  /** A type tree that represents an existing or inferred type */
+  case class TypeTree[-T >: Untyped]()(implicit @constructorOnly src: SourceFile)
+    extends DenotingTree[T] with TypTree[T] {
+    type ThisTree[-T >: Untyped] = TypeTree[T]
+    override def isEmpty: Boolean = !hasType
+    override def toString: String =
+      s"TypeTree${if (hasType) s"[$typeOpt]" else ""}"
+  }
+
+  /** A type tree whose type is inferred. These trees appear in two contexts
+   *    - as an argument of a TypeApply. In that case its type is always a TypeVar
+   *    - as a (result-)type of an inferred ValDef or DefDef.
+   *  Every TypeVar is created as the type of one InferredTypeTree.
+   */
+  class InferredTypeTree[-T >: Untyped](implicit @constructorOnly src: SourceFile) extends TypeTree[T]
+
+  /** ref.type */
+  case class SingletonTypeTree[-T >: Untyped] private[ast] (ref: Tree[T])(implicit @constructorOnly src: SourceFile)
+    extends DenotingTree[T] with TypTree[T] {
+    type ThisTree[-T >: Untyped] = SingletonTypeTree[T]
+  }
+
+  /** tpt { refinements } */
+  case class RefinedTypeTree[-T >: Untyped] private[ast] (tpt: Tree[T], refinements: List[Tree[T]])(implicit @constructorOnly src: SourceFile)
+    extends ProxyTree[T] with TypTree[T] {
+    type ThisTree[-T >: Untyped] = RefinedTypeTree[T]
+    def forwardTo: Tree[T] = tpt
+  }
+
+  /** tpt[args] */
+  case class AppliedTypeTree[-T >: Untyped] private[ast] (tpt: Tree[T], args: List[Tree[T]])(implicit @constructorOnly src: SourceFile)
+    extends ProxyTree[T] with TypTree[T] {
+    type ThisTree[-T >: Untyped] = AppliedTypeTree[T]
+    def forwardTo: Tree[T] = tpt
+  }
+
+  /** [typeparams] -> tpt
+   *
+   *  Note: the type of such a tree is not necessarily a `HKTypeLambda`, it can
+   *  also be a `TypeBounds` where the upper bound is an `HKTypeLambda`, and the
+   *  lower bound is either a reference to `Nothing` or an `HKTypeLambda`,
+   *  this happens because these trees are typed by `HKTypeLambda#fromParams` which
+   *  makes sure to move bounds outside of the type lambda itself to simplify their
+   *  handling in the compiler.
+   *
+   *  You may ask: why not normalize the trees too? That way,
+   *
+   *      LambdaTypeTree(X, TypeBoundsTree(A, B))
+   *
+   *  would become,
+   *
+   *      TypeBoundsTree(LambdaTypeTree(X, A), LambdaTypeTree(X, B))
+   *
+   *  which would maintain consistency between a tree and its type. The problem
+   *  with this definition is that the same tree `X` appears twice, therefore
+   *  we'd have to create two symbols for it which makes it harder to relate the
+   *  source code written by the user with the trees used by the compiler (for
+   *  example, to make "find all references" work in the IDE).
+   */
+  case class LambdaTypeTree[-T >: Untyped] private[ast] (tparams: List[TypeDef[T]], body: Tree[T])(implicit @constructorOnly src: SourceFile)
+    extends TypTree[T] {
+    type ThisTree[-T >: Untyped] = LambdaTypeTree[T]
+  }
+
+  case class TermLambdaTypeTree[-T >: Untyped] private[ast] (params: List[ValDef[T]], body: Tree[T])(implicit @constructorOnly src: SourceFile)
+    extends TypTree[T] {
+    type ThisTree[-T >: Untyped] = TermLambdaTypeTree[T]
+  }
+
+  /** [bound] selector match { cases } */
+  case class MatchTypeTree[-T >: Untyped] private[ast] (bound: Tree[T], selector: Tree[T], cases: List[CaseDef[T]])(implicit @constructorOnly src: SourceFile)
+    extends TypTree[T] {
+    type ThisTree[-T >: Untyped] = MatchTypeTree[T]
+  }
+
+  /** => T */
+  case class ByNameTypeTree[-T >: Untyped] private[ast] (result: Tree[T])(implicit @constructorOnly src: SourceFile)
+  extends TypTree[T] {
+    type ThisTree[-T >: Untyped] = ByNameTypeTree[T]
+  }
+
+  /** >: lo <: hi
+   *  >: lo <: hi = alias  for RHS of bounded opaque type
+   */
+  case class TypeBoundsTree[-T >: Untyped] private[ast] (lo: Tree[T], hi: Tree[T], alias: Tree[T])(implicit @constructorOnly src: SourceFile)
+    extends TypTree[T] {
+    type ThisTree[-T >: Untyped] = TypeBoundsTree[T]
+  }
+
+  /** name @ body */
+  case class Bind[-T >: Untyped] private[ast] (name: Name, body: Tree[T])(implicit @constructorOnly src: SourceFile)
+    extends NamedDefTree[T] with PatternTree[T] {
+    type ThisTree[-T >: Untyped] = Bind[T]
+    override def isType: Boolean = name.isTypeName
+    override def isTerm: Boolean = name.isTermName
+
+    override def nameSpan(using Context): Span =
+      if span.exists then Span(span.start, span.start + name.toString.length) else span
+  }
+
+  /** tree_1 | ... | tree_n */
+  case class Alternative[-T >: Untyped] private[ast] (trees: List[Tree[T]])(implicit @constructorOnly src: SourceFile)
+    extends PatternTree[T] {
+    type ThisTree[-T >: Untyped] = Alternative[T]
+  }
+
+  /** The typed translation of `extractor(patterns)` in a pattern. The translation has the following
+   *  components:
+   *
+   *  @param fun       is `extractor.unapply` (or, for backwards compatibility, `extractor.unapplySeq`)
+   *                   possibly with type parameters
+   *  @param implicits Any implicit parameters passed to the unapply after the selector
+   *  @param patterns  The argument patterns in the pattern match.
+   *
+   *  It is typed with same type as first `fun` argument
+   *  Given a match selector `sel` a pattern UnApply(fun, implicits, patterns) is roughly translated as follows
+   *
+   *    val result = fun(sel)(implicits)
+   *    if (result.isDefined) "match patterns against result"
+   */
+  case class UnApply[-T >: Untyped] private[ast] (fun: Tree[T], implicits: List[Tree[T]], patterns: List[Tree[T]])(implicit @constructorOnly src: SourceFile)
+    extends ProxyTree[T] with PatternTree[T] {
+    type ThisTree[-T >: Untyped] = UnApply[T]
+    def forwardTo = fun
+  }
+
+  /** mods val name: tpt = rhs */
+  case class ValDef[-T >: Untyped] private[ast] (name: TermName, tpt: Tree[T], private var preRhs: LazyTree[T @uncheckedVariance])(implicit @constructorOnly src: SourceFile)
+    extends ValOrDefDef[T], ValOrTypeDef[T] {
+    type ThisTree[-T >: Untyped] = ValDef[T]
+    assert(isEmpty || (tpt ne genericEmptyTree))
+    def unforced: LazyTree[T] = preRhs
+    protected def force(x: Tree[T @uncheckedVariance]): Unit = preRhs = x
+  }
+
+  /** mods def name[tparams](vparams_1)...(vparams_n): tpt = rhs */
+  case class DefDef[-T >: Untyped] private[ast] (name: TermName,
+      paramss: List[ParamClause[T]], tpt: Tree[T], private var preRhs: LazyTree[T @uncheckedVariance])(implicit @constructorOnly src: SourceFile)
+    extends ValOrDefDef[T] {
+    type ThisTree[-T >: Untyped] = DefDef[T]
+    assert(tpt ne genericEmptyTree)
+    def unforced: LazyTree[T] = preRhs
+    protected def force(x: Tree[T @uncheckedVariance]): Unit = preRhs = x
+
+    def leadingTypeParams(using Context): List[TypeDef[T]] = paramss match
+      case (tparams @ (tparam: TypeDef[_]) :: _) :: _ => tparams.asInstanceOf[List[TypeDef[T]]]
+      case _ => Nil
+
+    def trailingParamss(using Context): List[ParamClause[T]] = paramss match
+      case ((tparam: TypeDef[_]) :: _) :: paramss1 => paramss1
+      case _ => paramss
+
+    def termParamss(using Context): List[List[ValDef[T]]] =
+      (if ctx.erasedTypes then paramss else untpd.termParamssIn(paramss))
+        .asInstanceOf[List[List[ValDef[T]]]]
+  }
+
+  /** mods class name template     or
+   *  mods trait name template     or
+   *  mods type name = rhs   or
+   *  mods type name >: lo <: hi,          if rhs = TypeBoundsTree(lo, hi)      or
+   *  mods type name >: lo <: hi = rhs     if rhs = TypeBoundsTree(lo, hi, alias) and opaque in mods
+   */
+  case class TypeDef[-T >: Untyped] private[ast] (name: TypeName, rhs: Tree[T])(implicit @constructorOnly src: SourceFile)
+    extends MemberDef[T], ValOrTypeDef[T] {
+    type ThisTree[-T >: Untyped] = TypeDef[T]
+
+    /** Is this a definition of a class? */
+    def isClassDef: Boolean = rhs.isInstanceOf[Template[?]]
+
+    def isBackquoted: Boolean = hasAttachment(Backquoted)
+  }
+
+  /** extends parents { self => body }
+   *  @param parentsOrDerived   A list of parents followed by a list of derived classes,
+   *                            if this is of class untpd.DerivingTemplate.
+   *                            Typed templates only have parents.
+   */
+  case class Template[-T >: Untyped] private[ast] (constr: DefDef[T], parentsOrDerived: List[Tree[T]], self: ValDef[T], private var preBody: LazyTreeList[T @uncheckedVariance])(implicit @constructorOnly src: SourceFile)
+    extends DefTree[T] with WithLazyField[List[Tree[T]]] {
+    type ThisTree[-T >: Untyped] = Template[T]
+    def unforcedBody: LazyTreeList[T] = unforced
+    def unforced: LazyTreeList[T] = preBody
+    protected def force(x: List[Tree[T @uncheckedVariance]]): Unit = preBody = x
+    def body(using Context): List[Tree[T]] = forceIfLazy
+
+    def parents: List[Tree[T]] = parentsOrDerived // overridden by DerivingTemplate
+    def derived: List[untpd.Tree] = Nil           // overridden by DerivingTemplate
+  }
+
+
+  abstract class ImportOrExport[-T >: Untyped](implicit @constructorOnly src: SourceFile)
+    extends DenotingTree[T] {
+    type ThisTree[-T >: Untyped] <: ImportOrExport[T]
+    val expr: Tree[T]
+    val selectors: List[untpd.ImportSelector]
+  }
+
+  /** import expr.selectors
+   *  where a selector is either an untyped `Ident`, `name` or
+   *  an untyped thicket consisting of `name` and `rename`.
+   */
+  case class Import[-T >: Untyped] private[ast] (expr: Tree[T], selectors: List[untpd.ImportSelector])(implicit @constructorOnly src: SourceFile)
+    extends ImportOrExport[T] {
+    type ThisTree[-T >: Untyped] = Import[T]
+  }
+
+  /** export expr.selectors
+   *  where a selector is either an untyped `Ident`, `name` or
+   *  an untyped thicket consisting of `name` and `rename`.
+   */
+  case class Export[-T >: Untyped] private[ast] (expr: Tree[T], selectors: List[untpd.ImportSelector])(implicit @constructorOnly src: SourceFile)
+    extends ImportOrExport[T] {
+      type ThisTree[-T >: Untyped] = Export[T]
+  }
+
+  /** package pid { stats } */
+  case class PackageDef[-T >: Untyped] private[ast] (pid: RefTree[T], stats: List[Tree[T]])(implicit @constructorOnly src: SourceFile)
+    extends ProxyTree[T] with WithEndMarker[T] {
+    type ThisTree[-T >: Untyped] = PackageDef[T]
+    def forwardTo: RefTree[T] = pid
+    protected def srcName(using Context): Name = pid.name
+  }
+
+  /** arg @annot */
+  case class Annotated[-T >: Untyped] private[ast] (arg: Tree[T], annot: Tree[T])(implicit @constructorOnly src: SourceFile)
+    extends ProxyTree[T] {
+    type ThisTree[-T >: Untyped] = Annotated[T]
+    def forwardTo: Tree[T] = arg
+  }
+
+  trait WithoutTypeOrPos[-T >: Untyped] extends Tree[T] {
+    override def withTypeUnchecked(tpe: Type): ThisTree[Type] = this.asInstanceOf[ThisTree[Type]]
+    override def span: Span = NoSpan
+    override def span_=(span: Span): Unit = {}
+  }
+
+  /** Temporary class that results from translation of ModuleDefs
+   *  (and possibly other statements).
+   *  The contained trees will be integrated when transformed with
+   *  a `transform(List[Tree])` call.
+   */
+  case class Thicket[-T >: Untyped](trees: List[Tree[T]])(implicit @constructorOnly src: SourceFile)
+    extends Tree[T] with WithoutTypeOrPos[T] {
+    myTpe = NoType.asInstanceOf[T]
+    type ThisTree[-T >: Untyped] = Thicket[T]
+
+    def mapElems(op: Tree[T] => Tree[T] @uncheckedVariance): Thicket[T] = {
+      val newTrees = trees.mapConserve(op)
+      if (trees eq newTrees)
+        this
+      else
+        Thicket[T](newTrees)(source).asInstanceOf[this.type]
+    }
+
+    override def foreachInThicket(op: Tree[T] => Unit): Unit =
+      trees foreach (_.foreachInThicket(op))
+
+    override def isEmpty: Boolean = trees.isEmpty
+    override def toList: List[Tree[T]] = flatten(trees)
+    override def toString: String = if (isEmpty) "EmptyTree" else "Thicket(" + trees.mkString(", ") + ")"
+    override def span: Span =
+      def combine(s: Span, ts: List[Tree[T]]): Span = ts match
+        case t :: ts1 => combine(s.union(t.span), ts1)
+        case nil => s
+      combine(NoSpan, trees)
+
+    override def withSpan(span: Span): this.type =
+      mapElems(_.withSpan(span)).asInstanceOf[this.type]
+  }
+
+  class EmptyTree[T >: Untyped] extends Thicket(Nil)(NoSource) {
+    // assert(uniqueId != 1492)
+    override def withSpan(span: Span) = throw AssertionError("Cannot change span of EmptyTree")
+  }
+
+  class EmptyValDef[T >: Untyped] extends ValDef[T](
+    nme.WILDCARD, genericEmptyTree[T], genericEmptyTree[T])(NoSource) with WithoutTypeOrPos[T] {
+    myTpe = NoType.asInstanceOf[T]
+    setMods(untpd.Modifiers(PrivateLocal))
+    override def isEmpty: Boolean = true
+    override def withSpan(span: Span) = throw AssertionError("Cannot change span of EmptyValDef")
+  }
+
+  @sharable val theEmptyTree = new EmptyTree[Type]()
+  @sharable val theEmptyValDef = new EmptyValDef[Type]()
+
+  def genericEmptyValDef[T >: Untyped]: ValDef[T]       = theEmptyValDef.asInstanceOf[ValDef[T]]
+  def genericEmptyTree[T >: Untyped]: Thicket[T]        = theEmptyTree.asInstanceOf[Thicket[T]]
+
+  /** Tree that replaces a level 1 splices in pickled (level 0) quotes.
+   *  It is only used when picking quotes (will never be in a TASTy file).
+   *
+   *  @param isTermHole If this hole is a term, otherwise it is a type hole.
+   *  @param idx The index of the hole in it's enclosing level 0 quote.
+   *  @param args The arguments of the splice to compute its content
+   *  @param content Lambda that computes the content of the hole. This tree is empty when in a quote pickle.
+   *  @param tpt Type of the hole
+   */
+  case class Hole[-T >: Untyped](isTermHole: Boolean, idx: Int, args: List[Tree[T]], content: Tree[T], tpt: Tree[T])(implicit @constructorOnly src: SourceFile) extends Tree[T] {
+    type ThisTree[-T >: Untyped] <: Hole[T]
+    override def isTerm: Boolean = isTermHole
+    override def isType: Boolean = !isTermHole
+  }
+
+  def flatten[T >: Untyped](trees: List[Tree[T]]): List[Tree[T]] = {
+    def recur(buf: ListBuffer[Tree[T]] | Null, remaining: List[Tree[T]]): ListBuffer[Tree[T]] | Null =
+      remaining match {
+        case Thicket(elems) :: remaining1 =>
+          var buf1 = buf
+          if (buf1 == null) {
+            buf1 = new ListBuffer[Tree[T]]
+            var scanned = trees
+            while (scanned `ne` remaining) {
+              buf1 += scanned.head
+              scanned = scanned.tail
+            }
+          }
+          recur(recur(buf1, elems), remaining1)
+        case tree :: remaining1 =>
+          if (buf != null) buf += tree
+          recur(buf, remaining1)
+        case nil =>
+          buf
+      }
+    val buf = recur(null, trees)
+    if (buf != null) buf.toList else trees
+  }
+
+  // ----- Lazy trees and tree sequences
+
+  /** A tree that can have a lazy field
+   *  The field is represented by some private `var` which is
+   *  accessed by `unforced` and `force`. Forcing the field will
+   *  set the `var` to the underlying value.
+   */
+  trait WithLazyField[+T <: AnyRef] {
+    def unforced: T | Lazy[T]
+    protected def force(x: T @uncheckedVariance): Unit
+    def forceIfLazy(using Context): T = unforced match {
+      case lzy: Lazy[T @unchecked] =>
+        val x = lzy.complete
+        force(x)
+        x
+      case x: T @ unchecked => x
+    }
+  }
+
+  /** A base trait for lazy tree fields.
+   *  These can be instantiated with Lazy instances which
+   *  can delay tree construction until the field is first demanded.
+   */
+  trait Lazy[+T <: AnyRef] {
+    def complete(using Context): T
+  }
+
+  // ----- Generic Tree Instances, inherited from `tpt` and `untpd`.
+
+  abstract class Instance[T >: Untyped <: Type] { inst =>
+
+    type Tree = Trees.Tree[T]
+    type TypTree = Trees.TypTree[T]
+    type TermTree = Trees.TermTree[T]
+    type PatternTree = Trees.PatternTree[T]
+    type DenotingTree = Trees.DenotingTree[T]
+    type ProxyTree = Trees.ProxyTree[T]
+    type NameTree = Trees.NameTree[T]
+    type RefTree = Trees.RefTree[T]
+    type DefTree = Trees.DefTree[T]
+    type NamedDefTree = Trees.NamedDefTree[T]
+    type MemberDef = Trees.MemberDef[T]
+    type ValOrDefDef = Trees.ValOrDefDef[T]
+    type ValOrTypeDef = Trees.ValOrTypeDef[T]
+    type LazyTree = Trees.LazyTree[T]
+    type LazyTreeList = Trees.LazyTreeList[T]
+    type ParamClause = Trees.ParamClause[T]
+
+    type Ident = Trees.Ident[T]
+    type SearchFailureIdent = Trees.SearchFailureIdent[T]
+    type Select = Trees.Select[T]
+    type SelectWithSig = Trees.SelectWithSig[T]
+    type This = Trees.This[T]
+    type Super = Trees.Super[T]
+    type Apply = Trees.Apply[T]
+    type TypeApply = Trees.TypeApply[T]
+    type GenericApply = Trees.GenericApply[T]
+    type Literal = Trees.Literal[T]
+    type New = Trees.New[T]
+    type Typed = Trees.Typed[T]
+    type NamedArg = Trees.NamedArg[T]
+    type Assign = Trees.Assign[T]
+    type Block = Trees.Block[T]
+    type If = Trees.If[T]
+    type InlineIf = Trees.InlineIf[T]
+    type Closure = Trees.Closure[T]
+    type Match = Trees.Match[T]
+    type InlineMatch = Trees.InlineMatch[T]
+    type CaseDef = Trees.CaseDef[T]
+    type Labeled = Trees.Labeled[T]
+    type Return = Trees.Return[T]
+    type WhileDo = Trees.WhileDo[T]
+    type Try = Trees.Try[T]
+    type SeqLiteral = Trees.SeqLiteral[T]
+    type JavaSeqLiteral = Trees.JavaSeqLiteral[T]
+    type Inlined = Trees.Inlined[T]
+    type TypeTree = Trees.TypeTree[T]
+    type InferredTypeTree = Trees.InferredTypeTree[T]
+    type SingletonTypeTree = Trees.SingletonTypeTree[T]
+    type RefinedTypeTree = Trees.RefinedTypeTree[T]
+    type AppliedTypeTree = Trees.AppliedTypeTree[T]
+    type LambdaTypeTree = Trees.LambdaTypeTree[T]
+    type TermLambdaTypeTree = Trees.TermLambdaTypeTree[T]
+    type MatchTypeTree = Trees.MatchTypeTree[T]
+    type ByNameTypeTree = Trees.ByNameTypeTree[T]
+    type TypeBoundsTree = Trees.TypeBoundsTree[T]
+    type Bind = Trees.Bind[T]
+    type Alternative = Trees.Alternative[T]
+    type UnApply = Trees.UnApply[T]
+    type ValDef = Trees.ValDef[T]
+    type DefDef = Trees.DefDef[T]
+    type TypeDef = Trees.TypeDef[T]
+    type Template = Trees.Template[T]
+    type Import = Trees.Import[T]
+    type Export = Trees.Export[T]
+    type ImportOrExport = Trees.ImportOrExport[T]
+    type PackageDef = Trees.PackageDef[T]
+    type Annotated = Trees.Annotated[T]
+    type Thicket = Trees.Thicket[T]
+
+    type Hole = Trees.Hole[T]
+
+    @sharable val EmptyTree: Thicket = genericEmptyTree
+    @sharable val EmptyValDef: ValDef = genericEmptyValDef
+    @sharable val ContextualEmptyTree: Thicket = new EmptyTree() // an empty tree marking a contextual closure
+
+    // ----- Auxiliary creation methods ------------------
+
+    def Thicket(): Thicket = EmptyTree
+    def Thicket(x1: Tree, x2: Tree)(implicit src: SourceFile): Thicket = new Thicket(x1 :: x2 :: Nil)
+    def Thicket(x1: Tree, x2: Tree, x3: Tree)(implicit src: SourceFile): Thicket = new Thicket(x1 :: x2 :: x3 :: Nil)
+    def Thicket(xs: List[Tree])(implicit src: SourceFile) = new Thicket(xs)
+
+    def flatTree(xs: List[Tree])(implicit src: SourceFile): Tree = flatten(xs) match {
+      case x :: Nil => x
+      case ys => Thicket(ys)
+    }
+
+    // ----- Helper classes for copying, transforming, accumulating -----------------
+
+    val cpy: TreeCopier
+
+    /** A class for copying trees. The copy methods avoid creating a new tree
+     *  If all arguments stay the same.
+     *
+     * Note: Some of the copy methods take a context.
+     * These are exactly those methods that are overridden in TypedTreeCopier
+     * so that they selectively retype themselves. Retyping needs a context.
+     */
+    abstract class TreeCopier {
+      protected def postProcess(tree: Tree, copied: untpd.Tree): copied.ThisTree[T]
+      protected def postProcess(tree: Tree, copied: untpd.MemberDef): copied.ThisTree[T]
+
+      /** Soucre of the copied tree */
+      protected def sourceFile(tree: Tree): SourceFile = tree.source
+
+      protected def finalize(tree: Tree, copied: untpd.Tree): copied.ThisTree[T] =
+        Stats.record(s"TreeCopier.finalize/${tree.getClass == copied.getClass}")
+        postProcess(tree, copied.withSpan(tree.span).withAttachmentsFrom(tree))
+
+      protected def finalize(tree: Tree, copied: untpd.MemberDef): copied.ThisTree[T] =
+        Stats.record(s"TreeCopier.finalize/${tree.getClass == copied.getClass}")
+        postProcess(tree, copied.withSpan(tree.span).withAttachmentsFrom(tree))
+
+      def Ident(tree: Tree)(name: Name)(using Context): Ident = tree match {
+        case tree: Ident if name == tree.name => tree
+        case _ => finalize(tree, untpd.Ident(name)(sourceFile(tree)))
+      }
+      def Select(tree: Tree)(qualifier: Tree, name: Name)(using Context): Select = tree match {
+        case tree: SelectWithSig =>
+          if ((qualifier eq tree.qualifier) && (name == tree.name)) tree
+          else finalize(tree, SelectWithSig(qualifier, name, tree.sig)(sourceFile(tree)))
+        case tree: Select if (qualifier eq tree.qualifier) && (name == tree.name) => tree
+        case _ => finalize(tree, untpd.Select(qualifier, name)(sourceFile(tree)))
+      }
+      /** Copy Ident or Select trees */
+      def Ref(tree: RefTree)(name: Name)(using Context): RefTree = tree match {
+        case Ident(_) => Ident(tree)(name)
+        case Select(qual, _) => Select(tree)(qual, name)
+      }
+      def This(tree: Tree)(qual: untpd.Ident)(using Context): This = tree match {
+        case tree: This if (qual eq tree.qual) => tree
+        case _ => finalize(tree, untpd.This(qual)(sourceFile(tree)))
+      }
+      def Super(tree: Tree)(qual: Tree, mix: untpd.Ident)(using Context): Super = tree match {
+        case tree: Super if (qual eq tree.qual) && (mix eq tree.mix) => tree
+        case _ => finalize(tree, untpd.Super(qual, mix)(sourceFile(tree)))
+      }
+      def Apply(tree: Tree)(fun: Tree, args: List[Tree])(using Context): Apply = tree match {
+        case tree: Apply if (fun eq tree.fun) && (args eq tree.args) => tree
+        case _ => finalize(tree, untpd.Apply(fun, args)(sourceFile(tree)))
+            //.ensuring(res => res.uniqueId != 2213, s"source = $tree, ${tree.uniqueId}, ${tree.span}")
+      }
+      def TypeApply(tree: Tree)(fun: Tree, args: List[Tree])(using Context): TypeApply = tree match {
+        case tree: TypeApply if (fun eq tree.fun) && (args eq tree.args) => tree
+        case _ => finalize(tree, untpd.TypeApply(fun, args)(sourceFile(tree)))
+      }
+      def Literal(tree: Tree)(const: Constant)(using Context): Literal = tree match {
+        case tree: Literal if const == tree.const => tree
+        case _ => finalize(tree, untpd.Literal(const)(sourceFile(tree)))
+      }
+      def New(tree: Tree)(tpt: Tree)(using Context): New = tree match {
+        case tree: New if (tpt eq tree.tpt) => tree
+        case _ => finalize(tree, untpd.New(tpt)(sourceFile(tree)))
+      }
+      def Typed(tree: Tree)(expr: Tree, tpt: Tree)(using Context): Typed = tree match {
+        case tree: Typed if (expr eq tree.expr) && (tpt eq tree.tpt) => tree
+        case tree => finalize(tree, untpd.Typed(expr, tpt)(sourceFile(tree)))
+      }
+      def NamedArg(tree: Tree)(name: Name, arg: Tree)(using Context): NamedArg = tree match {
+        case tree: NamedArg if (name == tree.name) && (arg eq tree.arg) => tree
+        case _ => finalize(tree, untpd.NamedArg(name, arg)(sourceFile(tree)))
+      }
+      def Assign(tree: Tree)(lhs: Tree, rhs: Tree)(using Context): Assign = tree match {
+        case tree: Assign if (lhs eq tree.lhs) && (rhs eq tree.rhs) => tree
+        case _ => finalize(tree, untpd.Assign(lhs, rhs)(sourceFile(tree)))
+      }
+      def Block(tree: Tree)(stats: List[Tree], expr: Tree)(using Context): Block = tree match {
+        case tree: Block if (stats eq tree.stats) && (expr eq tree.expr) => tree
+        case _ => finalize(tree, untpd.Block(stats, expr)(sourceFile(tree)))
+      }
+      def If(tree: Tree)(cond: Tree, thenp: Tree, elsep: Tree)(using Context): If = tree match {
+        case tree: If if (cond eq tree.cond) && (thenp eq tree.thenp) && (elsep eq tree.elsep) => tree
+        case tree: InlineIf => finalize(tree, untpd.InlineIf(cond, thenp, elsep)(sourceFile(tree)))
+        case _ => finalize(tree, untpd.If(cond, thenp, elsep)(sourceFile(tree)))
+      }
+      def Closure(tree: Tree)(env: List[Tree], meth: Tree, tpt: Tree)(using Context): Closure = tree match {
+        case tree: Closure if (env eq tree.env) && (meth eq tree.meth) && (tpt eq tree.tpt) => tree
+        case _ => finalize(tree, untpd.Closure(env, meth, tpt)(sourceFile(tree)))
+      }
+      def Match(tree: Tree)(selector: Tree, cases: List[CaseDef])(using Context): Match = tree match {
+        case tree: Match if (selector eq tree.selector) && (cases eq tree.cases) => tree
+        case tree: InlineMatch => finalize(tree, untpd.InlineMatch(selector, cases)(sourceFile(tree)))
+        case _ => finalize(tree, untpd.Match(selector, cases)(sourceFile(tree)))
+      }
+      def CaseDef(tree: Tree)(pat: Tree, guard: Tree, body: Tree)(using Context): CaseDef = tree match {
+        case tree: CaseDef if (pat eq tree.pat) && (guard eq tree.guard) && (body eq tree.body) => tree
+        case _ => finalize(tree, untpd.CaseDef(pat, guard, body)(sourceFile(tree)))
+      }
+      def Labeled(tree: Tree)(bind: Bind, expr: Tree)(using Context): Labeled = tree match {
+        case tree: Labeled if (bind eq tree.bind) && (expr eq tree.expr) => tree
+        case _ => finalize(tree, untpd.Labeled(bind, expr)(sourceFile(tree)))
+      }
+      def Return(tree: Tree)(expr: Tree, from: Tree)(using Context): Return = tree match {
+        case tree: Return if (expr eq tree.expr) && (from eq tree.from) => tree
+        case _ => finalize(tree, untpd.Return(expr, from)(sourceFile(tree)))
+      }
+      def WhileDo(tree: Tree)(cond: Tree, body: Tree)(using Context): WhileDo = tree match {
+        case tree: WhileDo if (cond eq tree.cond) && (body eq tree.body) => tree
+        case _ => finalize(tree, untpd.WhileDo(cond, body)(sourceFile(tree)))
+      }
+      def Try(tree: Tree)(expr: Tree, cases: List[CaseDef], finalizer: Tree)(using Context): Try = tree match {
+        case tree: Try if (expr eq tree.expr) && (cases eq tree.cases) && (finalizer eq tree.finalizer) => tree
+        case _ => finalize(tree, untpd.Try(expr, cases, finalizer)(sourceFile(tree)))
+      }
+      def SeqLiteral(tree: Tree)(elems: List[Tree], elemtpt: Tree)(using Context): SeqLiteral = tree match {
+        case tree: JavaSeqLiteral =>
+          if ((elems eq tree.elems) && (elemtpt eq tree.elemtpt)) tree
+          else finalize(tree, untpd.JavaSeqLiteral(elems, elemtpt))
+        case tree: SeqLiteral if (elems eq tree.elems) && (elemtpt eq tree.elemtpt) => tree
+        case _ => finalize(tree, untpd.SeqLiteral(elems, elemtpt)(sourceFile(tree)))
+      }
+      def Inlined(tree: Tree)(call: tpd.Tree, bindings: List[MemberDef], expansion: Tree)(using Context): Inlined = tree match {
+        case tree: Inlined if (call eq tree.call) && (bindings eq tree.bindings) && (expansion eq tree.expansion) => tree
+        case _ => finalize(tree, untpd.Inlined(call, bindings, expansion)(sourceFile(tree)))
+      }
+      def SingletonTypeTree(tree: Tree)(ref: Tree)(using Context): SingletonTypeTree = tree match {
+        case tree: SingletonTypeTree if (ref eq tree.ref) => tree
+        case _ => finalize(tree, untpd.SingletonTypeTree(ref)(sourceFile(tree)))
+      }
+      def RefinedTypeTree(tree: Tree)(tpt: Tree, refinements: List[Tree])(using Context): RefinedTypeTree = tree match {
+        case tree: RefinedTypeTree if (tpt eq tree.tpt) && (refinements eq tree.refinements) => tree
+        case _ => finalize(tree, untpd.RefinedTypeTree(tpt, refinements)(sourceFile(tree)))
+      }
+      def AppliedTypeTree(tree: Tree)(tpt: Tree, args: List[Tree])(using Context): AppliedTypeTree = tree match {
+        case tree: AppliedTypeTree if (tpt eq tree.tpt) && (args eq tree.args) => tree
+        case _ => finalize(tree, untpd.AppliedTypeTree(tpt, args)(sourceFile(tree)))
+      }
+      def LambdaTypeTree(tree: Tree)(tparams: List[TypeDef], body: Tree)(using Context): LambdaTypeTree = tree match {
+        case tree: LambdaTypeTree if (tparams eq tree.tparams) && (body eq tree.body) => tree
+        case _ => finalize(tree, untpd.LambdaTypeTree(tparams, body)(sourceFile(tree)))
+      }
+      def TermLambdaTypeTree(tree: Tree)(params: List[ValDef], body: Tree)(using Context): TermLambdaTypeTree = tree match {
+        case tree: TermLambdaTypeTree if (params eq tree.params) && (body eq tree.body) => tree
+        case _ => finalize(tree, untpd.TermLambdaTypeTree(params, body)(sourceFile(tree)))
+      }
+      def MatchTypeTree(tree: Tree)(bound: Tree, selector: Tree, cases: List[CaseDef])(using Context): MatchTypeTree = tree match {
+        case tree: MatchTypeTree if (bound eq tree.bound) && (selector eq tree.selector) && (cases eq tree.cases) => tree
+        case _ => finalize(tree, untpd.MatchTypeTree(bound, selector, cases)(sourceFile(tree)))
+      }
+      def ByNameTypeTree(tree: Tree)(result: Tree)(using Context): ByNameTypeTree = tree match {
+        case tree: ByNameTypeTree if (result eq tree.result) => tree
+        case _ => finalize(tree, untpd.ByNameTypeTree(result)(sourceFile(tree)))
+      }
+      def TypeBoundsTree(tree: Tree)(lo: Tree, hi: Tree, alias: Tree)(using Context): TypeBoundsTree = tree match {
+        case tree: TypeBoundsTree if (lo eq tree.lo) && (hi eq tree.hi) && (alias eq tree.alias) => tree
+        case _ => finalize(tree, untpd.TypeBoundsTree(lo, hi, alias)(sourceFile(tree)))
+      }
+      def Bind(tree: Tree)(name: Name, body: Tree)(using Context): Bind = tree match {
+        case tree: Bind if (name eq tree.name) && (body eq tree.body) => tree
+        case _ => finalize(tree, untpd.Bind(name, body)(sourceFile(tree)))
+      }
+      def Alternative(tree: Tree)(trees: List[Tree])(using Context): Alternative = tree match {
+        case tree: Alternative if (trees eq tree.trees) => tree
+        case _ => finalize(tree, untpd.Alternative(trees)(sourceFile(tree)))
+      }
+      def UnApply(tree: Tree)(fun: Tree, implicits: List[Tree], patterns: List[Tree])(using Context): UnApply = tree match {
+        case tree: UnApply if (fun eq tree.fun) && (implicits eq tree.implicits) && (patterns eq tree.patterns) => tree
+        case _ => finalize(tree, untpd.UnApply(fun, implicits, patterns)(sourceFile(tree)))
+      }
+      def ValDef(tree: Tree)(name: TermName, tpt: Tree, rhs: LazyTree)(using Context): ValDef = tree match {
+        case tree: ValDef if (name == tree.name) && (tpt eq tree.tpt) && (rhs eq tree.unforcedRhs) => tree
+        case _ => finalize(tree, untpd.ValDef(name, tpt, rhs)(sourceFile(tree)))
+      }
+      def DefDef(tree: Tree)(name: TermName, paramss: List[ParamClause], tpt: Tree, rhs: LazyTree)(using Context): DefDef = tree match {
+        case tree: DefDef if (name == tree.name) && (paramss eq tree.paramss) && (tpt eq tree.tpt) && (rhs eq tree.unforcedRhs) => tree
+        case _ => finalize(tree, untpd.DefDef(name, paramss, tpt, rhs)(sourceFile(tree)))
+      }
+      def TypeDef(tree: Tree)(name: TypeName, rhs: Tree)(using Context): TypeDef = tree match {
+        case tree: TypeDef if (name == tree.name) && (rhs eq tree.rhs) => tree
+        case _ => finalize(tree, untpd.TypeDef(name, rhs)(sourceFile(tree)))
+      }
+      def Template(tree: Tree)(constr: DefDef, parents: List[Tree], derived: List[untpd.Tree], self: ValDef, body: LazyTreeList)(using Context): Template = tree match {
+        case tree: Template if (constr eq tree.constr) && (parents eq tree.parents) && (derived eq tree.derived) && (self eq tree.self) && (body eq tree.unforcedBody) => tree
+        case tree => finalize(tree, untpd.Template(constr, parents, derived, self, body)(sourceFile(tree)))
+      }
+      def Import(tree: Tree)(expr: Tree, selectors: List[untpd.ImportSelector])(using Context): Import = tree match {
+        case tree: Import if (expr eq tree.expr) && (selectors eq tree.selectors) => tree
+        case _ => finalize(tree, untpd.Import(expr, selectors)(sourceFile(tree)))
+      }
+      def Export(tree: Tree)(expr: Tree, selectors: List[untpd.ImportSelector])(using Context): Export = tree match {
+        case tree: Export if (expr eq tree.expr) && (selectors eq tree.selectors) => tree
+        case _ => finalize(tree, untpd.Export(expr, selectors)(sourceFile(tree)))
+      }
+      def PackageDef(tree: Tree)(pid: RefTree, stats: List[Tree])(using Context): PackageDef = tree match {
+        case tree: PackageDef if (pid eq tree.pid) && (stats eq tree.stats) => tree
+        case _ => finalize(tree, untpd.PackageDef(pid, stats)(sourceFile(tree)))
+      }
+      def Annotated(tree: Tree)(arg: Tree, annot: Tree)(using Context): Annotated = tree match {
+        case tree: Annotated if (arg eq tree.arg) && (annot eq tree.annot) => tree
+        case _ => finalize(tree, untpd.Annotated(arg, annot)(sourceFile(tree)))
+      }
+      def Thicket(tree: Tree)(trees: List[Tree])(using Context): Thicket = tree match {
+        case tree: Thicket if (trees eq tree.trees) => tree
+        case _ => finalize(tree, untpd.Thicket(trees)(sourceFile(tree)))
+      }
+      def Hole(tree: Tree)(isTerm: Boolean, idx: Int, args: List[Tree], content: Tree, tpt: Tree)(using Context): Hole = tree match {
+        case tree: Hole if isTerm == tree.isTerm && idx == tree.idx && args.eq(tree.args) && content.eq(tree.content) && content.eq(tree.content) => tree
+        case _ => finalize(tree, untpd.Hole(isTerm, idx, args, content, tpt)(sourceFile(tree)))
+      }
+
+      // Copier methods with default arguments; these demand that the original tree
+      // is of the same class as the copy. We only include trees with more than 2 elements here.
+      def If(tree: If)(cond: Tree = tree.cond, thenp: Tree = tree.thenp, elsep: Tree = tree.elsep)(using Context): If =
+        If(tree: Tree)(cond, thenp, elsep)
+      def Closure(tree: Closure)(env: List[Tree] = tree.env, meth: Tree = tree.meth, tpt: Tree = tree.tpt)(using Context): Closure =
+        Closure(tree: Tree)(env, meth, tpt)
+      def CaseDef(tree: CaseDef)(pat: Tree = tree.pat, guard: Tree = tree.guard, body: Tree = tree.body)(using Context): CaseDef =
+        CaseDef(tree: Tree)(pat, guard, body)
+      def Try(tree: Try)(expr: Tree = tree.expr, cases: List[CaseDef] = tree.cases, finalizer: Tree = tree.finalizer)(using Context): Try =
+        Try(tree: Tree)(expr, cases, finalizer)
+      def UnApply(tree: UnApply)(fun: Tree = tree.fun, implicits: List[Tree] = tree.implicits, patterns: List[Tree] = tree.patterns)(using Context): UnApply =
+        UnApply(tree: Tree)(fun, implicits, patterns)
+      def ValDef(tree: ValDef)(name: TermName = tree.name, tpt: Tree = tree.tpt, rhs: LazyTree = tree.unforcedRhs)(using Context): ValDef =
+        ValDef(tree: Tree)(name, tpt, rhs)
+      def DefDef(tree: DefDef)(name: TermName = tree.name, paramss: List[ParamClause] = tree.paramss, tpt: Tree = tree.tpt, rhs: LazyTree = tree.unforcedRhs)(using Context): DefDef =
+        DefDef(tree: Tree)(name, paramss, tpt, rhs)
+      def TypeDef(tree: TypeDef)(name: TypeName = tree.name, rhs: Tree = tree.rhs)(using Context): TypeDef =
+        TypeDef(tree: Tree)(name, rhs)
+      def Template(tree: Template)(constr: DefDef = tree.constr, parents: List[Tree] = tree.parents, derived: List[untpd.Tree] = tree.derived, self: ValDef = tree.self, body: LazyTreeList = tree.unforcedBody)(using Context): Template =
+        Template(tree: Tree)(constr, parents, derived, self, body)
+      def Hole(tree: Hole)(isTerm: Boolean = tree.isTerm, idx: Int = tree.idx, args: List[Tree] = tree.args, content: Tree = tree.content, tpt: Tree = tree.tpt)(using Context): Hole =
+        Hole(tree: Tree)(isTerm, idx, args, content, tpt)
+
+    }
+
+    /** Hook to indicate that a transform of some subtree should be skipped */
+    protected def skipTransform(tree: Tree)(using Context): Boolean = false
+
+    /** For untyped trees, this is just the identity.
+     *  For typed trees, a context derived form `ctx` that records `call` as the
+     *  innermost enclosing call for which the inlined version is currently
+     *  processed.
+     */
+    protected def inlineContext(call: Tree)(using Context): Context = ctx
+
+    /** The context to use when mapping or accumulating over a tree */
+    def localCtx(tree: Tree)(using Context): Context
+
+    /** The context to use when transforming a tree.
+      * It ensures that the source is correct, and that the local context is used if
+      * that's necessary for transforming the whole tree.
+      * TODO: ensure transform is always called with the correct context as argument
+      * @see https://github.com/lampepfl/dotty/pull/13880#discussion_r836395977
+      */
+    def transformCtx(tree: Tree)(using Context): Context =
+      val sourced =
+        if tree.source.exists && tree.source != ctx.source
+        then ctx.withSource(tree.source)
+        else ctx
+      tree match
+        case t: (MemberDef | PackageDef | LambdaTypeTree | TermLambdaTypeTree) =>
+          localCtx(t)(using sourced)
+        case _ =>
+          sourced
+
+    abstract class TreeMap(val cpy: TreeCopier = inst.cpy) { self =>
+      def transform(tree: Tree)(using Context): Tree = {
+        inContext(transformCtx(tree)) {
+          Stats.record(s"TreeMap.transform/$getClass")
+          if (skipTransform(tree)) tree
+          else tree match {
+            case Ident(name) =>
+              tree
+            case Select(qualifier, name) =>
+              cpy.Select(tree)(transform(qualifier), name)
+            case This(qual) =>
+              tree
+            case Super(qual, mix) =>
+              cpy.Super(tree)(transform(qual), mix)
+            case Apply(fun, args) =>
+              cpy.Apply(tree)(transform(fun), transform(args))
+            case TypeApply(fun, args) =>
+              cpy.TypeApply(tree)(transform(fun), transform(args))
+            case Literal(const) =>
+              tree
+            case New(tpt) =>
+              cpy.New(tree)(transform(tpt))
+            case Typed(expr, tpt) =>
+              cpy.Typed(tree)(transform(expr), transform(tpt))
+            case NamedArg(name, arg) =>
+              cpy.NamedArg(tree)(name, transform(arg))
+            case Assign(lhs, rhs) =>
+              cpy.Assign(tree)(transform(lhs), transform(rhs))
+            case blk: Block =>
+              transformBlock(blk)
+            case If(cond, thenp, elsep) =>
+              cpy.If(tree)(transform(cond), transform(thenp), transform(elsep))
+            case Closure(env, meth, tpt) =>
+              cpy.Closure(tree)(transform(env), transform(meth), transform(tpt))
+            case Match(selector, cases) =>
+              cpy.Match(tree)(transform(selector), transformSub(cases))
+            case CaseDef(pat, guard, body) =>
+              cpy.CaseDef(tree)(transform(pat), transform(guard), transform(body))
+            case Labeled(bind, expr) =>
+              cpy.Labeled(tree)(transformSub(bind), transform(expr))
+            case Return(expr, from) =>
+              cpy.Return(tree)(transform(expr), transformSub(from))
+            case WhileDo(cond, body) =>
+              cpy.WhileDo(tree)(transform(cond), transform(body))
+            case Try(block, cases, finalizer) =>
+              cpy.Try(tree)(transform(block), transformSub(cases), transform(finalizer))
+            case SeqLiteral(elems, elemtpt) =>
+              cpy.SeqLiteral(tree)(transform(elems), transform(elemtpt))
+            case Inlined(call, bindings, expansion) =>
+              cpy.Inlined(tree)(call, transformSub(bindings), transform(expansion)(using inlineContext(call)))
+            case TypeTree() =>
+              tree
+            case SingletonTypeTree(ref) =>
+              cpy.SingletonTypeTree(tree)(transform(ref))
+            case RefinedTypeTree(tpt, refinements) =>
+              cpy.RefinedTypeTree(tree)(transform(tpt), transformSub(refinements))
+            case AppliedTypeTree(tpt, args) =>
+              cpy.AppliedTypeTree(tree)(transform(tpt), transform(args))
+            case LambdaTypeTree(tparams, body) =>
+              cpy.LambdaTypeTree(tree)(transformSub(tparams), transform(body))
+            case TermLambdaTypeTree(params, body) =>
+              cpy.TermLambdaTypeTree(tree)(transformSub(params), transform(body))
+            case MatchTypeTree(bound, selector, cases) =>
+              cpy.MatchTypeTree(tree)(transform(bound), transform(selector), transformSub(cases))
+            case ByNameTypeTree(result) =>
+              cpy.ByNameTypeTree(tree)(transform(result))
+            case TypeBoundsTree(lo, hi, alias) =>
+              cpy.TypeBoundsTree(tree)(transform(lo), transform(hi), transform(alias))
+            case Bind(name, body) =>
+              cpy.Bind(tree)(name, transform(body))
+            case Alternative(trees) =>
+              cpy.Alternative(tree)(transform(trees))
+            case UnApply(fun, implicits, patterns) =>
+              cpy.UnApply(tree)(transform(fun), transform(implicits), transform(patterns))
+            case EmptyValDef =>
+              tree
+            case tree @ ValDef(name, tpt, _) =>
+              val tpt1 = transform(tpt)
+              val rhs1 = transform(tree.rhs)
+              cpy.ValDef(tree)(name, tpt1, rhs1)
+            case tree @ DefDef(name, paramss, tpt, _) =>
+              cpy.DefDef(tree)(name, transformParamss(paramss), transform(tpt), transform(tree.rhs))
+            case tree @ TypeDef(name, rhs) =>
+              cpy.TypeDef(tree)(name, transform(rhs))
+            case tree @ Template(constr, parents, self, _) if tree.derived.isEmpty =>
+              cpy.Template(tree)(transformSub(constr), transform(tree.parents), Nil, transformSub(self), transformStats(tree.body, tree.symbol))
+            case Import(expr, selectors) =>
+              cpy.Import(tree)(transform(expr), selectors)
+            case Export(expr, selectors) =>
+              cpy.Export(tree)(transform(expr), selectors)
+            case PackageDef(pid, stats) =>
+              cpy.PackageDef(tree)(transformSub(pid), transformStats(stats, ctx.owner))
+            case Annotated(arg, annot) =>
+              cpy.Annotated(tree)(transform(arg), transform(annot))
+            case Thicket(trees) =>
+              val trees1 = transform(trees)
+              if (trees1 eq trees) tree else Thicket(trees1)
+            case tree @ Hole(_, _, args, content, tpt) =>
+              cpy.Hole(tree)(args = transform(args), content = transform(content), tpt = transform(tpt))
+            case _ =>
+              transformMoreCases(tree)
+          }
+        }
+      }
+
+      def transformStats(trees: List[Tree], exprOwner: Symbol)(using Context): List[Tree] =
+        transform(trees)
+      def transformBlock(blk: Block)(using Context): Block =
+        cpy.Block(blk)(transformStats(blk.stats, ctx.owner), transform(blk.expr))
+      def transform(trees: List[Tree])(using Context): List[Tree] =
+        flatten(trees mapConserve (transform(_)))
+      def transformSub[Tr <: Tree](tree: Tr)(using Context): Tr =
+        transform(tree).asInstanceOf[Tr]
+      def transformSub[Tr <: Tree](trees: List[Tr])(using Context): List[Tr] =
+        transform(trees).asInstanceOf[List[Tr]]
+      def transformParams(params: ParamClause)(using Context): ParamClause =
+        transform(params).asInstanceOf[ParamClause]
+      def transformParamss(paramss: List[ParamClause])(using Context): List[ParamClause] =
+        paramss.mapConserve(transformParams)
+
+      protected def transformMoreCases(tree: Tree)(using Context): Tree = {
+        assert(ctx.reporter.errorsReported)
+        tree
+      }
+    }
+
+    abstract class TreeAccumulator[X] { self: TreeAccumulator[X] @retains(caps.*) =>
+      // Ties the knot of the traversal: call `foldOver(x, tree))` to dive in the `tree` node.
+      def apply(x: X, tree: Tree)(using Context): X
+
+      def apply(x: X, trees: List[Tree])(using Context): X =
+        def fold(x: X, trees: List[Tree]): X = trees match
+          case tree :: rest => fold(apply(x, tree), rest)
+          case Nil => x
+        fold(x, trees)
+
+      def foldOver(x: X, tree: Tree)(using Context): X =
+        if (tree.source != ctx.source && tree.source.exists)
+          foldOver(x, tree)(using ctx.withSource(tree.source))
+        else {
+          Stats.record(s"TreeAccumulator.foldOver/$getClass")
+          tree match {
+            case Ident(name) =>
+              x
+            case Select(qualifier, name) =>
+              this(x, qualifier)
+            case This(qual) =>
+              x
+            case Super(qual, mix) =>
+              this(x, qual)
+            case Apply(fun, args) =>
+              this(this(x, fun), args)
+            case TypeApply(fun, args) =>
+              this(this(x, fun), args)
+            case Literal(const) =>
+              x
+            case New(tpt) =>
+              this(x, tpt)
+            case Typed(expr, tpt) =>
+              this(this(x, expr), tpt)
+            case NamedArg(name, arg) =>
+              this(x, arg)
+            case Assign(lhs, rhs) =>
+              this(this(x, lhs), rhs)
+            case Block(stats, expr) =>
+              this(this(x, stats), expr)
+            case If(cond, thenp, elsep) =>
+              this(this(this(x, cond), thenp), elsep)
+            case Closure(env, meth, tpt) =>
+              this(this(this(x, env), meth), tpt)
+            case Match(selector, cases) =>
+              this(this(x, selector), cases)
+            case CaseDef(pat, guard, body) =>
+              this(this(this(x, pat), guard), body)
+            case Labeled(bind, expr) =>
+              this(this(x, bind), expr)
+            case Return(expr, from) =>
+              this(this(x, expr), from)
+            case WhileDo(cond, body) =>
+              this(this(x, cond), body)
+            case Try(block, handler, finalizer) =>
+              this(this(this(x, block), handler), finalizer)
+            case SeqLiteral(elems, elemtpt) =>
+              this(this(x, elems), elemtpt)
+            case Inlined(call, bindings, expansion) =>
+              this(this(x, bindings), expansion)(using inlineContext(call))
+            case TypeTree() =>
+              x
+            case SingletonTypeTree(ref) =>
+              this(x, ref)
+            case RefinedTypeTree(tpt, refinements) =>
+              this(this(x, tpt), refinements)
+            case AppliedTypeTree(tpt, args) =>
+              this(this(x, tpt), args)
+            case LambdaTypeTree(tparams, body) =>
+              inContext(localCtx(tree)) {
+                this(this(x, tparams), body)
+              }
+            case TermLambdaTypeTree(params, body) =>
+              inContext(localCtx(tree)) {
+                this(this(x, params), body)
+              }
+            case MatchTypeTree(bound, selector, cases) =>
+              this(this(this(x, bound), selector), cases)
+            case ByNameTypeTree(result) =>
+              this(x, result)
+            case TypeBoundsTree(lo, hi, alias) =>
+              this(this(this(x, lo), hi), alias)
+            case Bind(name, body) =>
+              this(x, body)
+            case Alternative(trees) =>
+              this(x, trees)
+            case UnApply(fun, implicits, patterns) =>
+              this(this(this(x, fun), implicits), patterns)
+            case tree @ ValDef(_, tpt, _) =>
+              inContext(localCtx(tree)) {
+                this(this(x, tpt), tree.rhs)
+              }
+            case tree @ DefDef(_, paramss, tpt, _) =>
+              inContext(localCtx(tree)) {
+                this(this(paramss.foldLeft(x)(apply), tpt), tree.rhs)
+              }
+            case TypeDef(_, rhs) =>
+              inContext(localCtx(tree)) {
+                this(x, rhs)
+              }
+            case tree @ Template(constr, parents, self, _) if tree.derived.isEmpty =>
+              this(this(this(this(x, constr), parents), self), tree.body)
+            case Import(expr, _) =>
+              this(x, expr)
+            case Export(expr, _) =>
+              this(x, expr)
+            case PackageDef(pid, stats) =>
+              this(this(x, pid), stats)(using localCtx(tree))
+            case Annotated(arg, annot) =>
+              this(this(x, arg), annot)
+            case Thicket(ts) =>
+              this(x, ts)
+            case Hole(_, _, args, content, tpt) =>
+              this(this(this(x, args), content), tpt)
+            case _ =>
+              foldMoreCases(x, tree)
+          }
+        }
+
+      def foldMoreCases(x: X, tree: Tree)(using Context): X = {
+        assert(ctx.reporter.hasUnreportedErrors
+                || ctx.reporter.errorsReported
+                || ctx.mode.is(Mode.Interactive), tree)
+          // In interactive mode, errors might come from previous runs.
+          // In case of errors it may be that typed trees point to untyped ones.
+          // The IDE can still traverse inside such trees, either in the run where errors
+          // are reported, or in subsequent ones.
+        x
+      }
+    }
+
+    abstract class TreeTraverser extends TreeAccumulator[Unit] {
+      def traverse(tree: Tree)(using Context): Unit
+      def traverse(trees: List[Tree])(using Context) = apply((), trees)
+      def apply(x: Unit, tree: Tree)(using Context): Unit = traverse(tree)
+      protected def traverseChildren(tree: Tree)(using Context): Unit = foldOver((), tree)
+    }
+
+    /** Fold `f` over all tree nodes, in depth-first, prefix order */
+    class DeepFolder[X](f: (X, Tree) => X) extends TreeAccumulator[X] {
+      def apply(x: X, tree: Tree)(using Context): X = foldOver(f(x, tree), tree)
+    }
+
+    /** Fold `f` over all tree nodes, in depth-first, prefix order, but don't visit
+     *  subtrees where `f` returns a different result for the root, i.e. `f(x, root) ne x`.
+     */
+    class ShallowFolder[X](f: (X, Tree) => X) extends TreeAccumulator[X] {
+      def apply(x: X, tree: Tree)(using Context): X = {
+        val x1 = f(x, tree)
+        if (x1.asInstanceOf[AnyRef] ne x.asInstanceOf[AnyRef]) x1
+        else foldOver(x1, tree)
+      }
+    }
+
+    def rename(tree: NameTree, newName: Name)(using Context): tree.ThisTree[T] = {
+      tree match {
+        case tree: Ident => cpy.Ident(tree)(newName)
+        case tree: Select => cpy.Select(tree)(tree.qualifier, newName)
+        case tree: Bind => cpy.Bind(tree)(newName, tree.body)
+        case tree: ValDef => cpy.ValDef(tree)(name = newName.asTermName)
+        case tree: DefDef => cpy.DefDef(tree)(name = newName.asTermName)
+        case tree: TypeDef => cpy.TypeDef(tree)(name = newName.asTypeName)
+      }
+    }.asInstanceOf[tree.ThisTree[T]]
+
+    object TypeDefs:
+      def unapply(xs: List[Tree]): Option[List[TypeDef]] = xs match
+        case (x: TypeDef) :: _ => Some(xs.asInstanceOf[List[TypeDef]])
+        case _ => None
+
+    object ValDefs:
+      def unapply(xs: List[Tree]): Option[List[ValDef]] = xs match
+        case Nil => Some(Nil)
+        case (x: ValDef) :: _ => Some(xs.asInstanceOf[List[ValDef]])
+        case _ => None
+
+    def termParamssIn(paramss: List[ParamClause]): List[List[ValDef]] = paramss match
+      case ValDefs(vparams) :: paramss1 =>
+        val paramss2 = termParamssIn(paramss1)
+        if paramss2 eq paramss1 then paramss.asInstanceOf[List[List[ValDef]]]
+        else vparams :: paramss2
+      case _ :: paramss1 =>
+        termParamssIn(paramss1)
+      case nil =>
+        Nil
+
+    /** If `tparams` is non-empty, add it to the left `paramss`, merging
+     *  it with a leading type parameter list of `paramss`, if one exists.
+     */
+    def joinParams(tparams: List[TypeDef], paramss: List[ParamClause]): List[ParamClause] =
+      if tparams.isEmpty then paramss
+      else paramss match
+        case TypeDefs(tparams1) :: paramss1 => (tparams ++ tparams1) :: paramss1
+        case _ => tparams :: paramss
+
+    def isTermOnly(paramss: List[ParamClause]): Boolean = paramss match
+      case Nil => true
+      case params :: paramss1 =>
+        params match
+          case (param: untpd.TypeDef) :: _ => false
+          case _ => isTermOnly(paramss1)
+
+    def asTermOnly(paramss: List[ParamClause]): List[List[ValDef]] =
+      assert(isTermOnly(paramss))
+      paramss.asInstanceOf[List[List[ValDef]]]
+
+    /** Delegate to FunProto or FunProtoTyped depending on whether the prefix is `untpd` or `tpd`. */
+    protected def FunProto(args: List[Tree], resType: Type)(using Context): ProtoTypes.FunProto
+
+    /** Construct the application `$receiver.$method[$targs]($args)` using overloading resolution
+     *  to find a matching overload of `$method` if necessary.
+     *  This is useful when overloading resolution needs to be performed in a phase after typer.
+     *  Note that this will not perform any kind of implicit search.
+     *
+     *  @param expectedType  An expected type of the application used to guide overloading resolution
+     */
+    def applyOverloaded(
+        receiver: tpd.Tree, method: TermName, args: List[Tree], targs: List[Type],
+        expectedType: Type)(using parentCtx: Context): tpd.Tree = {
+      given ctx: Context = parentCtx.retractMode(Mode.ImplicitsEnabled)
+      import dotty.tools.dotc.ast.tpd.TreeOps
+
+      val typer = ctx.typer
+      val proto = FunProto(args, expectedType)
+      val denot = receiver.tpe.member(method)
+      if !denot.exists then
+        overload.println(i"members = ${receiver.tpe.decls}")
+        report.error(i"no member $receiver . $method", receiver.srcPos)
+      val selected =
+        if (denot.isOverloaded) {
+          def typeParamCount(tp: Type) = tp.widen match {
+            case tp: PolyType => tp.paramInfos.length
+            case _ => 0
+          }
+          val allAlts = denot.alternatives
+            .map(denot => TermRef(receiver.tpe, denot.symbol))
+            .filter(tr => typeParamCount(tr) == targs.length)
+            .filter { _.widen match {
+              case MethodTpe(_, _, x: MethodType) => !x.isImplicitMethod
+              case _ => true
+            }}
+          val alternatives = ctx.typer.resolveOverloaded(allAlts, proto)
+          assert(alternatives.size == 1,
+            i"${if (alternatives.isEmpty) "no" else "multiple"} overloads available for " +
+              i"$method on ${receiver.tpe.widenDealiasKeepAnnots} with targs: $targs%, %; args: $args%, %; expectedType: $expectedType." +
+              i"all alternatives: ${allAlts.map(_.symbol.showDcl).mkString(", ")}\n" +
+              i"matching alternatives: ${alternatives.map(_.symbol.showDcl).mkString(", ")}.") // this is parsed from bytecode tree. there's nothing user can do about it
+            alternatives.head
+        }
+        else TermRef(receiver.tpe, denot.symbol)
+      val fun = receiver.select(selected).appliedToTypes(targs)
+
+      val apply = untpd.Apply(fun, args)
+      typer.ApplyTo(apply, fun, selected, proto, expectedType)
+    }
+
+
+    def resolveConstructor(atp: Type, args: List[Tree])(using Context): tpd.Tree = {
+      val targs = atp.argTypes
+      withoutMode(Mode.PatternOrTypeBits) {
+        applyOverloaded(tpd.New(atp.typeConstructor), nme.CONSTRUCTOR, args, targs, atp)
+      }
+    }
+  }
+}
diff --git a/tests/pos-with-compiler-cc/dotc/ast/tpd.scala b/tests/pos-with-compiler-cc/dotc/ast/tpd.scala
new file mode 100644
index 000000000000..1f43daec4d37
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/ast/tpd.scala
@@ -0,0 +1,1546 @@
+package dotty.tools
+package dotc
+package ast
+
+import dotty.tools.dotc.transform.{ExplicitOuter, Erasure}
+import typer.ProtoTypes
+import transform.SymUtils._
+import transform.TypeUtils._
+import core._
+import Scopes.newScope
+import util.Spans._, Types._, Contexts._, Constants._, Names._, Flags._, NameOps._
+import Symbols._, StdNames._, Annotations._, Trees._, Symbols._
+import Decorators._, DenotTransformers._
+import collection.{immutable, mutable}
+import util.{Property, SourceFile}
+import NameKinds.{TempResultName, OuterSelectName}
+import typer.ConstFold
+
+import scala.annotation.tailrec
+import scala.collection.mutable.ListBuffer
+import language.experimental.pureFunctions
+
+/** Some creators for typed trees */
+object tpd extends Trees.Instance[Type] with TypedTreeInfo {
+
+  private def ta(using Context) = ctx.typeAssigner
+
+  def Ident(tp: NamedType)(using Context): Ident =
+    ta.assignType(untpd.Ident(tp.name), tp)
+
+  def Select(qualifier: Tree, name: Name)(using Context): Select =
+    ta.assignType(untpd.Select(qualifier, name), qualifier)
+
+  def Select(qualifier: Tree, tp: NamedType)(using Context): Select =
+    untpd.Select(qualifier, tp.name).withType(tp)
+
+  def This(cls: ClassSymbol)(using Context): This =
+    untpd.This(untpd.Ident(cls.name)).withType(cls.thisType)
+
+  def Super(qual: Tree, mix: untpd.Ident, mixinClass: Symbol)(using Context): Super =
+    ta.assignType(untpd.Super(qual, mix), qual, mixinClass)
+
+  def Super(qual: Tree, mixName: TypeName, mixinClass: Symbol = NoSymbol)(using Context): Super =
+    Super(qual, if (mixName.isEmpty) untpd.EmptyTypeIdent else untpd.Ident(mixName), mixinClass)
+
+  def Apply(fn: Tree, args: List[Tree])(using Context): Apply = fn match
+    case Block(Nil, expr) =>
+      Apply(expr, args)
+    case _: RefTree | _: GenericApply | _: Inlined | _: Hole =>
+      ta.assignType(untpd.Apply(fn, args), fn, args)
+
+  def TypeApply(fn: Tree, args: List[Tree])(using Context): TypeApply = fn match
+    case Block(Nil, expr) =>
+      TypeApply(expr, args)
+    case _: RefTree | _: GenericApply =>
+      ta.assignType(untpd.TypeApply(fn, args), fn, args)
+
+  def Literal(const: Constant)(using Context): Literal =
+    ta.assignType(untpd.Literal(const))
+
+  def unitLiteral(using Context): Literal =
+    Literal(Constant(()))
+
+  def nullLiteral(using Context): Literal =
+    Literal(Constant(null))
+
+  def New(tpt: Tree)(using Context): New =
+    ta.assignType(untpd.New(tpt), tpt)
+
+  def New(tp: Type)(using Context): New = New(TypeTree(tp))
+
+  def Typed(expr: Tree, tpt: Tree)(using Context): Typed =
+    ta.assignType(untpd.Typed(expr, tpt), tpt)
+
+  def NamedArg(name: Name, arg: Tree)(using Context): NamedArg =
+    ta.assignType(untpd.NamedArg(name, arg), arg)
+
+  def Assign(lhs: Tree, rhs: Tree)(using Context): Assign =
+    ta.assignType(untpd.Assign(lhs, rhs))
+
+  def Block(stats: List[Tree], expr: Tree)(using Context): Block =
+    ta.assignType(untpd.Block(stats, expr), stats, expr)
+
+  /** Join `stats` in front of `expr` creating a new block if necessary */
+  def seq(stats: List[Tree], expr: Tree)(using Context): Tree =
+    if (stats.isEmpty) expr
+    else expr match {
+      case Block(_, _: Closure) =>
+        Block(stats, expr)  // leave closures in their own block
+      case Block(estats, eexpr) =>
+        cpy.Block(expr)(stats ::: estats, eexpr).withType(ta.avoidingType(eexpr, stats))
+      case _ =>
+        Block(stats, expr)
+    }
+
+  def If(cond: Tree, thenp: Tree, elsep: Tree)(using Context): If =
+    ta.assignType(untpd.If(cond, thenp, elsep), thenp, elsep)
+
+  def InlineIf(cond: Tree, thenp: Tree, elsep: Tree)(using Context): If =
+    ta.assignType(untpd.InlineIf(cond, thenp, elsep), thenp, elsep)
+
+  def Closure(env: List[Tree], meth: Tree, tpt: Tree)(using Context): Closure =
+    ta.assignType(untpd.Closure(env, meth, tpt), meth, tpt)
+
+  /** A function def
+   *
+   *    vparams => expr
+   *
+   *  gets expanded to
+   *
+   *    { def $anonfun(vparams) = expr; Closure($anonfun) }
+   *
+   *  where the closure's type is the target type of the expression (FunctionN, unless
+   *  otherwise specified).
+   */
+  def Closure(meth: TermSymbol, rhsFn: List[List[Tree]] => Tree, targs: List[Tree] = Nil, targetType: Type = NoType)(using Context): Block = {
+    val targetTpt = if (targetType.exists) TypeTree(targetType) else EmptyTree
+    val call =
+      if (targs.isEmpty) Ident(TermRef(NoPrefix, meth))
+      else TypeApply(Ident(TermRef(NoPrefix, meth)), targs)
+    Block(
+      DefDef(meth, rhsFn) :: Nil,
+      Closure(Nil, call, targetTpt))
+  }
+
+  /** A closure whose anonymous function has the given method type */
+  def Lambda(tpe: MethodType, rhsFn: List[Tree] => Tree)(using Context): Block = {
+    val meth = newAnonFun(ctx.owner, tpe)
+    Closure(meth, tss => rhsFn(tss.head).changeOwner(ctx.owner, meth))
+  }
+
+  def CaseDef(pat: Tree, guard: Tree, body: Tree)(using Context): CaseDef =
+    ta.assignType(untpd.CaseDef(pat, guard, body), pat, body)
+
+  def Match(selector: Tree, cases: List[CaseDef])(using Context): Match =
+    ta.assignType(untpd.Match(selector, cases), selector, cases)
+
+  def InlineMatch(selector: Tree, cases: List[CaseDef])(using Context): Match =
+    ta.assignType(untpd.InlineMatch(selector, cases), selector, cases)
+
+  def Labeled(bind: Bind, expr: Tree)(using Context): Labeled =
+    ta.assignType(untpd.Labeled(bind, expr))
+
+  def Labeled(sym: TermSymbol, expr: Tree)(using Context): Labeled =
+    Labeled(Bind(sym, EmptyTree), expr)
+
+  def Return(expr: Tree, from: Tree)(using Context): Return =
+    ta.assignType(untpd.Return(expr, from))
+
+  def Return(expr: Tree, from: Symbol)(using Context): Return =
+    Return(expr, Ident(from.termRef))
+
+  def WhileDo(cond: Tree, body: Tree)(using Context): WhileDo =
+    ta.assignType(untpd.WhileDo(cond, body))
+
+  def Try(block: Tree, cases: List[CaseDef], finalizer: Tree)(using Context): Try =
+    ta.assignType(untpd.Try(block, cases, finalizer), block, cases)
+
+  def SeqLiteral(elems: List[Tree], elemtpt: Tree)(using Context): SeqLiteral =
+    ta.assignType(untpd.SeqLiteral(elems, elemtpt), elems, elemtpt)
+
+  def JavaSeqLiteral(elems: List[Tree], elemtpt: Tree)(using Context): JavaSeqLiteral =
+    ta.assignType(untpd.JavaSeqLiteral(elems, elemtpt), elems, elemtpt).asInstanceOf[JavaSeqLiteral]
+
+  def Inlined(call: Tree, bindings: List[MemberDef], expansion: Tree)(using Context): Inlined =
+    ta.assignType(untpd.Inlined(call, bindings, expansion), bindings, expansion)
+
+  def TypeTree(tp: Type, inferred: Boolean = false)(using Context): TypeTree =
+    (if inferred then untpd.InferredTypeTree() else untpd.TypeTree()).withType(tp)
+
+  def SingletonTypeTree(ref: Tree)(using Context): SingletonTypeTree =
+    ta.assignType(untpd.SingletonTypeTree(ref), ref)
+
+  def RefinedTypeTree(parent: Tree, refinements: List[Tree], refineCls: ClassSymbol)(using Context): Tree =
+    ta.assignType(untpd.RefinedTypeTree(parent, refinements), parent, refinements, refineCls)
+
+  def AppliedTypeTree(tycon: Tree, args: List[Tree])(using Context): AppliedTypeTree =
+    ta.assignType(untpd.AppliedTypeTree(tycon, args), tycon, args)
+
+  def ByNameTypeTree(result: Tree)(using Context): ByNameTypeTree =
+    ta.assignType(untpd.ByNameTypeTree(result), result)
+
+  def LambdaTypeTree(tparams: List[TypeDef], body: Tree)(using Context): LambdaTypeTree =
+    ta.assignType(untpd.LambdaTypeTree(tparams, body), tparams, body)
+
+  def MatchTypeTree(bound: Tree, selector: Tree, cases: List[CaseDef])(using Context): MatchTypeTree =
+    ta.assignType(untpd.MatchTypeTree(bound, selector, cases), bound, selector, cases)
+
+  def TypeBoundsTree(lo: Tree, hi: Tree, alias: Tree = EmptyTree)(using Context): TypeBoundsTree =
+    ta.assignType(untpd.TypeBoundsTree(lo, hi, alias), lo, hi, alias)
+
+  def Bind(sym: Symbol, body: Tree)(using Context): Bind =
+    ta.assignType(untpd.Bind(sym.name, body), sym)
+
+  /** A pattern corresponding to `sym: tpe` */
+  def BindTyped(sym: TermSymbol, tpe: Type)(using Context): Bind =
+    Bind(sym, Typed(Underscore(tpe), TypeTree(tpe)))
+
+  def Alternative(trees: List[Tree])(using Context): Alternative =
+    ta.assignType(untpd.Alternative(trees), trees)
+
+  def UnApply(fun: Tree, implicits: List[Tree], patterns: List[Tree], proto: Type)(using Context): UnApply = {
+    assert(fun.isInstanceOf[RefTree] || fun.isInstanceOf[GenericApply])
+    ta.assignType(untpd.UnApply(fun, implicits, patterns), proto)
+  }
+
+  def ValDef(sym: TermSymbol, rhs: LazyTree = EmptyTree, inferred: Boolean = false)(using Context): ValDef =
+    ta.assignType(untpd.ValDef(sym.name, TypeTree(sym.info, inferred), rhs), sym)
+
+  def SyntheticValDef(name: TermName, rhs: Tree, flags: FlagSet = EmptyFlags)(using Context): ValDef =
+    ValDef(newSymbol(ctx.owner, name, Synthetic | flags, rhs.tpe.widen, coord = rhs.span), rhs)
+
+  def DefDef(sym: TermSymbol, paramss: List[List[Symbol]],
+             resultType: Type, rhs: Tree)(using Context): DefDef =
+    sym.setParamss(paramss)
+    ta.assignType(
+      untpd.DefDef(
+        sym.name,
+        paramss.map {
+          case TypeSymbols(params) => params.map(param => TypeDef(param).withSpan(param.span))
+          case TermSymbols(params) => params.map(param => ValDef(param).withSpan(param.span))
+          case _ => unreachable()
+        },
+        TypeTree(resultType),
+        rhs),
+      sym)
+
+  def DefDef(sym: TermSymbol, rhs: Tree = EmptyTree)(using Context): DefDef =
+    ta.assignType(DefDef(sym, Function.const(rhs) _), sym)
+
+  /** A DefDef with given method symbol `sym`.
+   *  @rhsFn  A function from parameter references
+   *          to the method's right-hand side.
+   *  Parameter symbols are taken from the `rawParamss` field of `sym`, or
+   *  are freshly generated if `rawParamss` is empty.
+   */
+  def DefDef(sym: TermSymbol, rhsFn: List[List[Tree]] => Tree)(using Context): DefDef =
+
+    // Map method type `tp` with remaining parameters stored in rawParamss to
+    // final result type and all (given or synthesized) parameters
+    def recur(tp: Type, remaining: List[List[Symbol]]): (Type, List[List[Symbol]]) = tp match
+      case tp: PolyType =>
+        val (tparams: List[TypeSymbol], remaining1) = remaining match
+          case tparams :: remaining1 =>
+            assert(tparams.hasSameLengthAs(tp.paramNames) && tparams.head.isType)
+            (tparams.asInstanceOf[List[TypeSymbol]], remaining1)
+          case nil =>
+            (newTypeParams(sym, tp.paramNames, EmptyFlags, tp.instantiateParamInfos(_)), Nil)
+        val (rtp, paramss) = recur(tp.instantiate(tparams.map(_.typeRef)), remaining1)
+        (rtp, tparams :: paramss)
+      case tp: MethodType =>
+        val isParamDependent = tp.isParamDependent
+        val previousParamRefs: ListBuffer[TermRef] =
+          // It is ok to assign `null` here.
+          // If `isParamDependent == false`, the value of `previousParamRefs` is not used.
+          if isParamDependent then mutable.ListBuffer[TermRef]() else (null: ListBuffer[TermRef] | Null).uncheckedNN
+
+        def valueParam(name: TermName, origInfo: Type): TermSymbol =
+          val maybeImplicit =
+            if tp.isContextualMethod then Given
+            else if tp.isImplicitMethod then Implicit
+            else EmptyFlags
+          val maybeErased = if tp.isErasedMethod then Erased else EmptyFlags
+
+          def makeSym(info: Type) = newSymbol(sym, name, TermParam | maybeImplicit | maybeErased, info, coord = sym.coord)
+
+          if isParamDependent then
+            val sym = makeSym(origInfo.substParams(tp, previousParamRefs.toList))
+            previousParamRefs += sym.termRef
+            sym
+          else makeSym(origInfo)
+        end valueParam
+
+        val (vparams: List[TermSymbol], remaining1) =
+          if tp.paramNames.isEmpty then (Nil, remaining)
+          else remaining match
+            case vparams :: remaining1 =>
+              assert(vparams.hasSameLengthAs(tp.paramNames) && vparams.head.isTerm)
+              (vparams.asInstanceOf[List[TermSymbol]], remaining1)
+            case nil =>
+              (tp.paramNames.lazyZip(tp.paramInfos).map(valueParam), Nil)
+        val (rtp, paramss) = recur(tp.instantiate(vparams.map(_.termRef)), remaining1)
+        (rtp, vparams :: paramss)
+      case _ =>
+        assert(remaining.isEmpty)
+        (tp.widenExpr, Nil)
+    end recur
+
+    val (rtp, paramss) = recur(sym.info, sym.rawParamss)
+    DefDef(sym, paramss, rtp, rhsFn(paramss.nestedMap(ref)))
+  end DefDef
+
+  def TypeDef(sym: TypeSymbol)(using Context): TypeDef =
+    ta.assignType(untpd.TypeDef(sym.name, TypeTree(sym.info)), sym)
+
+  def ClassDef(cls: ClassSymbol, constr: DefDef, body: List[Tree], superArgs: List[Tree] = Nil)(using Context): TypeDef = {
+    val firstParent :: otherParents = cls.info.parents: @unchecked
+    val superRef =
+      if (cls.is(Trait)) TypeTree(firstParent)
+      else {
+        def isApplicable(ctpe: Type): Boolean = ctpe match {
+          case ctpe: PolyType =>
+            isApplicable(ctpe.instantiate(firstParent.argTypes))
+          case ctpe: MethodType =>
+            (superArgs corresponds ctpe.paramInfos)(_.tpe <:< _)
+          case _ =>
+            false
+        }
+        val constr = firstParent.decl(nme.CONSTRUCTOR).suchThat(constr => isApplicable(constr.info))
+        New(firstParent, constr.symbol.asTerm, superArgs)
+      }
+    ClassDefWithParents(cls, constr, superRef :: otherParents.map(TypeTree(_)), body)
+  }
+
+  def ClassDefWithParents(cls: ClassSymbol, constr: DefDef, parents: List[Tree], body: List[Tree])(using Context): TypeDef = {
+    val selfType =
+      if (cls.classInfo.selfInfo ne NoType) ValDef(newSelfSym(cls))
+      else EmptyValDef
+    def isOwnTypeParam(stat: Tree) =
+      stat.symbol.is(TypeParam) && stat.symbol.owner == cls
+    val bodyTypeParams = body filter isOwnTypeParam map (_.symbol)
+    val newTypeParams =
+      for (tparam <- cls.typeParams if !(bodyTypeParams contains tparam))
+      yield TypeDef(tparam)
+    val findLocalDummy = FindLocalDummyAccumulator(cls)
+    val localDummy = body.foldLeft(NoSymbol: Symbol)(findLocalDummy.apply)
+      .orElse(newLocalDummy(cls))
+    val impl = untpd.Template(constr, parents, Nil, selfType, newTypeParams ++ body)
+      .withType(localDummy.termRef)
+    ta.assignType(untpd.TypeDef(cls.name, impl), cls)
+  }
+
+  /** An anonymous class
+   *
+   *      new parents { forwarders }
+   *
+   *  where `forwarders` contains forwarders for all functions in `fns`.
+   *  @param parents    a non-empty list of class types
+   *  @param fns        a non-empty of functions for which forwarders should be defined in the class.
+   *  The class has the same owner as the first function in `fns`.
+   *  Its position is the union of all functions in `fns`.
+   */
+  def AnonClass(parents: List[Type], fns: List[TermSymbol], methNames: List[TermName])(using Context): Block = {
+    AnonClass(fns.head.owner, parents, fns.map(_.span).reduceLeft(_ union _)) { cls =>
+      def forwarder(fn: TermSymbol, name: TermName) = {
+        val fwdMeth = fn.copy(cls, name, Synthetic | Method | Final).entered.asTerm
+        for overridden <- fwdMeth.allOverriddenSymbols do
+          if overridden.is(Extension) then fwdMeth.setFlag(Extension)
+          if !overridden.is(Deferred) then fwdMeth.setFlag(Override)
+        DefDef(fwdMeth, ref(fn).appliedToArgss(_))
+      }
+      fns.lazyZip(methNames).map(forwarder)
+    }
+  }
+
+  /** An anonymous class
+   *
+   *      new parents { body }
+   *
+   * with the specified owner and position.
+   */
+  def AnonClass(owner: Symbol, parents: List[Type], coord: Coord)(body: ClassSymbol => List[Tree])(using Context): Block =
+    val parents1 =
+      if (parents.head.classSymbol.is(Trait)) {
+        val head = parents.head.parents.head
+        if (head.isRef(defn.AnyClass)) defn.AnyRefType :: parents else head :: parents
+      }
+      else parents
+    val cls = newNormalizedClassSymbol(owner, tpnme.ANON_CLASS, Synthetic | Final, parents1, coord = coord)
+    val constr = newConstructor(cls, Synthetic, Nil, Nil).entered
+    val cdef = ClassDef(cls, DefDef(constr), body(cls))
+    Block(cdef :: Nil, New(cls.typeRef, Nil))
+
+  def Import(expr: Tree, selectors: List[untpd.ImportSelector])(using Context): Import =
+    ta.assignType(untpd.Import(expr, selectors), newImportSymbol(ctx.owner, expr))
+
+  def Export(expr: Tree, selectors: List[untpd.ImportSelector])(using Context): Export =
+    ta.assignType(untpd.Export(expr, selectors))
+
+  def PackageDef(pid: RefTree, stats: List[Tree])(using Context): PackageDef =
+    ta.assignType(untpd.PackageDef(pid, stats), pid)
+
+  def Annotated(arg: Tree, annot: Tree)(using Context): Annotated =
+    ta.assignType(untpd.Annotated(arg, annot), arg, annot)
+
+  def Throw(expr: Tree)(using Context): Tree =
+    ref(defn.throwMethod).appliedTo(expr)
+
+  def Hole(isTermHole: Boolean, idx: Int, args: List[Tree], content: Tree, tpt: Tree)(using Context): Hole =
+    ta.assignType(untpd.Hole(isTermHole, idx, args, content, tpt), tpt)
+
+  // ------ Making references ------------------------------------------------------
+
+  def prefixIsElidable(tp: NamedType)(using Context): Boolean = {
+    val typeIsElidable = tp.prefix match {
+      case pre: ThisType =>
+        tp.isType ||
+        pre.cls.isStaticOwner ||
+        tp.symbol.isParamOrAccessor && !pre.cls.is(Trait) && ctx.owner.enclosingClass == pre.cls
+          // was ctx.owner.enclosingClass.derivesFrom(pre.cls) which was not tight enough
+          // and was spuriously triggered in case inner class would inherit from outer one
+          // eg anonymous TypeMap inside TypeMap.andThen
+      case pre: TermRef =>
+        pre.symbol.is(Module) && pre.symbol.isStatic
+      case pre =>
+        pre `eq` NoPrefix
+    }
+    typeIsElidable ||
+    tp.symbol.is(JavaStatic) ||
+    tp.symbol.hasAnnotation(defn.ScalaStaticAnnot)
+  }
+
+  def needsSelect(tp: Type)(using Context): Boolean = tp match {
+    case tp: TermRef => !prefixIsElidable(tp)
+    case _ => false
+  }
+
+  /** A tree representing the same reference as the given type */
+  def ref(tp: NamedType, needLoad: Boolean = true)(using Context): Tree =
+    if (tp.isType) TypeTree(tp)
+    else if (prefixIsElidable(tp)) Ident(tp)
+    else if (tp.symbol.is(Module) && ctx.owner.isContainedIn(tp.symbol.moduleClass))
+      followOuterLinks(This(tp.symbol.moduleClass.asClass))
+    else if (tp.symbol hasAnnotation defn.ScalaStaticAnnot)
+      Ident(tp)
+    else
+      val pre = tp.prefix
+      if (pre.isSingleton) followOuterLinks(singleton(pre.dealias, needLoad)).select(tp)
+      else
+        val res = Select(TypeTree(pre), tp)
+        if needLoad && !res.symbol.isStatic then
+          throw new TypeError(em"cannot establish a reference to $res")
+        res
+
+  def ref(sym: Symbol)(using Context): Tree =
+    ref(NamedType(sym.owner.thisType, sym.name, sym.denot))
+
+  private def followOuterLinks(t: Tree)(using Context) = t match {
+    case t: This if ctx.erasedTypes && !(t.symbol == ctx.owner.enclosingClass || t.symbol.isStaticOwner) =>
+      // after erasure outer paths should be respected
+      ExplicitOuter.OuterOps(ctx).path(toCls = t.tpe.classSymbol)
+    case t =>
+      t
+  }
+
+  def singleton(tp: Type, needLoad: Boolean = true)(using Context): Tree = tp.dealias match {
+    case tp: TermRef => ref(tp, needLoad)
+    case tp: ThisType => This(tp.cls)
+    case tp: SkolemType => singleton(tp.narrow, needLoad)
+    case SuperType(qual, _) => singleton(qual, needLoad)
+    case ConstantType(value) => Literal(value)
+  }
+
+  /** A path that corresponds to the given type `tp`. Error if `tp` is not a refinement
+   *  of an addressable singleton type.
+   */
+  def pathFor(tp: Type)(using Context): Tree = {
+    def recur(tp: Type): Tree = tp match {
+      case tp: NamedType =>
+        tp.info match {
+          case TypeAlias(alias) => recur(alias)
+          case _: TypeBounds => EmptyTree
+          case _ => singleton(tp)
+        }
+      case tp: TypeProxy => recur(tp.superType)
+      case _ => EmptyTree
+    }
+    recur(tp).orElse {
+      report.error(em"$tp is not an addressable singleton type")
+      TypeTree(tp)
+    }
+  }
+
+  /** A tree representing a `newXYZArray` operation of the right
+   *  kind for the given element type in `elemTpe`. No type arguments or
+   *  `length` arguments are given.
+   */
+  def newArray(elemTpe: Type, returnTpe: Type, span: Span, dims: JavaSeqLiteral)(using Context): Tree = {
+    val elemClass = elemTpe.classSymbol
+    def newArr =
+      ref(defn.DottyArraysModule).select(defn.newArrayMethod).withSpan(span)
+
+    if (!ctx.erasedTypes) {
+      assert(!TypeErasure.isGeneric(elemTpe), elemTpe) //needs to be done during typer. See Applications.convertNewGenericArray
+      newArr.appliedToTypeTrees(TypeTree(returnTpe) :: Nil).appliedToTermArgs(clsOf(elemTpe) :: clsOf(returnTpe) :: dims :: Nil).withSpan(span)
+    }
+    else  // after erasure
+      newArr.appliedToTermArgs(clsOf(elemTpe) :: clsOf(returnTpe) :: dims :: Nil).withSpan(span)
+  }
+
+  /** The wrapped array method name for an array of type elemtp */
+  def wrapArrayMethodName(elemtp: Type)(using Context): TermName = {
+    val elemCls = elemtp.classSymbol
+    if (elemCls.isPrimitiveValueClass) nme.wrapXArray(elemCls.name)
+    else if (elemCls.derivesFrom(defn.ObjectClass) && !elemCls.isNotRuntimeClass) nme.wrapRefArray
+    else nme.genericWrapArray
+  }
+
+  /** A tree representing a `wrapXYZArray(tree)` operation of the right
+   *  kind for the given element type in `elemTpe`.
+   */
+  def wrapArray(tree: Tree, elemtp: Type)(using Context): Tree =
+    val wrapper = ref(defn.getWrapVarargsArrayModule)
+      .select(wrapArrayMethodName(elemtp))
+      .appliedToTypes(if (elemtp.isPrimitiveValueType) Nil else elemtp :: Nil)
+    val actualElem = wrapper.tpe.widen.firstParamTypes.head
+    wrapper.appliedTo(tree.ensureConforms(actualElem))
+
+  // ------ Creating typed equivalents of trees that exist only in untyped form -------
+
+  /** new C(args), calling the primary constructor of C */
+  def New(tp: Type, args: List[Tree])(using Context): Apply =
+    New(tp, tp.dealias.typeSymbol.primaryConstructor.asTerm, args)
+
+  /** new C(args), calling given constructor `constr` of C */
+  def New(tp: Type, constr: TermSymbol, args: List[Tree])(using Context): Apply = {
+    val targs = tp.argTypes
+    val tycon = tp.typeConstructor
+    New(tycon)
+      .select(TermRef(tycon, constr))
+      .appliedToTypes(targs)
+      .appliedToTermArgs(args)
+  }
+
+  /** An object def
+   *
+   *     object obs extends parents { decls }
+   *
+   *  gets expanded to
+   *
+   *     <module> val obj = new obj$
+   *     <module> class obj$ extends parents { this: obj.type => decls }
+   *
+   *  (The following no longer applies:
+   *  What's interesting here is that the block is well typed
+   *  (because class obj$ is hoistable), but the type of the `obj` val is
+   *  not expressible. What needs to happen in general when
+   *  inferring the type of a val from its RHS, is: if the type contains
+   *  a class that has the val itself as owner, then that class
+   *  is remapped to have the val's owner as owner. Remapping could be
+   *  done by cloning the class with the new owner and substituting
+   *  everywhere in the tree. We know that remapping is safe
+   *  because the only way a local class can appear in the RHS of a val is
+   *  by being hoisted outside of a block, and the necessary checks are
+   *  done at this point already.
+   *
+   *  On the other hand, for method result type inference, if the type of
+   *  the RHS of a method contains a class owned by the method, this would be
+   *  an error.)
+   */
+  def ModuleDef(sym: TermSymbol, body: List[Tree])(using Context): tpd.Thicket = {
+    val modcls = sym.moduleClass.asClass
+    val constrSym = modcls.primaryConstructor orElse newDefaultConstructor(modcls).entered
+    val constr = DefDef(constrSym.asTerm, EmptyTree)
+    val clsdef = ClassDef(modcls, constr, body)
+    val valdef = ValDef(sym, New(modcls.typeRef).select(constrSym).appliedToNone)
+    Thicket(valdef, clsdef)
+  }
+
+  /** A `_` with given type */
+  def Underscore(tp: Type)(using Context): Ident = untpd.Ident(nme.WILDCARD).withType(tp)
+
+  def defaultValue(tpe: Type)(using Context): Tree = {
+    val tpw = tpe.widen
+
+    if (tpw isRef defn.IntClass) Literal(Constant(0))
+    else if (tpw isRef defn.LongClass) Literal(Constant(0L))
+    else if (tpw isRef defn.BooleanClass) Literal(Constant(false))
+    else if (tpw isRef defn.CharClass) Literal(Constant('\u0000'))
+    else if (tpw isRef defn.FloatClass) Literal(Constant(0f))
+    else if (tpw isRef defn.DoubleClass) Literal(Constant(0d))
+    else if (tpw isRef defn.ByteClass) Literal(Constant(0.toByte))
+    else if (tpw isRef defn.ShortClass) Literal(Constant(0.toShort))
+    else nullLiteral.select(defn.Any_asInstanceOf).appliedToType(tpe)
+  }
+
+  private class FindLocalDummyAccumulator(cls: ClassSymbol)(using Context) extends TreeAccumulator[Symbol] {
+    def apply(sym: Symbol, tree: Tree)(using Context) =
+      if (sym.exists) sym
+      else if (tree.isDef) {
+        val owner = tree.symbol.owner
+        if (owner.isLocalDummy && owner.owner == cls) owner
+        else if (owner == cls) foldOver(sym, tree)
+        else sym
+      }
+      else foldOver(sym, tree)
+  }
+
+  /** The owner to be used in a local context when traversing a tree */
+  def localOwner(tree: Tree)(using Context): Symbol =
+    val sym = tree.symbol
+    (if sym.is(PackageVal) then sym.moduleClass else sym).orElse(ctx.owner)
+
+  /** The local context to use when traversing trees */
+  def localCtx(tree: Tree)(using Context): Context = ctx.withOwner(localOwner(tree))
+
+  override val cpy: TypedTreeCopier = // Type ascription needed to pick up any new members in TreeCopier (currently there are none)
+    TypedTreeCopier()
+
+  val cpyBetweenPhases: TimeTravellingTreeCopier = TimeTravellingTreeCopier()
+
+  class TypedTreeCopier extends TreeCopier {
+    def postProcess(tree: Tree, copied: untpd.Tree): copied.ThisTree[Type] =
+      copied.withTypeUnchecked(tree.tpe)
+    def postProcess(tree: Tree, copied: untpd.MemberDef): copied.ThisTree[Type] =
+      copied.withTypeUnchecked(tree.tpe)
+
+    protected val untpdCpy = untpd.cpy
+
+    override def Select(tree: Tree)(qualifier: Tree, name: Name)(using Context): Select = {
+      val tree1 = untpdCpy.Select(tree)(qualifier, name)
+      tree match {
+        case tree: Select if qualifier.tpe eq tree.qualifier.tpe =>
+          tree1.withTypeUnchecked(tree.tpe)
+        case _ =>
+          val tree2: Select = tree.tpe match {
+            case tpe: NamedType =>
+              val qualType = qualifier.tpe.widenIfUnstable
+              if qualType.isExactlyNothing then tree1.withTypeUnchecked(tree.tpe)
+              else tree1.withType(tpe.derivedSelect(qualType))
+            case _ => tree1.withTypeUnchecked(tree.tpe)
+          }
+          ConstFold.Select(tree2)
+      }
+    }
+
+    override def Apply(tree: Tree)(fun: Tree, args: List[Tree])(using Context): Apply = {
+      val tree1 = untpdCpy.Apply(tree)(fun, args)
+      tree match {
+        case tree: Apply
+        if (fun.tpe eq tree.fun.tpe) && sameTypes(args, tree.args) =>
+          tree1.withTypeUnchecked(tree.tpe)
+        case _ => ta.assignType(tree1, fun, args)
+      }
+    }
+
+    override def TypeApply(tree: Tree)(fun: Tree, args: List[Tree])(using Context): TypeApply = {
+      val tree1 = untpdCpy.TypeApply(tree)(fun, args)
+      tree match {
+        case tree: TypeApply
+        if (fun.tpe eq tree.fun.tpe) && sameTypes(args, tree.args) =>
+          tree1.withTypeUnchecked(tree.tpe)
+        case _ => ta.assignType(tree1, fun, args)
+      }
+    }
+
+    override def Literal(tree: Tree)(const: Constant)(using Context): Literal =
+      ta.assignType(untpdCpy.Literal(tree)(const))
+
+    override def New(tree: Tree)(tpt: Tree)(using Context): New =
+      ta.assignType(untpdCpy.New(tree)(tpt), tpt)
+
+    override def Typed(tree: Tree)(expr: Tree, tpt: Tree)(using Context): Typed =
+      ta.assignType(untpdCpy.Typed(tree)(expr, tpt), tpt)
+
+    override def NamedArg(tree: Tree)(name: Name, arg: Tree)(using Context): NamedArg =
+      ta.assignType(untpdCpy.NamedArg(tree)(name, arg), arg)
+
+    override def Assign(tree: Tree)(lhs: Tree, rhs: Tree)(using Context): Assign =
+      ta.assignType(untpdCpy.Assign(tree)(lhs, rhs))
+
+    override def Block(tree: Tree)(stats: List[Tree], expr: Tree)(using Context): Block = {
+      val tree1 = untpdCpy.Block(tree)(stats, expr)
+      tree match {
+        case tree: Block if (expr.tpe eq tree.expr.tpe) && (expr.tpe eq tree.tpe) =>
+          // The last guard is a conservative check: if `tree.tpe` is different from `expr.tpe`, then
+          // it was computed from widening `expr.tpe`, and tree transforms might cause `expr.tpe.widen`
+          // to change even if `expr.tpe` itself didn't change, e.g:
+          //     { val s = ...;  s }
+          // If the type of `s` changed, then the type of the block might have changed, even though `expr.tpe`
+          // will still be `TermRef(NoPrefix, s)`
+          tree1.withTypeUnchecked(tree.tpe)
+        case _ => ta.assignType(tree1, stats, expr)
+      }
+    }
+
+    override def If(tree: Tree)(cond: Tree, thenp: Tree, elsep: Tree)(using Context): If = {
+      val tree1 = untpdCpy.If(tree)(cond, thenp, elsep)
+      tree match {
+        case tree: If if (thenp.tpe eq tree.thenp.tpe) && (elsep.tpe eq tree.elsep.tpe) &&
+          ((tree.tpe eq thenp.tpe) || (tree.tpe eq elsep.tpe)) =>
+          // The last guard is a conservative check similar to the one done in `Block` above,
+          // if `tree.tpe` is not identical to the type of one of its branch, it might have been
+          // computed from the widened type of the branches, so the same reasoning than
+          // in `Block` applies.
+          tree1.withTypeUnchecked(tree.tpe)
+        case _ => ta.assignType(tree1, thenp, elsep)
+      }
+    }
+
+    override def Closure(tree: Tree)(env: List[Tree], meth: Tree, tpt: Tree)(using Context): Closure = {
+      val tree1 = untpdCpy.Closure(tree)(env, meth, tpt)
+      tree match {
+        case tree: Closure if sameTypes(env, tree.env) && (meth.tpe eq tree.meth.tpe) && (tpt.tpe eq tree.tpt.tpe) =>
+          tree1.withTypeUnchecked(tree.tpe)
+        case _ => ta.assignType(tree1, meth, tpt)
+      }
+    }
+
+    override def Match(tree: Tree)(selector: Tree, cases: List[CaseDef])(using Context): Match = {
+      val tree1 = untpdCpy.Match(tree)(selector, cases)
+      tree match {
+        case tree: Match if sameTypes(cases, tree.cases) => tree1.withTypeUnchecked(tree.tpe)
+        case _ => ta.assignType(tree1, selector, cases)
+      }
+    }
+
+    override def CaseDef(tree: Tree)(pat: Tree, guard: Tree, body: Tree)(using Context): CaseDef = {
+      val tree1 = untpdCpy.CaseDef(tree)(pat, guard, body)
+      tree match {
+        case tree: CaseDef if body.tpe eq tree.body.tpe => tree1.withTypeUnchecked(tree.tpe)
+        case _ => ta.assignType(tree1, pat, body)
+      }
+    }
+
+    override def Labeled(tree: Tree)(bind: Bind, expr: Tree)(using Context): Labeled =
+      ta.assignType(untpdCpy.Labeled(tree)(bind, expr))
+
+    override def Return(tree: Tree)(expr: Tree, from: Tree)(using Context): Return =
+      ta.assignType(untpdCpy.Return(tree)(expr, from))
+
+    override def WhileDo(tree: Tree)(cond: Tree, body: Tree)(using Context): WhileDo =
+      ta.assignType(untpdCpy.WhileDo(tree)(cond, body))
+
+    override def Try(tree: Tree)(expr: Tree, cases: List[CaseDef], finalizer: Tree)(using Context): Try = {
+      val tree1 = untpdCpy.Try(tree)(expr, cases, finalizer)
+      tree match {
+        case tree: Try if (expr.tpe eq tree.expr.tpe) && sameTypes(cases, tree.cases) => tree1.withTypeUnchecked(tree.tpe)
+        case _ => ta.assignType(tree1, expr, cases)
+      }
+    }
+
+    override def Inlined(tree: Tree)(call: Tree, bindings: List[MemberDef], expansion: Tree)(using Context): Inlined = {
+      val tree1 = untpdCpy.Inlined(tree)(call, bindings, expansion)
+      tree match {
+        case tree: Inlined if sameTypes(bindings, tree.bindings) && (expansion.tpe eq tree.expansion.tpe) =>
+          tree1.withTypeUnchecked(tree.tpe)
+        case _ => ta.assignType(tree1, bindings, expansion)
+      }
+    }
+
+    override def SeqLiteral(tree: Tree)(elems: List[Tree], elemtpt: Tree)(using Context): SeqLiteral = {
+      val tree1 = untpdCpy.SeqLiteral(tree)(elems, elemtpt)
+      tree match {
+        case tree: SeqLiteral
+        if sameTypes(elems, tree.elems) && (elemtpt.tpe eq tree.elemtpt.tpe) =>
+          tree1.withTypeUnchecked(tree.tpe)
+        case _ =>
+          ta.assignType(tree1, elems, elemtpt)
+      }
+    }
+
+    override def Annotated(tree: Tree)(arg: Tree, annot: Tree)(using Context): Annotated = {
+      val tree1 = untpdCpy.Annotated(tree)(arg, annot)
+      tree match {
+        case tree: Annotated if (arg.tpe eq tree.arg.tpe) && (annot eq tree.annot) => tree1.withTypeUnchecked(tree.tpe)
+        case _ => ta.assignType(tree1, arg, annot)
+      }
+    }
+
+    override def If(tree: If)(cond: Tree = tree.cond, thenp: Tree = tree.thenp, elsep: Tree = tree.elsep)(using Context): If =
+      If(tree: Tree)(cond, thenp, elsep)
+    override def Closure(tree: Closure)(env: List[Tree] = tree.env, meth: Tree = tree.meth, tpt: Tree = tree.tpt)(using Context): Closure =
+      Closure(tree: Tree)(env, meth, tpt)
+    override def CaseDef(tree: CaseDef)(pat: Tree = tree.pat, guard: Tree = tree.guard, body: Tree = tree.body)(using Context): CaseDef =
+      CaseDef(tree: Tree)(pat, guard, body)
+    override def Try(tree: Try)(expr: Tree = tree.expr, cases: List[CaseDef] = tree.cases, finalizer: Tree = tree.finalizer)(using Context): Try =
+      Try(tree: Tree)(expr, cases, finalizer)
+  }
+
+  class TimeTravellingTreeCopier extends TypedTreeCopier {
+    override def Apply(tree: Tree)(fun: Tree, args: List[Tree])(using Context): Apply =
+      tree match
+        case tree: Apply
+        if (tree.fun eq fun) && (tree.args eq args)
+           && tree.tpe.isInstanceOf[ConstantType]
+           && isPureExpr(tree) => tree
+        case _ =>
+          ta.assignType(untpdCpy.Apply(tree)(fun, args), fun, args)
+      // Note: Reassigning the original type if `fun` and `args` have the same types as before
+      // does not work here in general: The computed type depends on the widened function type, not
+      // the function type itself. A tree transform may keep the function type the
+      // same but its widened type might change.
+      // However, we keep constant types of pure expressions. This uses the underlying assumptions
+      // that pure functions yielding a constant will not change in later phases.
+
+    override def TypeApply(tree: Tree)(fun: Tree, args: List[Tree])(using Context): TypeApply =
+      ta.assignType(untpdCpy.TypeApply(tree)(fun, args), fun, args)
+      // Same remark as for Apply
+
+    override def Closure(tree: Tree)(env: List[Tree], meth: Tree, tpt: Tree)(using Context): Closure =
+            ta.assignType(untpdCpy.Closure(tree)(env, meth, tpt), meth, tpt)
+
+    override def Closure(tree: Closure)(env: List[Tree] = tree.env, meth: Tree = tree.meth, tpt: Tree = tree.tpt)(using Context): Closure =
+      Closure(tree: Tree)(env, meth, tpt)
+  }
+
+  override def skipTransform(tree: Tree)(using Context): Boolean = tree.tpe.isError
+
+  implicit class TreeOps[ThisTree <: tpd.Tree](private val tree: ThisTree) extends AnyVal {
+
+    def isValue(using Context): Boolean =
+      tree.isTerm && tree.tpe.widen.isValueType
+
+    def isValueOrPattern(using Context): Boolean =
+      tree.isValue || tree.isPattern
+
+    def isValueType: Boolean =
+      tree.isType && tree.tpe.isValueType
+
+    def isInstantiation: Boolean = tree match {
+      case Apply(Select(New(_), nme.CONSTRUCTOR), _) => true
+      case _ => false
+    }
+
+    def shallowFold[T](z: T)(op: (T, tpd.Tree) => T)(using Context): T =
+      ShallowFolder(op).apply(z, tree)
+
+    def deepFold[T](z: T)(op: (T, tpd.Tree) => T)(using Context): T =
+      DeepFolder(op).apply(z, tree)
+
+    def find[T](pred: (tpd.Tree) => Boolean)(using Context): Option[tpd.Tree] =
+      shallowFold[Option[tpd.Tree]](None)((accum, tree) => if (pred(tree)) Some(tree) else accum)
+
+    def subst(from: List[Symbol], to: List[Symbol])(using Context): ThisTree =
+      TreeTypeMap(substFrom = from, substTo = to).apply(tree)
+
+    /** Change owner from `from` to `to`. If `from` is a weak owner, also change its
+     *  owner to `to`, and continue until a non-weak owner is reached.
+     */
+    def changeOwner(from: Symbol, to: Symbol)(using Context): ThisTree = {
+      @tailrec def loop(from: Symbol, froms: List[Symbol], tos: List[Symbol]): ThisTree =
+        if (from.isWeakOwner && !from.owner.isClass)
+          loop(from.owner, from :: froms, to :: tos)
+        else
+          //println(i"change owner ${from :: froms}%, % ==> $tos of $tree")
+          TreeTypeMap(oldOwners = from :: froms, newOwners = tos).apply(tree)
+      if (from == to) tree else loop(from, Nil, to :: Nil)
+    }
+
+    /**
+     * Set the owner of every definition in this tree which is not itself contained in this
+     * tree to be `newowner`
+     */
+    def changeNonLocalOwners(newOwner: Symbol)(using Context): Tree = {
+      val ownerAcc = new TreeAccumulator[immutable.Set[Symbol]] {
+        def apply(ss: immutable.Set[Symbol], tree: Tree)(using Context) = tree match {
+          case tree: DefTree =>
+            val sym = tree.symbol
+            if sym.exists && !sym.owner.is(Package) then ss + sym.owner else ss
+          case _ =>
+            foldOver(ss, tree)
+        }
+      }
+      val owners = ownerAcc(immutable.Set.empty[Symbol], tree).toList
+      val newOwners = List.fill(owners.size)(newOwner)
+      TreeTypeMap(oldOwners = owners, newOwners = newOwners).apply(tree)
+    }
+
+    /** After phase `trans`, set the owner of every definition in this tree that was formerly
+     *  owner by `from` to `to`.
+     */
+    def changeOwnerAfter(from: Symbol, to: Symbol, trans: DenotTransformer)(using Context): ThisTree =
+      if (ctx.phase == trans.next) {
+        val traverser = new TreeTraverser {
+          def traverse(tree: Tree)(using Context) = tree match {
+            case tree: DefTree =>
+              val sym = tree.symbol
+              val prevDenot = atPhase(trans)(sym.denot)
+              if (prevDenot.effectiveOwner == from.skipWeakOwner) {
+                val d = sym.copySymDenotation(owner = to)
+                d.installAfter(trans)
+                d.transformAfter(trans, d => if (d.owner eq from) d.copySymDenotation(owner = to) else d)
+              }
+              if (sym.isWeakOwner) traverseChildren(tree)
+            case _ =>
+              traverseChildren(tree)
+          }
+        }
+        traverser.traverse(tree)
+        tree
+      }
+      else atPhase(trans.next)(changeOwnerAfter(from, to, trans))
+
+    /** A select node with the given selector name and a computed type */
+    def select(name: Name)(using Context): Select =
+      Select(tree, name)
+
+    /** A select node with the given selector name such that the designated
+     *  member satisfies predicate `p`. Useful for disambiguating overloaded members.
+     */
+    def select(name: Name, p: Symbol => Boolean)(using Context): Select =
+      select(tree.tpe.member(name).suchThat(p).symbol)
+
+    /** A select node with the given type */
+    def select(tp: NamedType)(using Context): Select =
+      untpd.Select(tree, tp.name).withType(tp)
+
+    /** A select node that selects the given symbol. Note: Need to make sure this
+     *  is in fact the symbol you would get when you select with the symbol's name,
+     *  otherwise a data race may occur which would be flagged by -Yno-double-bindings.
+     */
+    def select(sym: Symbol)(using Context): Select = {
+      val tp =
+        if (sym.isType) {
+          assert(!sym.is(TypeParam))
+          TypeRef(tree.tpe, sym.asType)
+        }
+        else
+          TermRef(tree.tpe, sym.name.asTermName, sym.denot.asSeenFrom(tree.tpe))
+      untpd.Select(tree, sym.name).withType(tp)
+    }
+
+    /** A select node with the given selector name and signature and a computed type */
+    def selectWithSig(name: Name, sig: Signature, target: Name)(using Context): Tree =
+      untpd.SelectWithSig(tree, name, sig).withType(tree.tpe.select(name.asTermName, sig, target))
+
+    /** A select node with selector name and signature taken from `sym`.
+     *  Note: Use this method instead of select(sym) if the referenced symbol
+     *  might be overridden in the type of the qualifier prefix. See note
+     *  on select(sym: Symbol).
+     */
+    def selectWithSig(sym: Symbol)(using Context): Tree =
+      selectWithSig(sym.name, sym.signature, sym.targetName)
+
+    /** A unary apply node with given argument: `tree(arg)` */
+    def appliedTo(arg: Tree)(using Context): Apply =
+      appliedToTermArgs(arg :: Nil)
+
+    /** An apply node with given arguments: `tree(arg, args0, ..., argsN)` */
+    def appliedTo(arg: Tree, args: Tree*)(using Context): Apply =
+      appliedToTermArgs(arg :: args.toList)
+
+    /** An apply node with given argument list `tree(args(0), ..., args(args.length - 1))` */
+    def appliedToTermArgs(args: List[Tree])(using Context): Apply =
+      Apply(tree, args)
+
+    /** An applied node that accepts only varargs as arguments */
+    def appliedToVarargs(args: List[Tree], tpt: Tree)(using Context): Apply =
+      appliedTo(repeated(args, tpt))
+
+    /** An apply or type apply node with given argument list */
+    def appliedToArgs(args: List[Tree])(using Context): GenericApply = args match
+      case arg :: args1 if arg.isType => TypeApply(tree, args)
+      case _ => Apply(tree, args)
+
+      /** The current tree applied to given argument lists:
+     *  `tree (argss(0)) ... (argss(argss.length -1))`
+     */
+    def appliedToArgss(argss: List[List[Tree]])(using Context): Tree =
+      argss.foldLeft(tree: Tree)(_.appliedToArgs(_))
+
+    /** The current tree applied to (): `tree()` */
+    def appliedToNone(using Context): Apply = Apply(tree, Nil)
+
+    /** The current tree applied to given type argument: `tree[targ]` */
+    def appliedToType(targ: Type)(using Context): Tree =
+      appliedToTypes(targ :: Nil)
+
+    /** The current tree applied to given type arguments: `tree[targ0, ..., targN]` */
+    def appliedToTypes(targs: List[Type])(using Context): Tree =
+      appliedToTypeTrees(targs map (TypeTree(_)))
+
+    /** The current tree applied to given type argument: `tree[targ]` */
+    def appliedToTypeTree(targ: Tree)(using Context): Tree =
+      appliedToTypeTrees(targ :: Nil)
+
+    /** The current tree applied to given type argument list: `tree[targs(0), ..., targs(targs.length - 1)]` */
+    def appliedToTypeTrees(targs: List[Tree])(using Context): Tree =
+      if targs.isEmpty then tree else TypeApply(tree, targs)
+
+    /** Apply to `()` unless tree's widened type is parameterless */
+    def ensureApplied(using Context): Tree =
+      if (tree.tpe.widen.isParameterless) tree else tree.appliedToNone
+
+    /** `tree == that` */
+    def equal(that: Tree)(using Context): Tree =
+      if (that.tpe.widen.isRef(defn.NothingClass))
+        Literal(Constant(false))
+      else
+        applyOverloaded(tree, nme.EQ, that :: Nil, Nil, defn.BooleanType)
+
+    /** `tree.isInstanceOf[tp]`, with special treatment of singleton types */
+    def isInstance(tp: Type)(using Context): Tree = tp.dealias match {
+      case ConstantType(c) if c.tag == StringTag =>
+        singleton(tp).equal(tree)
+      case tp: SingletonType =>
+        if tp.widen.derivesFrom(defn.ObjectClass) then
+          tree.ensureConforms(defn.ObjectType).select(defn.Object_eq).appliedTo(singleton(tp))
+        else
+          singleton(tp).equal(tree)
+      case _ =>
+        tree.select(defn.Any_isInstanceOf).appliedToType(tp)
+    }
+
+    /** tree.asInstanceOf[`tp`] */
+    def asInstance(tp: Type)(using Context): Tree = {
+      assert(tp.isValueType, i"bad cast: $tree.asInstanceOf[$tp]")
+      tree.select(defn.Any_asInstanceOf).appliedToType(tp)
+    }
+
+    /** cast tree to `tp`, assuming no exception is raised, i.e the operation is pure */
+    def cast(tp: Type)(using Context): Tree = cast(TypeTree(tp))
+
+    /** cast tree to `tp`, assuming no exception is raised, i.e the operation is pure */
+    def cast(tpt: TypeTree)(using Context): Tree =
+      assert(tpt.tpe.isValueType, i"bad cast: $tree.asInstanceOf[$tpt]")
+      tree.select(if (ctx.erasedTypes) defn.Any_asInstanceOf else defn.Any_typeCast)
+        .appliedToTypeTree(tpt)
+
+    /** cast `tree` to `tp` (or its box/unbox/cast equivalent when after
+     *  erasure and value and non-value types are mixed),
+     *  unless tree's type already conforms to `tp`.
+     */
+    def ensureConforms(tp: Type)(using Context): Tree =
+      if (tree.tpe <:< tp) tree
+      else if (!ctx.erasedTypes) cast(tp)
+      else Erasure.Boxing.adaptToType(tree, tp)
+
+    /** `tree ne null` (might need a cast to be type correct) */
+    def testNotNull(using Context): Tree = {
+      // If the receiver is of type `Nothing` or `Null`, add an ascription or cast
+      // so that the selection succeeds.
+      // e.g. `null.ne(null)` doesn't type, but `(null: AnyRef).ne(null)` does.
+      val receiver =
+        if tree.tpe.isBottomType then
+          if ctx.explicitNulls then tree.cast(defn.AnyRefType)
+          else Typed(tree, TypeTree(defn.AnyRefType))
+        else tree.ensureConforms(defn.ObjectType)
+      // also need to cast the null literal to AnyRef in explicit nulls
+      val nullLit = if ctx.explicitNulls then nullLiteral.cast(defn.AnyRefType) else nullLiteral
+      receiver.select(defn.Object_ne).appliedTo(nullLit).withSpan(tree.span)
+    }
+
+    /** If inititializer tree is `_`, the default value of its type,
+     *  otherwise the tree itself.
+     */
+    def wildcardToDefault(using Context): Tree =
+      if (isWildcardArg(tree)) defaultValue(tree.tpe) else tree
+
+    /** `this && that`, for boolean trees `this`, `that` */
+    def and(that: Tree)(using Context): Tree =
+      tree.select(defn.Boolean_&&).appliedTo(that)
+
+    /** `this || that`, for boolean trees `this`, `that` */
+    def or(that: Tree)(using Context): Tree =
+      tree.select(defn.Boolean_||).appliedTo(that)
+
+    /** The translation of `tree = rhs`.
+     *  This is either the tree as an assignment, or a setter call.
+     */
+    def becomes(rhs: Tree)(using Context): Tree = {
+      val sym = tree.symbol
+      if (sym.is(Method)) {
+        val setter = sym.setter.orElse {
+          assert(sym.name.isSetterName && sym.info.firstParamTypes.nonEmpty, sym)
+          sym
+        }
+        val qual = tree match {
+          case id: Ident => desugarIdentPrefix(id)
+          case Select(qual, _) => qual
+        }
+        qual.select(setter).appliedTo(rhs)
+      }
+      else Assign(tree, rhs)
+    }
+
+    /** tree @annot
+     *
+     *  works differently for type trees and term trees
+     */
+    def annotated(annot: Tree)(using Context): Tree =
+      if (tree.isTerm)
+        Typed(tree, TypeTree(AnnotatedType(tree.tpe.widenIfUnstable, Annotation(annot))))
+      else
+        Annotated(tree, annot)
+
+    /** A synthetic select with that will be turned into an outer path by ExplicitOuter.
+     *  @param levels  How many outer levels to select
+     *  @param tp      The type of the destination of the outer path.
+     */
+    def outerSelect(levels: Int, tp: Type)(using Context): Tree =
+      untpd.Select(tree, OuterSelectName(EmptyTermName, levels)).withType(SkolemType(tp))
+
+    /** Replace Inlined nodes and InlineProxy references to underlying arguments */
+    def underlyingArgument(using Context): Tree = {
+      val mapToUnderlying = new MapToUnderlying {
+        /** Should get the rhs of this binding
+         *  Returns true if the symbol is a val or def generated by eta-expansion/inline
+         */
+        override protected def skipLocal(sym: Symbol): Boolean =
+          sym.isOneOf(InlineProxy | Synthetic)
+      }
+      mapToUnderlying.transform(tree)
+    }
+
+    /** Replace Ident nodes references to the underlying tree that defined them */
+    def underlying(using Context): Tree = MapToUnderlying().transform(tree)
+
+    // --- Higher order traversal methods -------------------------------
+
+    /** Apply `f` to each subtree of this tree */
+    def foreachSubTree(f: Tree => Unit)(using Context): Unit = {
+      val traverser = new TreeTraverser {
+        def traverse(tree: Tree)(using Context) = foldOver(f(tree), tree)
+      }
+      traverser.traverse(tree)
+    }
+
+    /** Is there a subtree of this tree that satisfies predicate `p`? */
+    def existsSubTree(p: Tree => Boolean)(using Context): Boolean = {
+      val acc = new TreeAccumulator[Boolean] {
+        def apply(x: Boolean, t: Tree)(using Context) = x || p(t) || foldOver(x, t)
+      }
+      acc(false, tree)
+    }
+
+    /** All subtrees of this tree that satisfy predicate `p`. */
+    def filterSubTrees(f: Tree => Boolean)(using Context): List[Tree] = {
+      val buf = mutable.ListBuffer[Tree]()
+      foreachSubTree { tree => if (f(tree)) buf += tree }
+      buf.toList
+    }
+
+    /** Set this tree as the `defTree` of its symbol and return this tree */
+    def setDefTree(using Context): ThisTree = {
+      val sym = tree.symbol
+      if (sym.exists) sym.defTree = tree
+      tree
+    }
+
+    def etaExpandCFT(using Context): Tree =
+      def expand(target: Tree, tp: Type)(using Context): Tree = tp match
+        case defn.ContextFunctionType(argTypes, resType, isErased) =>
+          val anonFun = newAnonFun(
+            ctx.owner,
+            MethodType.companion(isContextual = true, isErased = isErased)(argTypes, resType),
+            coord = ctx.owner.coord)
+          def lambdaBody(refss: List[List[Tree]]) =
+            expand(target.select(nme.apply).appliedToArgss(refss), resType)(
+              using ctx.withOwner(anonFun))
+          Closure(anonFun, lambdaBody)
+        case _ =>
+          target
+      expand(tree, tree.tpe.widen)
+  }
+
+  inline val MapRecursionLimit = 10
+
+  extension (trees: List[Tree])
+
+    /** A map that expands to a recursive function. It's equivalent to
+     *
+     *    flatten(trees.mapConserve(op))
+     *
+     *  and falls back to it after `MaxRecursionLimit` recursions.
+     *  Before that it uses a simpler method that uses stackspace
+     *  instead of heap.
+     *  Note `op` is duplicated in the generated code, so it should be
+     *  kept small.
+     */
+    inline def mapInline(inline op: Tree => Tree): List[Tree] =
+      def recur(trees: List[Tree], count: Int): List[Tree] =
+        if count > MapRecursionLimit then
+          // use a slower implementation that avoids stack overflows
+          flatten(trees.mapConserve(op))
+        else trees match
+          case tree :: rest =>
+            val tree1 = op(tree)
+            val rest1 = recur(rest, count + 1)
+            if (tree1 eq tree) && (rest1 eq rest) then trees
+            else tree1 match
+              case Thicket(elems1) => elems1 ::: rest1
+              case _ => tree1 :: rest1
+          case nil => nil
+      recur(trees, 0)
+
+    /** Transform statements while maintaining import contexts and expression contexts
+     *  in the same way as Typer does. The code addresses additional concerns:
+     *   - be tail-recursive where possible
+     *   - don't re-allocate trees where nothing has changed
+     */
+    inline def mapStatements[T](
+        exprOwner: Symbol,
+        inline op: Tree => Context ?=> Tree,
+        inline wrapResult: List[Tree] => Context ?=> T)(using Context): T =
+      @tailrec
+      def loop(mapped: mutable.ListBuffer[Tree] | Null, unchanged: List[Tree], pending: List[Tree])(using Context): T =
+        pending match
+          case stat :: rest =>
+            val statCtx = stat match
+              case _: DefTree | _: ImportOrExport => ctx
+              case _ => ctx.exprContext(stat, exprOwner)
+            val stat1 = op(stat)(using statCtx)
+            val restCtx = stat match
+              case stat: Import => ctx.importContext(stat, stat.symbol)
+              case _ => ctx
+            if stat1 eq stat then
+              loop(mapped, unchanged, rest)(using restCtx)
+            else
+              val buf = if mapped == null then new mutable.ListBuffer[Tree] else mapped
+              var xc = unchanged
+              while xc ne pending do
+                buf += xc.head
+                xc = xc.tail
+              stat1 match
+                case Thicket(stats1) => buf ++= stats1
+                case _ => buf += stat1
+              loop(buf, rest, rest)(using restCtx)
+          case nil =>
+            wrapResult(
+              if mapped == null then unchanged
+              else mapped.prependToList(unchanged))
+
+      loop(null, trees, trees)
+    end mapStatements
+  end extension
+
+  /** A treemap that generates the same contexts as the original typer for statements.
+   *  This means:
+   *    - statements that are not definitions get the exprOwner as owner
+   *    - imports are reflected in the contexts of subsequent statements
+   */
+  class TreeMapWithPreciseStatContexts(cpy: TreeCopier = tpd.cpy) extends TreeMap(cpy):
+    def transformStats[T](trees: List[Tree], exprOwner: Symbol, wrapResult: List[Tree] => Context ?=> T)(using Context): T =
+      trees.mapStatements(exprOwner, transform(_), wrapResult)
+    final override def transformStats(trees: List[Tree], exprOwner: Symbol)(using Context): List[Tree] =
+      transformStats(trees, exprOwner, sameStats)
+    override def transformBlock(blk: Block)(using Context) =
+      transformStats(blk.stats, ctx.owner,
+        stats1 => ctx ?=> cpy.Block(blk)(stats1, transform(blk.expr)))
+
+  val sameStats: List[Tree] => Context ?=> List[Tree] = stats => stats
+
+  /** Map Inlined nodes, NamedArgs, Blocks with no statements and local references to underlying arguments.
+   *  Also drops Inline and Block with no statements.
+   */
+  private class MapToUnderlying extends TreeMap {
+    override def transform(tree: Tree)(using Context): Tree = tree match {
+      case tree: Ident if isBinding(tree.symbol) && skipLocal(tree.symbol) =>
+        tree.symbol.defTree match {
+          case defTree: ValOrDefDef =>
+            val rhs = defTree.rhs
+            assert(!rhs.isEmpty)
+            transform(rhs)
+          case _ => tree
+        }
+      case Inlined(_, Nil, arg) => transform(arg)
+      case Block(Nil, arg) => transform(arg)
+      case NamedArg(_, arg) => transform(arg)
+      case tree => super.transform(tree)
+    }
+
+    /** Should get the rhs of this binding */
+    protected def skipLocal(sym: Symbol): Boolean = true
+
+    /** Is this a symbol that of a local val or parameterless def for which we could get the rhs */
+    private def isBinding(sym: Symbol)(using Context): Boolean =
+      sym.isTerm && !sym.is(Param) && !sym.owner.isClass &&
+      !(sym.is(Method) && sym.info.isInstanceOf[MethodOrPoly]) // if is a method it is parameterless
+  }
+
+  extension (xs: List[tpd.Tree])
+    def tpes: List[Type] = xs match {
+      case x :: xs1 => x.tpe :: xs1.tpes
+      case nil => Nil
+    }
+
+  /** A trait for loaders that compute trees. Currently implemented just by DottyUnpickler. */
+  trait TreeProvider {
+    protected def computeRootTrees(using Context): List[Tree]
+
+    private var myTrees: List[Tree] | Null = _
+
+    /** Get trees defined by this provider. Cache them if -Yretain-trees is set. */
+    def rootTrees(using Context): List[Tree] =
+      if (ctx.settings.YretainTrees.value) {
+        if (myTrees == null) myTrees = computeRootTrees
+        myTrees.uncheckedNN
+      }
+      else computeRootTrees
+
+    /** Get first tree defined by this provider, or EmptyTree if none exists */
+    def tree(using Context): Tree =
+      rootTrees.headOption.getOrElse(EmptyTree)
+
+    /** Is it possible that the tree to load contains a definition of or reference to `id`? */
+    def mightContain(id: String)(using Context): Boolean = true
+  }
+
+  // convert a numeric with a toXXX method
+  def primitiveConversion(tree: Tree, numericCls: Symbol)(using Context): Tree = {
+    val mname      = "to".concat(numericCls.name)
+    val conversion = tree.tpe member(mname)
+    if (conversion.symbol.exists)
+      tree.select(conversion.symbol.termRef).ensureApplied
+    else if (tree.tpe.widen isRef numericCls)
+      tree
+    else {
+      report.warning(i"conversion from ${tree.tpe.widen} to ${numericCls.typeRef} will always fail at runtime.")
+      Throw(New(defn.ClassCastExceptionClass.typeRef, Nil)).withSpan(tree.span)
+    }
+  }
+
+  /** A tree that corresponds to `Predef.classOf[$tp]` in source */
+  def clsOf(tp: Type)(using Context): Tree =
+    if ctx.erasedTypes && !tp.isRef(defn.UnitClass) then
+      Literal(Constant(TypeErasure.erasure(tp)))
+    else
+      Literal(Constant(tp))
+
+  @tailrec
+  def sameTypes(trees: List[tpd.Tree], trees1: List[tpd.Tree]): Boolean =
+    if (trees.isEmpty) trees.isEmpty
+    else if (trees1.isEmpty) trees.isEmpty
+    else (trees.head.tpe eq trees1.head.tpe) && sameTypes(trees.tail, trees1.tail)
+
+  /** If `tree`'s purity level is less than `level`, let-bind it so that it gets evaluated
+   *  only once. I.e. produce a
+   *
+   *     { val x = 'tree ;  ~within('x) }
+   *
+   *  instead of otherwise
+   *
+   *     ~within('tree)
+   */
+  def letBindUnless(level: TreeInfo.PurityLevel, tree: Tree)(within: Tree => Tree)(using Context): Tree =
+    if (exprPurity(tree) >= level) within(tree)
+    else {
+      val vdef = SyntheticValDef(TempResultName.fresh(), tree)
+      Block(vdef :: Nil, within(Ident(vdef.namedType)))
+    }
+
+  /** Let bind `tree` unless `tree` is at least idempotent */
+  def evalOnce(tree: Tree)(within: Tree => Tree)(using Context): Tree =
+    letBindUnless(TreeInfo.Idempotent, tree)(within)
+
+  def runtimeCall(name: TermName, args: List[Tree])(using Context): Tree =
+    Ident(defn.ScalaRuntimeModule.requiredMethod(name).termRef).appliedToTermArgs(args)
+
+  /** An extractor that pulls out type arguments */
+  object MaybePoly:
+    def unapply(tree: Tree): Option[(Tree, List[Tree])] = tree match
+      case TypeApply(tree, targs) => Some(tree, targs)
+      case _ => Some(tree, Nil)
+
+  object TypeArgs:
+    def unapply(ts: List[Tree]): Option[List[Tree]] =
+      if ts.nonEmpty && ts.head.isType then Some(ts) else None
+
+  /** Split argument clauses into a leading type argument clause if it exists and
+   *  remaining clauses
+   */
+  def splitArgs(argss: List[List[Tree]]): (List[Tree], List[List[Tree]]) = argss match
+    case TypeArgs(targs) :: argss1 => (targs, argss1)
+    case _ => (Nil, argss)
+
+  def joinArgs(targs: List[Tree], argss: List[List[Tree]]): List[List[Tree]] =
+    if targs.isEmpty then argss else targs :: argss
+
+  /** A key to be used in a context property that tracks enclosing inlined calls */
+  private val InlinedCalls = Property.Key[List[Tree]]()
+
+  /** A key to be used in a context property that tracks the number of inlined trees */
+  private val InlinedTrees = Property.Key[Counter]()
+  final class Counter {
+    var count: Int = 0
+  }
+
+  /** Record an enclosing inlined call.
+   *  EmptyTree calls (for parameters) cancel the next-enclosing call in the list instead of being added to it.
+   *  We assume parameters are never nested inside parameters.
+   */
+  override def inlineContext(call: Tree)(using Context): Context = {
+    // We assume enclosingInlineds is already normalized, and only process the new call with the head.
+    val oldIC = enclosingInlineds
+
+    val newIC =
+      if call.isEmpty then
+        oldIC match
+          case t1 :: ts2 => ts2
+          case _ => oldIC
+      else
+        call :: oldIC
+
+    val ctx1 = ctx.fresh.setProperty(InlinedCalls, newIC)
+    if oldIC.isEmpty then ctx1.setProperty(InlinedTrees, new Counter) else ctx1
+  }
+
+  /** All enclosing calls that are currently inlined, from innermost to outermost.
+   */
+  def enclosingInlineds(using Context): List[Tree] =
+    ctx.property(InlinedCalls).getOrElse(Nil)
+
+  /** Record inlined trees */
+  def addInlinedTrees(n: Int)(using Context): Unit =
+    ctx.property(InlinedTrees).foreach(_.count += n)
+
+  /** Check if the limit on the number of inlined trees has been reached */
+  def reachedInlinedTreesLimit(using Context): Boolean =
+    ctx.property(InlinedTrees) match
+      case Some(c) => c.count > ctx.settings.XmaxInlinedTrees.value
+      case None => false
+
+  /** The source file where the symbol of the `inline` method referred to by `call`
+   *  is defined
+   */
+  def sourceFile(call: Tree)(using Context): SourceFile = call.symbol.source
+
+  /** Desugar identifier into a select node. Return the tree itself if not possible */
+  def desugarIdent(tree: Ident)(using Context): RefTree = {
+    val qual = desugarIdentPrefix(tree)
+    if (qual.isEmpty) tree
+    else qual.select(tree.symbol)
+  }
+
+  /** Recover identifier prefix (e.g. this) if it exists */
+  def desugarIdentPrefix(tree: Ident)(using Context): Tree = tree.tpe match {
+    case TermRef(prefix: TermRef, _) =>
+      prefix.info match
+        case mt: MethodType if mt.paramInfos.isEmpty && mt.resultType.typeSymbol.is(Module) =>
+          ref(mt.resultType.typeSymbol.sourceModule)
+        case _ =>
+          ref(prefix)
+    case TermRef(prefix: ThisType, _) =>
+      This(prefix.cls)
+    case _ =>
+      EmptyTree
+  }
+
+  /**
+   * The symbols that are imported with `expr.name`
+   *
+   * @param expr The base of the import statement
+   * @param name The name that is being imported.
+   * @return All the symbols that would be imported with `expr.name`.
+   */
+  def importedSymbols(expr: Tree, name: Name)(using Context): List[Symbol] = {
+    def lookup(name: Name): Symbol = expr.tpe.member(name).symbol
+    val symbols =
+      List(lookup(name.toTermName),
+           lookup(name.toTypeName),
+           lookup(name.moduleClassName),
+           lookup(name.sourceModuleName))
+
+    symbols.map(_.sourceSymbol).filter(_.exists).distinct
+  }
+
+  /**
+   * All the symbols that are imported by the first selector of `imp` that matches
+   * `selectorPredicate`.
+   *
+   * @param imp The import statement to analyze
+   * @param selectorPredicate A test to find the selector to use.
+   * @return The symbols imported.
+   */
+  def importedSymbols(imp: Import,
+                      selectorPredicate: untpd.ImportSelector -> Boolean = util.common.alwaysTrue)
+                     (using Context): List[Symbol] =
+    imp.selectors.find(selectorPredicate) match
+      case Some(sel) => importedSymbols(imp.expr, sel.name)
+      case _ => Nil
+
+  /**
+   * The list of select trees that resolve to the same symbols as the ones that are imported
+   * by `imp`.
+   */
+  def importSelections(imp: Import)(using Context): List[Select] = {
+    def imported(sym: Symbol, id: untpd.Ident, rename: Option[untpd.Ident]): List[Select] = {
+      // Give a zero-extent position to the qualifier to prevent it from being included several
+      // times in results in the language server.
+      val noPosExpr = focusPositions(imp.expr)
+      val selectTree = Select(noPosExpr, sym.name).withSpan(id.span)
+      rename match {
+        case None =>
+          selectTree :: Nil
+        case Some(rename) =>
+          // Get the type of the symbol that is actually selected, and construct a select
+          // node with the new name and the type of the real symbol.
+          val name = if (sym.name.isTypeName) rename.name.toTypeName else rename.name
+          val actual = Select(noPosExpr, sym.name)
+          val renameTree = Select(noPosExpr, name).withSpan(rename.span).withType(actual.tpe)
+          selectTree :: renameTree :: Nil
+      }
+    }
+
+    imp.selectors.flatMap { sel =>
+      if sel.isWildcard then Nil
+      else
+        val renamedOpt = sel.renamed match
+          case renamed: untpd.Ident => Some(renamed)
+          case untpd.EmptyTree => None
+        importedSymbols(imp.expr, sel.name).flatMap { sym =>
+          imported(sym, sel.imported, renamedOpt)
+        }
+    }
+  }
+
+  /** Creates the tuple type tree repesentation of the type trees in `ts` */
+  def tupleTypeTree(elems: List[Tree])(using Context): Tree = {
+    val arity = elems.length
+    if arity <= Definitions.MaxTupleArity then
+      val tupleTp = defn.TupleType(arity)
+      if tupleTp != null then
+        AppliedTypeTree(TypeTree(tupleTp), elems)
+      else nestedPairsTypeTree(elems)
+    else nestedPairsTypeTree(elems)
+  }
+
+  /** Creates the nested pairs type tree repesentation of the type trees in `ts` */
+  def nestedPairsTypeTree(ts: List[Tree])(using Context): Tree =
+    ts.foldRight[Tree](TypeTree(defn.EmptyTupleModule.termRef))((x, acc) => AppliedTypeTree(TypeTree(defn.PairClass.typeRef), x :: acc :: Nil))
+
+  /** Replaces all positions in `tree` with zero-extent positions */
+  private def focusPositions(tree: Tree)(using Context): Tree = {
+    val transformer = new tpd.TreeMap {
+      override def transform(tree: Tree)(using Context): Tree =
+        super.transform(tree).withSpan(tree.span.focus)
+    }
+    transformer.transform(tree)
+  }
+
+  /** Convert a list of trees to a vararg-compatible tree.
+   *  Used to make arguments for methods that accept varargs.
+   */
+  def repeated(trees: List[Tree], tpt: Tree)(using Context): Tree =
+    ctx.typeAssigner.arrayToRepeated(JavaSeqLiteral(trees, tpt))
+
+  /** Create a tree representing a list containing all
+   *  the elements of the argument list. A "list of tree to
+   *  tree of list" conversion.
+   *
+   *  @param trees  the elements the list represented by
+   *                the resulting tree should contain.
+   *  @param tpe    the type of the elements of the resulting list.
+   *
+   */
+  def mkList(trees: List[Tree], tpt: Tree)(using Context): Tree =
+    ref(defn.ListModule).select(nme.apply)
+      .appliedToTypeTree(tpt)
+      .appliedToVarargs(trees, tpt)
+
+
+  protected def FunProto(args: List[Tree], resType: Type)(using Context) =
+    ProtoTypes.FunProtoTyped(args, resType)(ctx.typer, ApplyKind.Regular)
+}
diff --git a/tests/pos-with-compiler-cc/dotc/ast/untpd.scala b/tests/pos-with-compiler-cc/dotc/ast/untpd.scala
new file mode 100644
index 000000000000..eb729d33a091
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/ast/untpd.scala
@@ -0,0 +1,819 @@
+package dotty.tools
+package dotc
+package ast
+
+import core._
+import Types._, Contexts._, Constants._, Names._, Flags._
+import dotty.tools.dotc.typer.ProtoTypes
+import Symbols._, StdNames._, Trees._
+import util.{Property, SourceFile, NoSource}
+import util.Spans.Span
+import annotation.constructorOnly
+import annotation.internal.sharable
+import Decorators._
+import annotation.retains
+import language.experimental.pureFunctions
+
+object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
+
+  // ----- Tree cases that exist in untyped form only ------------------
+
+  abstract class OpTree(implicit @constructorOnly src: SourceFile) extends Tree {
+    def op: Ident
+    override def isTerm: Boolean = op.isTerm
+    override def isType: Boolean = op.isType
+  }
+
+  /** A typed subtree of an untyped tree needs to be wrapped in a TypedSplice
+   *  @param owner               The current owner at the time the tree was defined
+   *  @param isExtensionReceiver The splice was created from the receiver `e` in an extension
+   *                             method call `e.f(...)`
+   */
+  abstract case class TypedSplice(splice: tpd.Tree)(val owner: Symbol, val isExtensionReceiver: Boolean)(implicit @constructorOnly src: SourceFile) extends ProxyTree {
+    def forwardTo: tpd.Tree = splice
+    override def toString =
+      def ext = if isExtensionReceiver then ", isExtensionReceiver = true" else ""
+      s"TypedSplice($splice$ext)"
+  }
+
+  object TypedSplice {
+    def apply(tree: tpd.Tree, isExtensionReceiver: Boolean = false)(using Context): TypedSplice =
+      new TypedSplice(tree)(ctx.owner, isExtensionReceiver) {}
+  }
+
+  /** mods object name impl */
+  case class ModuleDef(name: TermName, impl: Template)(implicit @constructorOnly src: SourceFile)
+    extends MemberDef {
+    type ThisTree[-T >: Untyped] <: Trees.NameTree[T] with Trees.MemberDef[T] with ModuleDef
+    def withName(name: Name)(using Context): ModuleDef = cpy.ModuleDef(this)(name.toTermName, impl)
+  }
+
+  /** An untyped template with a derives clause. Derived parents are added to the end
+   *  of the `parents` list. `derivedCount` keeps track of how many there are.
+   *  This representation was chosen because it balances two concerns:
+   *   - maximize overlap between DerivingTemplate and Template for code streamlining
+   *   - keep invariant that elements of untyped trees align with source positions
+   */
+  class DerivingTemplate(constr: DefDef, parentsOrDerived: List[Tree], self: ValDef, preBody: LazyTreeList, derivedCount: Int)(implicit @constructorOnly src: SourceFile)
+  extends Template(constr, parentsOrDerived, self, preBody) {
+    override val parents = parentsOrDerived.dropRight(derivedCount)
+    override val derived = parentsOrDerived.takeRight(derivedCount)
+  }
+
+  case class ParsedTry(expr: Tree, handler: Tree, finalizer: Tree)(implicit @constructorOnly src: SourceFile) extends TermTree
+
+  case class SymbolLit(str: String)(implicit @constructorOnly src: SourceFile) extends TermTree
+
+  /** An interpolated string
+   *  @param segments  a list of two element tickets consisting of string literal and argument tree,
+   *                   possibly with a simple string literal as last element of the list
+   */
+  case class InterpolatedString(id: TermName, segments: List[Tree])(implicit @constructorOnly src: SourceFile)
+    extends TermTree
+
+  /** A function type or closure */
+  case class Function(args: List[Tree], body: Tree)(implicit @constructorOnly src: SourceFile) extends Tree {
+    override def isTerm: Boolean = body.isTerm
+    override def isType: Boolean = body.isType
+  }
+
+  /** A function type or closure with `implicit`, `erased`, or `given` modifiers */
+  class FunctionWithMods(args: List[Tree], body: Tree, val mods: Modifiers)(implicit @constructorOnly src: SourceFile)
+    extends Function(args, body)
+
+  /** A polymorphic function type */
+  case class PolyFunction(targs: List[Tree], body: Tree)(implicit @constructorOnly src: SourceFile) extends Tree {
+    override def isTerm = body.isTerm
+    override def isType = body.isType
+  }
+
+  /** A function created from a wildcard expression
+   *  @param  placeholderParams  a list of definitions of synthetic parameters.
+   *  @param  body               the function body where wildcards are replaced by
+   *                             references to synthetic parameters.
+   *  This is equivalent to Function, except that forms a special case for the overlapping
+   *  positions tests.
+   */
+  class WildcardFunction(placeholderParams: List[ValDef], body: Tree)(implicit @constructorOnly src: SourceFile)
+    extends Function(placeholderParams, body)
+
+  case class InfixOp(left: Tree, op: Ident, right: Tree)(implicit @constructorOnly src: SourceFile) extends OpTree
+  case class PostfixOp(od: Tree, op: Ident)(implicit @constructorOnly src: SourceFile) extends OpTree
+  case class PrefixOp(op: Ident, od: Tree)(implicit @constructorOnly src: SourceFile) extends OpTree
+  case class Parens(t: Tree)(implicit @constructorOnly src: SourceFile) extends ProxyTree {
+    def forwardTo: Tree = t
+  }
+  case class Tuple(trees: List[Tree])(implicit @constructorOnly src: SourceFile) extends Tree {
+    override def isTerm: Boolean = trees.isEmpty || trees.head.isTerm
+    override def isType: Boolean = !isTerm
+  }
+  case class Throw(expr: Tree)(implicit @constructorOnly src: SourceFile) extends TermTree
+  case class Quote(quoted: Tree)(implicit @constructorOnly src: SourceFile) extends TermTree
+  case class Splice(expr: Tree)(implicit @constructorOnly src: SourceFile) extends TermTree {
+    def isInBraces: Boolean = span.end != expr.span.end
+  }
+  case class ForYield(enums: List[Tree], expr: Tree)(implicit @constructorOnly src: SourceFile) extends TermTree
+  case class ForDo(enums: List[Tree], body: Tree)(implicit @constructorOnly src: SourceFile) extends TermTree
+  case class GenFrom(pat: Tree, expr: Tree, checkMode: GenCheckMode)(implicit @constructorOnly src: SourceFile) extends Tree
+  case class GenAlias(pat: Tree, expr: Tree)(implicit @constructorOnly src: SourceFile) extends Tree
+  case class ContextBounds(bounds: TypeBoundsTree, cxBounds: List[Tree])(implicit @constructorOnly src: SourceFile) extends TypTree
+  case class PatDef(mods: Modifiers, pats: List[Tree], tpt: Tree, rhs: Tree)(implicit @constructorOnly src: SourceFile) extends DefTree
+  case class ExtMethods(paramss: List[ParamClause], methods: List[Tree])(implicit @constructorOnly src: SourceFile) extends Tree
+  case class MacroTree(expr: Tree)(implicit @constructorOnly src: SourceFile) extends Tree
+
+  case class ImportSelector(imported: Ident, renamed: Tree = EmptyTree, bound: Tree = EmptyTree)(implicit @constructorOnly src: SourceFile) extends Tree {
+    // TODO: Make bound a typed tree?
+
+    /** It's a `given` selector */
+    val isGiven: Boolean = imported.name.isEmpty
+
+    /** It's a `given` or `_` selector */
+    val isWildcard: Boolean = isGiven || imported.name == nme.WILDCARD
+
+    /** The imported name, EmptyTermName if it's a given selector */
+    val name: TermName = imported.name.asInstanceOf[TermName]
+
+    /** The renamed part (which might be `_`), if present, or `name`, if missing */
+    val rename: TermName = renamed match
+      case Ident(rename: TermName) => rename
+      case _ => name
+  }
+
+  case class Number(digits: String, kind: NumberKind)(implicit @constructorOnly src: SourceFile) extends TermTree
+
+  enum NumberKind {
+    case Whole(radix: Int)
+    case Decimal
+    case Floating
+  }
+
+  /** {x1, ..., xN} T   (only relevant under captureChecking) */
+  case class CapturingTypeTree(refs: List[Tree], parent: Tree)(implicit @constructorOnly src: SourceFile) extends TypTree
+
+  /** Short-lived usage in typer, does not need copy/transform/fold infrastructure */
+  case class DependentTypeTree(tp: List[Symbol] -> Type)(implicit @constructorOnly src: SourceFile) extends Tree
+
+  @sharable object EmptyTypeIdent extends Ident(tpnme.EMPTY)(NoSource) with WithoutTypeOrPos[Untyped] {
+    override def isEmpty: Boolean = true
+  }
+
+  def WildcardTypeBoundsTree()(using src: SourceFile): TypeBoundsTree = TypeBoundsTree(EmptyTree, EmptyTree, EmptyTree)
+  object WildcardTypeBoundsTree:
+    def unapply(tree: untpd.Tree): Boolean = tree match
+      case TypeBoundsTree(EmptyTree, EmptyTree, _) => true
+      case _ => false
+
+
+  /** A block generated by the XML parser, only treated specially by
+   *  `Positioned#checkPos` */
+  class XMLBlock(stats: List[Tree], expr: Tree)(implicit @constructorOnly src: SourceFile) extends Block(stats, expr)
+
+  /** An enum to control checking or filtering of patterns in GenFrom trees */
+  enum GenCheckMode {
+    case Ignore       // neither filter nor check since filtering was done before
+    case Check        // check that pattern is irrefutable
+    case CheckAndFilter // both check and filter (transitional period starting with 3.2)
+    case FilterNow    // filter out non-matching elements if we are not in 3.2 or later
+    case FilterAlways // filter out non-matching elements since pattern is prefixed by `case`
+  }
+
+  // ----- Modifiers -----------------------------------------------------
+  /** Mod is intended to record syntactic information about modifiers, it's
+    * NOT a replacement of FlagSet.
+    *
+    * For any query about semantic information, check `flags` instead.
+    */
+  sealed abstract class Mod(val flags: FlagSet)(implicit @constructorOnly src: SourceFile)
+  extends Positioned
+
+  object Mod {
+    case class Private()(implicit @constructorOnly src: SourceFile) extends Mod(Flags.Private)
+
+    case class Protected()(implicit @constructorOnly src: SourceFile) extends Mod(Flags.Protected)
+
+    case class Var()(implicit @constructorOnly src: SourceFile) extends Mod(Flags.Mutable)
+
+    case class Implicit()(implicit @constructorOnly src: SourceFile) extends Mod(Flags.Implicit)
+
+    case class Given()(implicit @constructorOnly src: SourceFile) extends Mod(Flags.Given)
+
+    case class Erased()(implicit @constructorOnly src: SourceFile) extends Mod(Flags.Erased)
+
+    case class Final()(implicit @constructorOnly src: SourceFile) extends Mod(Flags.Final)
+
+    case class Sealed()(implicit @constructorOnly src: SourceFile) extends Mod(Flags.Sealed)
+
+    case class Opaque()(implicit @constructorOnly src: SourceFile) extends Mod(Flags.Opaque)
+
+    case class Open()(implicit @constructorOnly src: SourceFile) extends Mod(Flags.Open)
+
+    case class Override()(implicit @constructorOnly src: SourceFile) extends Mod(Flags.Override)
+
+    case class Abstract()(implicit @constructorOnly src: SourceFile) extends Mod(Flags.Abstract)
+
+    case class Lazy()(implicit @constructorOnly src: SourceFile) extends Mod(Flags.Lazy)
+
+    case class Inline()(implicit @constructorOnly src: SourceFile) extends Mod(Flags.Inline)
+
+    case class Transparent()(implicit @constructorOnly src: SourceFile) extends Mod(Flags.Transparent)
+
+    case class Infix()(implicit @constructorOnly src: SourceFile) extends Mod(Flags.Infix)
+
+    /** Used under pureFunctions to mark impure function types `A => B` in `FunctionWithMods` */
+    case class Impure()(implicit @constructorOnly src: SourceFile) extends Mod(Flags.Impure)
+  }
+
+  /** Modifiers and annotations for definitions
+   *
+   *  @param flags          The set flags
+   *  @param privateWithin  If a private or protected has is followed by a
+   *                        qualifier [q], the name q, "" as a typename otherwise.
+   *  @param annotations    The annotations preceding the modifiers
+   */
+  case class Modifiers (
+    flags: FlagSet = EmptyFlags,
+    privateWithin: TypeName = tpnme.EMPTY,
+    annotations: List[Tree] = Nil,
+    mods: List[Mod] = Nil) {
+
+    def is(flag: Flag): Boolean = flags.is(flag)
+    def is(flag: Flag, butNot: FlagSet): Boolean = flags.is(flag, butNot = butNot)
+    def isOneOf(fs: FlagSet): Boolean = flags.isOneOf(fs)
+    def isOneOf(fs: FlagSet, butNot: FlagSet): Boolean = flags.isOneOf(fs, butNot = butNot)
+    def isAllOf(fc: FlagSet): Boolean = flags.isAllOf(fc)
+
+    def | (fs: FlagSet): Modifiers = withFlags(flags | fs)
+    def & (fs: FlagSet): Modifiers = withFlags(flags & fs)
+    def &~(fs: FlagSet): Modifiers = withFlags(flags &~ fs)
+
+    def toTypeFlags: Modifiers = withFlags(flags.toTypeFlags)
+    def toTermFlags: Modifiers = withFlags(flags.toTermFlags)
+
+    def withFlags(flags: FlagSet): Modifiers =
+      if (this.flags == flags) this
+      else copy(flags = flags)
+
+    def withoutFlags(flags: FlagSet): Modifiers =
+      if (this.isOneOf(flags))
+        Modifiers(this.flags &~ flags, this.privateWithin, this.annotations, this.mods.filterNot(_.flags.isOneOf(flags)))
+      else this
+
+    def withAddedMod(mod: Mod): Modifiers =
+      if (mods.exists(_ eq mod)) this
+      else withMods(mods :+ mod)
+
+    private def compatible(flags1: FlagSet, flags2: FlagSet): Boolean =
+      flags1.isEmpty || flags2.isEmpty
+      || flags1.isTermFlags && flags2.isTermFlags
+      || flags1.isTypeFlags && flags2.isTypeFlags
+
+    /** Add `flags` to thos modifier set, checking that there are no type/term conflicts.
+     *  If there are conflicts, issue an error and return the modifiers consisting of
+     *  the added flags only. The reason to do it this way is that the added flags usually
+     *  describe the core of a construct whereas the existing set are the modifiers
+     *  given in the source.
+     */
+    def withAddedFlags(flags: FlagSet, span: Span)(using Context): Modifiers =
+      if this.flags.isAllOf(flags) then this
+      else if compatible(this.flags, flags) then this | flags
+      else
+        val what = if flags.isTermFlags then "values" else "types"
+        report.error(em"${(flags & ModifierFlags).flagsString} $what cannot be ${this.flags.flagsString}", ctx.source.atSpan(span))
+        Modifiers(flags)
+
+    /** Modifiers with given list of Mods. It is checked that
+     *  all modifiers are already accounted for in `flags` and `privateWithin`.
+     */
+    def withMods(ms: List[Mod]): Modifiers =
+      if (mods eq ms) this
+      else {
+        if (ms.nonEmpty)
+          for (m <- ms)
+            assert(flags.isAllOf(m.flags)
+                || m.isInstanceOf[Mod.Private] && !privateWithin.isEmpty
+                || (m.isInstanceOf[Mod.Abstract] || m.isInstanceOf[Mod.Override]) && flags.is(AbsOverride),
+                s"unaccounted modifier: $m in $this with flags ${flags.flagsString} when adding $ms")
+        copy(mods = ms)
+      }
+
+    def withAddedAnnotation(annot: Tree): Modifiers =
+      if (annotations.exists(_ eq annot)) this
+      else withAnnotations(annotations :+ annot)
+
+    def withAnnotations(annots: List[Tree]): Modifiers =
+      if (annots eq annotations) this
+      else copy(annotations = annots)
+
+    def withPrivateWithin(pw: TypeName): Modifiers =
+      if (pw.isEmpty) this
+      else copy(privateWithin = pw)
+
+    def hasFlags: Boolean = flags != EmptyFlags
+    def hasAnnotations: Boolean = annotations.nonEmpty
+    def hasPrivateWithin: Boolean = privateWithin != tpnme.EMPTY
+    def hasMod(cls: Class[?]) = mods.exists(_.getClass == cls)
+
+    private def isEnum = is(Enum, butNot = JavaDefined)
+
+    def isEnumCase: Boolean = isEnum && is(Case)
+    def isEnumClass: Boolean = isEnum && !is(Case)
+  }
+
+  @sharable val EmptyModifiers: Modifiers = Modifiers()
+
+  // ----- TypeTrees that refer to other tree's symbols -------------------
+
+  /** A type tree that gets its type from some other tree's symbol. Enters the
+   *  type tree in the References attachment of the `from` tree as a side effect.
+   */
+  abstract class DerivedTypeTree(implicit @constructorOnly src: SourceFile) extends TypeTree {
+
+    private var myWatched: Tree = EmptyTree
+
+    /** The watched tree; used only for printing */
+    def watched: Tree = myWatched
+
+    /** Install the derived type tree as a dependency on `original` */
+    def watching(original: DefTree): this.type = {
+      myWatched = original
+      val existing = original.attachmentOrElse(References, Nil)
+      original.putAttachment(References, this :: existing)
+      this
+    }
+
+    /** Install the derived type tree as a dependency on `sym` */
+    def watching(sym: Symbol): this.type = withAttachment(OriginalSymbol, sym)
+
+    /** A hook to ensure that all necessary symbols are completed so that
+     *  OriginalSymbol attachments are propagated to this tree
+     */
+    def ensureCompletions(using Context): Unit = ()
+
+    /** The method that computes the tree with the derived type */
+    def derivedTree(originalSym: Symbol)(using Context): tpd.Tree
+  }
+
+  /** Property key containing TypeTrees whose type is computed
+   *  from the symbol in this type. These type trees have marker trees
+   *  TypeRefOfSym or InfoOfSym as their originals.
+   */
+  val References: Property.Key[List[DerivedTypeTree]] = Property.Key()
+
+  /** Property key for TypeTrees marked with TypeRefOfSym or InfoOfSym
+   *  which contains the symbol of the original tree from which this
+   *  TypeTree is derived.
+   */
+  val OriginalSymbol: Property.Key[Symbol] = Property.Key()
+
+  /** Property key for contextual Apply trees of the form `fn given arg` */
+  val KindOfApply: Property.StickyKey[ApplyKind] = Property.StickyKey()
+
+  // ------ Creation methods for untyped only -----------------
+
+  def Ident(name: Name)(implicit src: SourceFile): Ident = new Ident(name)
+  def SearchFailureIdent(name: Name, explanation: -> String)(implicit src: SourceFile): SearchFailureIdent = new SearchFailureIdent(name, explanation)
+  def Select(qualifier: Tree, name: Name)(implicit src: SourceFile): Select = new Select(qualifier, name)
+  def SelectWithSig(qualifier: Tree, name: Name, sig: Signature)(implicit src: SourceFile): Select = new SelectWithSig(qualifier, name, sig)
+  def This(qual: Ident)(implicit src: SourceFile): This = new This(qual)
+  def Super(qual: Tree, mix: Ident)(implicit src: SourceFile): Super = new Super(qual, mix)
+  def Apply(fun: Tree, args: List[Tree])(implicit src: SourceFile): Apply = new Apply(fun, args)
+  def TypeApply(fun: Tree, args: List[Tree])(implicit src: SourceFile): TypeApply = new TypeApply(fun, args)
+  def Literal(const: Constant)(implicit src: SourceFile): Literal = new Literal(const)
+  def New(tpt: Tree)(implicit src: SourceFile): New = new New(tpt)
+  def Typed(expr: Tree, tpt: Tree)(implicit src: SourceFile): Typed = new Typed(expr, tpt)
+  def NamedArg(name: Name, arg: Tree)(implicit src: SourceFile): NamedArg = new NamedArg(name, arg)
+  def Assign(lhs: Tree, rhs: Tree)(implicit src: SourceFile): Assign = new Assign(lhs, rhs)
+  def Block(stats: List[Tree], expr: Tree)(implicit src: SourceFile): Block = new Block(stats, expr)
+  def If(cond: Tree, thenp: Tree, elsep: Tree)(implicit src: SourceFile): If = new If(cond, thenp, elsep)
+  def InlineIf(cond: Tree, thenp: Tree, elsep: Tree)(implicit src: SourceFile): If = new InlineIf(cond, thenp, elsep)
+  def Closure(env: List[Tree], meth: Tree, tpt: Tree)(implicit src: SourceFile): Closure = new Closure(env, meth, tpt)
+  def Match(selector: Tree, cases: List[CaseDef])(implicit src: SourceFile): Match = new Match(selector, cases)
+  def InlineMatch(selector: Tree, cases: List[CaseDef])(implicit src: SourceFile): Match = new InlineMatch(selector, cases)
+  def CaseDef(pat: Tree, guard: Tree, body: Tree)(implicit src: SourceFile): CaseDef = new CaseDef(pat, guard, body)
+  def Labeled(bind: Bind, expr: Tree)(implicit src: SourceFile): Labeled = new Labeled(bind, expr)
+  def Return(expr: Tree, from: Tree)(implicit src: SourceFile): Return = new Return(expr, from)
+  def WhileDo(cond: Tree, body: Tree)(implicit src: SourceFile): WhileDo = new WhileDo(cond, body)
+  def Try(expr: Tree, cases: List[CaseDef], finalizer: Tree)(implicit src: SourceFile): Try = new Try(expr, cases, finalizer)
+  def SeqLiteral(elems: List[Tree], elemtpt: Tree)(implicit src: SourceFile): SeqLiteral = new SeqLiteral(elems, elemtpt)
+  def JavaSeqLiteral(elems: List[Tree], elemtpt: Tree)(implicit src: SourceFile): JavaSeqLiteral = new JavaSeqLiteral(elems, elemtpt)
+  def Inlined(call: tpd.Tree, bindings: List[MemberDef], expansion: Tree)(implicit src: SourceFile): Inlined = new Inlined(call, bindings, expansion)
+  def TypeTree()(implicit src: SourceFile): TypeTree = new TypeTree()
+  def InferredTypeTree()(implicit src: SourceFile): TypeTree = new InferredTypeTree()
+  def SingletonTypeTree(ref: Tree)(implicit src: SourceFile): SingletonTypeTree = new SingletonTypeTree(ref)
+  def RefinedTypeTree(tpt: Tree, refinements: List[Tree])(implicit src: SourceFile): RefinedTypeTree = new RefinedTypeTree(tpt, refinements)
+  def AppliedTypeTree(tpt: Tree, args: List[Tree])(implicit src: SourceFile): AppliedTypeTree = new AppliedTypeTree(tpt, args)
+  def LambdaTypeTree(tparams: List[TypeDef], body: Tree)(implicit src: SourceFile): LambdaTypeTree = new LambdaTypeTree(tparams, body)
+  def TermLambdaTypeTree(params: List[ValDef], body: Tree)(implicit src: SourceFile): TermLambdaTypeTree = new TermLambdaTypeTree(params, body)
+  def MatchTypeTree(bound: Tree, selector: Tree, cases: List[CaseDef])(implicit src: SourceFile): MatchTypeTree = new MatchTypeTree(bound, selector, cases)
+  def ByNameTypeTree(result: Tree)(implicit src: SourceFile): ByNameTypeTree = new ByNameTypeTree(result)
+  def TypeBoundsTree(lo: Tree, hi: Tree, alias: Tree = EmptyTree)(implicit src: SourceFile): TypeBoundsTree = new TypeBoundsTree(lo, hi, alias)
+  def Bind(name: Name, body: Tree)(implicit src: SourceFile): Bind = new Bind(name, body)
+  def Alternative(trees: List[Tree])(implicit src: SourceFile): Alternative = new Alternative(trees)
+  def UnApply(fun: Tree, implicits: List[Tree], patterns: List[Tree])(implicit src: SourceFile): UnApply = new UnApply(fun, implicits, patterns)
+  def ValDef(name: TermName, tpt: Tree, rhs: LazyTree)(implicit src: SourceFile): ValDef = new ValDef(name, tpt, rhs)
+  def DefDef(name: TermName, paramss: List[ParamClause], tpt: Tree, rhs: LazyTree)(implicit src: SourceFile): DefDef = new DefDef(name, paramss, tpt, rhs)
+  def TypeDef(name: TypeName, rhs: Tree)(implicit src: SourceFile): TypeDef = new TypeDef(name, rhs)
+  def Template(constr: DefDef, parents: List[Tree], derived: List[Tree], self: ValDef, body: LazyTreeList)(implicit src: SourceFile): Template =
+    if (derived.isEmpty) new Template(constr, parents, self, body)
+    else new DerivingTemplate(constr, parents ++ derived, self, body, derived.length)
+  def Import(expr: Tree, selectors: List[ImportSelector])(implicit src: SourceFile): Import = new Import(expr, selectors)
+  def Export(expr: Tree, selectors: List[ImportSelector])(implicit src: SourceFile): Export = new Export(expr, selectors)
+  def PackageDef(pid: RefTree, stats: List[Tree])(implicit src: SourceFile): PackageDef = new PackageDef(pid, stats)
+  def Annotated(arg: Tree, annot: Tree)(implicit src: SourceFile): Annotated = new Annotated(arg, annot)
+  def Hole(isTermHole: Boolean, idx: Int, args: List[Tree], content: Tree, tpt: Tree)(implicit src: SourceFile): Hole = new Hole(isTermHole, idx, args, content, tpt)
+
+  // ------ Additional creation methods for untyped only -----------------
+
+  /**     new T(args1)...(args_n)
+   *  ==>
+   *      new T.<init>[Ts](args1)...(args_n)
+   *
+   *  where `Ts` are the class type arguments of `T` or its class type alias.
+   *  Note: we also keep any type arguments as parts of `T`. This is necessary to allow
+   *  navigation into these arguments from the IDE, and to do the right thing in
+   *  PrepareInlineable.
+   */
+  def New(tpt: Tree, argss: List[List[Tree]])(using Context): Tree =
+    ensureApplied(argss.foldLeft(makeNew(tpt))(Apply(_, _)))
+
+  /** A new expression with constrictor and possibly type arguments. See
+   *  `New(tpt, argss)` for details.
+   */
+  def makeNew(tpt: Tree)(using Context): Tree = {
+    val (tycon, targs) = tpt match {
+      case AppliedTypeTree(tycon, targs) =>
+        (tycon, targs)
+      case TypedSplice(tpt1: tpd.Tree) =>
+        val argTypes = tpt1.tpe.dealias.argTypesLo
+        def wrap(tpe: Type) = TypeTree(tpe).withSpan(tpt.span)
+        (tpt, argTypes.map(wrap))
+      case _ =>
+        (tpt, Nil)
+    }
+    val nu: Tree = Select(New(tycon), nme.CONSTRUCTOR)
+    if (targs.nonEmpty) TypeApply(nu, targs) else nu
+  }
+
+  def Block(stat: Tree, expr: Tree)(implicit src: SourceFile): Block =
+    Block(stat :: Nil, expr)
+
+  def Apply(fn: Tree, arg: Tree)(implicit src: SourceFile): Apply =
+    Apply(fn, arg :: Nil)
+
+  def ensureApplied(tpt: Tree)(implicit src: SourceFile): Tree = tpt match {
+    case _: Apply => tpt
+    case _ => Apply(tpt, Nil)
+  }
+
+  def AppliedTypeTree(tpt: Tree, arg: Tree)(implicit src: SourceFile): AppliedTypeTree =
+    AppliedTypeTree(tpt, arg :: Nil)
+
+  def TypeTree(tpe: Type)(using Context): TypedSplice =
+    TypedSplice(TypeTree().withTypeUnchecked(tpe))
+
+  def InferredTypeTree(tpe: Type)(using Context): TypedSplice =
+    TypedSplice(new InferredTypeTree().withTypeUnchecked(tpe))
+
+  def unitLiteral(implicit src: SourceFile): Literal = Literal(Constant(()))
+
+  def ref(tp: NamedType)(using Context): Tree =
+    TypedSplice(tpd.ref(tp))
+
+  def ref(sym: Symbol)(using Context): Tree =
+    TypedSplice(tpd.ref(sym))
+
+  def rawRef(tp: NamedType)(using Context): Tree =
+    if tp.typeParams.isEmpty then ref(tp)
+    else AppliedTypeTree(ref(tp), tp.typeParams.map(_ => WildcardTypeBoundsTree()))
+
+  def rootDot(name: Name)(implicit src: SourceFile): Select = Select(Ident(nme.ROOTPKG), name)
+  def scalaDot(name: Name)(implicit src: SourceFile): Select = Select(rootDot(nme.scala), name)
+  def scalaAnnotationDot(name: Name)(using SourceFile): Select = Select(scalaDot(nme.annotation), name)
+  def scalaRuntimeDot(name: Name)(using SourceFile): Select = Select(scalaDot(nme.runtime), name)
+  def scalaUnit(implicit src: SourceFile): Select = scalaDot(tpnme.Unit)
+  def scalaAny(implicit src: SourceFile): Select = scalaDot(tpnme.Any)
+  def javaDotLangDot(name: Name)(implicit src: SourceFile): Select = Select(Select(Ident(nme.java), nme.lang), name)
+
+  def captureRoot(using Context): Select =
+    Select(scalaDot(nme.caps), nme.CAPTURE_ROOT)
+
+  def makeConstructor(tparams: List[TypeDef], vparamss: List[List[ValDef]], rhs: Tree = EmptyTree)(using Context): DefDef =
+    DefDef(nme.CONSTRUCTOR, joinParams(tparams, vparamss), TypeTree(), rhs)
+
+  def emptyConstructor(using Context): DefDef =
+    makeConstructor(Nil, Nil)
+
+  def makeSelfDef(name: TermName, tpt: Tree)(using Context): ValDef =
+    ValDef(name, tpt, EmptyTree).withFlags(PrivateLocal)
+
+  def makeTupleOrParens(ts: List[Tree])(using Context): Tree = ts match {
+    case t :: Nil => Parens(t)
+    case _ => Tuple(ts)
+  }
+
+  def makeTuple(ts: List[Tree])(using Context): Tree = ts match {
+    case t :: Nil => t
+    case _ => Tuple(ts)
+  }
+
+  def makeAndType(left: Tree, right: Tree)(using Context): AppliedTypeTree =
+    AppliedTypeTree(ref(defn.andType.typeRef), left :: right :: Nil)
+
+  def makeParameter(pname: TermName, tpe: Tree, mods: Modifiers, isBackquoted: Boolean = false)(using Context): ValDef = {
+    val vdef = ValDef(pname, tpe, EmptyTree)
+    if (isBackquoted) vdef.pushAttachment(Backquoted, ())
+    vdef.withMods(mods | Param)
+  }
+
+  def makeSyntheticParameter(n: Int = 1, tpt: Tree | Null = null, flags: FlagSet = SyntheticTermParam)(using Context): ValDef =
+    ValDef(nme.syntheticParamName(n), if (tpt == null) TypeTree() else tpt, EmptyTree)
+      .withFlags(flags)
+
+  def lambdaAbstract(params: List[ValDef] | List[TypeDef], tpt: Tree)(using Context): Tree =
+    params match
+      case Nil               => tpt
+      case (vd: ValDef) :: _ => TermLambdaTypeTree(params.asInstanceOf[List[ValDef]], tpt)
+      case _                 => LambdaTypeTree(params.asInstanceOf[List[TypeDef]], tpt)
+
+  def lambdaAbstractAll(paramss: List[List[ValDef] | List[TypeDef]], tpt: Tree)(using Context): Tree =
+    paramss.foldRight(tpt)(lambdaAbstract)
+
+  /** A reference to given definition. If definition is a repeated
+   *  parameter, the reference will be a repeated argument.
+   */
+  def refOfDef(tree: MemberDef)(using Context): Tree = tree match {
+    case ValDef(_, PostfixOp(_, Ident(tpnme.raw.STAR)), _) => repeated(Ident(tree.name))
+    case _ => Ident(tree.name)
+  }
+
+  /** A repeated argument such as `arg: _*` */
+  def repeated(arg: Tree)(using Context): Typed = Typed(arg, Ident(tpnme.WILDCARD_STAR))
+
+
+// --------- Copier/Transformer/Accumulator classes for untyped trees -----
+
+  def localCtx(tree: Tree)(using Context): Context = ctx
+
+  override val cpy: UntypedTreeCopier = UntypedTreeCopier()
+
+  class UntypedTreeCopier extends TreeCopier {
+
+    def postProcess(tree: Tree, copied: Tree): copied.ThisTree[Untyped] =
+      copied.asInstanceOf[copied.ThisTree[Untyped]]
+
+    def postProcess(tree: Tree, copied: MemberDef): copied.ThisTree[Untyped] = {
+      tree match {
+        case tree: MemberDef => copied.withMods(tree.rawMods)
+        case _ => copied
+      }
+    }.asInstanceOf[copied.ThisTree[Untyped]]
+
+    def ModuleDef(tree: Tree)(name: TermName, impl: Template)(using Context): ModuleDef = tree match {
+      case tree: ModuleDef if (name eq tree.name) && (impl eq tree.impl) => tree
+      case _ => finalize(tree, untpd.ModuleDef(name, impl)(tree.source))
+    }
+    def ParsedTry(tree: Tree)(expr: Tree, handler: Tree, finalizer: Tree)(using Context): TermTree = tree match {
+      case tree: ParsedTry if (expr eq tree.expr) && (handler eq tree.handler) && (finalizer eq tree.finalizer) => tree
+      case _ => finalize(tree, untpd.ParsedTry(expr, handler, finalizer)(tree.source))
+    }
+    def SymbolLit(tree: Tree)(str: String)(using Context): TermTree = tree match {
+      case tree: SymbolLit if str == tree.str => tree
+      case _ => finalize(tree, untpd.SymbolLit(str)(tree.source))
+    }
+    def InterpolatedString(tree: Tree)(id: TermName, segments: List[Tree])(using Context): TermTree = tree match {
+      case tree: InterpolatedString if (id eq tree.id) && (segments eq tree.segments) => tree
+      case _ => finalize(tree, untpd.InterpolatedString(id, segments)(tree.source))
+    }
+    def Function(tree: Tree)(args: List[Tree], body: Tree)(using Context): Tree = tree match {
+      case tree: Function if (args eq tree.args) && (body eq tree.body) => tree
+      case _ => finalize(tree, untpd.Function(args, body)(tree.source))
+    }
+    def PolyFunction(tree: Tree)(targs: List[Tree], body: Tree)(using Context): Tree = tree match {
+      case tree: PolyFunction if (targs eq tree.targs) && (body eq tree.body) => tree
+      case _ => finalize(tree, untpd.PolyFunction(targs, body)(tree.source))
+    }
+    def InfixOp(tree: Tree)(left: Tree, op: Ident, right: Tree)(using Context): Tree = tree match {
+      case tree: InfixOp if (left eq tree.left) && (op eq tree.op) && (right eq tree.right) => tree
+      case _ => finalize(tree, untpd.InfixOp(left, op, right)(tree.source))
+    }
+    def PostfixOp(tree: Tree)(od: Tree, op: Ident)(using Context): Tree = tree match {
+      case tree: PostfixOp if (od eq tree.od) && (op eq tree.op) => tree
+      case _ => finalize(tree, untpd.PostfixOp(od, op)(tree.source))
+    }
+    def PrefixOp(tree: Tree)(op: Ident, od: Tree)(using Context): Tree = tree match {
+      case tree: PrefixOp if (op eq tree.op) && (od eq tree.od) => tree
+      case _ => finalize(tree, untpd.PrefixOp(op, od)(tree.source))
+    }
+    def Parens(tree: Tree)(t: Tree)(using Context): ProxyTree = tree match {
+      case tree: Parens if t eq tree.t => tree
+      case _ => finalize(tree, untpd.Parens(t)(tree.source))
+    }
+    def Tuple(tree: Tree)(trees: List[Tree])(using Context): Tree = tree match {
+      case tree: Tuple if trees eq tree.trees => tree
+      case _ => finalize(tree, untpd.Tuple(trees)(tree.source))
+    }
+    def Throw(tree: Tree)(expr: Tree)(using Context): TermTree = tree match {
+      case tree: Throw if expr eq tree.expr => tree
+      case _ => finalize(tree, untpd.Throw(expr)(tree.source))
+    }
+    def Quote(tree: Tree)(quoted: Tree)(using Context): Tree = tree match {
+      case tree: Quote if quoted eq tree.quoted => tree
+      case _ => finalize(tree, untpd.Quote(quoted)(tree.source))
+    }
+    def Splice(tree: Tree)(expr: Tree)(using Context): Tree = tree match {
+      case tree: Splice if expr eq tree.expr => tree
+      case _ => finalize(tree, untpd.Splice(expr)(tree.source))
+    }
+    def ForYield(tree: Tree)(enums: List[Tree], expr: Tree)(using Context): TermTree = tree match {
+      case tree: ForYield if (enums eq tree.enums) && (expr eq tree.expr) => tree
+      case _ => finalize(tree, untpd.ForYield(enums, expr)(tree.source))
+    }
+    def ForDo(tree: Tree)(enums: List[Tree], body: Tree)(using Context): TermTree = tree match {
+      case tree: ForDo if (enums eq tree.enums) && (body eq tree.body) => tree
+      case _ => finalize(tree, untpd.ForDo(enums, body)(tree.source))
+    }
+    def GenFrom(tree: Tree)(pat: Tree, expr: Tree, checkMode: GenCheckMode)(using Context): Tree = tree match {
+      case tree: GenFrom if (pat eq tree.pat) && (expr eq tree.expr) && (checkMode == tree.checkMode) => tree
+      case _ => finalize(tree, untpd.GenFrom(pat, expr, checkMode)(tree.source))
+    }
+    def GenAlias(tree: Tree)(pat: Tree, expr: Tree)(using Context): Tree = tree match {
+      case tree: GenAlias if (pat eq tree.pat) && (expr eq tree.expr) => tree
+      case _ => finalize(tree, untpd.GenAlias(pat, expr)(tree.source))
+    }
+    def ContextBounds(tree: Tree)(bounds: TypeBoundsTree, cxBounds: List[Tree])(using Context): TypTree = tree match {
+      case tree: ContextBounds if (bounds eq tree.bounds) && (cxBounds eq tree.cxBounds) => tree
+      case _ => finalize(tree, untpd.ContextBounds(bounds, cxBounds)(tree.source))
+    }
+    def PatDef(tree: Tree)(mods: Modifiers, pats: List[Tree], tpt: Tree, rhs: Tree)(using Context): Tree = tree match {
+      case tree: PatDef if (mods eq tree.mods) && (pats eq tree.pats) && (tpt eq tree.tpt) && (rhs eq tree.rhs) => tree
+      case _ => finalize(tree, untpd.PatDef(mods, pats, tpt, rhs)(tree.source))
+    }
+    def ExtMethods(tree: Tree)(paramss: List[ParamClause], methods: List[Tree])(using Context): Tree = tree match
+      case tree: ExtMethods if (paramss eq tree.paramss) && (methods == tree.methods) => tree
+      case _ => finalize(tree, untpd.ExtMethods(paramss, methods)(tree.source))
+    def ImportSelector(tree: Tree)(imported: Ident, renamed: Tree, bound: Tree)(using Context): Tree = tree match {
+      case tree: ImportSelector if (imported eq tree.imported) && (renamed eq tree.renamed) && (bound eq tree.bound) => tree
+      case _ => finalize(tree, untpd.ImportSelector(imported, renamed, bound)(tree.source))
+    }
+    def Number(tree: Tree)(digits: String, kind: NumberKind)(using Context): Tree = tree match {
+      case tree: Number if (digits == tree.digits) && (kind == tree.kind) => tree
+      case _ => finalize(tree, untpd.Number(digits, kind))
+    }
+    def CapturingTypeTree(tree: Tree)(refs: List[Tree], parent: Tree)(using Context): Tree = tree match
+      case tree: CapturingTypeTree if (refs eq tree.refs) && (parent eq tree.parent) => tree
+      case _ => finalize(tree, untpd.CapturingTypeTree(refs, parent))
+
+    def TypedSplice(tree: Tree)(splice: tpd.Tree)(using Context): ProxyTree = tree match {
+      case tree: TypedSplice if splice `eq` tree.splice => tree
+      case _ => finalize(tree, untpd.TypedSplice(splice)(using ctx))
+    }
+    def MacroTree(tree: Tree)(expr: Tree)(using Context): Tree = tree match {
+      case tree: MacroTree if expr `eq` tree.expr => tree
+      case _ => finalize(tree, untpd.MacroTree(expr)(tree.source))
+    }
+  }
+
+  abstract class UntypedTreeMap(cpy: UntypedTreeCopier = untpd.cpy) extends TreeMap(cpy) {
+    override def transformMoreCases(tree: Tree)(using Context): Tree = tree match {
+      case ModuleDef(name, impl) =>
+        cpy.ModuleDef(tree)(name, transformSub(impl))
+      case tree: DerivingTemplate =>
+        cpy.Template(tree)(transformSub(tree.constr), transform(tree.parents),
+          transform(tree.derived), transformSub(tree.self), transformStats(tree.body, tree.symbol))
+      case ParsedTry(expr, handler, finalizer) =>
+        cpy.ParsedTry(tree)(transform(expr), transform(handler), transform(finalizer))
+      case SymbolLit(str) =>
+        cpy.SymbolLit(tree)(str)
+      case InterpolatedString(id, segments) =>
+        cpy.InterpolatedString(tree)(id, segments.mapConserve(transform))
+      case Function(args, body) =>
+        cpy.Function(tree)(transform(args), transform(body))
+      case PolyFunction(targs, body) =>
+        cpy.PolyFunction(tree)(transform(targs), transform(body))
+      case InfixOp(left, op, right) =>
+        cpy.InfixOp(tree)(transform(left), op, transform(right))
+      case PostfixOp(od, op) =>
+        cpy.PostfixOp(tree)(transform(od), op)
+      case PrefixOp(op, od) =>
+        cpy.PrefixOp(tree)(op, transform(od))
+      case Parens(t) =>
+        cpy.Parens(tree)(transform(t))
+      case Tuple(trees) =>
+        cpy.Tuple(tree)(transform(trees))
+      case Throw(expr) =>
+        cpy.Throw(tree)(transform(expr))
+      case Quote(t) =>
+        cpy.Quote(tree)(transform(t))
+      case Splice(expr) =>
+        cpy.Splice(tree)(transform(expr))
+      case ForYield(enums, expr) =>
+        cpy.ForYield(tree)(transform(enums), transform(expr))
+      case ForDo(enums, body) =>
+        cpy.ForDo(tree)(transform(enums), transform(body))
+      case GenFrom(pat, expr, checkMode) =>
+        cpy.GenFrom(tree)(transform(pat), transform(expr), checkMode)
+      case GenAlias(pat, expr) =>
+        cpy.GenAlias(tree)(transform(pat), transform(expr))
+      case ContextBounds(bounds, cxBounds) =>
+        cpy.ContextBounds(tree)(transformSub(bounds), transform(cxBounds))
+      case PatDef(mods, pats, tpt, rhs) =>
+        cpy.PatDef(tree)(mods, transform(pats), transform(tpt), transform(rhs))
+      case ExtMethods(paramss, methods) =>
+        cpy.ExtMethods(tree)(transformParamss(paramss), transformSub(methods))
+      case ImportSelector(imported, renamed, bound) =>
+        cpy.ImportSelector(tree)(transformSub(imported), transform(renamed), transform(bound))
+      case Number(_, _) | TypedSplice(_) =>
+        tree
+      case MacroTree(expr) =>
+        cpy.MacroTree(tree)(transform(expr))
+      case CapturingTypeTree(refs, parent) =>
+        cpy.CapturingTypeTree(tree)(transform(refs), transform(parent))
+      case _ =>
+        super.transformMoreCases(tree)
+    }
+  }
+
+  abstract class UntypedTreeAccumulator[X] extends TreeAccumulator[X] {
+    self: UntypedTreeAccumulator[X] @retains(caps.*) =>
+    override def foldMoreCases(x: X, tree: Tree)(using Context): X = tree match {
+      case ModuleDef(name, impl) =>
+        this(x, impl)
+      case tree: DerivingTemplate =>
+        this(this(this(this(this(x, tree.constr), tree.parents), tree.derived), tree.self), tree.body)
+      case ParsedTry(expr, handler, finalizer) =>
+        this(this(this(x, expr), handler), finalizer)
+      case SymbolLit(str) =>
+        x
+      case InterpolatedString(id, segments) =>
+        this(x, segments)
+      case Function(args, body) =>
+        this(this(x, args), body)
+      case PolyFunction(targs, body) =>
+        this(this(x, targs), body)
+      case InfixOp(left, op, right) =>
+        this(this(this(x, left), op), right)
+      case PostfixOp(od, op) =>
+        this(this(x, od), op)
+      case PrefixOp(op, od) =>
+        this(this(x, op), od)
+      case Parens(t) =>
+        this(x, t)
+      case Tuple(trees) =>
+        this(x, trees)
+      case Throw(expr) =>
+        this(x, expr)
+      case Quote(t) =>
+        this(x, t)
+      case Splice(expr) =>
+        this(x, expr)
+      case ForYield(enums, expr) =>
+        this(this(x, enums), expr)
+      case ForDo(enums, body) =>
+        this(this(x, enums), body)
+      case GenFrom(pat, expr, _) =>
+        this(this(x, pat), expr)
+      case GenAlias(pat, expr) =>
+        this(this(x, pat), expr)
+      case ContextBounds(bounds, cxBounds) =>
+        this(this(x, bounds), cxBounds)
+      case PatDef(mods, pats, tpt, rhs) =>
+        this(this(this(x, pats), tpt), rhs)
+      case ExtMethods(paramss, methods) =>
+        this(paramss.foldLeft(x)(apply), methods)
+      case ImportSelector(imported, renamed, bound) =>
+        this(this(this(x, imported), renamed), bound)
+      case Number(_, _) =>
+        x
+      case TypedSplice(splice) =>
+        this(x, splice)
+      case MacroTree(expr) =>
+        this(x, expr)
+      case CapturingTypeTree(refs, parent) =>
+        this(this(x, refs), parent)
+      case _ =>
+        super.foldMoreCases(x, tree)
+    }
+  }
+
+  abstract class UntypedTreeTraverser extends UntypedTreeAccumulator[Unit] {
+    def traverse(tree: Tree)(using Context): Unit
+    def apply(x: Unit, tree: Tree)(using Context): Unit = traverse(tree)
+    protected def traverseChildren(tree: Tree)(using Context): Unit = foldOver((), tree)
+  }
+
+  /** Fold `f` over all tree nodes, in depth-first, prefix order */
+  class UntypedDeepFolder[X](f: (X, Tree) => X) extends UntypedTreeAccumulator[X] {
+    def apply(x: X, tree: Tree)(using Context): X = foldOver(f(x, tree), tree)
+  }
+
+  /** Is there a subtree of this tree that satisfies predicate `p`? */
+  extension (tree: Tree) def existsSubTree(p: Tree => Boolean)(using Context): Boolean = {
+    val acc = new UntypedTreeAccumulator[Boolean] {
+      def apply(x: Boolean, t: Tree)(using Context) = x || p(t) || foldOver(x, t)
+    }
+    acc(false, tree)
+  }
+
+  protected def FunProto(args: List[Tree], resType: Type)(using Context) =
+    ProtoTypes.FunProto(args, resType)(ctx.typer, ApplyKind.Regular)
+}
diff --git a/tests/pos-with-compiler-cc/dotc/cc/BoxedTypeCache.scala b/tests/pos-with-compiler-cc/dotc/cc/BoxedTypeCache.scala
new file mode 100644
index 000000000000..56b3f5ba5047
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/cc/BoxedTypeCache.scala
@@ -0,0 +1,19 @@
+package dotty.tools
+package dotc
+package cc
+
+import core.*
+import Types.*, Symbols.*, Contexts.*
+
+/** A one-element cache for the boxed version of an unboxed capturing type */
+class BoxedTypeCache:
+  private var boxed: Type = compiletime.uninitialized
+  private var unboxed: Type = NoType
+
+  def apply(tp: AnnotatedType)(using Context): Type =
+    if tp ne unboxed then
+      unboxed = tp
+      val CapturingType(parent, refs) = tp: @unchecked
+      boxed = CapturingType(parent, refs, boxed = true)
+    boxed
+end BoxedTypeCache
\ No newline at end of file
diff --git a/tests/pos-with-compiler-cc/dotc/cc/CaptureAnnotation.scala b/tests/pos-with-compiler-cc/dotc/cc/CaptureAnnotation.scala
new file mode 100644
index 000000000000..fd89159e2076
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/cc/CaptureAnnotation.scala
@@ -0,0 +1,76 @@
+package dotty.tools
+package dotc
+package cc
+
+import core.*
+import Types.*, Symbols.*, Contexts.*, Annotations.*
+import ast.Trees.*
+import ast.{tpd, untpd}
+import Decorators.*
+import config.Printers.capt
+import printing.Printer
+import printing.Texts.Text
+
+/** An annotation representing a capture set and whether it is boxed.
+ *  It simulates a normal @retains annotation except that it is more efficient,
+ *  supports variables as capture sets, and adds a `boxed` flag.
+ *  These annotations are created during capture checking. Before that
+ *  there are only regular @retains and @retainsByName annotations.
+ *  @param refs    the capture set
+ *  @param boxed   whether the type carrying the annotation is boxed
+ *  @param cls     the underlying class (either annotation.retains or annotation.retainsByName)
+ */
+case class CaptureAnnotation(refs: CaptureSet, boxed: Boolean)(cls: Symbol) extends Annotation:
+  import CaptureAnnotation.*
+  import tpd.*
+
+  /** A cache for boxed version of a capturing type with this annotation */
+  val boxedType = BoxedTypeCache()
+
+  /** Reconstitute annotation tree from capture set */
+  override def tree(using Context) =
+    val elems = refs.elems.toList.map {
+      case cr: TermRef => ref(cr)
+      case cr: TermParamRef => untpd.Ident(cr.paramName).withType(cr)
+      case cr: ThisType => This(cr.cls)
+    }
+    val arg = repeated(elems, TypeTree(defn.AnyType))
+    New(symbol.typeRef, arg :: Nil)
+
+  override def symbol(using Context) = cls
+
+  override def derivedAnnotation(tree: Tree)(using Context): Annotation = this
+
+  def derivedAnnotation(refs: CaptureSet, boxed: Boolean)(using Context): Annotation =
+    if (this.refs eq refs) && (this.boxed == boxed) then this
+    else CaptureAnnotation(refs, boxed)(cls)
+
+  override def sameAnnotation(that: Annotation)(using Context): Boolean = that match
+    case CaptureAnnotation(refs, boxed) =>
+      this.refs == refs && this.boxed == boxed && this.symbol == that.symbol
+    case _ => false
+
+  override def mapWith(tm: TypeMap)(using Context) =
+    val elems = refs.elems.toList
+    val elems1 = elems.mapConserve(tm)
+    if elems1 eq elems then this
+    else if elems1.forall(_.isInstanceOf[CaptureRef])
+    then derivedAnnotation(CaptureSet(elems1.asInstanceOf[List[CaptureRef]]*), boxed)
+    else EmptyAnnotation
+
+  override def refersToParamOf(tl: TermLambda)(using Context): Boolean =
+    refs.elems.exists {
+      case TermParamRef(tl1, _) => tl eq tl1
+      case _ => false
+    }
+
+  override def toText(printer: Printer): Text = refs.toText(printer)
+
+  override def hash: Int =
+    (refs.hashCode << 1) | (if boxed then 1 else 0)
+
+  override def eql(that: Annotation) = that match
+    case that: CaptureAnnotation => (this.refs eq that.refs) && (this.boxed == that.boxed)
+    case _ => false
+
+end CaptureAnnotation
diff --git a/tests/pos-with-compiler-cc/dotc/cc/CaptureOps.scala b/tests/pos-with-compiler-cc/dotc/cc/CaptureOps.scala
new file mode 100644
index 000000000000..3dfd1324ae1e
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/cc/CaptureOps.scala
@@ -0,0 +1,253 @@
+package dotty.tools
+package dotc
+package cc
+
+import core.*
+import Types.*, Symbols.*, Contexts.*, Annotations.*, Flags.*
+import ast.{tpd, untpd}
+import Decorators.*, NameOps.*
+import config.Printers.capt
+import util.Property.Key
+import tpd.*
+import config.Feature
+
+private val Captures: Key[CaptureSet] = Key()
+private val BoxedType: Key[BoxedTypeCache] = Key()
+
+/** The arguments of a @retains or @retainsByName annotation */
+private[cc] def retainedElems(tree: Tree)(using Context): List[Tree] = tree match
+  case Apply(_, Typed(SeqLiteral(elems, _), _) :: Nil) => elems
+  case _ => Nil
+
+/** An exception thrown if a @retains argument is not syntactically a CaptureRef */
+class IllegalCaptureRef(tpe: Type) extends Exception
+
+extension (tree: Tree)
+
+  /** Map tree with CaptureRef type to its type, throw IllegalCaptureRef otherwise */
+  def toCaptureRef(using Context): CaptureRef = tree.tpe match
+    case ref: CaptureRef => ref
+    case tpe => throw IllegalCaptureRef(tpe)
+
+  /** Convert a @retains or @retainsByName annotation tree to the capture set it represents.
+   *  For efficience, the result is cached as an Attachment on the tree.
+   */
+  def toCaptureSet(using Context): CaptureSet =
+    tree.getAttachment(Captures) match
+      case Some(refs) => refs
+      case None =>
+        val refs = CaptureSet(retainedElems(tree).map(_.toCaptureRef)*)
+          .showing(i"toCaptureSet $tree --> $result", capt)
+        tree.putAttachment(Captures, refs)
+        refs
+
+  /** Under pureFunctions, add a @retainsByName(*)` annotation to the argument of
+   *  a by name parameter type, turning the latter into an impure by name parameter type.
+   */
+  def adaptByNameArgUnderPureFuns(using Context): Tree =
+    if Feature.pureFunsEnabledSomewhere then
+      val rbn = defn.RetainsByNameAnnot
+      Annotated(tree,
+        New(rbn.typeRef).select(rbn.primaryConstructor).appliedTo(
+          Typed(
+            SeqLiteral(ref(defn.captureRoot) :: Nil, TypeTree(defn.AnyType)),
+            TypeTree(defn.RepeatedParamType.appliedTo(defn.AnyType))
+          )
+        )
+      )
+    else tree
+
+extension (tp: Type)
+
+  /** @pre `tp` is a CapturingType */
+  def derivedCapturingType(parent: Type, refs: CaptureSet)(using Context): Type = tp match
+    case tp @ CapturingType(p, r) =>
+      if (parent eq p) && (refs eq r) then tp
+      else CapturingType(parent, refs, tp.isBoxed)
+
+  /** If this is a unboxed capturing type with nonempty capture set, its boxed version.
+   *  Or, if type is a TypeBounds of capturing types, the version where the bounds are boxed.
+   *  The identity for all other types.
+   */
+  def boxed(using Context): Type = tp.dealias match
+    case tp @ CapturingType(parent, refs) if !tp.isBoxed && !refs.isAlwaysEmpty =>
+      tp.annot match
+        case ann: CaptureAnnotation =>
+          ann.boxedType(tp)
+        case ann =>
+          ann.tree.getAttachment(BoxedType) match
+            case None => ann.tree.putAttachment(BoxedType, BoxedTypeCache())
+            case _ =>
+          ann.tree.attachment(BoxedType)(tp)
+    case tp: RealTypeBounds =>
+      tp.derivedTypeBounds(tp.lo.boxed, tp.hi.boxed)
+    case _ =>
+      tp
+
+  /** If `sym` is a type parameter, the boxed version of `tp`, otherwise `tp` */
+  def boxedIfTypeParam(sym: Symbol)(using Context) =
+    if sym.is(TypeParam) then tp.boxed else tp
+
+  /** The boxed version of `tp`, unless `tycon` is a function symbol */
+  def boxedUnlessFun(tycon: Type)(using Context) =
+    if ctx.phase != Phases.checkCapturesPhase || defn.isFunctionSymbol(tycon.typeSymbol)
+    then tp
+    else tp.boxed
+
+  /** The capture set consisting of all top-level captures of `tp` that appear under a box.
+   *  Unlike for `boxed` this also considers parents of capture types, unions and
+   *  intersections, and type proxies other than abstract types.
+   */
+  def boxedCaptureSet(using Context): CaptureSet =
+    def getBoxed(tp: Type): CaptureSet = tp match
+      case tp @ CapturingType(parent, refs) =>
+        val pcs = getBoxed(parent)
+        if tp.isBoxed then refs ++ pcs else pcs
+      case tp: TypeRef if tp.symbol.isAbstractType => CaptureSet.empty
+      case tp: TypeProxy => getBoxed(tp.superType)
+      case tp: AndType => getBoxed(tp.tp1) ** getBoxed(tp.tp2)
+      case tp: OrType => getBoxed(tp.tp1) ++ getBoxed(tp.tp2)
+      case _ => CaptureSet.empty
+    getBoxed(tp)
+
+  /** Is the boxedCaptureSet of this type nonempty? */
+  def isBoxedCapturing(using Context) = !tp.boxedCaptureSet.isAlwaysEmpty
+
+  /** If this type is a capturing type, the version with boxed statues as given by `boxed`.
+   *  If it is a TermRef of a capturing type, and the box status flips, widen to a capturing
+   *  type that captures the TermRef.
+   */
+  def forceBoxStatus(boxed: Boolean)(using Context): Type = tp.widenDealias match
+    case tp @ CapturingType(parent, refs) if tp.isBoxed != boxed =>
+      val refs1 = tp match
+        case ref: CaptureRef if ref.isTracked => ref.singletonCaptureSet
+        case _ => refs
+      CapturingType(parent, refs1, boxed)
+    case _ =>
+      tp
+
+  /** Map capturing type to their parents. Capturing types accessible
+   *  via dealising are also stripped.
+   */
+  def stripCapturing(using Context): Type = tp.dealiasKeepAnnots match
+    case CapturingType(parent, _) =>
+      parent.stripCapturing
+    case atd @ AnnotatedType(parent, annot) =>
+      atd.derivedAnnotatedType(parent.stripCapturing, annot)
+    case _ =>
+      tp
+
+  /** Under pureFunctions, map regular function type to impure function type
+   */
+  def adaptFunctionTypeUnderPureFuns(using Context): Type = tp match
+    case AppliedType(fn, args)
+    if Feature.pureFunsEnabledSomewhere && defn.isFunctionClass(fn.typeSymbol) =>
+      val fname = fn.typeSymbol.name
+      defn.FunctionType(
+        fname.functionArity,
+        isContextual = fname.isContextFunction,
+        isErased = fname.isErasedFunction,
+        isImpure = true).appliedTo(args)
+    case _ =>
+      tp
+
+  /** Under pureFunctions, add a @retainsByName(*)` annotation to the argument of
+   *  a by name parameter type, turning the latter into an impure by name parameter type.
+   */
+  def adaptByNameArgUnderPureFuns(using Context): Type =
+    if Feature.pureFunsEnabledSomewhere then
+      AnnotatedType(tp,
+        CaptureAnnotation(CaptureSet.universal, boxed = false)(defn.RetainsByNameAnnot))
+    else
+      tp
+
+  def isCapturingType(using Context): Boolean =
+    tp match
+      case CapturingType(_, _) => true
+      case _ => false
+
+  /** Is type known to be always pure by its class structure,
+   *  so that adding a capture set to it would not make sense?
+   */
+  def isAlwaysPure(using Context): Boolean = tp.dealias match
+    case tp: (TypeRef | AppliedType) =>
+      val sym = tp.typeSymbol
+      if sym.isClass then sym.isPureClass
+      else tp.superType.isAlwaysPure
+    case CapturingType(parent, refs) =>
+      parent.isAlwaysPure || refs.isAlwaysEmpty
+    case tp: TypeProxy =>
+      tp.superType.isAlwaysPure
+    case tp: AndType =>
+      tp.tp1.isAlwaysPure || tp.tp2.isAlwaysPure
+    case tp: OrType =>
+      tp.tp1.isAlwaysPure && tp.tp2.isAlwaysPure
+    case _ =>
+      false
+
+extension (sym: Symbol)
+
+  /** A class is pure if:
+   *   - one its base types has an explicitly declared self type with an empty capture set
+   *   - or it is a value class
+   *   - or it is Nothing or Null
+   */
+  def isPureClass(using Context): Boolean = sym match
+    case cls: ClassSymbol =>
+      val AnyValClass = defn.AnyValClass
+      cls.baseClasses.exists(bc =>
+        bc == AnyValClass
+        || {
+          val selfType = bc.givenSelfType
+          selfType.exists && selfType.captureSet.isAlwaysEmpty
+        })
+      || cls == defn.NothingClass
+      || cls == defn.NullClass
+    case _ =>
+      false
+
+  /** Does this symbol allow results carrying the universal capability?
+   *  Currently this is true only for function type applies (since their
+   *  results are unboxed) and `erasedValue` since this function is magic in
+   *  that is allows to conjure global capabilies from nothing (aside: can we find a
+   *  more controlled way to achieve this?).
+   *  But it could be generalized to other functions that so that they can take capability
+   *  classes as arguments.
+   */
+  def allowsRootCapture(using Context): Boolean =
+    sym == defn.Compiletime_erasedValue
+    || defn.isFunctionClass(sym.maybeOwner)
+
+  /** When applying `sym`, would the result type be unboxed?
+   *  This is the case if the result type contains a top-level reference to an enclosing
+   *  class or method type parameter and the method does not allow root capture.
+   *  If the type parameter is instantiated to a boxed type, that type would
+   *  have to be unboxed in the method's result.
+   */
+  def unboxesResult(using Context): Boolean =
+    def containsEnclTypeParam(tp: Type): Boolean = tp.strippedDealias match
+      case tp @ TypeRef(pre: ThisType, _) => tp.symbol.is(Param)
+      case tp: TypeParamRef => true
+      case tp: AndOrType => containsEnclTypeParam(tp.tp1) || containsEnclTypeParam(tp.tp2)
+      case tp: RefinedType => containsEnclTypeParam(tp.parent) || containsEnclTypeParam(tp.refinedInfo)
+      case _ => false
+    containsEnclTypeParam(sym.info.finalResultType)
+    && !sym.allowsRootCapture
+    && sym != defn.Caps_unsafeBox
+    && sym != defn.Caps_unsafeUnbox
+
+extension (tp: AnnotatedType)
+  /** Is this a boxed capturing type? */
+  def isBoxed(using Context): Boolean = tp.annot match
+    case ann: CaptureAnnotation => ann.boxed
+    case _ => false
+
+extension (ts: List[Type])
+  /** Equivalent to ts.mapconserve(_.boxedUnlessFun(tycon)) but more efficient where
+   *  it is the identity.
+   */
+  def boxedUnlessFun(tycon: Type)(using Context) =
+    if ctx.phase != Phases.checkCapturesPhase || defn.isFunctionClass(tycon.typeSymbol)
+    then ts
+    else ts.mapconserve(_.boxed)
+
diff --git a/tests/pos-with-compiler-cc/dotc/cc/CaptureSet.scala b/tests/pos-with-compiler-cc/dotc/cc/CaptureSet.scala
new file mode 100644
index 000000000000..48ff614f2910
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/cc/CaptureSet.scala
@@ -0,0 +1,906 @@
+package dotty.tools
+package dotc
+package cc
+
+import core.*
+import Types.*, Symbols.*, Flags.*, Contexts.*, Decorators.*
+import config.Printers.capt
+import Annotations.Annotation
+import annotation.threadUnsafe
+import annotation.constructorOnly
+import annotation.internal.sharable
+import reporting.trace
+import printing.{Showable, Printer}
+import printing.Texts.*
+import util.{SimpleIdentitySet, Property}
+import util.common.alwaysTrue
+import scala.collection.mutable
+import config.Config.ccAllowUnsoundMaps
+import language.experimental.pureFunctions
+
+/** A class for capture sets. Capture sets can be constants or variables.
+ *  Capture sets support inclusion constraints <:< where <:< is subcapturing.
+ *
+ *  They also allow
+ *   - mapping with functions from elements to capture sets
+ *   - filtering with predicates on elements
+ *   - intersecting wo capture sets
+ *
+ *  That is, constraints can be of the forms
+ *
+ *    cs1 <:< cs2
+ *    cs1 = ∪ {f(x) | x ∈ cs2}     where f is a function from capture references to capture sets.
+ *    cs1 = ∪ {x | x ∈ cs2, p(x)}  where p is a predicate on capture references
+ *    cs1 = cs2 ∩ cs2
+ *
+ *  We call the resulting constraint system "monadic set constraints".
+ *  To support capture propagation across maps, mappings are supported only
+ *  if the mapped function is either a bijection or if it is idempotent
+ *  on capture references (c.f. doc comment on `map` below).
+ */
+sealed abstract class CaptureSet extends Showable, caps.Pure:
+  import CaptureSet.*
+
+  /** The elements of this capture set. For capture variables,
+   *  the elements known so far.
+   */
+  def elems: Refs
+
+  /** Is this capture set constant (i.e. not an unsolved capture variable)?
+   *  Solved capture variables count as constant.
+   */
+  def isConst: Boolean
+
+  /** Is this capture set always empty? For unsolved capture veriables, returns
+   *  always false.
+   */
+  def isAlwaysEmpty: Boolean
+
+  /** Is this capture set definitely non-empty? */
+  final def isNotEmpty: Boolean = !elems.isEmpty
+
+  /** Convert to Const. @pre: isConst */
+  def asConst: Const = this match
+    case c: Const => c
+    case v: Var =>
+      assert(v.isConst)
+      Const(v.elems)
+
+  /** Cast to variable. @pre: !isConst */
+  def asVar: Var =
+    assert(!isConst)
+    asInstanceOf[Var]
+
+  /** Does this capture set contain the root reference `*` as element? */
+  final def isUniversal(using Context) =
+    elems.exists {
+      case ref: TermRef => ref.symbol == defn.captureRoot
+      case _ => false
+    }
+
+  /** Add new elements to this capture set if allowed.
+   *  @pre `newElems` is not empty and does not overlap with `this.elems`.
+   *  Constant capture sets never allow to add new elements.
+   *  Variables allow it if and only if the new elements can be included
+   *  in all their dependent sets.
+   *  @param origin   The set where the elements come from, or `empty` if not known.
+   *  @return CompareResult.OK if elements were added, or a conflicting
+   *          capture set that prevents addition otherwise.
+   */
+  protected def addNewElems(newElems: Refs, origin: CaptureSet)(using Context, VarState): CompareResult
+
+  /** If this is a variable, add `cs` as a dependent set */
+  protected def addDependent(cs: CaptureSet)(using Context, VarState): CompareResult
+
+  /** If `cs` is a variable, add this capture set as one of its dependent sets */
+  protected def addAsDependentTo(cs: CaptureSet)(using Context): this.type =
+    cs.addDependent(this)(using ctx, UnrecordedState)
+    this
+
+  /** Try to include all references of `elems` that are not yet accounted for by this
+   *  capture set. Inclusion is via `addNewElems`.
+   *  @param origin   The set where the elements come from, or `empty` if not known.
+   *  @return  CompareResult.OK if all unaccounted elements could be added,
+   *           capture set that prevents addition otherwise.
+   */
+  protected final def tryInclude(elems: Refs, origin: CaptureSet)(using Context, VarState): CompareResult =
+    val unaccounted = elems.filter(!accountsFor(_))
+    if unaccounted.isEmpty then CompareResult.OK
+    else addNewElems(unaccounted, origin)
+
+  /** Equivalent to `tryInclude({elem}, origin)`, but more efficient */
+  protected final def tryInclude(elem: CaptureRef, origin: CaptureSet)(using Context, VarState): CompareResult =
+    if accountsFor(elem) then CompareResult.OK
+    else addNewElems(elem.singletonCaptureSet.elems, origin)
+
+  /* x subsumes y if x is the same as y, or x is a this reference and y refers to a field of x */
+  extension (x: CaptureRef) private def subsumes(y: CaptureRef) =
+    (x eq y)
+    || y.match
+        case y: TermRef => y.prefix eq x
+        case _ => false
+
+  /** {x} <:< this   where <:< is subcapturing, but treating all variables
+   *                 as frozen.
+   */
+  def accountsFor(x: CaptureRef)(using Context): Boolean =
+    reporting.trace(i"$this accountsFor $x, ${x.captureSetOfInfo}?", show = true) {
+      elems.exists(_.subsumes(x))
+      || !x.isRootCapability && x.captureSetOfInfo.subCaptures(this, frozen = true).isOK
+    }
+
+  /** A more optimistic version of accountsFor, which does not take variable supersets
+   *  of the `x` reference into account. A set might account for `x` if it accounts
+   *  for `x` in a state where we assume all supersets of `x` have just the elements
+   *  known at this point. On the other hand if x's capture set has no known elements,
+   *  a set `cs` might account for `x` only if it subsumes `x` or it contains the
+   *  root capability `*`.
+   */
+  def mightAccountFor(x: CaptureRef)(using Context): Boolean =
+    reporting.trace(i"$this mightAccountFor $x, ${x.captureSetOfInfo}?", show = true) {
+      elems.exists(elem => elem.subsumes(x) || elem.isRootCapability)
+      || !x.isRootCapability
+        && {
+          val elems = x.captureSetOfInfo.elems
+          !elems.isEmpty && elems.forall(mightAccountFor)
+        }
+    }
+
+  /** A more optimistic version of subCaptures used to choose one of two typing rules
+   *  for selections and applications. `cs1 mightSubcapture cs2` if `cs2` might account for
+   *  every element currently known to be in `cs1`.
+   */
+  def mightSubcapture(that: CaptureSet)(using Context): Boolean =
+    elems.forall(that.mightAccountFor)
+
+  /** The subcapturing test.
+   *  @param frozen   if true, no new variables or dependent sets are allowed to
+   *                  be added when making this test. An attempt to add either
+   *                  will result in failure.
+   */
+  final def subCaptures(that: CaptureSet, frozen: Boolean)(using Context): CompareResult =
+    subCaptures(that)(using ctx, if frozen then FrozenState else VarState())
+
+  /** The subcapturing test, using a given VarState */
+  private def subCaptures(that: CaptureSet)(using Context, VarState): CompareResult =
+    def recur(elems: List[CaptureRef]): CompareResult = elems match
+      case elem :: elems1 =>
+        var result = that.tryInclude(elem, this)
+        if !result.isOK && !elem.isRootCapability && summon[VarState] != FrozenState then
+          result = elem.captureSetOfInfo.subCaptures(that)
+        if result.isOK then
+          recur(elems1)
+        else
+          varState.rollBack()
+          result
+      case Nil =>
+        addDependent(that)
+    recur(elems.toList)
+      .showing(i"subcaptures $this <:< $that = ${result.show}", capt)
+
+  /** Two capture sets are considered =:= equal if they mutually subcapture each other
+   *  in a frozen state.
+   */
+  def =:= (that: CaptureSet)(using Context): Boolean =
+       this.subCaptures(that, frozen = true).isOK
+    && that.subCaptures(this, frozen = true).isOK
+
+  /** The smallest capture set (via <:<) that is a superset of both
+   *  `this` and `that`
+   */
+  def ++ (that: CaptureSet)(using Context): CaptureSet =
+    if this.subCaptures(that, frozen = true).isOK then that
+    else if that.subCaptures(this, frozen = true).isOK then this
+    else if this.isConst && that.isConst then Const(this.elems ++ that.elems)
+    else Var(this.elems ++ that.elems).addAsDependentTo(this).addAsDependentTo(that)
+
+  /** The smallest superset (via <:<) of this capture set that also contains `ref`.
+   */
+  def + (ref: CaptureRef)(using Context): CaptureSet =
+    this ++ ref.singletonCaptureSet
+
+  /** The largest capture set (via <:<) that is a subset of both `this` and `that`
+   */
+  def **(that: CaptureSet)(using Context): CaptureSet =
+    if this.subCaptures(that, frozen = true).isOK then this
+    else if that.subCaptures(this, frozen = true).isOK then that
+    else if this.isConst && that.isConst then Const(elemIntersection(this, that))
+    else Intersected(this, that)
+
+  /** The largest subset (via <:<) of this capture set that does not account for
+   *  any of the elements in the constant capture set `that`
+   */
+  def -- (that: CaptureSet.Const)(using Context): CaptureSet =
+    val elems1 = elems.filter(!that.accountsFor(_))
+    if elems1.size == elems.size then this
+    else if this.isConst then Const(elems1)
+    else Diff(asVar, that)
+
+  /** The largest subset (via <:<) of this capture set that does not account for `ref` */
+  def - (ref: CaptureRef)(using Context): CaptureSet =
+    this -- ref.singletonCaptureSet
+
+  /** The largest subset (via <:<) of this capture set that only contains elements
+   *  for which `p` is true.
+   */
+  def filter(p: CaptureRef -> Boolean)(using Context): CaptureSet =
+    if this.isConst then
+      val elems1 = elems.filter(p)
+      if elems1 == elems then this
+      else Const(elems.filter(p))
+    else Filtered(asVar, p)
+
+  /** Capture set obtained by applying `tm` to all elements of the current capture set
+   *  and joining the results. If the current capture set is a variable, the same
+   *  transformation is applied to all future additions of new elements.
+   *
+   *  Note: We have a problem how we handle the situation where we have a mapped set
+   *
+   *    cs2 = tm(cs1)
+   *
+   *  and then the propagation solver adds a new element `x` to `cs2`. What do we
+   *  know in this case about `cs1`? We can answer this question in a sound way only
+   *  if `tm` is a bijection on capture references or it is idempotent on capture references.
+   *  (see definition in IdempotentCapRefMap).
+   *  If `tm` is a bijection we know that `tm^-1(x)` must be in `cs1`. If `tm` is idempotent
+   *  one possible solution is that `x` is in `cs1`, which is what we assume in this case.
+   *  That strategy is sound but not complete.
+   *
+   *  If `tm` is some other map, we don't know how to handle this case. For now,
+   *  we simply refuse to handle other maps. If they do need to be handled,
+   *  `OtherMapped` provides some approximation to a solution, but it is neither
+   *  sound nor complete.
+   */
+  def map(tm: TypeMap)(using Context): CaptureSet = tm match
+    case tm: BiTypeMap =>
+      val mappedElems = elems.map(tm.forward)
+      if isConst then
+        if mappedElems == elems then this
+        else Const(mappedElems)
+      else BiMapped(asVar, tm, mappedElems)
+    case tm: IdentityCaptRefMap =>
+      this
+    case _ =>
+      val mapped = mapRefs(elems, tm, tm.variance)
+      if isConst then
+        if mapped.isConst && mapped.elems == elems then this
+        else mapped
+      else Mapped(asVar, tm, tm.variance, mapped)
+
+  /** A mapping resulting from substituting parameters of a BindingType to a list of types */
+  def substParams(tl: BindingType, to: List[Type])(using Context) =
+    map(Substituters.SubstParamsMap(tl, to))
+
+  /** Invoke handler if this set has (or later aquires) the root capability `*` */
+  def disallowRootCapability(handler: () => Context ?=> Unit)(using Context): this.type =
+    if isUniversal then handler()
+    this
+
+  /** An upper approximation of this capture set, i.e. a constant set that is
+   *  subcaptured by this set. If the current set is a variable
+   *  it is the intersection of all upper approximations of known supersets
+   *  of the variable.
+   *  The upper approximation is meaningful only if it is constant. If not,
+   *  `upperApprox` can return an arbitrary capture set variable.
+   *  `upperApprox` is used in `solve`.
+   */
+  protected def upperApprox(origin: CaptureSet)(using Context): CaptureSet
+
+  /** Assuming set this set dependds on was just solved to be constant, propagate this info
+   *  to this set. This might result in the set being solved to be constant
+   *  itself.
+   */
+  protected def propagateSolved()(using Context): Unit = ()
+
+  /** This capture set with a description that tells where it comes from */
+  def withDescription(description: String): CaptureSet
+
+  /** The provided description (using `withDescription`) for this capture set or else "" */
+  def description: String
+
+  /** A regular @retains or @retainsByName annotation with the elements of this set as arguments. */
+  def toRegularAnnotation(cls: Symbol)(using Context): Annotation =
+    Annotation(CaptureAnnotation(this, boxed = false)(cls).tree)
+
+  override def toText(printer: Printer): Text =
+    Str("{") ~ Text(elems.toList.map(printer.toTextCaptureRef), ", ") ~ Str("}") ~~ description
+
+object CaptureSet:
+  type Refs = SimpleIdentitySet[CaptureRef]
+  type Vars = SimpleIdentitySet[Var]
+  type Deps = SimpleIdentitySet[CaptureSet]
+
+  @sharable private var varId = 0
+
+  /** If set to `true`, capture stack traces that tell us where sets are created */
+  private final val debugSets = false
+
+  private val emptySet = SimpleIdentitySet.empty
+
+  /** The empty capture set `{}` */
+  val empty: CaptureSet.Const = Const(emptySet)
+
+  /** The universal capture set `{*}` */
+  def universal(using Context): CaptureSet =
+    defn.captureRoot.termRef.singletonCaptureSet
+
+  /** Used as a recursion brake */
+  @sharable private[dotc] val Pending = Const(SimpleIdentitySet.empty)
+
+  /** The empty capture set with a description that says it's the elf type of an
+   *  exception class.
+   */
+  val emptyOfException: CaptureSet.Const = Const(emptySet, "of an exception class")
+
+  def apply(elems: CaptureRef*)(using Context): CaptureSet.Const =
+    if elems.isEmpty then empty
+    else Const(SimpleIdentitySet(elems.map(_.normalizedRef)*))
+
+  def apply(elems: Refs)(using Context): CaptureSet.Const =
+    if elems.isEmpty then empty else Const(elems)
+
+  /** The subclass of constant capture sets with given elements `elems` */
+  class Const private[CaptureSet] (val elems: Refs, val description: String = "") extends CaptureSet:
+    def isConst = true
+    def isAlwaysEmpty = elems.isEmpty
+
+    def addNewElems(elems: Refs, origin: CaptureSet)(using Context, VarState): CompareResult =
+      CompareResult.fail(this)
+
+    def addDependent(cs: CaptureSet)(using Context, VarState) = CompareResult.OK
+
+    def upperApprox(origin: CaptureSet)(using Context): CaptureSet = this
+
+    def withDescription(description: String): Const = Const(elems, description)
+
+    override def toString = elems.toString
+  end Const
+
+  /** The subclass of captureset variables with given initial elements */
+  class Var(initialElems: Refs = emptySet) extends CaptureSet:
+
+    /** A unique identification number for diagnostics */
+    val id =
+      varId += 1
+      varId
+
+    /** A variable is solved if it is aproximated to a from-then-on constant set. */
+    private var isSolved: Boolean = false
+
+    /** The elements currently known to be in the set */
+    var elems: Refs = initialElems
+
+    /** The sets currently known to be dependent sets (i.e. new additions to this set
+     *  are propagated to these dependent sets.)
+     */
+    var deps: Deps = emptySet
+
+    def isConst = isSolved
+    def isAlwaysEmpty = false
+
+    /** A handler to be invoked if the root reference `*` is added to this set
+     *  The handler is pure in the sense that it will only output diagnostics.
+     */
+    var rootAddedHandler: () -> Context ?-> Unit = () => ()
+
+    var description: String = ""
+
+    /** Record current elements in given VarState provided it does not yet
+     *  contain an entry for this variable.
+     */
+    private def recordElemsState()(using VarState): Boolean =
+      varState.getElems(this) match
+        case None => varState.putElems(this, elems)
+        case _ => true
+
+    /** Record current dependent sets in given VarState provided it does not yet
+     *  contain an entry for this variable.
+     */
+    private[CaptureSet] def recordDepsState()(using VarState): Boolean =
+      varState.getDeps(this) match
+        case None => varState.putDeps(this, deps)
+        case _ => true
+
+    /** Reset elements to what was recorded in `state` */
+    def resetElems()(using state: VarState): Unit =
+      elems = state.elems(this)
+
+    /** Reset dependent sets to what was recorded in `state` */
+    def resetDeps()(using state: VarState): Unit =
+      deps = state.deps(this)
+
+    def addNewElems(newElems: Refs, origin: CaptureSet)(using Context, VarState): CompareResult =
+      if !isConst && recordElemsState() then
+        elems ++= newElems
+        if isUniversal then rootAddedHandler()
+        // assert(id != 2 || elems.size != 2, this)
+        (CompareResult.OK /: deps) { (r, dep) =>
+          r.andAlso(dep.tryInclude(newElems, this))
+        }
+      else // fail if variable is solved or given VarState is frozen
+        CompareResult.fail(this)
+
+    def addDependent(cs: CaptureSet)(using Context, VarState): CompareResult =
+      if (cs eq this) || cs.isUniversal || isConst then
+        CompareResult.OK
+      else if recordDepsState() then
+        deps += cs
+        CompareResult.OK
+      else
+        CompareResult.fail(this)
+
+    override def disallowRootCapability(handler: () -> Context ?-> Unit)(using Context): this.type =
+      rootAddedHandler = handler
+      super.disallowRootCapability(handler)
+
+    private var computingApprox = false
+
+    /** Roughly: the intersection of all constant known supersets of this set.
+     *  The aim is to find an as-good-as-possible constant set that is a superset
+     *  of this set. The universal set {*} is a sound fallback.
+     */
+    final def upperApprox(origin: CaptureSet)(using Context): CaptureSet =
+      if computingApprox then universal
+      else if isConst then this
+      else
+        computingApprox = true
+        try computeApprox(origin).ensuring(_.isConst)
+        finally computingApprox = false
+
+    /** The intersection of all upper approximations of dependent sets */
+    protected def computeApprox(origin: CaptureSet)(using Context): CaptureSet =
+      (universal /: deps) { (acc, sup) => acc ** sup.upperApprox(this) }
+
+    /** Widen the variable's elements to its upper approximation and
+     *  mark it as constant from now on. This is used for contra-variant type variables
+     *  in the results of defs and vals.
+     */
+    def solve()(using Context): Unit =
+      if !isConst then
+        val approx = upperApprox(empty)
+        //println(i"solving var $this $approx ${approx.isConst} deps = ${deps.toList}")
+        val newElems = approx.elems -- elems
+        if newElems.isEmpty || addNewElems(newElems, empty)(using ctx, VarState()).isOK then
+          markSolved()
+
+    /** Mark set as solved and propagate this info to all dependent sets */
+    def markSolved()(using Context): Unit =
+      isSolved = true
+      deps.foreach(_.propagateSolved())
+
+    def withDescription(description: String): this.type =
+      this.description =
+        if this.description.isEmpty then description
+        else s"${this.description} and $description"
+      this
+
+    /** Used for diagnostics and debugging: A string that traces the creation
+     *  history of a variable by following source links. Each variable on the
+     *  path is characterized by the variable's id and the first letter of the
+     *  variable's class name. The path ends in a plain variable with letter `V` that
+     *  is not derived from some other variable.
+     */
+    protected def ids(using Context): String =
+      val trail = this.match
+        case dv: DerivedVar => dv.source.ids
+        case _ => ""
+      s"$id${getClass.getSimpleName.nn.take(1)}$trail"
+
+    /** Adds variables to the ShownVars context property if that exists, which
+     *  establishes a record of all variables printed in an error message.
+     *  Prints variables wih ids under -Ycc-debug.
+     */
+    override def toText(printer: Printer): Text = inContext(printer.printerContext) {
+      for vars <- ctx.property(ShownVars) do vars += this
+      super.toText(printer) ~ (Str(ids) provided !isConst && ctx.settings.YccDebug.value)
+    }
+
+    override def toString = s"Var$id$elems"
+  end Var
+
+  /** A variable that is derived from some other variable via a map or filter. */
+  abstract class DerivedVar(initialElems: Refs)(using @constructorOnly ctx: Context)
+  extends Var(initialElems):
+
+    // For debugging: A trace where a set was created. Note that logically it would make more
+    // sense to place this variable in Mapped, but that runs afoul of the initializatuon checker.
+    val stack = if debugSets && this.isInstanceOf[Mapped] then (new Throwable).getStackTrace().nn.take(20) else null
+
+    /** The variable from which this variable is derived */
+    def source: Var
+
+    addAsDependentTo(source)
+
+    override def propagateSolved()(using Context) =
+      if source.isConst && !isConst then markSolved()
+  end DerivedVar
+
+  /** A variable that changes when `source` changes, where all additional new elements are mapped
+   *  using   ∪ { tm(x) | x <- source.elems }.
+   *  @param source   the original set that is mapped
+   *  @param tm       the type map, which is assumed to be idempotent on capture refs
+   *                  (except if ccUnsoundMaps is enabled)
+   *  @param variance the assumed variance with which types with capturesets of size >= 2 are approximated
+   *                  (i.e. co: full capture set, contra: empty set, nonvariant is not allowed.)
+   *  @param initial  The initial mappings of source's elements at the point the Mapped set is created.
+   */
+  class Mapped private[CaptureSet]
+    (val source: Var, tm: TypeMap, variance: Int, initial: CaptureSet)(using @constructorOnly ctx: Context)
+  extends DerivedVar(initial.elems):
+    addAsDependentTo(initial)  // initial mappings could change by propagation
+
+    private def mapIsIdempotent = tm.isInstanceOf[IdempotentCaptRefMap]
+
+    assert(ccAllowUnsoundMaps || mapIsIdempotent, tm.getClass)
+
+    private def whereCreated(using Context): String =
+      if stack == null then ""
+      else i"""
+              |Stack trace of variable creation:"
+              |${stack.mkString("\n")}"""
+
+    override def addNewElems(newElems: Refs, origin: CaptureSet)(using Context, VarState): CompareResult =
+      val added =
+        if origin eq source then // elements have to be mapped
+          mapRefs(newElems, tm, variance)
+        else
+          // elements are added by subcapturing propagation with this Mapped set
+          // as superset; no mapping is necessary or allowed.
+          Const(newElems)
+      super.addNewElems(added.elems, origin)
+        .andAlso {
+          if added.isConst then CompareResult.OK
+          else if added.asVar.recordDepsState() then { addAsDependentTo(added); CompareResult.OK }
+          else CompareResult.fail(this)
+        }
+        .andAlso {
+          if (origin ne source) && mapIsIdempotent then
+            // `tm` is idempotent, propagate back elems from image set.
+            // This is sound, since we know that for `r in newElems: tm(r) = r`, hence
+            // `r` is _one_ possible solution in `source` that would make an `r` appear in this set.
+            // It's not necessarily the only possible solution, so the scheme is incomplete.
+            source.tryInclude(newElems, this)
+          else if !mapIsIdempotent && variance <= 0 && !origin.isConst && (origin ne initial) && (origin ne source) then
+            // The map is neither a BiTypeMap nor an idempotent type map.
+            // In that case there's no much we can do.
+            // The scheme then does not propagate added elements back to source and rejects adding
+            // elements from variable sources in contra- and non-variant positions. In essence,
+            // we approximate types resulting from such maps by returning a possible super type
+            // from the actual type. But this is neither sound nor complete.
+            report.warning(i"trying to add elems ${CaptureSet(newElems)} from unrecognized source $origin of mapped set $this$whereCreated")
+            CompareResult.fail(this)
+          else
+            CompareResult.OK
+        }
+
+    override def computeApprox(origin: CaptureSet)(using Context): CaptureSet =
+      if source eq origin then
+        // it's a mapping of origin, so not a superset of `origin`,
+        // therefore don't contribute to the intersection.
+        universal
+      else
+        source.upperApprox(this).map(tm)
+
+    override def propagateSolved()(using Context) =
+      if initial.isConst then super.propagateSolved()
+
+    override def toString = s"Mapped$id($source, elems = $elems)"
+  end Mapped
+
+  /** A mapping where the type map is required to be a bijection.
+   *  Parameters as in Mapped.
+   */
+  final class BiMapped private[CaptureSet]
+    (val source: Var, bimap: BiTypeMap, initialElems: Refs)(using @constructorOnly ctx: Context)
+  extends DerivedVar(initialElems):
+
+    override def addNewElems(newElems: Refs, origin: CaptureSet)(using Context, VarState): CompareResult =
+      if origin eq source then
+        super.addNewElems(newElems.map(bimap.forward), origin)
+      else
+        super.addNewElems(newElems, origin)
+          .andAlso {
+            source.tryInclude(newElems.map(bimap.backward), this)
+              .showing(i"propagating new elems ${CaptureSet(newElems)} backward from $this to $source", capt)
+          }
+
+    /** For a BiTypeMap, supertypes of the mapped type also constrain
+     *  the source via the inverse type mapping and vice versa. That is, if
+     *   B = f(A) and B <: C, then A <: f^-1(C), so C should flow into
+     *  the upper approximation of A.
+     *  Conversely if A <: C2, then we also know that B <: f(C2).
+     *  These situations are modeled by the two branches of the conditional below.
+     */
+    override def computeApprox(origin: CaptureSet)(using Context): CaptureSet =
+      val supApprox = super.computeApprox(this)
+      if source eq origin then supApprox.map(bimap.inverseTypeMap)
+      else source.upperApprox(this).map(bimap) ** supApprox
+
+    override def toString = s"BiMapped$id($source, elems = $elems)"
+  end BiMapped
+
+  /** A variable with elements given at any time as { x <- source.elems | p(x) } */
+  class Filtered private[CaptureSet]
+    (val source: Var, p: CaptureRef -> Boolean)(using @constructorOnly ctx: Context)
+  extends DerivedVar(source.elems.filter(p)):
+
+    override def addNewElems(newElems: Refs, origin: CaptureSet)(using Context, VarState): CompareResult =
+      val filtered = newElems.filter(p)
+      if origin eq source then
+        super.addNewElems(filtered, origin)
+      else
+        // Filtered elements have to be back-propagated to source.
+        // Elements that don't satisfy `p` are not allowed.
+        super.addNewElems(newElems, origin)
+          .andAlso {
+            if filtered.size == newElems.size then source.tryInclude(newElems, this)
+            else CompareResult.fail(this)
+          }
+
+    override def computeApprox(origin: CaptureSet)(using Context): CaptureSet =
+      if source eq origin then
+        // it's a filter of origin, so not a superset of `origin`,
+        // therefore don't contribute to the intersection.
+        universal
+      else
+        source.upperApprox(this).filter(p)
+
+    override def toString = s"${getClass.getSimpleName}$id($source, elems = $elems)"
+  end Filtered
+
+  /** A variable with elements given at any time as { x <- source.elems | !other.accountsFor(x) } */
+  class Diff(source: Var, other: Const)(using Context)
+  extends Filtered(source, !other.accountsFor(_))
+
+  class Intersected(cs1: CaptureSet, cs2: CaptureSet)(using Context)
+  extends Var(elemIntersection(cs1, cs2)):
+    addAsDependentTo(cs1)
+    addAsDependentTo(cs2)
+    deps += cs1
+    deps += cs2
+
+    override def addNewElems(newElems: Refs, origin: CaptureSet)(using Context, VarState): CompareResult =
+      val added =
+        if origin eq cs1 then newElems.filter(cs2.accountsFor)
+        else if origin eq cs2 then newElems.filter(cs1.accountsFor)
+        else newElems
+          // If origin is not cs1 or cs2, then newElems will be propagated to
+          // cs1, cs2 since they are in deps.
+      super.addNewElems(added, origin)
+
+    override def computeApprox(origin: CaptureSet)(using Context): CaptureSet =
+      if (origin eq cs1) || (origin eq cs2) then
+        // it's a combination of origin with some other set, so not a superset of `origin`,
+        // therefore don't contribute to the intersection.
+        universal
+      else
+        CaptureSet(elemIntersection(cs1.upperApprox(this), cs2.upperApprox(this)))
+
+    override def propagateSolved()(using Context) =
+      if cs1.isConst && cs2.isConst && !isConst then markSolved()
+  end Intersected
+
+  def elemIntersection(cs1: CaptureSet, cs2: CaptureSet)(using Context): Refs =
+    cs1.elems.filter(cs2.mightAccountFor) ++ cs2.elems.filter(cs1.mightAccountFor)
+
+  /** Extrapolate tm(r) according to `variance`. Let r1 be the result of tm(r).
+   *    - If r1 is a tracked CaptureRef, return {r1}
+   *    - If r1 has an empty capture set, return {}
+   *    - Otherwise,
+   *        - if the variance is covariant, return r1's capture set
+   *        - if the variance is contravariant, return {}
+   *        - Otherwise assertion failure
+   */
+  def extrapolateCaptureRef(r: CaptureRef, tm: TypeMap, variance: Int)(using Context): CaptureSet =
+    val r1 = tm(r)
+    val upper = r1.captureSet
+    def isExact =
+      upper.isAlwaysEmpty || upper.isConst && upper.elems.size == 1 && upper.elems.contains(r1)
+    if variance > 0 || isExact then upper
+    else if variance < 0 then CaptureSet.empty
+    else assert(false, i"trying to add $upper from $r via ${tm.getClass} in a non-variant setting")
+
+  /** Apply `f` to each element in `xs`, and join result sets with `++` */
+  def mapRefs(xs: Refs, f: CaptureRef => CaptureSet)(using Context): CaptureSet =
+    ((empty: CaptureSet) /: xs)((cs, x) => cs ++ f(x))
+
+  /** Apply extrapolated `tm` to each element in `xs`, and join result sets with `++` */
+  def mapRefs(xs: Refs, tm: TypeMap, variance: Int)(using Context): CaptureSet =
+    mapRefs(xs, extrapolateCaptureRef(_, tm, variance))
+
+  /** Return true iff
+   *   - arg1 is a TypeBounds >: CL T <: CH T of two capturing types with equal parents.
+   *   - arg2 is a capturing type CA U
+   *   - CH <: CA <: CL
+   *  In other words, we can unify CL, CH and CA.
+   */
+  def subCapturesRange(arg1: TypeBounds, arg2: Type)(using Context): Boolean = arg1 match
+    case TypeBounds(CapturingType(lo, loRefs), CapturingType(hi, hiRefs)) if lo =:= hi =>
+      given VarState = VarState()
+      val cs2 = arg2.captureSet
+      hiRefs.subCaptures(cs2).isOK && cs2.subCaptures(loRefs).isOK
+    case _ =>
+      false
+
+  /** A TypeMap with the property that every capture reference in the image
+   *  of the map is mapped to itself. I.e. for all capture references r1, r2,
+   *  if M(r1) == r2 then M(r2) == r2.
+   */
+  trait IdempotentCaptRefMap extends TypeMap
+
+  /** A TypeMap that is the identity on capture references */
+  trait IdentityCaptRefMap extends TypeMap
+
+  type CompareResult = CompareResult.TYPE
+
+  /** The result of subcapturing comparisons is an opaque type CompareResult.TYPE.
+   *  This is either OK, indicating success, or
+   *  another capture set, indicating failure. The failure capture set
+   *  is the one that did not allow propagaton of elements into it.
+   */
+  object CompareResult:
+    opaque type TYPE = CaptureSet
+    val OK: TYPE = Const(emptySet)
+    def fail(cs: CaptureSet): TYPE = cs
+
+    extension (result: TYPE)
+      /** The result is OK */
+      def isOK: Boolean = result eq OK
+      /** If not isOK, the blocking capture set */
+      def blocking: CaptureSet = result
+      inline def andAlso(op: Context ?=> TYPE)(using Context): TYPE = if result.isOK then op else result
+      def show(using Context): String = if result.isOK then "OK" else i"$result"
+  end CompareResult
+
+  /** A VarState serves as a snapshot mechanism that can undo
+   *  additions of elements or super sets if an operation fails
+   */
+  class VarState:
+
+    /** A map from captureset variables to their elements at the time of the snapshot. */
+    private val elemsMap: util.EqHashMap[Var, Refs] = new util.EqHashMap
+
+    /** A map from captureset variables to their dependent sets at the time of the snapshot. */
+    private val depsMap: util.EqHashMap[Var, Deps] = new util.EqHashMap
+
+    /** The recorded elements of `v` (it's required that a recording was made) */
+    def elems(v: Var): Refs = elemsMap(v)
+
+    /** Optionally the recorded elements of `v`, None if nothing was recorded for `v` */
+    def getElems(v: Var): Option[Refs] = elemsMap.get(v)
+
+    /** Record elements, return whether this was allowed.
+     *  By default, recording is allowed but the special state FrozenState
+     *  overrides this.
+     */
+    def putElems(v: Var, elems: Refs): Boolean = { elemsMap(v) = elems; true }
+
+    /** The recorded dependent sets of `v` (it's required that a recording was made) */
+    def deps(v: Var): Deps = depsMap(v)
+
+    /** Optionally the recorded dependent sets of `v`, None if nothing was recorded for `v` */
+    def getDeps(v: Var): Option[Deps] = depsMap.get(v)
+
+    /** Record dependent sets, return whether this was allowed.
+     *  By default, recording is allowed but the special state FrozenState
+     *  overrides this.
+     */
+    def putDeps(v: Var, deps: Deps): Boolean = { depsMap(v) = deps; true }
+
+    /** Roll back global state to what was recorded in this VarState */
+    def rollBack(): Unit =
+      elemsMap.keysIterator.foreach(_.resetElems()(using this))
+      depsMap.keysIterator.foreach(_.resetDeps()(using this))
+  end VarState
+
+  /** A special state that does not allow to record elements or dependent sets.
+   *  In effect this means that no new elements or dependent sets can be added
+   *  in this state (since the previous state cannot be recorded in a snapshot)
+   */
+  @sharable
+  object FrozenState extends VarState:
+    override def putElems(v: Var, refs: Refs) = false
+    override def putDeps(v: Var, deps: Deps) = false
+    override def rollBack(): Unit = ()
+
+  @sharable
+  /** A special state that turns off recording of elements. Used only
+   *  in `addSub` to prevent cycles in recordings.
+   */
+  private object UnrecordedState extends VarState:
+    override def putElems(v: Var, refs: Refs) = true
+    override def putDeps(v: Var, deps: Deps) = true
+    override def rollBack(): Unit = ()
+
+  /** The current VarState, as passed by the implicit context */
+  def varState(using state: VarState): VarState = state
+
+  /* Not needed:
+  def ofClass(cinfo: ClassInfo, argTypes: List[Type])(using Context): CaptureSet =
+    CaptureSet.empty
+      def captureSetOf(tp: Type): CaptureSet = tp match
+        case tp: TypeRef if tp.symbol.is(ParamAccessor) =>
+          def mapArg(accs: List[Symbol], tps: List[Type]): CaptureSet = accs match
+            case acc :: accs1 if tps.nonEmpty =>
+              if acc == tp.symbol then tps.head.captureSet
+              else mapArg(accs1, tps.tail)
+            case _ =>
+              empty
+          mapArg(cinfo.cls.paramAccessors, argTypes)
+        case _ =>
+          tp.captureSet
+      val css =
+        for
+          parent <- cinfo.parents if parent.classSymbol == defn.RetainingClass
+          arg <- parent.argInfos
+        yield captureSetOf(arg)
+      css.foldLeft(empty)(_ ++ _)
+  */
+
+  /** The capture set of the type underlying a CaptureRef */
+  def ofInfo(ref: CaptureRef)(using Context): CaptureSet = ref match
+    case ref: TermRef if ref.isRootCapability => ref.singletonCaptureSet
+    case _ => ofType(ref.underlying)
+
+  /** Capture set of a type */
+  def ofType(tp: Type)(using Context): CaptureSet =
+    def recur(tp: Type): CaptureSet = tp.dealias match
+      case tp: TermRef =>
+        tp.captureSet
+      case tp: TermParamRef =>
+        tp.captureSet
+      case _: TypeRef =>
+        if tp.classSymbol.hasAnnotation(defn.CapabilityAnnot) then universal else empty
+      case _: TypeParamRef =>
+        empty
+      case CapturingType(parent, refs) =>
+        recur(parent) ++ refs
+      case AppliedType(tycon, args) =>
+        val cs = recur(tycon)
+        tycon.typeParams match
+          case tparams @ (LambdaParam(tl, _) :: _) => cs.substParams(tl, args)
+          case _ => cs
+      case tp: TypeProxy =>
+        recur(tp.underlying)
+      case AndType(tp1, tp2) =>
+        recur(tp1) ** recur(tp2)
+      case OrType(tp1, tp2) =>
+        recur(tp1) ++ recur(tp2)
+      case _ =>
+        empty
+    recur(tp)
+      .showing(i"capture set of $tp = $result", capt)
+
+  private val ShownVars: Property.Key[mutable.Set[Var]] = Property.Key()
+
+  /** Perform `op`. Under -Ycc-debug, collect and print info about all variables reachable
+   *  via `(_.deps)*` from the variables that were shown in `op`.
+   */
+  def withCaptureSetsExplained[T](op: Context ?=> T)(using ctx: Context): T =
+    if ctx.settings.YccDebug.value then
+      val shownVars = mutable.Set[Var]()
+      inContext(ctx.withProperty(ShownVars, Some(shownVars))) {
+        try op
+        finally
+          val reachable = mutable.Set[Var]()
+          val todo = mutable.Queue[Var]() ++= shownVars
+          def incl(cv: Var): Unit =
+            if !reachable.contains(cv) then todo += cv
+          while todo.nonEmpty do
+            val cv = todo.dequeue()
+            if !reachable.contains(cv) then
+              reachable += cv
+              cv.deps.foreach {
+                case cv: Var => incl(cv)
+                case _ =>
+              }
+              cv match
+                case cv: DerivedVar => incl(cv.source)
+                case _ =>
+          val allVars = reachable.toArray.sortBy(_.id)
+          println(i"Capture set dependencies:")
+          for cv <- allVars do
+            println(i"  ${cv.show.padTo(20, ' ')} :: ${cv.deps.toList}%, %")
+      }
+    else op
+end CaptureSet
diff --git a/tests/pos-with-compiler-cc/dotc/cc/CapturingType.scala b/tests/pos-with-compiler-cc/dotc/cc/CapturingType.scala
new file mode 100644
index 000000000000..e9862f1f20b8
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/cc/CapturingType.scala
@@ -0,0 +1,72 @@
+package dotty.tools
+package dotc
+package cc
+
+import core.*
+import Types.*, Symbols.*, Contexts.*
+
+/** A (possibly boxed) capturing type. This is internally represented as an annotated type with a @retains
+ *  or @retainsByName annotation, but the extractor will succeed only at phase CheckCaptures.
+ *  That way, we can ignore caturing information until phase CheckCaptures since it is
+ *  wrapped in a plain annotation.
+ *
+ *  The same trick does not work for the boxing information. Boxing is context dependent, so
+ *  we have to add that information in the Setup step preceding CheckCaptures. Boxes are
+ *  added for all type arguments of methods. For type arguments of applied types a different
+ *  strategy is used where we box arguments of applied types that are not functions when
+ *  accessing the argument.
+ *
+ *  An alternative strategy would add boxes also to arguments of applied types during setup.
+ *  But this would have to be done for all possibly accessibly types from the compiled units
+ *  as well as their dependencies. It's difficult to do this in a DenotationTransformer without
+ *  accidentally forcing symbol infos. That's why this alternative was not implemented.
+ *  If we would go back on this it would make sense to also treat captuyring types different
+ *  from annotations and to generate them all during Setup and in DenotationTransformers.
+ */
+object CapturingType:
+
+  /** Smart constructor that drops empty capture sets and fuses compatible capturiong types.
+   *  An outer type capturing type A can be fused with an inner capturing type B if their
+   *  boxing status is the same or if A is boxed.
+   */
+  def apply(parent: Type, refs: CaptureSet, boxed: Boolean = false)(using Context): Type =
+    if refs.isAlwaysEmpty then parent
+    else parent match
+      case parent @ CapturingType(parent1, refs1) if boxed || !parent.isBoxed =>
+        apply(parent1, refs ++ refs1, boxed)
+      case _ =>
+        AnnotatedType(parent, CaptureAnnotation(refs, boxed)(defn.RetainsAnnot))
+
+  /** An extractor that succeeds only during CheckCapturingPhase. Boxing statis is
+   *  returned separately by CaptureOps.isBoxed.
+   */
+  def unapply(tp: AnnotatedType)(using Context): Option[(Type, CaptureSet)] =
+    if ctx.phase == Phases.checkCapturesPhase
+      && tp.annot.symbol == defn.RetainsAnnot
+      && !ctx.mode.is(Mode.IgnoreCaptures)
+    then
+      EventuallyCapturingType.unapply(tp)
+    else None
+
+end CapturingType
+
+/** An extractor for types that will be capturing types at phase CheckCaptures. Also
+ *  included are types that indicate captures on enclosing call-by-name parameters
+ *  before phase ElimByName.
+ */
+object EventuallyCapturingType:
+
+  def unapply(tp: AnnotatedType)(using Context): Option[(Type, CaptureSet)] =
+    val sym = tp.annot.symbol
+    if sym == defn.RetainsAnnot || sym == defn.RetainsByNameAnnot then
+      tp.annot match
+        case ann: CaptureAnnotation =>
+          Some((tp.parent, ann.refs))
+        case ann =>
+          try Some((tp.parent, ann.tree.toCaptureSet))
+          catch case ex: IllegalCaptureRef => None
+    else None
+
+end EventuallyCapturingType
+
+
diff --git a/tests/pos-with-compiler-cc/dotc/cc/CheckCaptures.scala b/tests/pos-with-compiler-cc/dotc/cc/CheckCaptures.scala
new file mode 100644
index 000000000000..97f8e1eea405
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/cc/CheckCaptures.scala
@@ -0,0 +1,949 @@
+package dotty.tools
+package dotc
+package cc
+
+import core.*
+import Phases.*, DenotTransformers.*, SymDenotations.*
+import Contexts.*, Names.*, Flags.*, Symbols.*, Decorators.*
+import Types.*, StdNames.*, Denotations.*
+import config.Printers.{capt, recheckr}
+import config.{Config, Feature}
+import ast.{tpd, untpd, Trees}
+import Trees.*
+import typer.RefChecks.{checkAllOverrides, checkSelfAgainstParents}
+import typer.Checking.{checkBounds, checkAppliedTypesIn}
+import util.{SimpleIdentitySet, EqHashMap, SrcPos}
+import transform.SymUtils.*
+import transform.{Recheck, PreRecheck}
+import Recheck.*
+import scala.collection.mutable
+import CaptureSet.{withCaptureSetsExplained, IdempotentCaptRefMap}
+import StdNames.nme
+import NameKinds.DefaultGetterName
+import reporting.trace
+import language.experimental.pureFunctions
+
+/** The capture checker */
+object CheckCaptures:
+  import ast.tpd.*
+
+  class Pre extends PreRecheck, SymTransformer:
+
+    override def isEnabled(using Context) = true
+
+  	/** Reset `private` flags of parameter accessors so that we can refine them
+     *  in Setup if they have non-empty capture sets. Special handling of some
+     *  symbols defined for case classes.
+     */
+    def transformSym(sym: SymDenotation)(using Context): SymDenotation =
+      if sym.isAllOf(PrivateParamAccessor) && !sym.hasAnnotation(defn.ConstructorOnlyAnnot) then
+        sym.copySymDenotation(initFlags = sym.flags &~ Private | Recheck.ResetPrivate)
+      else if Synthetics.needsTransform(sym) then
+        Synthetics.transformToCC(sym)
+      else
+        sym
+  end Pre
+
+  /** A class describing environments.
+   *  @param owner         the current owner
+   *  @param nestedInOwner true if the environment is a temporary one nested in the owner's environment,
+   *                       and does not have a different actual owner symbol (this happens when doing box adaptation).
+   *  @param captured      the caputure set containing all references to tracked free variables outside of boxes
+   *  @param isBoxed       true if the environment is inside a box (in which case references are not counted)
+   *  @param outer0        the next enclosing environment
+   */
+  case class Env(
+    owner: Symbol,
+    nestedInOwner: Boolean,
+    captured: CaptureSet,
+    isBoxed: Boolean,
+    outer0: Env | Null
+  ):
+    def outer = outer0.nn
+
+    def isOutermost = outer0 == null
+
+    /** If an environment is open it tracks free references */
+    def isOpen = !captured.isAlwaysEmpty && !isBoxed
+  end Env
+
+  /** Similar normal substParams, but this is an approximating type map that
+   *  maps parameters in contravariant capture sets to the empty set.
+   *  TODO: check what happens with non-variant.
+   */
+  final class SubstParamsMap(from: BindingType, to: List[Type])(using Context)
+  extends ApproximatingTypeMap, IdempotentCaptRefMap:
+    def apply(tp: Type): Type = tp match
+      case tp: ParamRef =>
+        if tp.binder == from then to(tp.paramNum) else tp
+      case tp: NamedType =>
+        if tp.prefix `eq` NoPrefix then tp
+        else tp.derivedSelect(apply(tp.prefix))
+      case _: ThisType =>
+        tp
+      case _ =>
+        mapOver(tp)
+
+  /** Check that a @retains annotation only mentions references that can be tracked.
+   *  This check is performed at Typer.
+   */
+  def checkWellformed(ann: Tree)(using Context): Unit =
+    for elem <- retainedElems(ann) do
+      elem.tpe match
+        case ref: CaptureRef =>
+          if !ref.canBeTracked then
+            report.error(em"$elem cannot be tracked since it is not a parameter or local value", elem.srcPos)
+        case tpe =>
+          report.error(em"$elem: $tpe is not a legal element of a capture set", elem.srcPos)
+
+  /** If `tp` is a capturing type, check that all references it mentions have non-empty
+   *  capture sets. Also: warn about redundant capture annotations.
+   *  This check is performed after capture sets are computed in phase cc.
+   */
+  def checkWellformedPost(tp: Type, pos: SrcPos)(using Context): Unit = tp match
+    case CapturingType(parent, refs) =>
+      for ref <- refs.elems do
+        if ref.captureSetOfInfo.elems.isEmpty then
+          report.error(em"$ref cannot be tracked since its capture set is empty", pos)
+        else if parent.captureSet.accountsFor(ref) then
+          report.warning(em"redundant capture: $parent already accounts for $ref", pos)
+    case _ =>
+
+  /** Warn if `ann`, which is a tree of a @retains annotation, defines some elements that
+   *  are already accounted for by other elements of the same annotation.
+   *  Note: We need to perform the check on the original annotation rather than its
+   *  capture set since the conversion to a capture set already eliminates redundant elements.
+   */
+  def warnIfRedundantCaptureSet(ann: Tree)(using Context): Unit =
+    // The lists `elems(i) :: prev.reverse :: elems(0),...,elems(i-1),elems(i+1),elems(n)`
+    // where `n == elems.length-1`, i <- 0..n`.
+    // I.e.
+    // choices(Nil, elems) = [[elems(i), elems(0), ..., elems(i-1), elems(i+1), .... elems(n)] | i <- 0..n]
+    def choices(prev: List[Tree], elems: List[Tree]): List[List[Tree]] = elems match
+      case Nil => Nil
+      case elem :: elems =>
+        List(elem :: (prev reverse_::: elems)) ++ choices(elem :: prev, elems)
+    for case first :: others <- choices(Nil, retainedElems(ann)) do
+      val firstRef = first.toCaptureRef
+      val remaining = CaptureSet(others.map(_.toCaptureRef)*)
+      if remaining.accountsFor(firstRef) then
+        report.warning(em"redundant capture: $remaining already accounts for $firstRef", ann.srcPos)
+
+class CheckCaptures extends Recheck, SymTransformer:
+  thisPhase =>
+
+  import ast.tpd.*
+  import CheckCaptures.*
+
+  def phaseName: String = "cc"
+  override def isEnabled(using Context) = true
+
+  def newRechecker()(using Context) = CaptureChecker(ctx)
+
+  override def run(using Context): Unit =
+    if Feature.ccEnabled then
+      checkOverrides.traverse(ctx.compilationUnit.tpdTree)
+      super.run
+
+  override def transformSym(sym: SymDenotation)(using Context): SymDenotation =
+    if Synthetics.needsTransform(sym) then Synthetics.transformFromCC(sym)
+    else super.transformSym(sym)
+
+  /** Check overrides again, taking capture sets into account.
+   *  TODO: Can we avoid doing overrides checks twice?
+   *  We need to do them here since only at this phase CaptureTypes are relevant
+   *  But maybe we can then elide the check during the RefChecks phase under captureChecking?
+   */
+  def checkOverrides = new TreeTraverser:
+    def traverse(t: Tree)(using Context) =
+      t match
+        case t: Template => checkAllOverrides(ctx.owner.asClass)
+        case _ =>
+      traverseChildren(t)
+
+  class CaptureChecker(ictx: Context) extends Rechecker(ictx):
+    import ast.tpd.*
+
+    override def keepType(tree: Tree) =
+      super.keepType(tree)
+      || tree.isInstanceOf[Try]  // type of `try` needs tp be checked for * escapes
+
+    /** Instantiate capture set variables appearing contra-variantly to their
+     *  upper approximation.
+     */
+    private def interpolator(startingVariance: Int = 1)(using Context) = new TypeTraverser:
+      variance = startingVariance
+      override def traverse(t: Type) =
+        t match
+          case CapturingType(parent, refs: CaptureSet.Var) =>
+            if variance < 0 then
+              capt.println(i"solving $t")
+              refs.solve()
+            traverse(parent)
+          case t @ RefinedType(_, nme.apply, rinfo) if defn.isFunctionOrPolyType(t) =>
+            traverse(rinfo)
+          case tp: TypeVar =>
+          case tp: TypeRef =>
+            traverse(tp.prefix)
+          case _ =>
+            traverseChildren(t)
+
+    /** If `tpt` is an inferred type, interpolate capture set variables appearing contra-
+     *  variantly in it.
+     */
+    private def interpolateVarsIn(tpt: Tree)(using Context): Unit =
+      if tpt.isInstanceOf[InferredTypeTree] then
+        interpolator().traverse(tpt.knownType)
+          .showing(i"solved vars in ${tpt.knownType}", capt)
+
+    /** Assert subcapturing `cs1 <: cs2` */
+    def assertSub(cs1: CaptureSet, cs2: CaptureSet)(using Context) =
+      assert(cs1.subCaptures(cs2, frozen = false).isOK, i"$cs1 is not a subset of $cs2")
+
+    /** Check subcapturing `{elem} <: cs`, report error on failure */
+    def checkElem(elem: CaptureRef, cs: CaptureSet, pos: SrcPos)(using Context) =
+      val res = elem.singletonCaptureSet.subCaptures(cs, frozen = false)
+      if !res.isOK then
+        report.error(i"$elem cannot be referenced here; it is not included in the allowed capture set ${res.blocking}", pos)
+
+    /** Check subcapturing `cs1 <: cs2`, report error on failure */
+    def checkSubset(cs1: CaptureSet, cs2: CaptureSet, pos: SrcPos)(using Context) =
+      val res = cs1.subCaptures(cs2, frozen = false)
+      if !res.isOK then
+        def header =
+          if cs1.elems.size == 1 then i"reference ${cs1.elems.toList}%, % is not"
+          else i"references $cs1 are not all"
+        report.error(i"$header included in allowed capture set ${res.blocking}", pos)
+
+    /** The current environment */
+    private var curEnv: Env = Env(NoSymbol, nestedInOwner = false, CaptureSet.empty, isBoxed = false, null)
+
+    private val myCapturedVars: util.EqHashMap[Symbol, CaptureSet] = EqHashMap()
+
+    /** If `sym` is a class or method nested inside a term, a capture set variable representing
+     *  the captured variables of the environment associated with `sym`.
+     */
+    def capturedVars(sym: Symbol)(using Context) =
+      myCapturedVars.getOrElseUpdate(sym,
+        if sym.ownersIterator.exists(_.isTerm) then CaptureSet.Var()
+        else CaptureSet.empty)
+
+    /** For all nested environments up to `limit` perform `op` */
+    def forallOuterEnvsUpTo(limit: Symbol)(op: Env => Unit)(using Context): Unit =
+      def recur(env: Env): Unit =
+        if env.isOpen && env.owner != limit then
+          op(env)
+          if !env.isOutermost then
+            var nextEnv = env.outer
+            if env.owner.isConstructor then
+              if nextEnv.owner != limit && !nextEnv.isOutermost then
+                recur(nextEnv.outer)
+            else recur(nextEnv)
+      recur(curEnv)
+
+    /** Include `sym` in the capture sets of all enclosing environments nested in the
+     *  the environment in which `sym` is defined.
+     */
+    def markFree(sym: Symbol, pos: SrcPos)(using Context): Unit =
+      if sym.exists then
+        val ref = sym.termRef
+        if ref.isTracked then
+          forallOuterEnvsUpTo(sym.enclosure) { env =>
+            capt.println(i"Mark $sym with cs ${ref.captureSet} free in ${env.owner}")
+            checkElem(ref, env.captured, pos)
+          }
+
+    /** Make sure (projected) `cs` is a subset of the capture sets of all enclosing
+     *  environments. At each stage, only include references from `cs` that are outside
+     *  the environment's owner
+     */
+    def markFree(cs: CaptureSet, pos: SrcPos)(using Context): Unit =
+      if !cs.isAlwaysEmpty then
+        forallOuterEnvsUpTo(ctx.owner.topLevelClass) { env =>
+          val included = cs.filter {
+            case ref: TermRef =>
+              (env.nestedInOwner || env.owner != ref.symbol.owner)
+                && env.owner.isContainedIn(ref.symbol.owner)
+            case ref: ThisType =>
+              (env.nestedInOwner || env.owner != ref.cls)
+                && env.owner.isContainedIn(ref.cls)
+            case _ => false
+          }
+          capt.println(i"Include call capture $included in ${env.owner}")
+          checkSubset(included, env.captured, pos)
+        }
+
+    /** Include references captured by the called method in the current environment stack */
+    def includeCallCaptures(sym: Symbol, pos: SrcPos)(using Context): Unit =
+      if sym.exists && curEnv.isOpen then markFree(capturedVars(sym), pos)
+
+    override def recheckIdent(tree: Ident)(using Context): Type =
+      if tree.symbol.is(Method) then includeCallCaptures(tree.symbol, tree.srcPos)
+      else markFree(tree.symbol, tree.srcPos)
+      super.recheckIdent(tree)
+
+    /** A specialized implementation of the selection rule.
+     *
+     *  E |- f: Cf f { m: Cr R }
+     *  ------------------------
+     *  E |- f.m: C R
+     *
+     *  The implementation picks as `C` one of `{f}` or `Cr`, depending on the
+     *  outcome of a `mightSubcapture` test. It picks `{f}` if this might subcapture Cr
+     *  and Cr otherwise.
+     */
+    override def recheckSelection(tree: Select, qualType: Type, name: Name, pt: Type)(using Context) = {
+      def disambiguate(denot: Denotation): Denotation = denot match
+        case MultiDenotation(denot1, denot2) =>
+          // This case can arise when we try to merge multiple types that have different
+          // capture sets on some part. For instance an asSeenFrom might produce
+          // a bi-mapped capture set arising from a substition. Applying the same substitution
+          // to the same type twice will nevertheless produce different capture setsw which can
+          // lead to a failure in disambiguation since neither alternative is better than the
+          // other in a frozen constraint. An example test case is disambiguate-select.scala.
+          // We address the problem by disambiguating while ignoring all capture sets as a fallback.
+          withMode(Mode.IgnoreCaptures) {
+            disambiguate(denot1).meet(disambiguate(denot2), qualType)
+          }
+        case _ => denot
+
+      val selType = recheckSelection(tree, qualType, name, disambiguate)
+      val selCs = selType.widen.captureSet
+      if selCs.isAlwaysEmpty || selType.widen.isBoxedCapturing || qualType.isBoxedCapturing then
+        selType
+      else
+        val qualCs = qualType.captureSet
+        capt.println(i"intersect $qualType, ${selType.widen}, $qualCs, $selCs in $tree")
+        if qualCs.mightSubcapture(selCs)
+            && !selCs.mightSubcapture(qualCs)
+            && !pt.stripCapturing.isInstanceOf[SingletonType]
+        then
+          selType.widen.stripCapturing.capturing(qualCs)
+            .showing(i"alternate type for select $tree: $selType --> $result, $qualCs / $selCs", capt)
+        else
+          selType
+    }//.showing(i"recheck sel $tree, $qualType = $result")
+
+    /** A specialized implementation of the apply rule.
+     *
+     *  E |- f: Cf (Ra -> Cr Rr)
+     *  E |- a: Ca Ra
+     *  ------------------------
+     *  E |- f a: C Rr
+     *
+     *  The implementation picks as `C` one of `{f, a}` or `Cr`, depending on the
+     *  outcome of a `mightSubcapture` test. It picks `{f, a}` if this might subcapture Cr
+     *  and Cr otherwise.
+     */
+    override def recheckApply(tree: Apply, pt: Type)(using Context): Type =
+      val meth = tree.fun.symbol
+      includeCallCaptures(meth, tree.srcPos)
+      def mapArgUsing(f: Type => Type) =
+        val arg :: Nil = tree.args: @unchecked
+        val argType0 = f(recheckStart(arg, pt))
+        val argType = super.recheckFinish(argType0, arg, pt)
+        super.recheckFinish(argType, tree, pt)
+
+      if meth == defn.Caps_unsafeBox then
+        mapArgUsing(_.forceBoxStatus(true))
+      else if meth == defn.Caps_unsafeUnbox then
+        mapArgUsing(_.forceBoxStatus(false))
+      else if meth == defn.Caps_unsafeBoxFunArg then
+        mapArgUsing {
+          case defn.FunctionOf(paramtpe :: Nil, restpe, isContectual, isErased) =>
+            defn.FunctionOf(paramtpe.forceBoxStatus(true) :: Nil, restpe, isContectual, isErased)
+        }
+      else
+        super.recheckApply(tree, pt) match
+          case appType @ CapturingType(appType1, refs) =>
+            tree.fun match
+              case Select(qual, _)
+              if !tree.fun.symbol.isConstructor
+                  && !qual.tpe.isBoxedCapturing
+                  && !tree.args.exists(_.tpe.isBoxedCapturing)
+                  && qual.tpe.captureSet.mightSubcapture(refs)
+                  && tree.args.forall(_.tpe.captureSet.mightSubcapture(refs))
+              =>
+                val callCaptures = tree.args.foldLeft(qual.tpe.captureSet)((cs, arg) =>
+                  cs ++ arg.tpe.captureSet)
+                appType.derivedCapturingType(appType1, callCaptures)
+                  .showing(i"narrow $tree: $appType, refs = $refs, qual = ${qual.tpe.captureSet} --> $result", capt)
+              case _ => appType
+          case appType => appType
+    end recheckApply
+
+    /** Handle an application of method `sym` with type `mt` to arguments of types `argTypes`.
+     *  This means:
+     *   - Instantiate result type with actual arguments
+     *   - If call is to a constructor:
+     *      - remember types of arguments corresponding to tracked
+     *        parameters in refinements.
+     *      - add capture set of instantiated class to capture set of result type.
+     */
+    override def instantiate(mt: MethodType, argTypes: List[Type], sym: Symbol)(using Context): Type =
+      val ownType =
+        if mt.isResultDependent then SubstParamsMap(mt, argTypes)(mt.resType)
+        else mt.resType
+
+      if sym.isConstructor then
+        val cls = sym.owner.asClass
+
+        /** First half of result pair:
+         *  Refine the type of a constructor call `new C(t_1, ..., t_n)`
+         *  to C{val x_1: T_1, ..., x_m: T_m} where x_1, ..., x_m are the tracked
+         *  parameters of C and T_1, ..., T_m are the types of the corresponding arguments.
+         *
+         *  Second half: union of all capture sets of arguments to tracked parameters.
+         */
+        def addParamArgRefinements(core: Type, initCs: CaptureSet): (Type, CaptureSet) =
+          mt.paramNames.lazyZip(argTypes).foldLeft((core, initCs)) { (acc, refine) =>
+            val (core, allCaptures) = acc
+            val (getterName, argType) = refine
+            val getter = cls.info.member(getterName).suchThat(_.is(ParamAccessor)).symbol
+            if getter.termRef.isTracked && !getter.is(Private)
+            then (RefinedType(core, getterName, argType), allCaptures ++ argType.captureSet)
+            else (core, allCaptures)
+          }
+
+        def augmentConstructorType(core: Type, initCs: CaptureSet): Type = core match
+          case core: MethodType =>
+            // more parameters to follow; augment result type
+            core.derivedLambdaType(resType = augmentConstructorType(core.resType, initCs))
+          case CapturingType(parent, refs) =>
+            // can happen for curried constructors if instantiate of a previous step
+            // added capture set to result.
+            augmentConstructorType(parent, initCs ++ refs)
+          case _ =>
+            val (refined, cs) = addParamArgRefinements(core, initCs)
+            refined.capturing(cs)
+
+        augmentConstructorType(ownType, CaptureSet.empty) match
+          case augmented: MethodType =>
+            augmented
+          case augmented =>
+            // add capture sets of class and constructor to final result of constructor call
+            augmented.capturing(capturedVars(cls) ++ capturedVars(sym))
+              .showing(i"constr type $mt with $argTypes%, % in $cls = $result", capt)
+      else ownType
+    end instantiate
+
+    override def recheckClosure(tree: Closure, pt: Type)(using Context): Type =
+      val cs = capturedVars(tree.meth.symbol)
+      capt.println(i"typing closure $tree with cvs $cs")
+      super.recheckClosure(tree, pt).capturing(cs)
+        .showing(i"rechecked $tree / $pt = $result", capt)
+
+    /** Additionally to normal processing, update types of closures if the expected type
+     *  is a function with only pure parameters. In that case, make the anonymous function
+     *  also have the same parameters as the prototype.
+     *  TODO: Develop a clearer rationale for this.
+     *  TODO: Can we generalize this to arbitrary parameters?
+     *        Currently some tests fail if we do this. (e.g. neg.../stackAlloc.scala, others)
+     */
+    override def recheckBlock(block: Block, pt: Type)(using Context): Type =
+      block match
+        case closureDef(mdef) =>
+          pt.dealias match
+            case defn.FunctionOf(ptformals, _, _, _)
+            if ptformals.nonEmpty && ptformals.forall(_.captureSet.isAlwaysEmpty) =>
+              // Redo setup of the anonymous function so that formal parameters don't
+              // get capture sets. This is important to avoid false widenings to `*`
+              // when taking the base type of the actual closures's dependent function
+              // type so that it conforms to the expected non-dependent function type.
+              // See withLogFile.scala for a test case.
+              val meth = mdef.symbol
+              // First, undo the previous setup which installed a completer for `meth`.
+              atPhase(preRecheckPhase.prev)(meth.denot.copySymDenotation())
+                .installAfter(preRecheckPhase)
+
+              // Next, update all parameter symbols to match expected formals
+              meth.paramSymss.head.lazyZip(ptformals).foreach { (psym, pformal) =>
+                psym.updateInfoBetween(preRecheckPhase, thisPhase, pformal.mapExprType)
+              }
+              // Next, update types of parameter ValDefs
+              mdef.paramss.head.lazyZip(ptformals).foreach { (param, pformal) =>
+                val ValDef(_, tpt, _) = param: @unchecked
+                tpt.rememberTypeAlways(pformal)
+              }
+              // Next, install a new completer reflecting the new parameters for the anonymous method
+              val mt = meth.info.asInstanceOf[MethodType]
+              val completer = new LazyType:
+                def complete(denot: SymDenotation)(using Context) =
+                  denot.info = mt.companion(ptformals, mdef.tpt.knownType)
+                    .showing(i"simplify info of $meth to $result", capt)
+                  recheckDef(mdef, meth)
+              meth.updateInfoBetween(preRecheckPhase, thisPhase, completer)
+            case _ =>
+        case _ =>
+      super.recheckBlock(block, pt)
+
+    override def recheckValDef(tree: ValDef, sym: Symbol)(using Context): Unit =
+      try
+        if !sym.is(Module) then // Modules are checked by checking the module class
+          super.recheckValDef(tree, sym)
+      finally
+        if !sym.is(Param) then
+          // Parameters with inferred types belong to anonymous methods. We need to wait
+          // for more info from the context, so we cannot interpolate. Note that we cannot
+          // expect to have all necessary info available at the point where the anonymous
+          // function is compiled since we do not propagate expected types into blocks.
+          interpolateVarsIn(tree.tpt)
+
+    override def recheckDefDef(tree: DefDef, sym: Symbol)(using Context): Unit =
+      if !Synthetics.isExcluded(sym) then
+        val saved = curEnv
+        val localSet = capturedVars(sym)
+        if !localSet.isAlwaysEmpty then curEnv = Env(sym, nestedInOwner = false, localSet, isBoxed = false, curEnv)
+        try super.recheckDefDef(tree, sym)
+        finally
+          interpolateVarsIn(tree.tpt)
+          curEnv = saved
+
+    /** Class-specific capture set relations:
+     *   1. The capture set of a class includes the capture sets of its parents.
+     *   2. The capture set of the self type of a class includes the capture set of the class.
+     *   3. The capture set of the self type of a class includes the capture set of every class parameter,
+     *      unless the parameter is marked @constructorOnly.
+     */
+    override def recheckClassDef(tree: TypeDef, impl: Template, cls: ClassSymbol)(using Context): Type =
+      val saved = curEnv
+      val localSet = capturedVars(cls)
+      for parent <- impl.parents do // (1)
+        checkSubset(capturedVars(parent.tpe.classSymbol), localSet, parent.srcPos)
+      if !localSet.isAlwaysEmpty then curEnv = Env(cls, nestedInOwner = false, localSet, isBoxed = false, curEnv)
+      try
+        val thisSet = cls.classInfo.selfType.captureSet.withDescription(i"of the self type of $cls")
+        checkSubset(localSet, thisSet, tree.srcPos) // (2)
+        for param <- cls.paramGetters do
+          if !param.hasAnnotation(defn.ConstructorOnlyAnnot) then
+            checkSubset(param.termRef.captureSet, thisSet, param.srcPos) // (3)
+        if cls.derivesFrom(defn.ThrowableClass) then
+          checkSubset(thisSet, CaptureSet.emptyOfException, tree.srcPos)
+        super.recheckClassDef(tree, impl, cls)
+      finally
+        curEnv = saved
+
+    /** If type is of the form `T @requiresCapability(x)`,
+     *  mark `x` as free in the current environment. This is used to require the
+     *  correct `CanThrow` capability when encountering a `throw`.
+     */
+    override def recheckTyped(tree: Typed)(using Context): Type =
+      tree.tpt.tpe match
+        case AnnotatedType(_, annot) if annot.symbol == defn.RequiresCapabilityAnnot =>
+          annot.tree match
+            case Apply(_, cap :: Nil) =>
+              markFree(cap.symbol, tree.srcPos)
+            case _ =>
+        case _ =>
+      super.recheckTyped(tree)
+
+    /* Currently not needed, since capture checking takes place after ElimByName.
+     * Keep around in case we need to get back to it
+    def recheckByNameArg(tree: Tree, pt: Type)(using Context): Type =
+      val closureDef(mdef) = tree: @unchecked
+      val arg = mdef.rhs
+      val localSet = CaptureSet.Var()
+      curEnv = Env(mdef.symbol, localSet, isBoxed = false, curEnv)
+      val result =
+        try
+          inContext(ctx.withOwner(mdef.symbol)) {
+            recheckStart(arg, pt).capturing(localSet)
+          }
+        finally curEnv = curEnv.outer
+      recheckFinish(result, arg, pt)
+    */
+
+    /** If expected type `pt` is boxed and the tree is a function or a reference,
+     *  don't propagate free variables.
+     *  Otherwise, if the result type is boxed, simulate an unboxing by
+     *  adding all references in the boxed capture set to the current environment.
+     */
+    override def recheck(tree: Tree, pt: Type = WildcardType)(using Context): Type =
+      if tree.isTerm && pt.isBoxedCapturing then
+        val saved = curEnv
+
+        tree match
+          case _: RefTree | closureDef(_) =>
+            curEnv = Env(curEnv.owner, nestedInOwner = false, CaptureSet.Var(), isBoxed = true, curEnv)
+          case _ =>
+
+        try super.recheck(tree, pt)
+        finally curEnv = saved
+      else
+        val res = super.recheck(tree, pt)
+        if tree.isTerm then markFree(res.boxedCaptureSet, tree.srcPos)
+        res
+
+    /** If `tree` is a reference or an application where the result type refers
+     *  to an enclosing class or method parameter of the reference, check that the result type
+     *  does not capture the universal capability. This is justified since the
+     *  result type would have to be implicitly unboxed.
+     *  TODO: Can we find a cleaner way to achieve this? Logically, this should be part
+     *  of simulated boxing and unboxing.
+     */
+    override def recheckFinish(tpe: Type, tree: Tree, pt: Type)(using Context): Type =
+      val typeToCheck = tree match
+        case _: Ident | _: Select | _: Apply | _: TypeApply if tree.symbol.unboxesResult =>
+          tpe
+        case _: Try =>
+          tpe
+        case _ =>
+          NoType
+      def checkNotUniversal(tp: Type): Unit = tp.widenDealias match
+        case wtp @ CapturingType(parent, refs) =>
+          refs.disallowRootCapability { () =>
+            val kind = if tree.isInstanceOf[ValDef] then "mutable variable" else "expression"
+            report.error(
+              em"""The $kind's type $wtp is not allowed to capture the root capability `*`.
+                  |This usually means that a capability persists longer than its allowed lifetime.""",
+              tree.srcPos)
+          }
+          checkNotUniversal(parent)
+        case _ =>
+      checkNotUniversal(typeToCheck)
+      super.recheckFinish(tpe, tree, pt)
+
+    /** Massage `actual` and `expected` types using the methods below before checking conformance */
+    override def checkConformsExpr(actual: Type, expected: Type, tree: Tree)(using Context): Unit =
+      val expected1 = addOuterRefs(expected, actual)
+      val actual1 = adaptBoxed(actual, expected1, tree.srcPos)
+      //println(i"check conforms $actual1 <<< $expected1")
+      super.checkConformsExpr(actual1, expected1, tree)
+
+    /** For the expected type, implement the rule outlined in #14390:
+     *   - when checking an expression `a: Ca Ta` against an expected type `Ce Te`,
+     *   - where the capture set `Ce` contains Cls.this,
+     *   - and where and all method definitions enclosing `a` inside class `Cls`
+     *     have only pure parameters,
+     *   - add to `Ce` all references to variables or this-references in `Ca`
+     *     that are outside `Cls`. These are all accessed through `Cls.this`,
+     *     so we can assume they are already accounted for by `Ce` and adding
+     *     them explicitly to `Ce` changes nothing.
+     */
+    private def addOuterRefs(expected: Type, actual: Type)(using Context): Type =
+      def isPure(info: Type): Boolean = info match
+        case info: PolyType => isPure(info.resType)
+        case info: MethodType => info.paramInfos.forall(_.captureSet.isAlwaysEmpty) && isPure(info.resType)
+        case _ => true
+      def isPureContext(owner: Symbol, limit: Symbol): Boolean =
+        if owner == limit then true
+        else if !owner.exists then false
+        else isPure(owner.info) && isPureContext(owner.owner, limit)
+      def augment(erefs: CaptureSet, arefs: CaptureSet): CaptureSet =
+        (erefs /: erefs.elems) { (erefs, eref) =>
+          eref match
+            case eref: ThisType if isPureContext(ctx.owner, eref.cls) =>
+              erefs ++ arefs.filter {
+                case aref: TermRef => eref.cls.isProperlyContainedIn(aref.symbol.owner)
+                case aref: ThisType => eref.cls.isProperlyContainedIn(aref.cls)
+                case _ => false
+              }
+            case _ =>
+              erefs
+        }
+      expected match
+        case CapturingType(ecore, erefs) =>
+          val erefs1 = augment(erefs, actual.captureSet)
+          if erefs1 ne erefs then
+            capt.println(i"augmented $expected from ${actual.captureSet} --> $erefs1")
+          expected.derivedCapturingType(ecore, erefs1)
+        case _ =>
+          expected
+
+    /** Adapt `actual` type to `expected` type by inserting boxing and unboxing conversions */
+    def adaptBoxed(actual: Type, expected: Type, pos: SrcPos)(using Context): Type =
+
+      /** Adapt function type `actual`, which is `aargs -> ares` (possibly with dependencies)
+       *  to `expected` type.
+       *  It returns the adapted type along with the additionally captured variable
+       *  during adaptation.
+       *   @param reconstruct  how to rebuild the adapted function type
+       */
+      def adaptFun(actual: Type, aargs: List[Type], ares: Type, expected: Type,
+          covariant: Boolean, boxed: Boolean,
+          reconstruct: (List[Type], Type) => Type): (Type, CaptureSet) =
+        val saved = curEnv
+        curEnv = Env(curEnv.owner, nestedInOwner = true, CaptureSet.Var(), isBoxed = false, if boxed then null else curEnv)
+
+        try
+          val (eargs, eres) = expected.dealias.stripCapturing match
+            case defn.FunctionOf(eargs, eres, _, _) => (eargs, eres)
+            case expected: MethodType => (expected.paramInfos, expected.resType)
+            case expected @ RefinedType(_, _, rinfo: MethodType) if defn.isFunctionType(expected) => (rinfo.paramInfos, rinfo.resType)
+            case _ => (aargs.map(_ => WildcardType), WildcardType)
+          val aargs1 = aargs.zipWithConserve(eargs) { (aarg, earg) => adapt(aarg, earg, !covariant) }
+          val ares1 = adapt(ares, eres, covariant)
+
+          val resTp =
+            if (ares1 eq ares) && (aargs1 eq aargs) then actual
+            else reconstruct(aargs1, ares1)
+
+          (resTp, curEnv.captured)
+        finally
+          curEnv = saved
+
+      /** Adapt type function type `actual` to the expected type.
+       *  @see [[adaptFun]]
+       */
+      def adaptTypeFun(
+          actual: Type, ares: Type, expected: Type,
+          covariant: Boolean, boxed: Boolean,
+          reconstruct: Type => Type): (Type, CaptureSet) =
+        val saved = curEnv
+        curEnv = Env(curEnv.owner, nestedInOwner = true, CaptureSet.Var(), isBoxed = false, if boxed then null else curEnv)
+
+        try
+          val eres = expected.dealias.stripCapturing match
+            case RefinedType(_, _, rinfo: PolyType) => rinfo.resType
+            case expected: PolyType => expected.resType
+            case _ => WildcardType
+
+          val ares1 = adapt(ares, eres, covariant)
+
+          val resTp =
+            if ares1 eq ares then actual
+            else reconstruct(ares1)
+
+          (resTp, curEnv.captured)
+        finally
+          curEnv = saved
+      end adaptTypeFun
+
+      def adaptInfo(actual: Type, expected: Type, covariant: Boolean): String =
+        val arrow = if covariant then "~~>" else "<~~"
+        i"adapting $actual $arrow $expected"
+
+      /** Destruct a capturing type `tp` to a tuple (cs, tp0, boxed),
+       *  where `tp0` is not a capturing type.
+       *
+       *  If `tp` is a nested capturing type, the return tuple always represents
+       *  the innermost capturing type. The outer capture annotations can be
+       *  reconstructed with the returned function.
+       */
+      def destructCapturingType(tp: Type, reconstruct: Type -> Type = (x: Type) => x) // !cc! need monomorphic default argument
+          : (Type, CaptureSet, Boolean, Type -> Type) =
+        tp.dealias match
+          case tp @ CapturingType(parent, cs) =>
+            if parent.dealias.isCapturingType then
+              destructCapturingType(parent, res => reconstruct(tp.derivedCapturingType(res, cs)))
+            else
+              (parent, cs, tp.isBoxed, reconstruct)
+          case actual =>
+            (actual, CaptureSet(), false, reconstruct)
+
+      def adapt(actual: Type, expected: Type, covariant: Boolean): Type = trace(adaptInfo(actual, expected, covariant), recheckr, show = true) {
+        if expected.isInstanceOf[WildcardType] then actual
+        else
+          val (parent, cs, actualIsBoxed, recon: (Type -> Type)) = destructCapturingType(actual)
+
+          val needsAdaptation = actualIsBoxed != expected.isBoxedCapturing
+          val insertBox = needsAdaptation && covariant != actualIsBoxed
+
+          val (parent1, cs1) = parent match {
+            case actual @ AppliedType(tycon, args) if defn.isNonRefinedFunction(actual) =>
+              val (parent1, leaked) = adaptFun(parent, args.init, args.last, expected, covariant, insertBox,
+                  (aargs1, ares1) => actual.derivedAppliedType(tycon, aargs1 :+ ares1))
+              (parent1, leaked ++ cs)
+            case actual @ RefinedType(_, _, rinfo: MethodType) if defn.isFunctionType(actual) =>
+              // TODO Find a way to combine handling of generic and dependent function types (here and elsewhere)
+              val (parent1, leaked) = adaptFun(parent, rinfo.paramInfos, rinfo.resType, expected, covariant, insertBox,
+                (aargs1, ares1) =>
+                  rinfo.derivedLambdaType(paramInfos = aargs1, resType = ares1)
+                    .toFunctionType(isJava = false, alwaysDependent = true))
+              (parent1, leaked ++ cs)
+            case actual: MethodType =>
+              val (parent1, leaked) = adaptFun(parent, actual.paramInfos, actual.resType, expected, covariant, insertBox,
+                (aargs1, ares1) =>
+                  actual.derivedLambdaType(paramInfos = aargs1, resType = ares1))
+              (parent1, leaked ++ cs)
+            case actual @ RefinedType(p, nme, rinfo: PolyType) if defn.isFunctionOrPolyType(actual) =>
+              val (parent1, leaked) = adaptTypeFun(parent, rinfo.resType, expected, covariant, insertBox,
+                ares1 =>
+                  val rinfo1 = rinfo.derivedLambdaType(rinfo.paramNames, rinfo.paramInfos, ares1)
+                  val actual1 = actual.derivedRefinedType(p, nme, rinfo1)
+                  actual1
+              )
+              (parent1, leaked ++ cs)
+            case _ =>
+              (parent, cs)
+          }
+
+          if needsAdaptation then
+            val criticalSet =          // the set which is not allowed to have `*`
+              if covariant then cs1    // can't box with `*`
+              else expected.captureSet // can't unbox with `*`
+            if criticalSet.isUniversal && expected.isValueType then
+              // We can't box/unbox the universal capability. Leave `actual` as it is
+              // so we get an error in checkConforms. This tends to give better error
+              // messages than disallowing the root capability in `criticalSet`.
+              if ctx.settings.YccDebug.value then
+                println(i"cannot box/unbox $actual vs $expected")
+              actual
+            else
+              // Disallow future addition of `*` to `criticalSet`.
+              criticalSet.disallowRootCapability { () =>
+                report.error(
+                  em"""$actual cannot be box-converted to $expected
+                      |since one of their capture sets contains the root capability `*`""",
+                pos)
+              }
+              if !insertBox then  // unboxing
+                markFree(criticalSet, pos)
+              recon(CapturingType(parent1, cs1, !actualIsBoxed))
+          else
+            recon(CapturingType(parent1, cs1, actualIsBoxed))
+      }
+
+      var actualw = actual.widenDealias
+      actual match
+        case ref: CaptureRef if ref.isTracked =>
+          actualw match
+            case CapturingType(p, refs) =>
+              actualw = actualw.derivedCapturingType(p, ref.singletonCaptureSet)
+                // given `a: C T`, improve `C T` to `{a} T`
+            case _ =>
+        case _ =>
+      val adapted = adapt(actualw, expected, covariant = true)
+      if adapted ne actualw then
+        capt.println(i"adapt boxed $actual vs $expected ===> $adapted")
+        adapted
+      else actual
+    end adaptBoxed
+
+    override def checkUnit(unit: CompilationUnit)(using Context): Unit =
+      Setup(preRecheckPhase, thisPhase, recheckDef)
+        .traverse(ctx.compilationUnit.tpdTree)
+      //println(i"SETUP:\n${Recheck.addRecheckedTypes.transform(ctx.compilationUnit.tpdTree)}")
+      withCaptureSetsExplained {
+        super.checkUnit(unit)
+        checkSelfTypes(unit.tpdTree)
+        postCheck(unit.tpdTree)
+        if ctx.settings.YccDebug.value then
+          show(unit.tpdTree) // this does not print tree, but makes its variables visible for dependency printing
+      }
+
+    /** Check that self types of subclasses conform to self types of super classes.
+     *  (See comment below how this is achieved). The check assumes that classes
+     *  without an explicit self type have the universal capture set `{*}` on the
+     *  self type. If a class without explicit self type is not `effectivelyFinal`
+     *  it is checked that the inferred self type is universal, in order to assure
+     *  that joint and separate compilation give the same result.
+     */
+    def checkSelfTypes(unit: tpd.Tree)(using Context): Unit =
+      val parentTrees = mutable.HashMap[Symbol, List[Tree]]()
+      unit.foreachSubTree {
+        case cdef @ TypeDef(_, impl: Template) => parentTrees(cdef.symbol) = impl.parents
+        case _ =>
+      }
+      // Perform self type checking. The problem here is that `checkParents` compares a
+      // self type of a subclass with the result of an asSeenFrom of the self type of the
+      // superclass. That's no good. We need to constrain the original superclass self type
+      // capture set, not the set mapped by asSeenFrom.
+      //
+      // Instead, we proceed from parent classes to child classes. For every class
+      // we first check its parents, and then interpolate the self type to an
+      // upper approximation that satisfies all constraints on its capture set.
+      // That means all capture sets of parent self types are constants, so mapping
+      // them with asSeenFrom is OK.
+      while parentTrees.nonEmpty do
+        val roots = parentTrees.keysIterator.filter {
+          cls => !parentTrees(cls).exists(ptree => parentTrees.contains(ptree.tpe.classSymbol))
+        }
+        assert(roots.nonEmpty)
+        for case root: ClassSymbol <- roots do
+          checkSelfAgainstParents(root, root.baseClasses)
+          val selfType = root.asClass.classInfo.selfType
+          interpolator(startingVariance = -1).traverse(selfType)
+          if !root.isEffectivelySealed  then
+            def matchesExplicitRefsInBaseClass(refs: CaptureSet, cls: ClassSymbol): Boolean =
+              cls.baseClasses.tail.exists { psym =>
+                val selfType = psym.asClass.givenSelfType
+                selfType.exists && selfType.captureSet.elems == refs.elems
+              }
+            selfType match
+              case CapturingType(_, refs: CaptureSet.Var)
+              if !refs.isUniversal && !matchesExplicitRefsInBaseClass(refs, root) =>
+                // Forbid inferred self types unless they are already implied by an explicit
+                // self type in a parent.
+                report.error(
+                  i"""$root needs an explicitly declared self type since its
+                     |inferred self type $selfType
+                     |is not visible in other compilation units that define subclasses.""",
+                  root.srcPos)
+              case _ =>
+          parentTrees -= root
+          capt.println(i"checked $root with $selfType")
+    end checkSelfTypes
+
+    /** Perform the following kinds of checks
+     *   - Check all explicitly written capturing types for well-formedness using `checkWellFormedPost`.
+     *   - Check that externally visible `val`s or `def`s have empty capture sets. If not,
+     *     suggest an explicit type. This is so that separate compilation (where external
+     *     symbols have empty capture sets) gives the same results as joint compilation.
+     */
+    def postCheck(unit: tpd.Tree)(using Context): Unit =
+      unit.foreachSubTree {
+        case _: InferredTypeTree =>
+        case tree: TypeTree if !tree.span.isZeroExtent =>
+          tree.knownType.foreachPart { tp =>
+            checkWellformedPost(tp, tree.srcPos)
+            tp match
+              case AnnotatedType(_, annot) if annot.symbol == defn.RetainsAnnot =>
+                warnIfRedundantCaptureSet(annot.tree)
+              case _ =>
+          }
+        case t: ValOrDefDef
+        if t.tpt.isInstanceOf[InferredTypeTree] && !Synthetics.isExcluded(t.symbol) =>
+          val sym = t.symbol
+          val isLocal =
+            sym.owner.ownersIterator.exists(_.isTerm)
+            || sym.accessBoundary(defn.RootClass).isContainedIn(sym.topLevelClass)
+          def canUseInferred =    // If canUseInferred is false, all capturing types in the type of `sym` need to be given explicitly
+            sym.is(Private)                   // private symbols can always have inferred types
+            || sym.name.is(DefaultGetterName) // default getters are exempted since otherwise it would be
+                                              // too annoying. This is a hole since a defualt getter's result type
+                                              // might leak into a type variable.
+            ||                                // non-local symbols cannot have inferred types since external capture types are not inferred
+              isLocal                         // local symbols still need explicit types if
+              && !sym.owner.is(Trait)         // they are defined in a trait, since we do OverridingPairs checking before capture inference
+          def isNotPureThis(ref: CaptureRef) = ref match {
+            case ref: ThisType => !ref.cls.isPureClass
+            case _ => true
+          }
+          if !canUseInferred then
+            val inferred = t.tpt.knownType
+            def checkPure(tp: Type) = tp match
+              case CapturingType(_, refs)
+              if !refs.elems.filter(isNotPureThis).isEmpty =>
+                val resultStr = if t.isInstanceOf[DefDef] then " result" else ""
+                report.error(
+                  em"""Non-local $sym cannot have an inferred$resultStr type
+                      |$inferred
+                      |with non-empty capture set $refs.
+                      |The type needs to be declared explicitly.""", t.srcPos)
+              case _ =>
+            inferred.foreachPart(checkPure, StopAt.Static)
+        case t @ TypeApply(fun, args) =>
+          fun.knownType.widen match
+            case tl: PolyType =>
+              val normArgs = args.lazyZip(tl.paramInfos).map { (arg, bounds) =>
+                arg.withType(arg.knownType.forceBoxStatus(
+                  bounds.hi.isBoxedCapturing | bounds.lo.isBoxedCapturing))
+              }
+              checkBounds(normArgs, tl)
+            case _ =>
+        case _ =>
+      }
+      if !ctx.reporter.errorsReported then
+        // We dont report errors hre if previous errors were reported, because other
+        // errors often result in bad applied types, but flagging these bad types gives
+        // often worse error messages than the original errors.
+        val checkApplied = new TreeTraverser:
+          def traverse(t: Tree)(using Context) = t match
+            case tree: InferredTypeTree =>
+            case tree: New =>
+            case tree: TypeTree => checkAppliedTypesIn(tree.withKnownType)
+            case _ => traverseChildren(t)
+        checkApplied.traverse(unit)
+  end CaptureChecker
+end CheckCaptures
diff --git a/tests/pos-with-compiler-cc/dotc/cc/Setup.scala b/tests/pos-with-compiler-cc/dotc/cc/Setup.scala
new file mode 100644
index 000000000000..95f2e71437a8
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/cc/Setup.scala
@@ -0,0 +1,482 @@
+package dotty.tools
+package dotc
+package cc
+
+import core._
+import Phases.*, DenotTransformers.*, SymDenotations.*
+import Contexts.*, Names.*, Flags.*, Symbols.*, Decorators.*
+import Types.*, StdNames.*
+import config.Printers.capt
+import ast.tpd
+import transform.Recheck.*
+import CaptureSet.IdentityCaptRefMap
+import Synthetics.isExcluded
+
+/** A tree traverser that prepares a compilation unit to be capture checked.
+ *  It does the following:
+ *    - For every inferred type, drop any retains annotations,
+ *      add capture sets to all its parts, add refinements to class types and function types.
+ *      (c.f. mapInferred)
+ *    - For explicit capturing types, expand throws aliases to the underlying (pure) function,
+ *      and add some implied capture sets to curried functions (c.f. expandThrowsAlias, expandAbbreviations).
+ *    - Add capture sets to self types of classes and objects, unless the self type was written explicitly.
+ *    - Box the types of mutable variables and type arguments to methods (type arguments of types
+ *      are boxed on access).
+ *    - Link the external types of val and def symbols with the inferred types based on their parameter symbols.
+ */
+class Setup(
+  preRecheckPhase: DenotTransformer,
+  thisPhase: DenotTransformer,
+  recheckDef: (tpd.ValOrDefDef, Symbol) => Context ?=> Unit)
+extends tpd.TreeTraverser:
+  import tpd.*
+
+  /** Create dependent function with underlying function class `tycon` and given
+   *  arguments `argTypes` and result `resType`.
+   */
+  private def depFun(tycon: Type, argTypes: List[Type], resType: Type)(using Context): Type =
+    MethodType.companion(
+        isContextual = defn.isContextFunctionClass(tycon.classSymbol),
+        isErased = defn.isErasedFunctionClass(tycon.classSymbol)
+      )(argTypes, resType)
+      .toFunctionType(isJava = false, alwaysDependent = true)
+
+  /** If `tp` is an unboxed capturing type or a function returning an unboxed capturing type,
+   *  convert it to be boxed.
+   */
+  private def box(tp: Type)(using Context): Type =
+    def recur(tp: Type): Type = tp.dealias match
+      case tp @ CapturingType(parent, refs) if !tp.isBoxed =>
+        tp.boxed
+      case tp1 @ AppliedType(tycon, args) if defn.isNonRefinedFunction(tp1) =>
+        val res = args.last
+        val boxedRes = recur(res)
+        if boxedRes eq res then tp
+        else tp1.derivedAppliedType(tycon, args.init :+ boxedRes)
+      case tp1 @ RefinedType(_, _, rinfo) if defn.isFunctionType(tp1) =>
+        val boxedRinfo = recur(rinfo)
+        if boxedRinfo eq rinfo then tp
+        else boxedRinfo.toFunctionType(isJava = false, alwaysDependent = true)
+      case tp1: MethodOrPoly =>
+        val res = tp1.resType
+        val boxedRes = recur(res)
+        if boxedRes eq res then tp
+        else tp1.derivedLambdaType(resType = boxedRes)
+      case _ => tp
+    tp match
+      case tp: MethodOrPoly => tp // don't box results of methods outside refinements
+      case _ => recur(tp)
+
+  /** Perform the following transformation steps everywhere in a type:
+    *  1. Drop retains annotations
+    *  2. Turn plain function types into dependent function types, so that
+    *     we can refer to their parameters in capture sets. Currently this is
+    *     only done at the toplevel, i.e. for function types that are not
+    *     themselves argument types of other function types. Without this restriction
+    *     pos.../lists.scala and pos/...curried-shorthands.scala fail.
+    *     Need to figure out why.
+    *  3. Refine other class types C by adding capture set variables to their parameter getters
+    *     (see addCaptureRefinements)
+    *  4. Add capture set variables to all types that can be tracked
+    *
+    *  Polytype bounds are only cleaned using step 1, but not otherwise transformed.
+    */
+  private def mapInferred(using Context) = new TypeMap:
+
+    /** Drop @retains annotations everywhere */
+    object cleanup extends TypeMap:
+      def apply(t: Type) = t match
+        case AnnotatedType(parent, annot) if annot.symbol == defn.RetainsAnnot =>
+          apply(parent)
+        case _ =>
+          mapOver(t)
+
+    /** Refine a possibly applied class type C where the class has tracked parameters
+     *  x_1: T_1, ..., x_n: T_n to C { val x_1: CV_1 T_1, ..., val x_n: CV_n T_n }
+     *  where CV_1, ..., CV_n are fresh capture sets.
+     */
+    def addCaptureRefinements(tp: Type): Type = tp match
+      case _: TypeRef | _: AppliedType if tp.typeParams.isEmpty =>
+        tp.typeSymbol match
+          case cls: ClassSymbol
+          if !defn.isFunctionClass(cls) && !cls.is(JavaDefined) =>
+            // We assume that Java classes can refer to capturing Scala types only indirectly,
+            // using type parameters. Hence, no need to refine them.
+            cls.paramGetters.foldLeft(tp) { (core, getter) =>
+              if getter.termRef.isTracked then
+                val getterType = tp.memberInfo(getter).strippedDealias
+                RefinedType(core, getter.name, CapturingType(getterType, CaptureSet.Var()))
+                  .showing(i"add capture refinement $tp --> $result", capt)
+              else
+                core
+            }
+          case _ => tp
+      case _ => tp
+
+    private def superTypeIsImpure(tp: Type): Boolean = {
+      tp.dealias match
+        case CapturingType(_, refs) =>
+          !refs.isAlwaysEmpty
+        case tp: (TypeRef | AppliedType) =>
+          val sym = tp.typeSymbol
+          if sym.isClass then
+            sym == defn.AnyClass
+              // we assume Any is a shorthand of {*} Any, so if Any is an upper
+              // bound, the type is taken to be impure.
+          else superTypeIsImpure(tp.superType)
+        case tp: (RefinedOrRecType | MatchType) =>
+          superTypeIsImpure(tp.underlying)
+        case tp: AndType =>
+          superTypeIsImpure(tp.tp1) || needsVariable(tp.tp2)
+        case tp: OrType =>
+          superTypeIsImpure(tp.tp1) && superTypeIsImpure(tp.tp2)
+        case _ =>
+          false
+    }.showing(i"super type is impure $tp = $result", capt)
+
+    /** Should a capture set variable be added on type `tp`? */
+    def needsVariable(tp: Type): Boolean = {
+      tp.typeParams.isEmpty && tp.match
+        case tp: (TypeRef | AppliedType) =>
+          val tp1 = tp.dealias
+          if tp1 ne tp then needsVariable(tp1)
+          else
+            val sym = tp1.typeSymbol
+            if sym.isClass then
+              !sym.isPureClass && sym != defn.AnyClass
+            else superTypeIsImpure(tp1)
+        case tp: (RefinedOrRecType | MatchType) =>
+          needsVariable(tp.underlying)
+        case tp: AndType =>
+          needsVariable(tp.tp1) && needsVariable(tp.tp2)
+        case tp: OrType =>
+          needsVariable(tp.tp1) || needsVariable(tp.tp2)
+        case CapturingType(parent, refs) =>
+          needsVariable(parent)
+          && refs.isConst      // if refs is a variable, no need to add another
+          && !refs.isUniversal // if refs is {*}, an added variable would not change anything
+        case _ =>
+          false
+    }.showing(i"can have inferred capture $tp = $result", capt)
+
+    /** Add a capture set variable to `tp` if necessary, or maybe pull out
+     *  an embedded capture set variable from a part of `tp`.
+     */
+    def addVar(tp: Type) = tp match
+      case tp @ RefinedType(parent @ CapturingType(parent1, refs), rname, rinfo) =>
+        CapturingType(tp.derivedRefinedType(parent1, rname, rinfo), refs, parent.isBoxed)
+      case tp: RecType =>
+        tp.parent match
+          case parent @ CapturingType(parent1, refs) =>
+            CapturingType(tp.derivedRecType(parent1), refs, parent.isBoxed)
+          case _ =>
+            tp // can return `tp` here since unlike RefinedTypes, RecTypes are never created
+                // by `mapInferred`. Hence if the underlying type admits capture variables
+                // a variable was already added, and the first case above would apply.
+      case AndType(tp1 @ CapturingType(parent1, refs1), tp2 @ CapturingType(parent2, refs2)) =>
+        assert(refs1.asVar.elems.isEmpty)
+        assert(refs2.asVar.elems.isEmpty)
+        assert(tp1.isBoxed == tp2.isBoxed)
+        CapturingType(AndType(parent1, parent2), refs1 ** refs2, tp1.isBoxed)
+      case tp @ OrType(tp1 @ CapturingType(parent1, refs1), tp2 @ CapturingType(parent2, refs2)) =>
+        assert(refs1.asVar.elems.isEmpty)
+        assert(refs2.asVar.elems.isEmpty)
+        assert(tp1.isBoxed == tp2.isBoxed)
+        CapturingType(OrType(parent1, parent2, tp.isSoft), refs1 ++ refs2, tp1.isBoxed)
+      case tp @ OrType(tp1 @ CapturingType(parent1, refs1), tp2) =>
+        CapturingType(OrType(parent1, tp2, tp.isSoft), refs1, tp1.isBoxed)
+      case tp @ OrType(tp1, tp2 @ CapturingType(parent2, refs2)) =>
+        CapturingType(OrType(tp1, parent2, tp.isSoft), refs2, tp2.isBoxed)
+      case _ if needsVariable(tp) =>
+        val cs = tp.dealias match
+          case CapturingType(_, refs) => CaptureSet.Var(refs.elems)
+          case _ => CaptureSet.Var()
+        CapturingType(tp, cs)
+      case _ =>
+        tp
+
+    private var isTopLevel = true
+
+    private def mapNested(ts: List[Type]): List[Type] =
+      val saved = isTopLevel
+      isTopLevel = false
+      try ts.mapConserve(this) finally isTopLevel = saved
+
+    def apply(t: Type) =
+      val tp = expandThrowsAlias(t)
+      val tp1 = tp match
+        case AnnotatedType(parent, annot) if annot.symbol == defn.RetainsAnnot =>
+          // Drop explicit retains annotations
+          apply(parent)
+        case tp @ AppliedType(tycon, args) =>
+          val tycon1 = this(tycon)
+          if defn.isNonRefinedFunction(tp) then
+            // Convert toplevel generic function types to dependent functions
+            val args0 = args.init
+            var res0 = args.last
+            val args1 = mapNested(args0)
+            val res1 = this(res0)
+            if isTopLevel then
+              depFun(tycon1, args1, res1)
+                .showing(i"add function refinement $tp --> $result", capt)
+            else if (tycon1 eq tycon) && (args1 eq args0) && (res1 eq res0) then
+              tp
+            else
+              tp.derivedAppliedType(tycon1, args1 :+ res1)
+          else
+            tp.derivedAppliedType(tycon1, args.mapConserve(arg => this(arg)))
+        case tp @ RefinedType(core, rname, rinfo) if defn.isFunctionType(tp) =>
+          val rinfo1 = apply(rinfo)
+          if rinfo1 ne rinfo then rinfo1.toFunctionType(isJava = false, alwaysDependent = true)
+          else tp
+        case tp: MethodType =>
+          tp.derivedLambdaType(
+            paramInfos = mapNested(tp.paramInfos),
+            resType = this(tp.resType))
+        case tp: TypeLambda =>
+          // Don't recurse into parameter bounds, just cleanup any stray retains annotations
+          tp.derivedLambdaType(
+            paramInfos = tp.paramInfos.mapConserve(cleanup(_).bounds),
+            resType = this(tp.resType))
+        case _ =>
+          mapOver(tp)
+      addVar(addCaptureRefinements(tp1))
+    end apply
+  end mapInferred
+
+  private def transformInferredType(tp: Type, boxed: Boolean)(using Context): Type =
+    val tp1 = mapInferred(tp)
+    if boxed then box(tp1) else tp1
+
+  /** Expand some aliases of function types to the underlying functions.
+   *  Right now, these are only $throws aliases, but this could be generalized.
+   */
+  private def expandThrowsAlias(tp: Type)(using Context) = tp match
+    case AppliedType(tycon, res :: exc :: Nil) if tycon.typeSymbol == defn.throwsAlias =>
+      // hard-coded expansion since $throws aliases in stdlib are defined with `?=>` rather than `?->`
+      defn.FunctionOf(defn.CanThrowClass.typeRef.appliedTo(exc) :: Nil, res, isContextual = true, isErased = true)
+    case _ => tp
+
+  private def expandThrowsAliases(using Context) = new TypeMap:
+    def apply(t: Type) = t match
+      case _: AppliedType =>
+        val t1 = expandThrowsAlias(t)
+        if t1 ne t then apply(t1) else mapOver(t)
+      case _: LazyRef =>
+        t
+      case t @ AnnotatedType(t1, ann) =>
+        // Don't map capture sets, since that would implicitly normalize sets that
+        // are not well-formed.
+        t.derivedAnnotatedType(apply(t1), ann)
+      case _ =>
+        mapOver(t)
+
+  /** Fill in capture sets of curried function types from left to right, using
+   *  a combination of the following two rules:
+   *
+   *   1. Expand `{c} (x: A) -> (y: B) -> C`
+   *          to `{c} (x: A) -> {c} (y: B) -> C`
+   *   2. Expand `(x: A) -> (y: B) -> C` where `x` is tracked
+   *          to `(x: A) -> {x} (y: B) -> C`
+   *
+   *  TODO: Should we also propagate capture sets to the left?
+   */
+  private def expandAbbreviations(using Context) = new TypeMap:
+
+    /** Propagate `outerCs` as well as all tracked parameters as capture set to the result type
+     *  of the dependent function type `tp`.
+     */
+    def propagateDepFunctionResult(tp: Type, outerCs: CaptureSet): Type = tp match
+      case RefinedType(parent, nme.apply, rinfo: MethodType) =>
+        val localCs = CaptureSet(rinfo.paramRefs.filter(_.isTracked)*)
+        val rinfo1 = rinfo.derivedLambdaType(
+          resType = propagateEnclosing(rinfo.resType, CaptureSet.empty, outerCs ++ localCs))
+        if rinfo1 ne rinfo then rinfo1.toFunctionType(isJava = false, alwaysDependent = true)
+        else tp
+
+    /** If `tp` is a function type:
+     *   - add `outerCs` as its capture set,
+     *   - propagate `currentCs`, `outerCs`, and all tracked parameters of `tp` to the right.
+     */
+    def propagateEnclosing(tp: Type, currentCs: CaptureSet, outerCs: CaptureSet): Type = tp match
+      case tp @ AppliedType(tycon, args) if defn.isFunctionClass(tycon.typeSymbol) =>
+        val tycon1 = this(tycon)
+        val args1 = args.init.mapConserve(this)
+        val tp1 =
+          if args1.exists(!_.captureSet.isAlwaysEmpty) then
+            val propagated = propagateDepFunctionResult(
+              depFun(tycon, args1, args.last), currentCs ++ outerCs)
+            propagated match
+              case RefinedType(_, _, mt: MethodType) =>
+                if mt.isCaptureDependent then propagated
+                else
+                  // No need to introduce dependent type, switch back to generic function type
+                  tp.derivedAppliedType(tycon1, args1 :+ mt.resType)
+          else
+            val resType1 = propagateEnclosing(
+              args.last, CaptureSet.empty, currentCs ++ outerCs)
+            tp.derivedAppliedType(tycon1, args1 :+ resType1)
+        tp1.capturing(outerCs)
+      case tp @ RefinedType(parent, nme.apply, rinfo: MethodType) if defn.isFunctionType(tp) =>
+        propagateDepFunctionResult(mapOver(tp), currentCs ++ outerCs)
+          .capturing(outerCs)
+      case _ =>
+        mapOver(tp)
+
+    def apply(tp: Type): Type = tp match
+      case CapturingType(parent, cs) =>
+        tp.derivedCapturingType(propagateEnclosing(parent, cs, CaptureSet.empty), cs)
+      case _ =>
+        propagateEnclosing(tp, CaptureSet.empty, CaptureSet.empty)
+  end expandAbbreviations
+
+  private def transformExplicitType(tp: Type, boxed: Boolean)(using Context): Type =
+    val tp1 = expandThrowsAliases(if boxed then box(tp) else tp)
+    if tp1 ne tp then capt.println(i"expanded: $tp --> $tp1")
+    if ctx.settings.YccNoAbbrev.value then tp1
+    else expandAbbreviations(tp1)
+
+  /** Transform type of type tree, and remember the transformed type as the type the tree */
+  private def transformTT(tree: TypeTree, boxed: Boolean, exact: Boolean)(using Context): Unit =
+    if !tree.hasRememberedType then
+      tree.rememberType(
+        if tree.isInstanceOf[InferredTypeTree] && !exact
+        then transformInferredType(tree.tpe, boxed)
+        else transformExplicitType(tree.tpe, boxed))
+
+  /** Substitute parameter symbols in `from` to paramRefs in corresponding
+   *  method or poly types `to`. We use a single BiTypeMap to do everything.
+   *  @param from  a list of lists of type or term parameter symbols of a curried method
+   *  @param to    a list of method or poly types corresponding one-to-one to the parameter lists
+   */
+  private class SubstParams(from: List[List[Symbol]], to: List[LambdaType])(using Context)
+  extends DeepTypeMap, BiTypeMap:
+
+    def apply(t: Type): Type = t match
+      case t: NamedType =>
+        val sym = t.symbol
+        def outer(froms: List[List[Symbol]], tos: List[LambdaType]): Type =
+          def inner(from: List[Symbol], to: List[ParamRef]): Type =
+            if from.isEmpty then outer(froms.tail, tos.tail)
+            else if sym eq from.head then to.head
+            else inner(from.tail, to.tail)
+          if tos.isEmpty then t
+          else inner(froms.head, tos.head.paramRefs)
+        outer(from, to)
+      case _ =>
+        mapOver(t)
+
+    def inverse(t: Type): Type = t match
+      case t: ParamRef =>
+        def recur(from: List[LambdaType], to: List[List[Symbol]]): Type =
+          if from.isEmpty then t
+          else if t.binder eq from.head then to.head(t.paramNum).namedType
+          else recur(from.tail, to.tail)
+        recur(to, from)
+      case _ =>
+        mapOver(t)
+  end SubstParams
+
+  /** Update info of `sym` for CheckCaptures phase only */
+  private def updateInfo(sym: Symbol, info: Type)(using Context) =
+    sym.updateInfoBetween(preRecheckPhase, thisPhase, info)
+
+  def traverse(tree: Tree)(using Context): Unit =
+    tree match
+      case tree: DefDef =>
+        if isExcluded(tree.symbol) then
+          return
+        tree.tpt match
+          case tpt: TypeTree if tree.symbol.allOverriddenSymbols.hasNext =>
+            tree.paramss.foreach(traverse)
+            transformTT(tpt, boxed = false, exact = true)
+            traverse(tree.rhs)
+            //println(i"TYPE of ${tree.symbol.showLocated} = ${tpt.knownType}")
+          case _ =>
+            traverseChildren(tree)
+      case tree @ ValDef(_, tpt: TypeTree, _) =>
+        transformTT(tpt,
+          boxed = tree.symbol.is(Mutable),    // types of mutable variables are boxed
+          exact = tree.symbol.allOverriddenSymbols.hasNext // types of symbols that override a parent don't get a capture set
+        )
+        traverse(tree.rhs)
+      case tree @ TypeApply(fn, args) =>
+        traverse(fn)
+        for case arg: TypeTree <- args do
+          transformTT(arg, boxed = true, exact = false) // type arguments in type applications are boxed
+      case _ =>
+        traverseChildren(tree)
+    tree match
+      case tree: TypeTree =>
+        transformTT(tree, boxed = false, exact = false) // other types are not boxed
+      case tree: ValOrDefDef =>
+        val sym = tree.symbol
+
+        // replace an existing symbol info with inferred types where capture sets of
+        // TypeParamRefs and TermParamRefs put in correspondence by BiTypeMaps with the
+        // capture sets of the types of the method's parameter symbols and result type.
+        def integrateRT(
+            info: Type,                     // symbol info to replace
+            psymss: List[List[Symbol]],     // the local (type and term) parameter symbols corresponding to `info`
+            prevPsymss: List[List[Symbol]], // the local parameter symbols seen previously in reverse order
+            prevLambdas: List[LambdaType]   // the outer method and polytypes generated previously in reverse order
+          ): Type =
+          info match
+            case mt: MethodOrPoly =>
+              val psyms = psymss.head
+              mt.companion(mt.paramNames)(
+                mt1 =>
+                  if !psyms.exists(_.isUpdatedAfter(preRecheckPhase)) && !mt.isParamDependent && prevLambdas.isEmpty then
+                    mt.paramInfos
+                  else
+                    val subst = SubstParams(psyms :: prevPsymss, mt1 :: prevLambdas)
+                    psyms.map(psym => subst(psym.info).asInstanceOf[mt.PInfo]),
+                mt1 =>
+                  integrateRT(mt.resType, psymss.tail, psyms :: prevPsymss, mt1 :: prevLambdas)
+              )
+            case info: ExprType =>
+              info.derivedExprType(resType =
+                integrateRT(info.resType, psymss, prevPsymss, prevLambdas))
+            case _ =>
+              val restp = tree.tpt.knownType
+              if prevLambdas.isEmpty then restp
+              else SubstParams(prevPsymss, prevLambdas)(restp)
+
+        if tree.tpt.hasRememberedType && !sym.isConstructor then
+          val newInfo = integrateRT(sym.info, sym.paramSymss, Nil, Nil)
+            .showing(i"update info $sym: ${sym.info} --> $result", capt)
+          if newInfo ne sym.info then
+            val completer = new LazyType:
+              def complete(denot: SymDenotation)(using Context) =
+                denot.info = newInfo
+                recheckDef(tree, sym)
+            updateInfo(sym, completer)
+      case tree: Bind =>
+        val sym = tree.symbol
+        updateInfo(sym, transformInferredType(sym.info, boxed = false))
+      case tree: TypeDef =>
+        tree.symbol match
+          case cls: ClassSymbol =>
+            val cinfo @ ClassInfo(prefix, _, ps, decls, selfInfo) = cls.classInfo
+            if (selfInfo eq NoType) || cls.is(ModuleClass) && !cls.isStatic then
+              // add capture set to self type of nested classes if no self type is given explicitly
+              val localRefs = CaptureSet.Var()
+              val newInfo = ClassInfo(prefix, cls, ps, decls,
+                CapturingType(cinfo.selfType, localRefs)
+                  .showing(i"inferred self type for $cls: $result", capt))
+              updateInfo(cls, newInfo)
+              cls.thisType.asInstanceOf[ThisType].invalidateCaches()
+              if cls.is(ModuleClass) then
+                // if it's a module, the capture set of the module reference is the capture set of the self type
+                val modul = cls.sourceModule
+                updateInfo(modul, CapturingType(modul.info, localRefs))
+                modul.termRef.invalidateCaches()
+          case _ =>
+            val info = atPhase(preRecheckPhase)(tree.symbol.info)
+            val newInfo = transformExplicitType(info, boxed = false)
+            if newInfo ne info then
+              updateInfo(tree.symbol, newInfo)
+              capt.println(i"update info of ${tree.symbol} from $info to $newInfo")
+      case _ =>
+  end traverse
+end Setup
diff --git a/tests/pos-with-compiler-cc/dotc/cc/Synthetics.scala b/tests/pos-with-compiler-cc/dotc/cc/Synthetics.scala
new file mode 100644
index 000000000000..dacbd27e0f35
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/cc/Synthetics.scala
@@ -0,0 +1,189 @@
+package dotty.tools
+package dotc
+package cc
+
+import core.*
+import Symbols.*, SymDenotations.*, Contexts.*, Flags.*, Types.*, Decorators.*
+import StdNames.nme
+import Names.Name
+import NameKinds.DefaultGetterName
+import Phases.checkCapturesPhase
+import config.Printers.capt
+
+/** Classification and transformation methods for synthetic
+ *  case class methods that need to be treated specially.
+ *  In particular, compute capturing types for some of these methods which
+ *  have inferred (result-)types that need to be established under separate
+ *  compilation.
+ */
+object Synthetics:
+  private def isSyntheticCopyMethod(sym: SymDenotation)(using Context) =
+    sym.name == nme.copy && sym.is(Synthetic) && sym.owner.isClass && sym.owner.is(Case)
+
+  private def isSyntheticCompanionMethod(sym: SymDenotation, names: Name*)(using Context): Boolean =
+     names.contains(sym.name) && sym.is(Synthetic) && sym.owner.is(Module) && sym.owner.companionClass.is(Case)
+
+  private def isSyntheticCopyDefaultGetterMethod(sym: SymDenotation)(using Context) = sym.name match
+    case DefaultGetterName(nme.copy, _) => sym.is(Synthetic) && sym.owner.isClass && sym.owner.is(Case)
+    case _ => false
+
+  /** Is `sym` a synthetic apply, copy, or copy default getter method?
+   *  The types of these symbols are transformed in a special way without
+   *  looking at the definitions's RHS
+   */
+  def needsTransform(symd: SymDenotation)(using Context): Boolean =
+    isSyntheticCopyMethod(symd)
+    || isSyntheticCompanionMethod(symd, nme.apply, nme.unapply)
+    || isSyntheticCopyDefaultGetterMethod(symd)
+    || (symd.symbol eq defn.Object_eq)
+    || (symd.symbol eq defn.Object_ne)
+
+  /** Method is excluded from regular capture checking.
+   *  Excluded are synthetic class members
+   *   - that override a synthesized case class symbol, or
+   *   - the fromProduct method, or
+   *   - members transformed specially as indicated by `needsTransform`.
+   */
+  def isExcluded(sym: Symbol)(using Context): Boolean =
+    sym.is(Synthetic)
+    && sym.owner.isClass
+    && ( defn.caseClassSynthesized.exists(
+             ccsym => sym.overriddenSymbol(ccsym.owner.asClass) == ccsym)
+        || isSyntheticCompanionMethod(sym, nme.fromProduct)
+        || needsTransform(sym))
+
+  /** Add capture dependencies to the type of the `apply` or `copy` method of a case class.
+   *  An apply method in a case class like this:
+   *    case class CC(a: {d} A, b: B, {*} c: C)
+   *  would get type
+   *    def apply(a': {d} A, b: B, {*} c': C): {a', c'} CC { val a = {a'} A, val c = {c'} C }
+   *  where `'` is used to indicate the difference between parameter symbol and refinement name.
+   *  Analogous for the copy method.
+   */
+  private def addCaptureDeps(info: Type)(using Context): Type = info match
+    case info: MethodType =>
+      val trackedParams = info.paramRefs.filter(atPhase(checkCapturesPhase)(_.isTracked))
+      def augmentResult(tp: Type): Type = tp match
+        case tp: MethodOrPoly =>
+          tp.derivedLambdaType(resType = augmentResult(tp.resType))
+        case _ =>
+          val refined = trackedParams.foldLeft(tp) { (parent, pref) =>
+            RefinedType(parent, pref.paramName,
+              CapturingType(
+                atPhase(ctx.phase.next)(pref.underlying.stripCapturing),
+                CaptureSet(pref)))
+          }
+          CapturingType(refined, CaptureSet(trackedParams*))
+      if trackedParams.isEmpty then info
+      else augmentResult(info).showing(i"augment apply/copy type $info to $result", capt)
+    case info: PolyType =>
+      info.derivedLambdaType(resType = addCaptureDeps(info.resType))
+    case _ =>
+      info
+
+  /** Drop capture dependencies from the type of `apply` or `copy` method of a case class */
+  private def dropCaptureDeps(tp: Type)(using Context): Type = tp match
+    case tp: MethodOrPoly =>
+      tp.derivedLambdaType(resType = dropCaptureDeps(tp.resType))
+    case CapturingType(parent, _) =>
+      dropCaptureDeps(parent)
+    case RefinedType(parent, _, _) =>
+      dropCaptureDeps(parent)
+    case _ =>
+      tp
+
+  /** Add capture information to the type of the default getter of a case class copy method */
+  private def addDefaultGetterCapture(info: Type, owner: Symbol, idx: Int)(using Context): Type = info match
+    case info: MethodOrPoly =>
+      info.derivedLambdaType(resType = addDefaultGetterCapture(info.resType, owner, idx))
+    case info: ExprType =>
+      info.derivedExprType(addDefaultGetterCapture(info.resType, owner, idx))
+    case EventuallyCapturingType(parent, _) =>
+      addDefaultGetterCapture(parent, owner, idx)
+    case info @ AnnotatedType(parent, annot) =>
+      info.derivedAnnotatedType(addDefaultGetterCapture(parent, owner, idx), annot)
+    case _ if idx < owner.asClass.paramGetters.length =>
+      val param = owner.asClass.paramGetters(idx)
+      val pinfo = param.info
+      atPhase(ctx.phase.next) {
+        if pinfo.captureSet.isAlwaysEmpty then info
+        else CapturingType(pinfo.stripCapturing, CaptureSet(param.termRef))
+      }
+    case _ =>
+      info
+
+  /** Drop capture information from the type of the default getter of a case class copy method */
+  private def dropDefaultGetterCapture(info: Type)(using Context): Type = info match
+    case info: MethodOrPoly =>
+      info.derivedLambdaType(resType = dropDefaultGetterCapture(info.resType))
+    case CapturingType(parent, _) =>
+      parent
+    case info @ AnnotatedType(parent, annot) =>
+      info.derivedAnnotatedType(dropDefaultGetterCapture(parent), annot)
+    case _ =>
+      info
+
+  /** Augment an unapply of type `(x: C): D` to `(x: {*} C): {x} D` */
+  private def addUnapplyCaptures(info: Type)(using Context): Type = info match
+    case info: MethodType =>
+      val paramInfo :: Nil = info.paramInfos: @unchecked
+      val newParamInfo =
+        CapturingType(paramInfo, CaptureSet.universal)
+      val trackedParam = info.paramRefs.head
+      def newResult(tp: Type): Type = tp match
+        case tp: MethodOrPoly =>
+          tp.derivedLambdaType(resType = newResult(tp.resType))
+        case _ =>
+          CapturingType(tp, CaptureSet(trackedParam))
+      info.derivedLambdaType(paramInfos = newParamInfo :: Nil, resType = newResult(info.resType))
+        .showing(i"augment unapply type $info to $result", capt)
+    case info: PolyType =>
+      info.derivedLambdaType(resType = addUnapplyCaptures(info.resType))
+
+  /** Drop added capture information from the type of an `unapply` */
+  private def dropUnapplyCaptures(info: Type)(using Context): Type = info match
+    case info: MethodType =>
+      info.paramInfos match
+        case CapturingType(oldParamInfo, _) :: Nil =>
+          def oldResult(tp: Type): Type = tp match
+            case tp: MethodOrPoly =>
+              tp.derivedLambdaType(resType = oldResult(tp.resType))
+            case CapturingType(tp, _) =>
+              tp
+          info.derivedLambdaType(paramInfos = oldParamInfo :: Nil, resType = oldResult(info.resType))
+        case _ =>
+          info
+    case info: PolyType =>
+      info.derivedLambdaType(resType = dropUnapplyCaptures(info.resType))
+
+  /** If `sym` refers to a synthetic apply, unapply, copy, or copy default getter method
+   *  of a case class, transform it to account for capture information.
+   *  The method is run in phase CheckCaptures.Pre
+   *  @pre needsTransform(sym)
+   */
+  def transformToCC(sym: SymDenotation)(using Context): SymDenotation = sym.name match
+    case DefaultGetterName(nme.copy, n) =>
+      sym.copySymDenotation(info = addDefaultGetterCapture(sym.info, sym.owner, n))
+    case nme.unapply =>
+      sym.copySymDenotation(info = addUnapplyCaptures(sym.info))
+    case nme.apply | nme.copy =>
+      sym.copySymDenotation(info = addCaptureDeps(sym.info))
+    case n if n == nme.eq || n == nme.ne =>
+      sym.copySymDenotation(info =
+        MethodType(defn.ObjectType.capturing(CaptureSet.universal) :: Nil, defn.BooleanType))
+
+  /** If `sym` refers to a synthetic apply, unapply, copy, or copy default getter method
+   *  of a case class, transform it back to what it was before the CC phase.
+   *  @pre needsTransform(sym)
+   */
+  def transformFromCC(sym: SymDenotation)(using Context): SymDenotation = sym.name match
+    case DefaultGetterName(nme.copy, n) =>
+      sym.copySymDenotation(info = dropDefaultGetterCapture(sym.info))
+    case nme.unapply =>
+      sym.copySymDenotation(info = dropUnapplyCaptures(sym.info))
+    case nme.apply | nme.copy =>
+      sym.copySymDenotation(info = dropCaptureDeps(sym.info))
+    case n if n == nme.eq || n == nme.ne =>
+      sym.copySymDenotation(info = defn.methOfAnyRef(defn.BooleanType))
+
+end Synthetics
\ No newline at end of file
diff --git a/tests/pos-with-compiler-cc/dotc/classpath/AggregateClassPath.scala b/tests/pos-with-compiler-cc/dotc/classpath/AggregateClassPath.scala
new file mode 100644
index 000000000000..51b261583feb
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/classpath/AggregateClassPath.scala
@@ -0,0 +1,162 @@
+/*
+ * Copyright (c) 2014 Contributor. All rights reserved.
+ */
+package dotty.tools
+package dotc.classpath
+
+import scala.language.unsafeNulls
+
+import java.net.URL
+import scala.collection.mutable.ArrayBuffer
+import scala.collection.immutable.ArraySeq
+import dotc.util
+
+import dotty.tools.io.{ AbstractFile, ClassPath, ClassRepresentation, EfficientClassPath }
+
+/**
+ * A classpath unifying multiple class- and sourcepath entries.
+ * The Classpath can obtain entries for classes and sources independently
+ * so it tries to do operations quite optimally - iterating only these collections
+ * which are needed in the given moment and only as far as it's necessary.
+ *
+ * @param aggregates classpath instances containing entries which this class processes
+ */
+case class AggregateClassPath(aggregates: Seq[ClassPath]) extends ClassPath {
+  override def findClassFile(className: String): Option[AbstractFile] = {
+    val (pkg, _) = PackageNameUtils.separatePkgAndClassNames(className)
+    aggregatesForPackage(PackageName(pkg)).iterator.map(_.findClassFile(className)).collectFirst {
+      case Some(x) => x
+    }
+  }
+  private val packageIndex: collection.mutable.Map[String, Seq[ClassPath]] = collection.mutable.Map()
+  private def aggregatesForPackage(pkg: PackageName): Seq[ClassPath] = packageIndex.synchronized {
+    packageIndex.getOrElseUpdate(pkg.dottedString, aggregates.filter(_.hasPackage(pkg)))
+  }
+
+  override def findClass(className: String): Option[ClassRepresentation] = {
+    val (pkg, _) = PackageNameUtils.separatePkgAndClassNames(className)
+
+    def findEntry(isSource: Boolean): Option[ClassRepresentation] =
+      aggregatesForPackage(PackageName(pkg)).iterator.map(_.findClass(className)).collectFirst {
+        case Some(s: SourceFileEntry) if isSource => s
+        case Some(s: ClassFileEntry) if !isSource => s
+      }
+
+    val classEntry = findEntry(isSource = false)
+    val sourceEntry = findEntry(isSource = true)
+
+    (classEntry, sourceEntry) match {
+      case (Some(c: ClassFileEntry), Some(s: SourceFileEntry)) => Some(ClassAndSourceFilesEntry(c.file, s.file))
+      case (c @ Some(_), _) => c
+      case (_, s) => s
+    }
+  }
+
+  override def asURLs: Seq[URL] = aggregates.flatMap(_.asURLs)
+
+  override def asClassPathStrings: Seq[String] = aggregates.map(_.asClassPathString).distinct
+
+  override def asSourcePathString: String = ClassPath.join(aggregates map (_.asSourcePathString): _*)
+
+  override private[dotty] def packages(inPackage: PackageName): Seq[PackageEntry] = {
+    val aggregatedPackages = aggregates.flatMap(_.packages(inPackage)).distinct
+    aggregatedPackages
+  }
+
+  override private[dotty] def classes(inPackage: PackageName): Seq[ClassFileEntry] =
+    getDistinctEntries(_.classes(inPackage))
+
+  override private[dotty] def sources(inPackage: PackageName): Seq[SourceFileEntry] =
+    getDistinctEntries(_.sources(inPackage))
+
+  override private[dotty] def hasPackage(pkg: PackageName): Boolean = aggregates.exists(_.hasPackage(pkg))
+  override private[dotty] def list(inPackage: PackageName): ClassPathEntries = {
+    val packages: java.util.HashSet[PackageEntry] = new java.util.HashSet[PackageEntry]()
+    val classesAndSourcesBuffer = collection.mutable.ArrayBuffer[ClassRepresentation]()
+    val onPackage: PackageEntry => Unit = packages.add(_)
+    val onClassesAndSources: ClassRepresentation => Unit = classesAndSourcesBuffer += _
+
+    aggregates.foreach { cp =>
+      try {
+        cp match {
+          case ecp: EfficientClassPath =>
+            ecp.list(inPackage, onPackage, onClassesAndSources)
+          case _ =>
+            val entries = cp.list(inPackage)
+            entries._1.foreach(entry => packages.add(entry))
+            classesAndSourcesBuffer ++= entries._2
+        }
+      } catch {
+        case ex: java.io.IOException =>
+          val e = FatalError(ex.getMessage)
+          e.initCause(ex)
+          throw e
+      }
+    }
+
+    val distinctPackages: Seq[PackageEntry] = {
+      val arr = packages.toArray(new Array[PackageEntry](packages.size()))
+      ArraySeq.unsafeWrapArray(arr)
+    }
+    val distinctClassesAndSources = mergeClassesAndSources(classesAndSourcesBuffer)
+    ClassPathEntries(distinctPackages, distinctClassesAndSources)
+  }
+
+  /**
+   * Returns only one entry for each name. If there's both a source and a class entry, it
+   * creates an entry containing both of them. If there would be more than one class or source
+   * entries for the same class it always would use the first entry of each type found on a classpath.
+   */
+  private def mergeClassesAndSources(entries: scala.collection.Seq[ClassRepresentation]): Seq[ClassRepresentation] = {
+    // based on the implementation from MergedClassPath
+    var count = 0
+    val indices = util.HashMap[String, Int]()
+    val mergedEntries = new ArrayBuffer[ClassRepresentation](entries.size)
+    for {
+      entry <- entries
+    } {
+      val name = entry.name
+      if (indices.contains(name)) {
+        val index = indices(name)
+        val existing = mergedEntries(index)
+
+        if (existing.binary.isEmpty && entry.binary.isDefined)
+          mergedEntries(index) = ClassAndSourceFilesEntry(entry.binary.get, existing.source.get)
+        if (existing.source.isEmpty && entry.source.isDefined)
+          mergedEntries(index) = ClassAndSourceFilesEntry(existing.binary.get, entry.source.get)
+      }
+      else {
+        indices(name) = count
+        mergedEntries += entry
+        count += 1
+      }
+    }
+    if (mergedEntries.isEmpty) Nil else mergedEntries.toIndexedSeq
+  }
+
+  private def getDistinctEntries[EntryType <: ClassRepresentation](getEntries: ClassPath => Seq[EntryType]): Seq[EntryType] = {
+    val seenNames = util.HashSet[String]()
+    val entriesBuffer = new ArrayBuffer[EntryType](1024)
+    for {
+      cp <- aggregates
+      entry <- getEntries(cp) if !seenNames.contains(entry.name)
+    }
+    {
+      entriesBuffer += entry
+      seenNames += entry.name
+    }
+    entriesBuffer.toIndexedSeq
+  }
+}
+
+object AggregateClassPath {
+  def createAggregate(parts: ClassPath*): ClassPath = {
+    val elems = new ArrayBuffer[ClassPath]()
+    parts foreach {
+      case AggregateClassPath(ps) => elems ++= ps
+      case p => elems += p
+    }
+    if (elems.size == 1) elems.head
+    else AggregateClassPath(elems.toIndexedSeq)
+  }
+}
diff --git a/tests/pos-with-compiler-cc/dotc/classpath/ClassPath.scala b/tests/pos-with-compiler-cc/dotc/classpath/ClassPath.scala
new file mode 100644
index 000000000000..176b6acf9c6c
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/classpath/ClassPath.scala
@@ -0,0 +1,85 @@
+/*
+ * Copyright (c) 2014 Contributor. All rights reserved.
+ */
+package dotty.tools.dotc.classpath
+
+import dotty.tools.io.AbstractFile
+import dotty.tools.io.ClassRepresentation
+
+case class ClassPathEntries(packages: scala.collection.Seq[PackageEntry], classesAndSources: scala.collection.Seq[ClassRepresentation]) {
+  def toTuple: (scala.collection.Seq[PackageEntry], scala.collection.Seq[ClassRepresentation]) = (packages, classesAndSources)
+}
+
+object ClassPathEntries {
+  val empty = ClassPathEntries(Seq.empty, Seq.empty)
+}
+
+trait ClassFileEntry extends ClassRepresentation {
+  def file: AbstractFile
+}
+
+trait SourceFileEntry extends ClassRepresentation {
+  def file: AbstractFile
+}
+
+case class PackageName(dottedString: String) {
+  val dirPathTrailingSlashJar: String = FileUtils.dirPathInJar(dottedString) + "/"
+
+  val dirPathTrailingSlash: String =
+    if (java.io.File.separatorChar == '/')
+      dirPathTrailingSlashJar
+    else
+      FileUtils.dirPath(dottedString) + java.io.File.separator
+
+  def isRoot: Boolean = dottedString.isEmpty
+
+  def entryName(entry: String): String = {
+    if (isRoot) entry else {
+      val builder = new java.lang.StringBuilder(dottedString.length + 1 + entry.length)
+      builder.append(dottedString)
+      builder.append('.')
+      builder.append(entry)
+      builder.toString
+    }
+  }
+}
+
+trait PackageEntry {
+  def name: String
+}
+
+private[dotty] case class ClassFileEntryImpl(file: AbstractFile) extends ClassFileEntry {
+  final def fileName: String = file.name
+  def name: String = FileUtils.stripClassExtension(file.name) // class name
+
+  def binary: Option[AbstractFile] = Some(file)
+  def source: Option[AbstractFile] = None
+}
+
+private[dotty] case class SourceFileEntryImpl(file: AbstractFile) extends SourceFileEntry {
+  final def fileName: String = file.name
+  def name: String = FileUtils.stripSourceExtension(file.name)
+
+  def binary: Option[AbstractFile] = None
+  def source: Option[AbstractFile] = Some(file)
+}
+
+private[dotty] case class ClassAndSourceFilesEntry(classFile: AbstractFile, srcFile: AbstractFile) extends ClassRepresentation {
+  final def fileName: String = classFile.name
+  def name: String = FileUtils.stripClassExtension(classFile.name)
+
+  def binary: Option[AbstractFile] = Some(classFile)
+  def source: Option[AbstractFile] = Some(srcFile)
+}
+
+private[dotty] case class PackageEntryImpl(name: String) extends PackageEntry
+
+private[dotty] trait NoSourcePaths {
+  def asSourcePathString: String = ""
+  private[dotty] def sources(inPackage: PackageName): Seq[SourceFileEntry] = Seq.empty
+}
+
+private[dotty] trait NoClassPaths {
+  def findClassFile(className: String): Option[AbstractFile] = None
+  private[dotty] def classes(inPackage: PackageName): Seq[ClassFileEntry] = Seq.empty
+}
diff --git a/tests/pos-with-compiler-cc/dotc/classpath/ClassPathFactory.scala b/tests/pos-with-compiler-cc/dotc/classpath/ClassPathFactory.scala
new file mode 100644
index 000000000000..ac8b69381938
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/classpath/ClassPathFactory.scala
@@ -0,0 +1,84 @@
+/*
+ * Copyright (c) 2014 Contributor. All rights reserved.
+ */
+package dotty.tools.dotc.classpath
+
+import dotty.tools.io.{AbstractFile, VirtualDirectory}
+import FileUtils._
+import dotty.tools.io.ClassPath
+import dotty.tools.dotc.core.Contexts._
+
+/**
+ * Provides factory methods for classpath. When creating classpath instances for a given path,
+ * it uses proper type of classpath depending on a types of particular files containing sources or classes.
+ */
+class ClassPathFactory {
+  /**
+    * Create a new classpath based on the abstract file.
+    */
+  def newClassPath(file: AbstractFile)(using Context): ClassPath = ClassPathFactory.newClassPath(file)
+
+  /**
+    * Creators for sub classpaths which preserve this context.
+    */
+  def sourcesInPath(path: String)(using Context): List[ClassPath] =
+    for {
+      file <- expandPath(path, expandStar = false)
+      dir <- Option(AbstractFile getDirectory file)
+    }
+    yield createSourcePath(dir)
+
+
+  def expandPath(path: String, expandStar: Boolean = true): List[String] = dotty.tools.io.ClassPath.expandPath(path, expandStar)
+
+  def expandDir(extdir: String): List[String] = dotty.tools.io.ClassPath.expandDir(extdir)
+
+  def contentsOfDirsInPath(path: String)(using Context): List[ClassPath] =
+    for {
+      dir <- expandPath(path, expandStar = false)
+      name <- expandDir(dir)
+      entry <- Option(AbstractFile.getDirectory(name))
+    }
+    yield newClassPath(entry)
+
+  def classesInExpandedPath(path: String)(using Context): IndexedSeq[ClassPath] =
+    classesInPathImpl(path, expand = true).toIndexedSeq
+
+  def classesInPath(path: String)(using Context): List[ClassPath] = classesInPathImpl(path, expand = false)
+
+  def classesInManifest(useManifestClassPath: Boolean)(using Context): List[ClassPath] =
+    if (useManifestClassPath) dotty.tools.io.ClassPath.manifests.map(url => newClassPath(AbstractFile getResources url))
+    else Nil
+
+  // Internal
+  protected def classesInPathImpl(path: String, expand: Boolean)(using Context): List[ClassPath] =
+    for {
+      file <- expandPath(path, expand)
+      dir <- {
+        def asImage = if (file.endsWith(".jimage")) Some(AbstractFile.getFile(file)) else None
+        Option(AbstractFile.getDirectory(file)).orElse(asImage)
+      }
+    }
+    yield newClassPath(dir)
+
+  private def createSourcePath(file: AbstractFile)(using Context): ClassPath =
+    if (file.isJarOrZip)
+      ZipAndJarSourcePathFactory.create(file)
+    else if (file.isDirectory)
+      new DirectorySourcePath(file.file)
+    else
+      sys.error(s"Unsupported sourcepath element: $file")
+}
+
+object ClassPathFactory {
+  def newClassPath(file: AbstractFile)(using Context): ClassPath = file match {
+    case vd: VirtualDirectory => VirtualDirectoryClassPath(vd)
+    case _ =>
+      if (file.isJarOrZip)
+        ZipAndJarClassPathFactory.create(file)
+      else if (file.isDirectory)
+        new DirectoryClassPath(file.file)
+      else
+        sys.error(s"Unsupported classpath element: $file")
+  }
+}
diff --git a/tests/pos-with-compiler-cc/dotc/classpath/DirectoryClassPath.scala b/tests/pos-with-compiler-cc/dotc/classpath/DirectoryClassPath.scala
new file mode 100644
index 000000000000..a5678970411b
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/classpath/DirectoryClassPath.scala
@@ -0,0 +1,313 @@
+/*
+ * Copyright (c) 2014 Contributor. All rights reserved.
+ */
+package dotty.tools.dotc.classpath
+
+import scala.language.unsafeNulls
+
+import java.io.{File => JFile}
+import java.net.URL
+import java.nio.file.{FileSystems, Files}
+
+import dotty.tools.dotc.classpath.PackageNameUtils.{packageContains, separatePkgAndClassNames}
+import dotty.tools.io.{AbstractFile, PlainFile, ClassPath, ClassRepresentation, EfficientClassPath, JDK9Reflectors}
+import FileUtils._
+import PlainFile.toPlainFile
+
+import scala.jdk.CollectionConverters._
+import scala.collection.immutable.ArraySeq
+import scala.util.control.NonFatal
+import language.experimental.pureFunctions
+
+/**
+ * A trait allowing to look for classpath entries in directories. It provides common logic for
+ * classes handling class and source files.
+ * It makes use of the fact that in the case of nested directories it's easy to find a file
+ * when we have a name of a package.
+ * It abstracts over the file representation to work with both JFile and AbstractFile.
+ */
+trait DirectoryLookup[FileEntryType <: ClassRepresentation] extends EfficientClassPath {
+  type F
+
+  val dir: F
+
+  protected def emptyFiles: Array[F] // avoids reifying ClassTag[F]
+  protected def getSubDir(dirName: String): Option[F]
+  protected def listChildren(dir: F, filter: Option[F -> Boolean] = (None: Option[F -> Boolean])): Array[F] // !cc! need explicit typing of default argument
+  protected def getName(f: F): String
+  protected def toAbstractFile(f: F): AbstractFile
+  protected def isPackage(f: F): Boolean
+
+  protected def createFileEntry(file: AbstractFile): FileEntryType
+  protected def isMatchingFile(f: F): Boolean
+
+  private def getDirectory(forPackage: PackageName): Option[F] =
+    if (forPackage.isRoot)
+      Some(dir)
+    else
+      getSubDir(forPackage.dirPathTrailingSlash)
+
+  override private[dotty] def hasPackage(pkg: PackageName): Boolean = getDirectory(pkg).isDefined
+
+  private[dotty] def packages(inPackage: PackageName): Seq[PackageEntry] = {
+    val dirForPackage = getDirectory(inPackage)
+    val nestedDirs: Array[F] = dirForPackage match {
+      case None => emptyFiles
+      case Some(directory) => listChildren(directory, Some(isPackage))
+    }
+    ArraySeq.unsafeWrapArray(nestedDirs).map(f => PackageEntryImpl(inPackage.entryName(getName(f))))
+  }
+
+  protected def files(inPackage: PackageName): Seq[FileEntryType] = {
+    val dirForPackage = getDirectory(inPackage)
+    val files: Array[F] = dirForPackage match {
+      case None => emptyFiles
+      case Some(directory) => listChildren(directory, Some(isMatchingFile))
+    }
+    files.iterator.map(f => createFileEntry(toAbstractFile(f))).toSeq
+  }
+
+  override def list(inPackage: PackageName, onPackageEntry: PackageEntry => Unit, onClassesAndSources: ClassRepresentation => Unit): Unit = {
+    val dirForPackage = getDirectory(inPackage)
+    dirForPackage match {
+      case None =>
+      case Some(directory) =>
+        for (file <- listChildren(directory)) {
+          if (isPackage(file))
+            onPackageEntry(PackageEntryImpl(inPackage.entryName(getName(file))))
+          else if (isMatchingFile(file))
+            onClassesAndSources(createFileEntry(toAbstractFile(file)))
+        }
+    }
+  }
+}
+
+trait JFileDirectoryLookup[FileEntryType <: ClassRepresentation] extends DirectoryLookup[FileEntryType] {
+  type F = JFile
+
+  protected def emptyFiles: Array[JFile] = Array.empty
+  protected def getSubDir(packageDirName: String): Option[JFile] = {
+    val packageDir = new JFile(dir, packageDirName)
+    if (packageDir.exists && packageDir.isDirectory) Some(packageDir)
+    else None
+  }
+  protected def listChildren(dir: JFile, filter: Option[JFile -> Boolean]): Array[JFile] = {
+    val listing = filter match {
+      case Some(f) => dir.listFiles(mkFileFilter(f))
+      case None => dir.listFiles()
+    }
+
+    if (listing != null) {
+      // Sort by file name for stable order of directory .class entries in package scope.
+      // This gives stable results ordering of base type sequences for unrelated classes
+      // with the same base type depth.
+      //
+      // Notably, this will stably infer`Product with Serializable`
+      // as the type of `case class C(); case class D(); List(C(), D()).head`, rather than the opposite order.
+      // On Mac, the HFS performs this sorting transparently, but on Linux the order is unspecified.
+      //
+      // Note this behaviour can be enabled in javac with `javac -XDsortfiles`, but that's only
+      // intended to improve determinism of the compiler for compiler hackers.
+      java.util.Arrays.sort(listing,
+        new java.util.Comparator[JFile] {
+          def compare(o1: JFile, o2: JFile) = o1.getName.compareTo(o2.getName)
+        })
+      listing
+    }
+    else Array()
+  }
+  protected def getName(f: JFile): String = f.getName
+  protected def toAbstractFile(f: JFile): AbstractFile = f.toPath.toPlainFile
+  protected def isPackage(f: JFile): Boolean = f.isPackage
+
+  assert(dir != null, "Directory file in DirectoryFileLookup cannot be null")
+
+  def asURLs: Seq[URL] = Seq(dir.toURI.toURL)
+  def asClassPathStrings: Seq[String] = Seq(dir.getPath)
+}
+
+object JrtClassPath {
+  import java.nio.file._, java.net.URI
+  def apply(release: Option[String]): Option[ClassPath] = {
+    import scala.util.Properties._
+    if (!isJavaAtLeast("9")) None
+    else {
+      // Longer term we'd like an official API for this in the JDK
+      // Discussion: http://mail.openjdk.java.net/pipermail/compiler-dev/2018-March/thread.html#11738
+
+      val currentMajorVersion: Int = JDK9Reflectors.runtimeVersionMajor(JDK9Reflectors.runtimeVersion()).intValue()
+      release match {
+        case Some(v) if v.toInt < currentMajorVersion =>
+          try {
+            val ctSym = Paths.get(javaHome).resolve("lib").resolve("ct.sym")
+            if (Files.notExists(ctSym)) None
+            else Some(new CtSymClassPath(ctSym, v.toInt))
+          } catch {
+            case NonFatal(_) => None
+          }
+        case _ =>
+          try {
+            val fs = FileSystems.getFileSystem(URI.create("jrt:/"))
+            Some(new JrtClassPath(fs))
+          } catch {
+            case _: ProviderNotFoundException | _: FileSystemNotFoundException => None
+          }
+      }
+    }
+  }
+}
+
+/**
+  * Implementation `ClassPath` based on the JDK 9 encapsulated runtime modules (JEP-220)
+  *
+  * https://bugs.openjdk.java.net/browse/JDK-8066492 is the most up to date reference
+  * for the structure of the jrt:// filesystem.
+  *
+  * The implementation assumes that no classes exist in the empty package.
+  */
+final class JrtClassPath(fs: java.nio.file.FileSystem) extends ClassPath with NoSourcePaths {
+  import java.nio.file.Path, java.nio.file._
+  type F = Path
+  private val dir: Path = fs.getPath("/packages")
+
+  // e.g. "java.lang" -> Seq("/modules/java.base")
+  private val packageToModuleBases: Map[String, Seq[Path]] = {
+    val ps = Files.newDirectoryStream(dir).iterator().asScala
+    def lookup(pack: Path): Seq[Path] =
+      Files.list(pack).iterator().asScala.map(l => if (Files.isSymbolicLink(l)) Files.readSymbolicLink(l) else l).toList
+    ps.map(p => (p.toString.stripPrefix("/packages/"), lookup(p))).toMap
+  }
+
+  /** Empty string represents root package */
+  override private[dotty] def hasPackage(pkg: PackageName): Boolean = packageToModuleBases.contains(pkg.dottedString)
+
+  override private[dotty] def packages(inPackage: PackageName): Seq[PackageEntry] =
+    packageToModuleBases.keysIterator.filter(pack => packageContains(inPackage.dottedString, pack)).map(PackageEntryImpl(_)).toVector
+
+  private[dotty] def classes(inPackage: PackageName): Seq[ClassFileEntry] =
+    if (inPackage.isRoot) Nil
+    else
+      packageToModuleBases.getOrElse(inPackage.dottedString, Nil).flatMap(x =>
+        Files.list(x.resolve(inPackage.dirPathTrailingSlash)).iterator().asScala.filter(_.getFileName.toString.endsWith(".class"))).map(x =>
+        ClassFileEntryImpl(x.toPlainFile)).toVector
+
+  override private[dotty] def list(inPackage: PackageName): ClassPathEntries =
+    if (inPackage.isRoot) ClassPathEntries(packages(inPackage), Nil)
+    else ClassPathEntries(packages(inPackage), classes(inPackage))
+
+  def asURLs: Seq[URL] = Seq(new URL("jrt:/"))
+  // We don't yet have a scheme to represent the JDK modules in our `-classpath`.
+  // java models them as entries in the new "module path", we'll probably need to follow this.
+  def asClassPathStrings: Seq[String] = Nil
+
+  def findClassFile(className: String): Option[AbstractFile] =
+    if (!className.contains(".")) None
+    else {
+      val (inPackage, _) = separatePkgAndClassNames(className)
+      packageToModuleBases.getOrElse(inPackage, Nil).iterator.flatMap{ x =>
+        val file = x.resolve(FileUtils.dirPath(className) + ".class")
+        if (Files.exists(file)) file.toPlainFile :: Nil else Nil
+      }.take(1).toList.headOption
+    }
+}
+
+/**
+  * Implementation `ClassPath` based on the \$JAVA_HOME/lib/ct.sym backing http://openjdk.java.net/jeps/247
+  */
+final class CtSymClassPath(ctSym: java.nio.file.Path, release: Int) extends ClassPath with NoSourcePaths {
+  import java.nio.file.Path, java.nio.file._
+
+  private val fileSystem: FileSystem = FileSystems.newFileSystem(ctSym, null: ClassLoader)
+  private val root: Path = fileSystem.getRootDirectories.iterator.next
+  private val roots = Files.newDirectoryStream(root).iterator.asScala.toList
+
+  // http://mail.openjdk.java.net/pipermail/compiler-dev/2018-March/011737.html
+  private def codeFor(major: Int): String = if (major < 10) major.toString else ('A' + (major - 10)).toChar.toString
+
+  private val releaseCode: String = codeFor(release)
+  private def fileNameMatchesRelease(fileName: String) = !fileName.contains("-") && fileName.contains(releaseCode) // exclude `9-modules`
+  private val rootsForRelease: List[Path] = roots.filter(root => fileNameMatchesRelease(root.getFileName.toString))
+
+  // e.g. "java.lang" -> Seq(/876/java/lang, /87/java/lang, /8/java/lang))
+  private val packageIndex: scala.collection.Map[String, scala.collection.Seq[Path]] = {
+    val index = collection.mutable.AnyRefMap[String, collection.mutable.ListBuffer[Path]]()
+    val isJava12OrHigher = scala.util.Properties.isJavaAtLeast("12")
+    rootsForRelease.foreach(root => Files.walk(root).iterator().asScala.filter(Files.isDirectory(_)).foreach { p =>
+      val moduleNamePathElementCount = if (isJava12OrHigher) 1 else 0
+      if (p.getNameCount > root.getNameCount + moduleNamePathElementCount) {
+        val packageDotted = p.subpath(moduleNamePathElementCount + root.getNameCount, p.getNameCount).toString.replace('/', '.')
+        index.getOrElseUpdate(packageDotted, new collection.mutable.ListBuffer) += p
+      }
+    })
+    index
+  }
+
+  /** Empty string represents root package */
+  override private[dotty] def hasPackage(pkg: PackageName) = packageIndex.contains(pkg.dottedString)
+  override private[dotty] def packages(inPackage: PackageName): Seq[PackageEntry] = {
+    packageIndex.keysIterator.filter(pack => packageContains(inPackage.dottedString, pack)).map(PackageEntryImpl(_)).toVector
+  }
+  private[dotty] def classes(inPackage: PackageName): Seq[ClassFileEntry] = {
+    if (inPackage.isRoot) Nil
+    else {
+      val sigFiles = packageIndex.getOrElse(inPackage.dottedString, Nil).iterator.flatMap(p =>
+        Files.list(p).iterator.asScala.filter(_.getFileName.toString.endsWith(".sig")))
+      sigFiles.map(f => ClassFileEntryImpl(f.toPlainFile)).toVector
+    }
+  }
+
+  override private[dotty] def list(inPackage: PackageName): ClassPathEntries =
+    if (inPackage.isRoot) ClassPathEntries(packages(inPackage), Nil)
+    else ClassPathEntries(packages(inPackage), classes(inPackage))
+
+  def asURLs: Seq[URL] = Nil
+  def asClassPathStrings: Seq[String] = Nil
+  def findClassFile(className: String): Option[AbstractFile] = {
+    if (!className.contains(".")) None
+    else {
+      val (inPackage, classSimpleName) = separatePkgAndClassNames(className)
+      packageIndex.getOrElse(inPackage, Nil).iterator.flatMap { p =>
+        val path = p.resolve(classSimpleName + ".sig")
+        if (Files.exists(path)) path.toPlainFile :: Nil else Nil
+      }.take(1).toList.headOption
+    }
+  }
+}
+
+case class DirectoryClassPath(dir: JFile) extends JFileDirectoryLookup[ClassFileEntryImpl] with NoSourcePaths {
+  override def findClass(className: String): Option[ClassRepresentation] = findClassFile(className) map ClassFileEntryImpl.apply
+
+  def findClassFile(className: String): Option[AbstractFile] = {
+    val relativePath = FileUtils.dirPath(className)
+    val classFile = new JFile(dir, relativePath + ".class")
+    if (classFile.exists) {
+      Some(classFile.toPath.toPlainFile)
+    }
+    else None
+  }
+
+  protected def createFileEntry(file: AbstractFile): ClassFileEntryImpl = ClassFileEntryImpl(file)
+  protected def isMatchingFile(f: JFile): Boolean = f.isClass
+
+  private[dotty] def classes(inPackage: PackageName): Seq[ClassFileEntry] = files(inPackage)
+}
+
+case class DirectorySourcePath(dir: JFile) extends JFileDirectoryLookup[SourceFileEntryImpl] with NoClassPaths {
+  def asSourcePathString: String = asClassPathString
+
+  protected def createFileEntry(file: AbstractFile): SourceFileEntryImpl = SourceFileEntryImpl(file)
+  protected def isMatchingFile(f: JFile): Boolean = endsScalaOrJava(f.getName)
+
+  override def findClass(className: String): Option[ClassRepresentation] = findSourceFile(className) map SourceFileEntryImpl.apply
+
+  private def findSourceFile(className: String): Option[AbstractFile] = {
+    val relativePath = FileUtils.dirPath(className)
+    val sourceFile = LazyList("scala", "java")
+      .map(ext => new JFile(dir, relativePath + "." + ext))
+      .collectFirst { case file if file.exists() => file }
+
+    sourceFile.map(_.toPath.toPlainFile)
+  }
+
+  private[dotty] def sources(inPackage: PackageName): Seq[SourceFileEntry] = files(inPackage)
+}
diff --git a/tests/pos-with-compiler-cc/dotc/classpath/FileUtils.scala b/tests/pos-with-compiler-cc/dotc/classpath/FileUtils.scala
new file mode 100644
index 000000000000..0f5ac16b40bf
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/classpath/FileUtils.scala
@@ -0,0 +1,85 @@
+/*
+ * Copyright (c) 2014 Contributor. All rights reserved.
+ */
+package dotty.tools
+package dotc.classpath
+
+import scala.language.unsafeNulls
+
+import java.io.{File => JFile, FileFilter}
+import java.net.URL
+import dotty.tools.io.AbstractFile
+import language.experimental.pureFunctions
+
+/**
+ * Common methods related to Java files and abstract files used in the context of classpath
+ */
+object FileUtils {
+  extension (file: AbstractFile) {
+    def isPackage: Boolean = file.isDirectory && mayBeValidPackage(file.name)
+
+    def isClass: Boolean = !file.isDirectory && file.hasExtension("class") && !file.name.endsWith("$class.class")
+      // FIXME: drop last condition when we stop being compatible with Scala 2.11
+
+    def isScalaOrJavaSource: Boolean = !file.isDirectory && (file.hasExtension("scala") || file.hasExtension("java"))
+
+    // TODO do we need to check also other files using ZipMagicNumber like in scala.tools.nsc.io.Jar.isJarOrZip?
+    def isJarOrZip: Boolean = file.hasExtension("jar") || file.hasExtension("zip")
+
+    /**
+     * Safe method returning a sequence containing one URL representing this file, when underlying file exists,
+     * and returning given default value in other case
+     */
+    def toURLs(default: => Seq[URL] = Seq.empty): Seq[URL] = if (file.file == null) default else Seq(file.toURL)
+  }
+
+  extension (file: JFile) {
+    def isPackage: Boolean = file.isDirectory && mayBeValidPackage(file.getName)
+
+    def isClass: Boolean = file.isFile && file.getName.endsWith(".class") && !file.getName.endsWith("$class.class")
+      // FIXME: drop last condition when we stop being compatible with Scala 2.11
+  }
+
+  private val SUFFIX_CLASS = ".class"
+  private val SUFFIX_SCALA = ".scala"
+  private val SUFFIX_JAVA = ".java"
+  private val SUFFIX_SIG = ".sig"
+
+  def stripSourceExtension(fileName: String): String =
+    if (endsScala(fileName)) stripClassExtension(fileName)
+    else if (endsJava(fileName)) stripJavaExtension(fileName)
+    else throw new FatalError("Unexpected source file ending: " + fileName)
+
+  def dirPath(forPackage: String): String = forPackage.replace('.', JFile.separatorChar)
+
+  def dirPathInJar(forPackage: String): String = forPackage.replace('.', '/')
+
+  inline private def ends (filename:String, suffix:String) = filename.endsWith(suffix) && filename.length > suffix.length
+
+  def endsClass(fileName: String): Boolean =
+    ends (fileName, SUFFIX_CLASS) || fileName.endsWith(SUFFIX_SIG)
+
+  def endsScalaOrJava(fileName: String): Boolean =
+    endsScala(fileName) || endsJava(fileName)
+
+  def endsJava(fileName: String): Boolean =
+    ends (fileName, SUFFIX_JAVA)
+
+  def endsScala(fileName: String): Boolean =
+    ends (fileName, SUFFIX_SCALA)
+
+  def stripClassExtension(fileName: String): String =
+    fileName.substring(0, fileName.lastIndexOf('.'))
+
+  def stripJavaExtension(fileName: String): String =
+    fileName.substring(0, fileName.length - 5) // equivalent of fileName.length - SUFFIX_JAVA.length
+
+  // probably it should match a pattern like [a-z_]{1}[a-z0-9_]* but it cannot be changed
+  // because then some tests in partest don't pass
+  def mayBeValidPackage(dirName: String): Boolean =
+    (dirName != "META-INF") && (dirName != "") && (dirName.charAt(0) != '.')
+
+  def mkFileFilter(f: JFile -> Boolean): FileFilter = new FileFilter {
+    def accept(pathname: JFile): Boolean = f(pathname)
+  }
+}
diff --git a/tests/pos-with-compiler-cc/dotc/classpath/PackageNameUtils.scala b/tests/pos-with-compiler-cc/dotc/classpath/PackageNameUtils.scala
new file mode 100644
index 000000000000..ea7412f15d8a
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/classpath/PackageNameUtils.scala
@@ -0,0 +1,37 @@
+/*
+ * Copyright (c) 2014 Contributor. All rights reserved.
+ */
+package dotty.tools.dotc.classpath
+
+import dotty.tools.io.ClassPath.RootPackage
+
+/**
+ * Common methods related to package names represented as String
+ */
+object PackageNameUtils {
+
+  /**
+   * @param fullClassName full class name with package
+   * @return (package, simple class name)
+   */
+  inline def separatePkgAndClassNames(fullClassName: String): (String, String) = {
+    val lastDotIndex = fullClassName.lastIndexOf('.')
+    if (lastDotIndex == -1)
+      (RootPackage, fullClassName)
+    else
+      (fullClassName.substring(0, lastDotIndex).nn, fullClassName.substring(lastDotIndex + 1).nn)
+  }
+
+  def packagePrefix(inPackage: String): String = if (inPackage == RootPackage) "" else inPackage + "."
+
+  /**
+   * `true` if `packageDottedName` is a package directly nested in `inPackage`, for example:
+   *   - `packageContains("scala", "scala.collection")`
+   *   - `packageContains("", "scala")`
+   */
+  def packageContains(inPackage: String, packageDottedName: String) = {
+    if (packageDottedName.contains("."))
+      packageDottedName.startsWith(inPackage) && packageDottedName.lastIndexOf('.') == inPackage.length
+    else inPackage == ""
+  }
+}
diff --git a/tests/pos-with-compiler-cc/dotc/classpath/VirtualDirectoryClassPath.scala b/tests/pos-with-compiler-cc/dotc/classpath/VirtualDirectoryClassPath.scala
new file mode 100644
index 000000000000..ac80d543b539
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/classpath/VirtualDirectoryClassPath.scala
@@ -0,0 +1,55 @@
+package dotty.tools.dotc.classpath
+
+import scala.language.unsafeNulls
+
+import dotty.tools.io.ClassRepresentation
+import dotty.tools.io.{AbstractFile, VirtualDirectory}
+import FileUtils._
+import java.net.URL
+
+import dotty.tools.io.ClassPath
+import language.experimental.pureFunctions
+
+case class VirtualDirectoryClassPath(dir: VirtualDirectory) extends ClassPath with DirectoryLookup[ClassFileEntryImpl] with NoSourcePaths {
+  type F = AbstractFile
+
+  // From AbstractFileClassLoader
+  private final def lookupPath(base: AbstractFile)(pathParts: Seq[String], directory: Boolean): AbstractFile = {
+    var file: AbstractFile = base
+    val dirParts = pathParts.init.iterator
+    while (dirParts.hasNext) {
+      val dirPart = dirParts.next
+      file = file.lookupName(dirPart, directory = true)
+      if (file == null)
+        return null
+    }
+    file.lookupName(pathParts.last, directory = directory)
+  }
+
+  protected def emptyFiles: Array[AbstractFile] = Array.empty
+  protected def getSubDir(packageDirName: String): Option[AbstractFile] =
+    Option(lookupPath(dir)(packageDirName.split(java.io.File.separator).toIndexedSeq, directory = true))
+  protected def listChildren(dir: AbstractFile, filter: Option[AbstractFile -> Boolean]): Array[F] = filter match {
+    case Some(f) => dir.iterator.filter(f).toArray
+    case _ => dir.toArray
+  }
+  def getName(f: AbstractFile): String = f.name
+  def toAbstractFile(f: AbstractFile): AbstractFile = f
+  def isPackage(f: AbstractFile): Boolean = f.isPackage
+
+  // mimic the behavior of the old nsc.util.DirectoryClassPath
+  def asURLs: Seq[URL] = Seq(new URL(dir.name))
+  def asClassPathStrings: Seq[String] = Seq(dir.path)
+
+  override def findClass(className: String): Option[ClassRepresentation] = findClassFile(className) map ClassFileEntryImpl.apply
+
+  def findClassFile(className: String): Option[AbstractFile] = {
+    val relativePath = FileUtils.dirPath(className) + ".class"
+    Option(lookupPath(dir)(relativePath.split(java.io.File.separator).toIndexedSeq, directory = false))
+  }
+
+  private[dotty] def classes(inPackage: PackageName): Seq[ClassFileEntry] = files(inPackage)
+
+  protected def createFileEntry(file: AbstractFile): ClassFileEntryImpl = ClassFileEntryImpl(file)
+  protected def isMatchingFile(f: AbstractFile): Boolean = f.isClass
+}
diff --git a/tests/pos-with-compiler-cc/dotc/classpath/ZipAndJarFileLookupFactory.scala b/tests/pos-with-compiler-cc/dotc/classpath/ZipAndJarFileLookupFactory.scala
new file mode 100644
index 000000000000..865f95551a0b
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/classpath/ZipAndJarFileLookupFactory.scala
@@ -0,0 +1,205 @@
+/*
+ * Copyright (c) 2014 Contributor. All rights reserved.
+ */
+package dotty.tools.dotc
+package classpath
+
+import scala.language.unsafeNulls
+
+import java.io.File
+import java.net.URL
+import java.nio.file.Files
+import java.nio.file.attribute.{BasicFileAttributes, FileTime}
+
+import scala.annotation.tailrec
+import dotty.tools.io.{AbstractFile, ClassPath, ClassRepresentation, FileZipArchive, ManifestResources}
+import dotty.tools.dotc.core.Contexts._
+import FileUtils._
+
+/**
+ * A trait providing an optional cache for classpath entries obtained from zip and jar files.
+ * It allows us to e.g. reduce significantly memory used by PresentationCompilers in Scala IDE
+ * when there are a lot of projects having a lot of common dependencies.
+ */
+sealed trait ZipAndJarFileLookupFactory {
+  private val cache = new FileBasedCache[ClassPath]
+
+  def create(zipFile: AbstractFile)(using Context): ClassPath =
+    val release = Option(ctx.settings.javaOutputVersion.value).filter(_.nonEmpty)
+    if (ctx.settings.YdisableFlatCpCaching.value || zipFile.file == null) createForZipFile(zipFile, release)
+    else createUsingCache(zipFile, release)
+
+  protected def createForZipFile(zipFile: AbstractFile, release: Option[String]): ClassPath
+
+  private def createUsingCache(zipFile: AbstractFile, release: Option[String]): ClassPath =
+    cache.getOrCreate(zipFile.file.toPath, () => createForZipFile(zipFile, release))
+}
+
+/**
+ * Manages creation of classpath for class files placed in zip and jar files.
+ * It should be the only way of creating them as it provides caching.
+ */
+object ZipAndJarClassPathFactory extends ZipAndJarFileLookupFactory {
+  private case class ZipArchiveClassPath(zipFile: File, override val release: Option[String])
+    extends ZipArchiveFileLookup[ClassFileEntryImpl]
+    with NoSourcePaths {
+
+    override def findClassFile(className: String): Option[AbstractFile] = {
+      val (pkg, simpleClassName) = PackageNameUtils.separatePkgAndClassNames(className)
+      file(PackageName(pkg), simpleClassName + ".class").map(_.file)
+    }
+
+    // This method is performance sensitive as it is used by SBT's ExtractDependencies phase.
+    override def findClass(className: String): Option[ClassRepresentation] = {
+      val (pkg, simpleClassName) = PackageNameUtils.separatePkgAndClassNames(className)
+      file(PackageName(pkg), simpleClassName + ".class")
+    }
+
+    override private[dotty] def classes(inPackage: PackageName): Seq[ClassFileEntry] = files(inPackage)
+
+    override protected def createFileEntry(file: FileZipArchive#Entry): ClassFileEntryImpl = ClassFileEntryImpl(file)
+    override protected def isRequiredFileType(file: AbstractFile): Boolean = file.isClass
+  }
+
+  /**
+   * This type of classpath is closely related to the support for JSR-223.
+   * Its usage can be observed e.g. when running:
+   * jrunscript -classpath scala-compiler.jar;scala-reflect.jar;scala-library.jar -l scala
+   * with a particularly prepared scala-library.jar. It should have all classes listed in the manifest like e.g. this entry:
+   * Name: scala/Function2$mcFJD$sp.class
+   */
+  private case class ManifestResourcesClassPath(file: ManifestResources) extends ClassPath with NoSourcePaths {
+    override def findClassFile(className: String): Option[AbstractFile] = {
+      val (pkg, simpleClassName) = PackageNameUtils.separatePkgAndClassNames(className)
+      classes(PackageName(pkg)).find(_.name == simpleClassName).map(_.file)
+    }
+
+    override def asClassPathStrings: Seq[String] = Seq(file.path)
+
+    override def asURLs: Seq[URL] = file.toURLs()
+
+    import ManifestResourcesClassPath.PackageFileInfo
+    import ManifestResourcesClassPath.PackageInfo
+
+    /**
+     * A cache mapping package name to abstract file for package directory and subpackages of given package.
+     *
+     * ManifestResources can iterate through the collections of entries from e.g. remote jar file.
+     * We can't just specify the path to the concrete directory etc. so we can't just 'jump' into
+     * given package, when it's needed. On the other hand we can iterate over entries to get
+     * AbstractFiles, iterate over entries of these files etc.
+     *
+     * Instead of traversing a tree of AbstractFiles once and caching all entries or traversing each time,
+     * when we need subpackages of a given package or its classes, we traverse once and cache only packages.
+     * Classes for given package can be then easily loaded when they are needed.
+     */
+    private lazy val cachedPackages: util.HashMap[String, PackageFileInfo] = {
+      val packages = util.HashMap[String, PackageFileInfo]()
+
+      def getSubpackages(dir: AbstractFile): List[AbstractFile] =
+        (for (file <- dir if file.isPackage) yield file).toList
+
+      @tailrec
+      def traverse(packagePrefix: String,
+                   filesForPrefix: List[AbstractFile],
+                   subpackagesQueue: collection.mutable.Queue[PackageInfo]): Unit = filesForPrefix match {
+        case pkgFile :: remainingFiles =>
+          val subpackages = getSubpackages(pkgFile)
+          val fullPkgName = packagePrefix + pkgFile.name
+          packages(fullPkgName) = PackageFileInfo(pkgFile, subpackages)
+          val newPackagePrefix = fullPkgName + "."
+          subpackagesQueue.enqueue(PackageInfo(newPackagePrefix, subpackages))
+          traverse(packagePrefix, remainingFiles, subpackagesQueue)
+        case Nil if subpackagesQueue.nonEmpty =>
+          val PackageInfo(packagePrefix, filesForPrefix) = subpackagesQueue.dequeue()
+          traverse(packagePrefix, filesForPrefix, subpackagesQueue)
+        case _ =>
+      }
+
+      val subpackages = getSubpackages(file)
+      packages(ClassPath.RootPackage) = PackageFileInfo(file, subpackages)
+      traverse(ClassPath.RootPackage, subpackages, collection.mutable.Queue())
+      packages
+    }
+
+    override private[dotty] def packages(inPackage: PackageName): Seq[PackageEntry] = cachedPackages.get(inPackage.dottedString) match {
+      case None => Seq.empty
+      case Some(PackageFileInfo(_, subpackages)) =>
+        subpackages.map(packageFile => PackageEntryImpl(inPackage.entryName(packageFile.name)))
+    }
+
+    override private[dotty] def classes(inPackage: PackageName): Seq[ClassFileEntry] = cachedPackages.get(inPackage.dottedString) match {
+      case None => Seq.empty
+      case Some(PackageFileInfo(pkg, _)) =>
+        (for (file <- pkg if file.isClass) yield ClassFileEntryImpl(file)).toSeq
+    }
+
+    override private[dotty] def hasPackage(pkg: PackageName) = cachedPackages.contains(pkg.dottedString)
+    override private[dotty] def list(inPackage: PackageName): ClassPathEntries = ClassPathEntries(packages(inPackage), classes(inPackage))
+  }
+
+  private object ManifestResourcesClassPath {
+    case class PackageFileInfo(packageFile: AbstractFile, subpackages: Seq[AbstractFile])
+    case class PackageInfo(packageName: String, subpackages: List[AbstractFile])
+  }
+
+  override protected def createForZipFile(zipFile: AbstractFile, release: Option[String]): ClassPath =
+    if (zipFile.file == null) createWithoutUnderlyingFile(zipFile)
+    else ZipArchiveClassPath(zipFile.file, release)
+
+  private def createWithoutUnderlyingFile(zipFile: AbstractFile) = zipFile match {
+    case manifestRes: ManifestResources =>
+      ManifestResourcesClassPath(manifestRes)
+    case _ =>
+      val errorMsg = s"Abstract files which don't have an underlying file and are not ManifestResources are not supported. There was $zipFile"
+      throw new IllegalArgumentException(errorMsg)
+  }
+}
+
+/**
+ * Manages creation of classpath for source files placed in zip and jar files.
+ * It should be the only way of creating them as it provides caching.
+ */
+object ZipAndJarSourcePathFactory extends ZipAndJarFileLookupFactory {
+  private case class ZipArchiveSourcePath(zipFile: File)
+    extends ZipArchiveFileLookup[SourceFileEntryImpl]
+    with NoClassPaths {
+
+    def release: Option[String] = None
+
+    override def asSourcePathString: String = asClassPathString
+
+    override private[dotty] def sources(inPackage: PackageName): Seq[SourceFileEntry] = files(inPackage)
+
+    override protected def createFileEntry(file: FileZipArchive#Entry): SourceFileEntryImpl = SourceFileEntryImpl(file)
+    override protected def isRequiredFileType(file: AbstractFile): Boolean = file.isScalaOrJavaSource
+  }
+
+  override protected def createForZipFile(zipFile: AbstractFile, release: Option[String]): ClassPath = ZipArchiveSourcePath(zipFile.file)
+}
+
+final class FileBasedCache[T] {
+  private case class Stamp(lastModified: FileTime, fileKey: Object)
+  private val cache = collection.mutable.Map.empty[java.nio.file.Path, (Stamp, T)]
+
+  def getOrCreate(path: java.nio.file.Path, create: () => T): T = cache.synchronized {
+    val attrs = Files.readAttributes(path, classOf[BasicFileAttributes])
+    val lastModified = attrs.lastModifiedTime()
+    // only null on some platforms, but that's okay, we just use the last modified timestamp as our stamp
+    val fileKey = attrs.fileKey()
+    val stamp = Stamp(lastModified, fileKey)
+    cache.get(path) match {
+      case Some((cachedStamp, cached)) if cachedStamp == stamp => cached
+      case _ =>
+        val value = create()
+        cache.put(path, (stamp, value))
+        value
+    }
+  }
+
+  def clear(): Unit = cache.synchronized {
+    // TODO support closing
+    // cache.valuesIterator.foreach(_.close())
+    cache.clear()
+  }
+}
diff --git a/tests/pos-with-compiler-cc/dotc/classpath/ZipArchiveFileLookup.scala b/tests/pos-with-compiler-cc/dotc/classpath/ZipArchiveFileLookup.scala
new file mode 100644
index 000000000000..e241feee8244
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/classpath/ZipArchiveFileLookup.scala
@@ -0,0 +1,72 @@
+/*
+ * Copyright (c) 2014 Contributor. All rights reserved.
+ */
+package dotty.tools.dotc.classpath
+
+import scala.language.unsafeNulls
+
+import java.io.File
+import java.net.URL
+
+import dotty.tools.io.{ AbstractFile, FileZipArchive }
+import FileUtils._
+import dotty.tools.io.{EfficientClassPath, ClassRepresentation}
+
+/**
+ * A trait allowing to look for classpath entries of given type in zip and jar files.
+ * It provides common logic for classes handling class and source files.
+ * It's aware of things like e.g. META-INF directory which is correctly skipped.
+ */
+trait ZipArchiveFileLookup[FileEntryType <: ClassRepresentation] extends EfficientClassPath {
+  val zipFile: File
+  def release: Option[String]
+
+  assert(zipFile != null, "Zip file in ZipArchiveFileLookup cannot be null")
+
+  override def asURLs: Seq[URL] = Seq(zipFile.toURI.toURL)
+  override def asClassPathStrings: Seq[String] = Seq(zipFile.getPath)
+
+  private val archive = new FileZipArchive(zipFile.toPath, release)
+
+  override private[dotty] def packages(inPackage: PackageName): Seq[PackageEntry] = {
+    for {
+      dirEntry <- findDirEntry(inPackage).toSeq
+      entry <- dirEntry.iterator if entry.isPackage
+    }
+    yield PackageEntryImpl(inPackage.entryName(entry.name))
+  }
+
+  protected def files(inPackage: PackageName): Seq[FileEntryType] =
+    for {
+      dirEntry <- findDirEntry(inPackage).toSeq
+      entry <- dirEntry.iterator if isRequiredFileType(entry)
+    }
+    yield createFileEntry(entry)
+
+  protected def file(inPackage: PackageName, name: String): Option[FileEntryType] =
+    for {
+      dirEntry <- findDirEntry(inPackage)
+      entry <- Option(dirEntry.lookupName(name, directory = false))
+      if isRequiredFileType(entry)
+    }
+    yield createFileEntry(entry)
+
+  override def hasPackage(pkg: PackageName) = findDirEntry(pkg).isDefined
+  def list(inPackage: PackageName, onPackageEntry: PackageEntry => Unit, onClassesAndSources: ClassRepresentation => Unit): Unit =
+    findDirEntry(inPackage) match {
+      case Some(dirEntry) =>
+        for (entry <- dirEntry.iterator) {
+          if (entry.isPackage)
+            onPackageEntry(PackageEntryImpl(inPackage.entryName(entry.name)))
+          else if (isRequiredFileType(entry))
+            onClassesAndSources(createFileEntry(entry))
+        }
+      case None =>
+    }
+
+  private def findDirEntry(pkg: PackageName): Option[archive.DirEntry] =
+    archive.allDirs.get(pkg.dirPathTrailingSlashJar)
+
+  protected def createFileEntry(file: FileZipArchive#Entry): FileEntryType
+  protected def isRequiredFileType(file: AbstractFile): Boolean
+}
diff --git a/tests/pos-with-compiler-cc/dotc/config/CliCommand.scala b/tests/pos-with-compiler-cc/dotc/config/CliCommand.scala
new file mode 100644
index 000000000000..68c900e405da
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/config/CliCommand.scala
@@ -0,0 +1,198 @@
+package dotty.tools.dotc
+package config
+
+import scala.language.unsafeNulls
+
+import Settings._
+import core.Contexts._
+import printing.Highlighting
+
+import scala.util.chaining.given
+import scala.PartialFunction.cond
+
+trait CliCommand:
+
+  type ConcreteSettings <: CommonScalaSettings with Settings.SettingGroup
+
+  def versionMsg: String
+
+  def ifErrorsMsg: String
+
+  /** The name of the command */
+  def cmdName: String
+
+  def isHelpFlag(using settings: ConcreteSettings)(using SettingsState): Boolean
+
+  def helpMsg(using settings: ConcreteSettings)(using SettingsState, Context): String
+
+  private def explainAdvanced = """
+    |-- Notes on option parsing --
+    |Boolean settings are always false unless set.
+    |Where multiple values are accepted, they should be comma-separated.
+    |  example: -Xplugin:plugin1,plugin2
+    |<phases> means one or a comma-separated list of:
+    |  - (partial) phase names with an optional "+" suffix to include the next phase
+    |  - the string "all"
+    |  example: -Xprint:all prints all phases.
+    |  example: -Xprint:typer,mixin prints the typer and mixin phases.
+    |  example: -Ylog:erasure+ logs the erasure phase and the phase after the erasure phase.
+    |           This is useful because during the tree transform of phase X, we often
+    |           already are in phase X + 1.
+  """
+
+  /** Distill arguments into summary detailing settings, errors and files to main */
+  def distill(args: Array[String], sg: Settings.SettingGroup)(ss: SettingsState = sg.defaultState)(using Context): ArgsSummary =
+
+    // expand out @filename to the contents of that filename
+    def expandedArguments = args.toList flatMap {
+      case x if x startsWith "@"  => CommandLineParser.expandArg(x)
+      case x                      => List(x)
+    }
+
+    sg.processArguments(expandedArguments, processAll = true, settingsState = ss)
+  end distill
+
+  /** Creates a help message for a subset of options based on cond */
+  protected def availableOptionsMsg(p: Setting[?] => Boolean)(using settings: ConcreteSettings)(using SettingsState): String =
+    // result is (Option Name, descrption\ndefault: value\nchoices: x, y, z
+    def help(s: Setting[?]): (String, String) =
+      // For now, skip the default values that do not make sense for the end user, such as 'false' for the version command.
+      def defaultValue = s.default match
+        case _: Int | _: String => s.default.toString
+        case _ => ""
+      val info = List(shortHelp(s), if defaultValue.nonEmpty then s"Default $defaultValue" else "", if s.legalChoices.nonEmpty then s"Choices ${s.legalChoices}" else "")
+      (s.name, info.filter(_.nonEmpty).mkString("\n"))
+    end help
+
+    val ss = settings.allSettings.filter(p).toList.sortBy(_.name)
+    val formatter = Columnator("", "", maxField = 30)
+    val fresh = ContextBase().initialCtx.fresh.setSettings(summon[SettingsState])
+    formatter(List(ss.map(help) :+ ("@<file>", "A text file containing compiler arguments (options and source files).")))(using fresh)
+  end availableOptionsMsg
+
+  protected def shortUsage: String = s"Usage: $cmdName <options> <source files>"
+
+  protected def createUsageMsg(label: String, shouldExplain: Boolean, cond: Setting[?] => Boolean)(using settings: ConcreteSettings)(using SettingsState): String =
+    val prefix = List(
+      Some(shortUsage),
+      Some(explainAdvanced).filter(_ => shouldExplain),
+      Some(label + " options include:")
+    ).flatten.mkString("\n")
+
+    prefix + "\n" + availableOptionsMsg(cond)
+
+  protected def isStandard(s: Setting[?])(using settings: ConcreteSettings)(using SettingsState): Boolean =
+    !isVerbose(s) && !isWarning(s) && !isAdvanced(s) && !isPrivate(s) || s.name == "-Werror" || s.name == "-Wconf"
+  protected def isVerbose(s: Setting[?])(using settings: ConcreteSettings)(using SettingsState): Boolean =
+    s.name.startsWith("-V") && s.name != "-V"
+  protected def isWarning(s: Setting[?])(using settings: ConcreteSettings)(using SettingsState): Boolean =
+    s.name.startsWith("-W") && s.name != "-W" || s.name == "-Xlint"
+  protected def isAdvanced(s: Setting[?])(using settings: ConcreteSettings)(using SettingsState): Boolean =
+    s.name.startsWith("-X") && s.name != "-X"
+  protected def isPrivate(s: Setting[?])(using settings: ConcreteSettings)(using SettingsState): Boolean =
+    s.name.startsWith("-Y") && s.name != "-Y"
+  protected def shortHelp(s: Setting[?])(using settings: ConcreteSettings)(using SettingsState): String =
+    s.description.linesIterator.next()
+  protected def isHelping(s: Setting[?])(using settings: ConcreteSettings)(using SettingsState): Boolean =
+    cond(s.value) {
+      case ss: List[?] if s.isMultivalue => ss.contains("help")
+      case s: String                     => "help" == s
+    }
+
+  /** Messages explaining usage and options */
+  protected def usageMessage(using settings: ConcreteSettings)(using SettingsState) =
+    createUsageMsg("where possible standard", shouldExplain = false, isStandard)
+  protected def vusageMessage(using settings: ConcreteSettings)(using SettingsState) =
+    createUsageMsg("Possible verbose", shouldExplain = true, isVerbose)
+  protected def wusageMessage(using settings: ConcreteSettings)(using SettingsState) =
+    createUsageMsg("Possible warning", shouldExplain = true, isWarning)
+  protected def xusageMessage(using settings: ConcreteSettings)(using SettingsState) =
+    createUsageMsg("Possible advanced", shouldExplain = true, isAdvanced)
+  protected def yusageMessage(using settings: ConcreteSettings)(using SettingsState) =
+    createUsageMsg("Possible private", shouldExplain = true, isPrivate)
+
+  /** Used for the formatted output of -Xshow-phases */
+  protected def phasesMessage(using Context): String =
+    val phases = new Compiler().phases
+    val formatter = Columnator("phase name", "description", maxField = 25)
+    formatter(phases.map(mega => mega.map(p => (p.phaseName, p.description))))
+
+  /** Provide usage feedback on argument summary, assuming that all settings
+   *  are already applied in context.
+   *  @return  Either Some list of files passed as arguments or None if further processing should be interrupted.
+   */
+  def checkUsage(summary: ArgsSummary, sourcesRequired: Boolean)(using settings: ConcreteSettings)(using SettingsState, Context): Option[List[String]] =
+    // Print all warnings encountered during arguments parsing
+    summary.warnings.foreach(report.warning(_))
+
+    if summary.errors.nonEmpty then
+      summary.errors foreach (report.error(_))
+      report.echo(ifErrorsMsg)
+      None
+    else if settings.version.value then
+      report.echo(versionMsg)
+      None
+    else if isHelpFlag then
+      report.echo(helpMsg)
+      None
+    else if (sourcesRequired && summary.arguments.isEmpty)
+      report.echo(usageMessage)
+      None
+    else
+      Some(summary.arguments)
+
+  extension [T](setting: Setting[T])
+    protected def value(using ss: SettingsState): T = setting.valueIn(ss)
+
+  extension (s: String)
+    def padLeft(width: Int): String = String.format(s"%${width}s", s)
+
+  // Formatting for -help and -Vphases in two columns, handling long field1 and wrapping long field2
+  class Columnator(heading1: String, heading2: String, maxField: Int, separation: Int = 2):
+    def apply(texts: List[List[(String, String)]])(using Context): String = StringBuilder().tap(columnate(_, texts)).toString
+
+    private def columnate(sb: StringBuilder, texts: List[List[(String, String)]])(using Context): Unit =
+      import Highlighting.*
+      val colors = Seq(Green(_), Yellow(_), Magenta(_), Cyan(_), Red(_))
+      val nocolor = texts.length == 1
+      def color(index: Int): String => Highlight = if nocolor then NoColor(_) else colors(index % colors.length)
+      val maxCol = ctx.settings.pageWidth.value
+      val field1 = maxField.min(texts.flatten.map(_._1.length).filter(_ < maxField).max) // widest field under maxField
+      val field2 = if field1 + separation + maxField < maxCol then maxCol - field1 - separation else 0 // skinny window -> terminal wrap
+      val separator = " " * separation
+      val EOL = "\n"
+      def formatField1(text: String): String = if text.length <= field1 then text.padLeft(field1) else text + EOL + "".padLeft(field1)
+      def formatField2(text: String): String =
+        def loopOverField2(fld: String): List[String] =
+          if field2 == 0 || fld.length <= field2 then List(fld)
+          else
+            fld.lastIndexOf(" ", field2) match
+              case -1 => List(fld)
+              case i  => val (prefix, rest) = fld.splitAt(i) ; prefix :: loopOverField2(rest.trim)
+        text.split("\n").toList.flatMap(loopOverField2).filter(_.nonEmpty).mkString(EOL + "".padLeft(field1) + separator)
+      end formatField2
+      def format(first: String, second: String, index: Int, colorPicker: Int => String => Highlight) =
+        sb.append(colorPicker(index)(formatField1(first)).show)
+          .append(separator)
+          .append(formatField2(second))
+          .append(EOL): Unit
+      def fancy(first: String, second: String, index: Int) = format(first, second, index, color)
+      def plain(first: String, second: String) = format(first, second, 0, _ => NoColor(_))
+
+      if heading1.nonEmpty then
+        plain(heading1, heading2)
+        plain("-" * heading1.length, "-" * heading2.length)
+
+      def emit(index: Int)(textPair: (String, String)): Unit = fancy(textPair._1, textPair._2, index)
+      def group(index: Int)(body: Int => Unit): Unit =
+        if !ctx.useColors then plain(s"{", "")
+        body(index)
+        if !ctx.useColors then plain(s"}", "")
+
+      texts.zipWithIndex.foreach { (text, index) =>
+        text match
+          case List(single) => emit(index)(single)
+          case Nil          =>
+          case mega         => group(index)(i => mega.foreach(emit(i)))
+      }
+  end Columnator
diff --git a/tests/pos-with-compiler-cc/dotc/config/CommandLineParser.scala b/tests/pos-with-compiler-cc/dotc/config/CommandLineParser.scala
new file mode 100644
index 000000000000..2e76561c9913
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/config/CommandLineParser.scala
@@ -0,0 +1,125 @@
+package dotty.tools.dotc.config
+
+import java.lang.Character.isWhitespace
+import java.nio.file.{Files, Paths}
+import scala.annotation.tailrec
+import scala.collection.mutable.ArrayBuffer
+import scala.jdk.CollectionConverters.*
+
+/** Split a line of text using shell conventions.
+ */
+object CommandLineParser:
+  inline private val DQ  = '"'
+  inline private val SQ  = '\''
+  inline private val EOF = -1
+
+  /** Split the line into tokens separated by whitespace.
+   *
+   *  Single or double quotes can be embedded to preserve internal whitespace:
+   *
+   *  `""" echo "hello, world!" """`   => "echo" :: "hello, world!" :: Nil
+   *  `""" echo hello,' 'world! """`   => "echo" :: "hello, world!" :: Nil
+   *  `""" echo \"hello, world!\" """` => "echo" :: "\"hello," :: "world!\"" :: Nil
+   *
+   *  The embedded quotes are stripped. Escaping backslash is not stripped.
+   *
+   *  Invoke `errorFn` with a descriptive message if an end quote is missing.
+   */
+  def tokenize(line: String, errorFn: String => Unit): List[String] =
+
+    var accum: List[String] = Nil
+
+    var pos   = 0
+    var start = 0
+    val qpos  = new ArrayBuffer[Int](16)    // positions of paired quotes in current token
+
+    inline def cur    = if done then EOF else line.charAt(pos): Int
+    inline def bump() = pos += 1
+    inline def done   = pos >= line.length
+
+    // Skip to the given unescaped end quote; false on no more input.
+    def skipToEndQuote(q: Int): Boolean =
+      var escaped = false
+      def terminal = cur match
+        case _ if escaped => escaped = false ; false
+        case '\\'         => escaped = true ; false
+        case `q` | EOF    => true
+        case _            => false
+      while !terminal do bump()
+      !done
+
+    // Skip to the next whitespace word boundary; record unescaped embedded quotes; false on missing quote.
+    def skipToDelim(): Boolean =
+      var escaped = false
+      inline def quote() = { qpos += pos ; bump() }
+      @tailrec def advance(): Boolean = cur match
+        case _ if escaped         => escaped = false ; bump() ; advance()
+        case '\\'                 => escaped = true ; bump() ; advance()
+        case q @ (DQ | SQ)        => { quote() ; skipToEndQuote(q) } && { quote() ; advance() }
+        case EOF                  => true
+        case c if isWhitespace(c) => true
+        case _                    => bump(); advance()
+      advance()
+
+    def copyText(): String =
+      val buf = new java.lang.StringBuilder
+      var p = start
+      var i = 0
+      while p < pos do
+        if i >= qpos.size then
+          buf.append(line, p, pos)
+          p = pos
+        else if p == qpos(i) then
+          buf.append(line, qpos(i)+1, qpos(i+1))
+          p = qpos(i+1)+1
+          i += 2
+        else
+          buf.append(line, p, qpos(i))
+          p = qpos(i)
+      buf.toString
+
+    // the current token, stripped of any embedded quotes.
+    def text(): String =
+      val res =
+        if qpos.isEmpty then line.substring(start, pos)
+        else if qpos(0) == start && qpos(1) == pos then line.substring(start+1, pos-1)
+        else copyText()
+      qpos.clear()
+      res.nn
+
+    inline def badquote() = errorFn(s"Unmatched quote [${qpos.last}](${line.charAt(qpos.last)})")
+
+    inline def skipWhitespace() = while isWhitespace(cur) do bump()
+
+    @tailrec def loop(): List[String] =
+      skipWhitespace()
+      start = pos
+      if done then
+        accum.reverse
+      else if !skipToDelim() then
+        badquote()
+        Nil
+      else
+        accum ::= text()
+        loop()
+    end loop
+
+    loop()
+  end tokenize
+
+  def tokenize(line: String): List[String] = tokenize(line, x => throw new ParseException(x))
+
+  /** Expands all arguments starting with @ to the contents of the file named like each argument.
+   */
+  def expandArg(arg: String): List[String] =
+    val path = Paths.get(arg.stripPrefix("@"))
+    if !Files.exists(path) then
+      System.err.nn.println(s"Argument file ${path.nn.getFileName} could not be found")
+      Nil
+    else
+      def stripComment(s: String) = s.indexOf('#') match { case -1 => s case i => s.substring(0, i) }
+      val lines = Files.readAllLines(path).nn
+      val params = lines.asScala.map(stripComment).filter(!_.nn.isEmpty).mkString(" ")
+      tokenize(params)
+
+  class ParseException(msg: String) extends RuntimeException(msg)
diff --git a/tests/pos-with-compiler-cc/dotc/config/CompilerCommand.scala b/tests/pos-with-compiler-cc/dotc/config/CompilerCommand.scala
new file mode 100644
index 000000000000..41e123472a75
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/config/CompilerCommand.scala
@@ -0,0 +1,26 @@
+package dotty.tools.dotc
+package config
+
+import Settings._
+import core.Contexts._
+
+abstract class CompilerCommand extends CliCommand:
+  type ConcreteSettings = ScalaSettings
+
+  final def helpMsg(using settings: ScalaSettings)(using SettingsState, Context): String =
+    settings.allSettings.find(isHelping) match
+      case Some(s) => s.description
+      case _ =>
+        if (settings.help.value) usageMessage
+        else if (settings.Vhelp.value) vusageMessage
+        else if (settings.Whelp.value) wusageMessage
+        else if (settings.Xhelp.value) xusageMessage
+        else if (settings.Yhelp.value) yusageMessage
+        else if (settings.showPlugins.value) ctx.base.pluginDescriptions
+        else if (settings.XshowPhases.value) phasesMessage
+        else ""
+
+  final def isHelpFlag(using settings: ScalaSettings)(using SettingsState): Boolean =
+    import settings._
+    val flags = Set(help, Vhelp,  Whelp, Xhelp, Yhelp, showPlugins, XshowPhases)
+    flags.exists(_.value) || allSettings.exists(isHelping)
diff --git a/tests/pos-with-compiler-cc/dotc/config/Config.scala b/tests/pos-with-compiler-cc/dotc/config/Config.scala
new file mode 100644
index 000000000000..17e3ec352e7c
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/config/Config.scala
@@ -0,0 +1,248 @@
+package dotty.tools.dotc.config
+
+object Config {
+
+  inline val cacheMembersNamed = true
+  inline val cacheAsSeenFrom = true
+  inline val cacheMemberNames = true
+  inline val cacheImplicitScopes = true
+  inline val cacheMatchReduced = true
+
+  /** If true, the `runWithOwner` operation uses a re-usable context,
+   *  similar to explore. This requires that the context does not escape
+   *  the call. If false, `runWithOwner` runs its operation argument
+   *  in a fresh context.
+   */
+  inline val reuseOwnerContexts = true
+
+  inline val checkCacheMembersNamed = false
+
+  /** When updating a constraint bound, check that the constrained parameter
+   *  does not appear at the top-level of either of its bounds.
+   */
+  inline val checkConstraintsNonCyclic = false
+
+  /** Check that each constraint resulting from a subtype test
+   *  is satisfiable. Also check that a type variable instantiation
+   *  satisfies its constraints.
+   *  Note that this can fail when bad bounds are in scope, like in
+   *  tests/neg/i4721a.scala.
+   */
+  inline val checkConstraintsSatisfiable = false
+
+  /** Check that each constraint is fully propagated. i.e.
+   *  If P <: Q then the upper bound of P is a subtype of the upper bound of Q
+   *  and the lower bound of Q is a subtype of the lower bound of P.
+   */
+  inline val checkConstraintsPropagated = false
+
+  /** Check that constraint bounds do not contain wildcard types */
+  inline val checkNoWildcardsInConstraint = false
+
+  /** If a constraint is over a type lambda `tl` and `tvar` is one of
+   *  the type variables associated with `tl` in the constraint, check
+   *  that the origin of `tvar` is a parameter of `tl`.
+   */
+  inline val checkConsistentVars = false
+
+  /** Check that constraints of globally committable typer states are closed.
+   *  NOTE: When enabled, the check can cause CyclicReference errors because
+   *  it traverses all elements of a type. Such failures were observed when
+   *  compiling all of dotty together (source seems to be in GenBCode which
+   *  accesses javac's settings.)
+   *
+   *  It is recommended to turn this option on only when chasing down
+   *  a TypeParamRef instantiation error. See comment in Types.TypeVar.instantiate.
+   */
+  inline val debugCheckConstraintsClosed = false
+
+  /** Check that no type appearing as the info of a SymDenotation contains
+   *  skolem types.
+   */
+  inline val checkNoSkolemsInInfo = false
+
+  /** Check that Name#toString is not called directly from backend by analyzing
+   *  the stack trace of each toString call on names. This is very expensive,
+   *  so not suitable for continuous testing. But it can be used to find a problem
+   *  when running a specific test.
+   */
+  inline val checkBackendNames = false
+
+  /** Check that re-used type comparers are in their initialization state */
+  inline val checkTypeComparerReset = false
+
+  /** Type comparer will fail with an assert if the upper bound
+   *  of a constrained parameter becomes Nothing. This should be turned
+   *  on only for specific debugging as normally instantiation to Nothing
+   *  is not an error condition.
+   */
+  inline val failOnInstantiationToNothing = false
+
+  /** Enable noDoubleDef checking if option "-YnoDoubleDefs" is set.
+    * The reason to have an option as well as the present global switch is
+    * that the noDoubleDef checking is done in a hotspot, and we do not
+    * want to incur the overhead of checking an option each time.
+    */
+  inline val checkNoDoubleBindings = true
+
+  /** Check positions for consistency after parsing */
+  inline val checkPositions = true
+
+  /** Check that typed trees don't point to untyped ones */
+  inline val checkTreesConsistent = false
+
+  /** Show subtype traces for all deep subtype recursions */
+  inline val traceDeepSubTypeRecursions = false
+
+  /** When explaining subtypes and this flag is set, also show the classes of the compared types. */
+  inline val verboseExplainSubtype = false
+
+  /** If this flag is set, take the fast path when comparing same-named type-aliases and types */
+  inline val fastPathForRefinedSubtype = true
+
+  /** If this flag is set, and we compute `T1[X1]` & `T2[X2]` as a new
+   *  upper bound of a constrained parameter, try to align the arguments by computing
+   *  `S1 =:= S2` (which might instantiate type parameters).
+   *  This rule is contentious because it cuts the constraint set.
+   *
+   *  For more info, see the comment in `TypeComparer#glbArgs`.
+   */
+  inline val alignArgsInAnd = true
+
+  /** If this flag is set, higher-kinded applications are checked for validity
+   */
+  inline val checkHKApplications = false
+
+  /** If this flag is set, method types are checked for valid parameter references
+   */
+  inline val checkMethodTypes = false
+
+  /** If this flag is set, it is checked that TypeRefs don't refer directly
+   *  to themselves.
+   */
+  inline val checkTypeRefCycles = false
+
+  /** If this flag is set, we check that types assigned to trees are error types only
+   *  if some error was already reported. There are complicicated scenarios where this
+   *  is not true. An example is TestNonCyclic in posTwice. If we remove the
+   *  first (unused) import `import dotty.tools.dotc.core.Types.Type` in `CompilationUnit`,
+   *  we end up assigning a CyclicReference error type to an import expression `annotation`
+   *  before the cyclic reference is reported. What happens is that the error was reported
+   *  as a result of a completion in a not-yet committed typerstate. So we cannot enforce
+   *  this in all circumstances. But since it is almost always true it is useful to
+   *  keep the Config option for debugging.
+   */
+  inline val checkUnreportedErrors = false
+
+  /** If this flag is set, it is checked that class type parameters are
+   *  only references with NoPrefix or ThisTypes as prefixes. This option
+   *  is usually disabled, because there are still some legitimate cases where
+   *  this can arise (e.g. for pos/Map.scala, in LambdaType.integrate).
+   */
+  inline val checkTypeParamRefs = false
+
+  /** The recursion depth for showing a summarized string */
+  inline val summarizeDepth = 2
+
+  /** Check that variances of lambda arguments match the
+   *  variance of the underlying lambda class.
+   */
+  inline val checkLambdaVariance = false
+
+  /** Check that certain types cannot be created in erasedTypes phases.
+   *  Note: Turning this option on will get some false negatives, since it is
+   *  possible that And/Or types are still created during erasure as the result
+   *  of some operation on an existing type.
+   */
+  inline val checkUnerased = false
+
+  /** Check that atoms-based comparisons match regular comparisons that do not
+   *  take atoms into account. The two have to give the same results, since
+   *  atoms comparison is intended to be just an optimization.
+   */
+  inline val checkAtomsComparisons = false
+
+  /** In `derivedSelect`, rewrite
+   *
+   *      (S & T)#A  -->  S#A & T#A
+   *      (S | T)#A  -->  S#A | T#A
+   *
+   *  Not sure whether this is useful. Preliminary measurements show a slowdown of about
+   *  7% for the build when this option is enabled.
+   */
+  inline val splitProjections = false
+
+  /** If this flag is on, always rewrite an application `S[Ts]` where `S` is an alias for
+   *  `[Xs] -> U` to `[Xs := Ts]U`.
+   *  Turning this flag on was observed to give a ~6% speedup on the JUnit test suite.
+   */
+  inline val simplifyApplications = true
+
+  /** Assume -indent by default */
+  inline val defaultIndent = true
+
+  /** If set, prints a trace of all symbol completions */
+  inline val showCompletions = false
+
+  /** If set, method results that are context functions are flattened by adding
+   *  the parameters of the context function results to the methods themselves.
+   *  This is an optimization that reduces closure allocations.
+   */
+  inline val flattenContextFunctionResults = true
+
+  /** If set, enables tracing */
+  inline val tracingEnabled = false
+
+  /** Initial capacity of the uniques HashMap.
+   *  Note: This should be a power of two to work with util.HashSet
+   */
+  inline val initialUniquesCapacity = 0x8000
+
+  /** How many recursive calls to NamedType#underlying are performed before logging starts. */
+  inline val LogPendingUnderlyingThreshold = 50
+
+  /** How many recursive calls to isSubType are performed before logging starts. */
+  inline val LogPendingSubTypesThreshold = 50
+
+  /** How many recursive calls to findMember are performed before logging names starts
+   *  Note: this threshold has to be chosen carefully. Too large, and programs
+   *  like tests/pos/IterableSelfRec go into polynomial (or even exponential?)
+   *  compile time slowdown. Too small and normal programs will cause the compiler  to
+   *  do inefficient operations on findMember. The current value is determined
+   *  so that (1) IterableSelfRec still compiles in reasonable time (< 10sec) (2) Compiling
+   *  dotty itself only causes small pending names lists to be generated (we measured
+   *  at max 6 elements) and these lists are never searched with contains.
+   */
+  inline val LogPendingFindMemberThreshold = 9
+
+  /** When in IDE, turn StaleSymbol errors into warnings instead of crashing */
+  inline val ignoreStaleInIDE = true
+
+  /** If true, `Denotation#asSeenFrom` is allowed to return an existing
+   *  `SymDenotation` instead of allocating a new `SingleDenotation` if
+   *  the two would only differ in their `prefix` (SymDenotation always
+   *  have `NoPrefix` as their prefix).
+   *  This is done for performance reasons: when compiling Dotty itself this
+   *  reduces the number of allocated denotations by ~50%.
+   */
+  inline val reuseSymDenotations = true
+
+  /** If `checkLevelsOnConstraints` is true, check levels of type variables
+   *  and create fresh ones as needed when bounds are first entered intot he constraint.
+   *  If `checkLevelsOnInstantiation` is true, allow level-incorrect constraints but
+   *  fix levels on type variable instantiation.
+   */
+  inline val checkLevelsOnConstraints = false
+  inline val checkLevelsOnInstantiation = true
+
+  /** If true, print capturing types in the form `{c} T`.
+   *  If false, print them in the form `T @retains(c)`.
+   */
+  inline val printCaptureSetsAsPrefix = true
+
+  /** If true, allow mappping capture set variables under captureChecking with maps that are neither
+   *  bijective nor idempotent. We currently do now know how to do this correctly in all
+   *  cases, though.
+   */
+  inline val ccAllowUnsoundMaps = false
+}
diff --git a/tests/pos-with-compiler-cc/dotc/config/Feature.scala b/tests/pos-with-compiler-cc/dotc/config/Feature.scala
new file mode 100644
index 000000000000..c482bbe0911f
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/config/Feature.scala
@@ -0,0 +1,168 @@
+package dotty.tools
+package dotc
+package config
+
+import core._
+import Contexts._, Symbols._, Names._
+import StdNames.nme
+import Decorators.*
+import util.{SrcPos, NoSourcePosition}
+import SourceVersion._
+import reporting.Message
+import NameKinds.QualifiedName
+import language.experimental.pureFunctions
+
+object Feature:
+
+  def experimental(str: PreName): TermName =
+    QualifiedName(nme.experimental, str.toTermName)
+
+  private def deprecated(str: PreName): TermName =
+    QualifiedName(nme.deprecated, str.toTermName)
+
+  private val namedTypeArguments = experimental("namedTypeArguments")
+  private val genericNumberLiterals = experimental("genericNumberLiterals")
+  val scala2macros = experimental("macros")
+
+  val dependent = experimental("dependent")
+  val erasedDefinitions = experimental("erasedDefinitions")
+  val symbolLiterals = deprecated("symbolLiterals")
+  val fewerBraces = experimental("fewerBraces")
+  val saferExceptions = experimental("saferExceptions")
+  val pureFunctions = experimental("pureFunctions")
+  val captureChecking = experimental("captureChecking")
+
+  val globalOnlyImports: Set[TermName] = Set(pureFunctions, captureChecking)
+
+  /** Is `feature` enabled by by a command-line setting? The enabling setting is
+   *
+   *       -language:<prefix>feature
+   *
+   *  where <prefix> is the fully qualified name of `owner`, followed by a ".",
+   *  but subtracting the prefix `scala.language.` at the front.
+   */
+  def enabledBySetting(feature: TermName)(using Context): Boolean =
+    ctx.base.settings.language.value.contains(feature.toString)
+
+  /** Is `feature` enabled by by an import? This is the case if the feature
+   *  is imported by a named import
+   *
+   *       import owner.feature
+   *
+   *  and there is no visible nested import that excludes the feature, as in
+   *
+   *       import owner.{ feature => _ }
+   */
+  def enabledByImport(feature: TermName)(using Context): Boolean =
+    //atPhase(typerPhase) {
+      val info = ctx.importInfo
+      info != null && info.featureImported(feature)
+    //}
+
+  /** Is `feature` enabled by either a command line setting or an import?
+   *  @param  feature   The name of the feature
+   *  @param  owner     The prefix symbol (nested in `scala.language`) where the
+   *                    feature is defined.
+   */
+  def enabled(feature: TermName)(using Context): Boolean =
+    enabledBySetting(feature) || enabledByImport(feature)
+
+  /** Is auto-tupling enabled? */
+  def autoTuplingEnabled(using Context): Boolean = !enabled(nme.noAutoTupling)
+
+  def dynamicsEnabled(using Context): Boolean = enabled(nme.dynamics)
+
+  def dependentEnabled(using Context) = enabled(dependent)
+
+  def namedTypeArgsEnabled(using Context) = enabled(namedTypeArguments)
+
+  def genericNumberLiteralsEnabled(using Context) = enabled(genericNumberLiterals)
+
+  def scala2ExperimentalMacroEnabled(using Context) = enabled(scala2macros)
+
+  /** Is pureFunctions enabled for this compilation unit? */
+  def pureFunsEnabled(using Context) =
+    enabledBySetting(pureFunctions)
+    || ctx.compilationUnit.knowsPureFuns
+    || ccEnabled
+
+  /** Is captureChecking enabled for this compilation unit? */
+  def ccEnabled(using Context) =
+    enabledBySetting(captureChecking)
+    || ctx.compilationUnit.needsCaptureChecking
+
+  /** Is pureFunctions enabled for any of the currently compiled compilation units? */
+  def pureFunsEnabledSomewhere(using Context) =
+    enabledBySetting(pureFunctions)
+    || ctx.run != null && ctx.run.nn.pureFunsImportEncountered
+    || ccEnabledSomewhere
+
+  /** Is captureChecking enabled for any of the currently compiled compilation units? */
+  def ccEnabledSomewhere(using Context) =
+    enabledBySetting(captureChecking)
+    || ctx.run != null && ctx.run.nn.ccImportEncountered
+
+  def sourceVersionSetting(using Context): SourceVersion =
+    SourceVersion.valueOf(ctx.settings.source.value)
+
+  def sourceVersion(using Context): SourceVersion =
+    ctx.compilationUnit.sourceVersion match
+      case Some(v) => v
+      case none => sourceVersionSetting
+
+  def migrateTo3(using Context): Boolean = sourceVersion == `3.0-migration`
+
+  /** If current source migrates to `version`, issue given warning message
+   *  and return `true`, otherwise return `false`.
+   */
+  def warnOnMigration(msg: Message, pos: SrcPos, version: SourceVersion)(using Context): Boolean =
+    if sourceVersion.isMigrating && sourceVersion.stable == version
+       || (version == `3.0` || version == `3.1`) && migrateTo3
+    then
+      report.migrationWarning(msg, pos)
+      true
+    else
+      false
+
+  def checkExperimentalFeature(which: String, srcPos: SrcPos, note: -> String = "")(using Context) =
+    if !isExperimentalEnabled then
+      report.error(i"Experimental $which may only be used with a nightly or snapshot version of the compiler$note", srcPos)
+
+  def checkExperimentalDef(sym: Symbol, srcPos: SrcPos)(using Context) =
+    if !isExperimentalEnabled then
+      val symMsg =
+        if sym.hasAnnotation(defn.ExperimentalAnnot) then
+          i"$sym is marked @experimental"
+        else if sym.owner.hasAnnotation(defn.ExperimentalAnnot) then
+          i"${sym.owner} is marked @experimental"
+        else
+          i"$sym inherits @experimental"
+      report.error(s"$symMsg and therefore may only be used in an experimental scope.", srcPos)
+
+  /** Check that experimental compiler options are only set for snapshot or nightly compiler versions. */
+  def checkExperimentalSettings(using Context): Unit =
+    for setting <- ctx.settings.language.value
+        if setting.startsWith("experimental.") && setting != "experimental.macros"
+    do checkExperimentalFeature(s"feature $setting", NoSourcePosition)
+
+  def isExperimentalEnabled(using Context): Boolean =
+    Properties.experimental && !ctx.settings.YnoExperimental.value
+
+  /** Handle language import `import language.<prefix>.<imported>` if it is one
+   *  of the global imports `pureFunctions` or `captureChecking`. In this case
+   *  make the compilation unit's and current run's fields accordingly.
+   *  @return true iff import that was handled
+   */
+  def handleGlobalLanguageImport(prefix: TermName, imported: Name)(using Context): Boolean =
+    val fullFeatureName = QualifiedName(prefix, imported.asTermName)
+    if fullFeatureName == pureFunctions then
+      ctx.compilationUnit.knowsPureFuns = true
+      if ctx.run != null then ctx.run.nn.pureFunsImportEncountered = true
+      true
+    else if fullFeatureName == captureChecking then
+      ctx.compilationUnit.needsCaptureChecking = true
+      if ctx.run != null then ctx.run.nn.ccImportEncountered = true
+      true
+    else
+      false
+end Feature
diff --git a/tests/pos-with-compiler-cc/dotc/config/JavaPlatform.scala b/tests/pos-with-compiler-cc/dotc/config/JavaPlatform.scala
new file mode 100644
index 000000000000..2b2f35e49451
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/config/JavaPlatform.scala
@@ -0,0 +1,69 @@
+package dotty.tools
+package dotc
+package config
+
+import io._
+import classpath.AggregateClassPath
+import core._
+import Symbols._, Types._, Contexts._, StdNames._
+import Flags._
+import transform.ExplicitOuter, transform.SymUtils._
+
+class JavaPlatform extends Platform {
+
+  private var currentClassPath: Option[ClassPath] = None
+
+  def classPath(using Context): ClassPath = {
+    if (currentClassPath.isEmpty)
+      currentClassPath = Some(new PathResolver().result)
+    val cp = currentClassPath.get
+    cp
+  }
+
+  // The given symbol is a method with the right name and signature to be a runnable java program.
+  def isMainMethod(sym: Symbol)(using Context): Boolean =
+    (sym.name == nme.main) && (sym.info match {
+      case MethodTpe(_, defn.ArrayOf(el) :: Nil, restpe) => el =:= defn.StringType && (restpe isRef defn.UnitClass)
+      case _ => false
+    })
+
+  /** Update classpath with a substituted subentry */
+  def updateClassPath(subst: Map[ClassPath, ClassPath]): Unit = currentClassPath.get match {
+    case AggregateClassPath(entries) =>
+      currentClassPath = Some(AggregateClassPath(entries map (e => subst.getOrElse(e, e))))
+    case cp: ClassPath =>
+      currentClassPath = Some(subst.getOrElse(cp, cp))
+  }
+
+  def rootLoader(root: TermSymbol)(using Context): SymbolLoader = new SymbolLoaders.PackageLoader(root, classPath)
+
+  /** Is the SAMType `cls` also a SAM under the rules of the JVM? */
+  def isSam(cls: ClassSymbol)(using Context): Boolean =
+    cls.isAllOf(NoInitsTrait) &&
+    cls.superClass == defn.ObjectClass &&
+    cls.directlyInheritedTraits.forall(_.is(NoInits)) &&
+    !ExplicitOuter.needsOuterIfReferenced(cls) &&
+    cls.typeRef.fields.isEmpty // Superaccessors already show up as abstract methods here, so no test necessary
+
+  /** We could get away with excluding BoxedBooleanClass for the
+   *  purpose of equality testing since it need not compare equal
+   *  to anything but other booleans, but it should be present in
+   *  case this is put to other uses.
+   */
+  def isMaybeBoxed(sym: ClassSymbol)(using Context): Boolean = {
+    val d = defn
+    import d._
+    (sym == ObjectClass) ||
+    (sym == JavaSerializableClass) ||
+    (sym == ComparableClass) ||
+    (sym derivesFrom BoxedNumberClass) ||
+    (sym derivesFrom BoxedCharClass) ||
+    (sym derivesFrom BoxedBooleanClass)
+  }
+
+  def shouldReceiveJavaSerializationMethods(sym: ClassSymbol)(using Context): Boolean =
+    true
+
+  def newClassLoader(bin: AbstractFile)(using Context): SymbolLoader =
+    new ClassfileLoader(bin)
+}
diff --git a/tests/pos-with-compiler-cc/dotc/config/OutputDirs.scala b/tests/pos-with-compiler-cc/dotc/config/OutputDirs.scala
new file mode 100644
index 000000000000..0411c5604768
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/config/OutputDirs.scala
@@ -0,0 +1,117 @@
+package dotty.tools
+package dotc
+package config
+
+import scala.language.unsafeNulls
+
+import io._
+
+/** A class for holding mappings from source directories to
+ *  their output location. This functionality can be accessed
+ *  only programmatically. The command line compiler uses a
+ *  single output location, but tools may use this functionality
+ *  to set output location per source directory.
+ */
+class OutputDirs {
+  /** Pairs of source directory - destination directory. */
+  private var outputDirs: List[(AbstractFile, AbstractFile)] = Nil
+
+  /** If this is not None, the output location where all
+   *  classes should go.
+   */
+  private var singleOutDir: Option[AbstractFile] = None
+
+  /** Add a destination directory for sources found under srcdir.
+   *  Both directories should exits.
+   */
+  def add(srcDir: String, outDir: String): Unit =
+    add(checkDir(AbstractFile.getDirectory(srcDir), srcDir),
+      checkDir(AbstractFile.getDirectory(outDir), outDir))
+
+  /** Check that dir is exists and is a directory. */
+  private def checkDir(dir: AbstractFile, name: String, allowJar: Boolean = false): AbstractFile = (
+    if (dir != null && dir.isDirectory)
+      dir
+    // was:      else if (allowJar && dir == null && Path.isJarOrZip(name, false))
+    else if (allowJar && dir == null && Jar.isJarOrZip(File(name), false))
+      new PlainFile(Path(name))
+    else
+      throw new FatalError(name + " does not exist or is not a directory"))
+
+  /** Set the single output directory. From now on, all files will
+   *  be dumped in there, regardless of previous calls to 'add'.
+   */
+  def setSingleOutput(outDir: String): Unit = {
+    val dst = AbstractFile.getDirectory(outDir)
+    setSingleOutput(checkDir(dst, outDir, true))
+  }
+
+  def getSingleOutput: Option[AbstractFile] = singleOutDir
+
+  /** Set the single output directory. From now on, all files will
+   *  be dumped in there, regardless of previous calls to 'add'.
+   */
+  def setSingleOutput(dir: AbstractFile): Unit =
+    singleOutDir = Some(dir)
+
+  def add(src: AbstractFile, dst: AbstractFile): Unit = {
+    singleOutDir = None
+    outputDirs ::= ((src, dst))
+  }
+
+  /** Return the list of source-destination directory pairs. */
+  def outputs: List[(AbstractFile, AbstractFile)] = outputDirs
+
+  /** Return the output directory for the given file.
+   */
+  def outputDirFor(src: AbstractFile): AbstractFile = {
+    def isBelow(srcDir: AbstractFile, outDir: AbstractFile) =
+      src.path.startsWith(srcDir.path)
+
+    singleOutDir match {
+      case Some(d) => d
+      case None =>
+        (outputs find (isBelow _).tupled) match {
+          case Some((_, d)) => d
+          case _ =>
+            throw new FatalError("Could not find an output directory for "
+              + src.path + " in " + outputs)
+        }
+    }
+  }
+
+  /** Return the source file path(s) which correspond to the given
+   *  classfile path and SourceFile attribute value, subject to the
+   *  condition that source files are arranged in the filesystem
+   *  according to Java package layout conventions.
+   *
+   *  The given classfile path must be contained in at least one of
+   *  the specified output directories. If it does not then this
+   *  method returns Nil.
+   *
+   *  Note that the source file is not required to exist, so assuming
+   *  a valid classfile path this method will always return a list
+   *  containing at least one element.
+   *
+   *  Also that if two or more source path elements target the same
+   *  output directory there will be two or more candidate source file
+   *  paths.
+   */
+  def srcFilesFor(classFile: AbstractFile, srcPath: String): List[AbstractFile] = {
+    def isBelow(srcDir: AbstractFile, outDir: AbstractFile) =
+      classFile.path.startsWith(outDir.path)
+
+    singleOutDir match {
+      case Some(d) =>
+        d match {
+          case _: VirtualDirectory | _: io.ZipArchive => Nil
+          case _ => List(d.lookupPathUnchecked(srcPath, false))
+        }
+      case None =>
+        (outputs filter (isBelow _).tupled) match {
+          case Nil => Nil
+          case matches => matches.map(_._1.lookupPathUnchecked(srcPath, false))
+        }
+    }
+  }
+}
diff --git a/tests/pos-with-compiler-cc/dotc/config/PathResolver.scala b/tests/pos-with-compiler-cc/dotc/config/PathResolver.scala
new file mode 100644
index 000000000000..afa30e38dc2a
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/config/PathResolver.scala
@@ -0,0 +1,268 @@
+package dotty.tools
+package dotc
+package config
+
+import scala.language.unsafeNulls
+
+import WrappedProperties.AccessControl
+import io.{ClassPath, Directory, Path}
+import classpath.{AggregateClassPath, ClassPathFactory, JrtClassPath}
+import ClassPath.split
+import PartialFunction.condOpt
+import core.Contexts._
+import Settings._
+import dotty.tools.io.File
+
+object PathResolver {
+
+  // Imports property/environment functions which suppress
+  // security exceptions.
+  import AccessControl._
+
+  def firstNonEmpty(xs: String*): String = xs find (_ != "") getOrElse ""
+
+  /** Map all classpath elements to absolute paths and reconstruct the classpath.
+   */
+  def makeAbsolute(cp: String): String = ClassPath.map(cp, x => Path(x).toAbsolute.path)
+
+  /** pretty print class path
+   */
+  def ppcp(s: String): String = split(s) match {
+    case Nil      => ""
+    case Seq(x)   => x
+    case xs       => xs.map("\n" + _).mkString
+  }
+
+  /** Values found solely by inspecting environment or property variables.
+   */
+  object Environment {
+    private def searchForBootClasspath = (
+      systemProperties find (_._1 endsWith ".boot.class.path") map (_._2) getOrElse ""
+    )
+
+    /** Environment variables which java pays attention to so it
+     *  seems we do as well.
+     */
+    def classPathEnv: String        =  envOrElse("CLASSPATH", "")
+    def sourcePathEnv: String       =  envOrElse("SOURCEPATH", "")
+
+    def javaBootClassPath: String   = propOrElse("sun.boot.class.path", searchForBootClasspath)
+
+    def javaExtDirs: String         = propOrEmpty("java.ext.dirs")
+    def scalaHome: String           = propOrEmpty("scala.home")
+    def scalaExtDirs: String        = propOrEmpty("scala.ext.dirs")
+
+    /** The java classpath and whether to use it.
+     */
+    def javaUserClassPath: String   = propOrElse("java.class.path", "")
+    def useJavaClassPath: Boolean    = propOrFalse("scala.usejavacp")
+
+    override def toString: String = s"""
+      |object Environment {
+      |  scalaHome          = $scalaHome (useJavaClassPath = $useJavaClassPath)
+      |  javaBootClassPath  = <${javaBootClassPath.length} chars>
+      |  javaExtDirs        = ${ppcp(javaExtDirs)}
+      |  javaUserClassPath  = ${ppcp(javaUserClassPath)}
+      |  scalaExtDirs       = ${ppcp(scalaExtDirs)}
+      |}""".trim.stripMargin
+  }
+
+  /** Default values based on those in Environment as interpreted according
+   *  to the path resolution specification.
+   */
+  object Defaults {
+    def scalaSourcePath: String    = Environment.sourcePathEnv
+    def javaBootClassPath: String  = Environment.javaBootClassPath
+    def javaUserClassPath: String  = Environment.javaUserClassPath
+    def javaExtDirs: String        = Environment.javaExtDirs
+    def useJavaClassPath: Boolean  = Environment.useJavaClassPath
+
+    def scalaHome: String          = Environment.scalaHome
+    def scalaHomeDir: Directory    = Directory(scalaHome)
+    def scalaHomeExists: Boolean   = scalaHomeDir.isDirectory
+    def scalaLibDir: Directory     = (scalaHomeDir / "lib").toDirectory
+    def scalaClassesDir: Directory = (scalaHomeDir / "classes").toDirectory
+
+    def scalaLibAsJar: File        = (scalaLibDir / "scala-library.jar").toFile
+    def scalaLibAsDir: Directory   = (scalaClassesDir / "library").toDirectory
+
+    def scalaLibDirFound: Option[Directory] =
+      if (scalaLibAsJar.isFile) Some(scalaLibDir)
+      else if (scalaLibAsDir.isDirectory) Some(scalaClassesDir)
+      else None
+
+    def scalaLibFound: String =
+      if (scalaLibAsJar.isFile) scalaLibAsJar.path
+      else if (scalaLibAsDir.isDirectory) scalaLibAsDir.path
+      else ""
+
+    // XXX It must be time for someone to figure out what all these things
+    // are intended to do.  This is disabled here because it was causing all
+    // the scala jars to end up on the classpath twice: one on the boot
+    // classpath as set up by the runner (or regular classpath under -nobootcp)
+    // and then again here.
+    def scalaBootClassPath: String  = ""
+    // scalaLibDirFound match {
+    //   case Some(dir) if scalaHomeExists =>
+    //     val paths = ClassPath expandDir dir.path
+    //     join(paths: _*)
+    //   case _                            => ""
+    // }
+
+    def scalaExtDirs: String = Environment.scalaExtDirs
+
+    def scalaPluginPath: String = (scalaHomeDir / "misc" / "scala-devel" / "plugins").path
+
+    override def toString: String = """
+      |object Defaults {
+      |  scalaHome            = %s
+      |  javaBootClassPath    = %s
+      |  scalaLibDirFound     = %s
+      |  scalaLibFound        = %s
+      |  scalaBootClassPath   = %s
+      |  scalaPluginPath      = %s
+      |}""".trim.stripMargin.format(
+        scalaHome,
+        ppcp(javaBootClassPath),
+        scalaLibDirFound, scalaLibFound,
+        ppcp(scalaBootClassPath), ppcp(scalaPluginPath)
+      )
+  }
+
+  def fromPathString(path: String)(using Context): ClassPath = {
+    val settings = ctx.settings.classpath.update(path)
+    inContext(ctx.fresh.setSettings(settings)) {
+      new PathResolver().result
+    }
+  }
+
+  /** Show values in Environment and Defaults when no argument is provided.
+   *  Otherwise, show values in Calculated as if those options had been given
+   *  to a scala runner.
+   */
+  def main(args: Array[String]): Unit =
+    if (args.isEmpty) {
+      println(Environment)
+      println(Defaults)
+    }
+    else inContext(ContextBase().initialCtx) {
+      val ArgsSummary(sstate, rest, errors, warnings) =
+        ctx.settings.processArguments(args.toList, true, ctx.settingsState)
+      errors.foreach(println)
+      val pr = inContext(ctx.fresh.setSettings(sstate)) {
+        new PathResolver()
+      }
+      println(" COMMAND: 'scala %s'".format(args.mkString(" ")))
+      println("RESIDUAL: 'scala %s'\n".format(rest.mkString(" ")))
+
+      pr.result match {
+        case cp: AggregateClassPath =>
+          println(s"ClassPath has ${cp.aggregates.size} entries and results in:\n${cp.asClassPathStrings}")
+      }
+    }
+}
+
+import PathResolver.{Defaults, ppcp}
+
+class PathResolver(using c: Context) {
+  import c.base.settings
+
+  private val classPathFactory = new ClassPathFactory
+
+  private def cmdLineOrElse(name: String, alt: String) =
+    commandLineFor(name) match {
+      case Some("") | None => alt
+      case Some(x)         => x
+    }
+
+  private def commandLineFor(s: String): Option[String] = condOpt(s) {
+    case "javabootclasspath"  => settings.javabootclasspath.value
+    case "javaextdirs"        => settings.javaextdirs.value
+    case "bootclasspath"      => settings.bootclasspath.value
+    case "extdirs"            => settings.extdirs.value
+    case "classpath" | "cp"   => settings.classpath.value
+    case "sourcepath"         => settings.sourcepath.value
+  }
+
+  /** Calculated values based on any given command line options, falling back on
+   *  those in Defaults.
+   */
+  object Calculated {
+    def scalaHome: String           = Defaults.scalaHome
+    def useJavaClassPath: Boolean   = settings.usejavacp.value || Defaults.useJavaClassPath
+    def javaBootClassPath: String   = cmdLineOrElse("javabootclasspath", Defaults.javaBootClassPath)
+    def javaExtDirs: String         = cmdLineOrElse("javaextdirs", Defaults.javaExtDirs)
+    def javaUserClassPath: String   = if (useJavaClassPath) Defaults.javaUserClassPath else ""
+    def scalaBootClassPath: String  = cmdLineOrElse("bootclasspath", Defaults.scalaBootClassPath)
+    def scalaExtDirs: String        = cmdLineOrElse("extdirs", Defaults.scalaExtDirs)
+    /** Scaladoc doesn't need any bootstrapping, otherwise will create errors such as:
+     * [scaladoc] ../scala-trunk/src/reflect/scala/reflect/macros/Reifiers.scala:89: error: object api is not a member of package reflect
+     * [scaladoc] case class ReificationException(val pos: reflect.api.PositionApi, val msg: String) extends Throwable(msg)
+     * [scaladoc]                                              ^
+     * Because bootstrapping looks at the sourcepath and creates the package "reflect" in "<root>" it will cause the
+     * typedIdentifier to pick <root>.reflect instead of the <root>.scala.reflect package.  Thus, no bootstrapping for scaladoc!
+     */
+    def sourcePath: String          = cmdLineOrElse("sourcepath", Defaults.scalaSourcePath)
+
+    def userClassPath: String =
+      if (!settings.classpath.isDefault) settings.classpath.value
+      else sys.env.getOrElse("CLASSPATH", ".")
+
+    import classPathFactory._
+
+    // Assemble the elements!
+    def basis: List[Traversable[ClassPath]] =
+      val release = Option(ctx.settings.javaOutputVersion.value).filter(_.nonEmpty)
+
+      List(
+        JrtClassPath(release),                        // 1. The Java 9+ classpath (backed by the jrt:/ virtual system, if available)
+        classesInPath(javaBootClassPath),             // 2. The Java bootstrap class path.
+        contentsOfDirsInPath(javaExtDirs),            // 3. The Java extension class path.
+        classesInExpandedPath(javaUserClassPath),     // 4. The Java application class path.
+        classesInPath(scalaBootClassPath),            // 5. The Scala boot class path.
+        contentsOfDirsInPath(scalaExtDirs),           // 6. The Scala extension class path.
+        classesInExpandedPath(userClassPath),         // 7. The Scala application class path.
+        sourcesInPath(sourcePath)                     // 8. The Scala source path.
+      )
+
+    lazy val containers: List[ClassPath] = basis.flatten.distinct
+
+    override def toString: String = """
+      |object Calculated {
+      |  scalaHome            = %s
+      |  javaBootClassPath    = %s
+      |  javaExtDirs          = %s
+      |  javaUserClassPath    = %s
+      |  useJavaClassPath     = %s
+      |  scalaBootClassPath   = %s
+      |  scalaExtDirs         = %s
+      |  userClassPath        = %s
+      |  sourcePath           = %s
+      |}""".trim.stripMargin.format(
+        scalaHome,
+        ppcp(javaBootClassPath), ppcp(javaExtDirs), ppcp(javaUserClassPath),
+        useJavaClassPath,
+        ppcp(scalaBootClassPath), ppcp(scalaExtDirs), ppcp(userClassPath),
+        ppcp(sourcePath)
+      )
+  }
+
+  def containers: List[ClassPath] = Calculated.containers
+
+  lazy val result: ClassPath = {
+    val cp = AggregateClassPath(containers.toIndexedSeq)
+
+    if (settings.YlogClasspath.value) {
+      Console.println("Classpath built from " + settings.toConciseString(ctx.settingsState))
+      Console.println("Defaults: " + PathResolver.Defaults)
+      Console.println("Calculated: " + Calculated)
+
+      val xs = (Calculated.basis drop 2).flatten.distinct
+      println("After java boot/extdirs classpath has %d entries:" format xs.size)
+      xs foreach (x => println("  " + x))
+    }
+    cp
+  }
+
+  def asURLs: Seq[java.net.URL] = result.asURLs
+}
diff --git a/tests/pos-with-compiler-cc/dotc/config/Platform.scala b/tests/pos-with-compiler-cc/dotc/config/Platform.scala
new file mode 100644
index 000000000000..0faacf1bcebb
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/config/Platform.scala
@@ -0,0 +1,46 @@
+package dotty.tools
+package dotc
+package config
+
+import io.{ClassPath, AbstractFile}
+import core.Contexts._, core.Symbols._
+import core.SymbolLoader
+import core.StdNames.nme
+import core.Flags.Module
+
+/** The platform dependent pieces of Global.
+ */
+abstract class Platform {
+
+  /** The root symbol loader. */
+  def rootLoader(root: TermSymbol)(using Context): SymbolLoader
+
+  /** The compiler classpath. */
+  def classPath(using Context): ClassPath
+
+  /** Update classpath with a substitution that maps entries to entries */
+  def updateClassPath(subst: Map[ClassPath, ClassPath]): Unit
+
+  /** Any platform-specific phases. */
+  //def platformPhases: List[SubComponent]
+
+  /** Is the SAMType `cls` also a SAM under the rules of the platform? */
+  def isSam(cls: ClassSymbol)(using Context): Boolean
+
+  /** The various ways a boxed primitive might materialize at runtime. */
+  def isMaybeBoxed(sym: ClassSymbol)(using Context): Boolean
+
+  /** Is the given class symbol eligible for Java serialization-specific methods? */
+  def shouldReceiveJavaSerializationMethods(sym: ClassSymbol)(using Context): Boolean
+
+  /** Create a new class loader to load class file `bin` */
+  def newClassLoader(bin: AbstractFile)(using Context): SymbolLoader
+
+  /** The given symbol is a method with the right name and signature to be a runnable program. */
+  def isMainMethod(sym: Symbol)(using Context): Boolean
+
+  /** The given class has a main method. */
+  final def hasMainMethod(sym: Symbol)(using Context): Boolean =
+    sym.info.member(nme.main).hasAltWith(d =>
+      isMainMethod(d.symbol) && (sym.is(Module) || d.symbol.isStatic))
+}
diff --git a/tests/pos-with-compiler-cc/dotc/config/Printers.scala b/tests/pos-with-compiler-cc/dotc/config/Printers.scala
new file mode 100644
index 000000000000..ecb189de9bb3
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/config/Printers.scala
@@ -0,0 +1,52 @@
+package dotty.tools.dotc.config
+
+object Printers {
+
+  class Printer {
+    def println(msg: => String): Unit = System.out.nn.println(msg)
+  }
+
+  object noPrinter extends Printer {
+    inline override def println(msg: => String): Unit = ()
+  }
+
+  val default = new Printer
+
+  val capt = noPrinter
+  val constr = noPrinter
+  val core = noPrinter
+  val checks = noPrinter
+  val config = noPrinter
+  val cyclicErrors = noPrinter
+  val debug = noPrinter
+  val derive = noPrinter
+  val desugar = noPrinter
+  val scaladoc = noPrinter
+  val exhaustivity = noPrinter
+  val gadts = noPrinter
+  val gadtsConstr = noPrinter
+  val hk = noPrinter
+  val implicits = noPrinter
+  val implicitsDetailed = noPrinter
+  val lexical = noPrinter
+  val init = noPrinter
+  val inlining = noPrinter
+  val interactiv = noPrinter
+  val matchTypes = noPrinter
+  val nullables = noPrinter
+  val overload = noPrinter
+  val patmatch = noPrinter
+  val pickling = noPrinter
+  val quotePickling = noPrinter
+  val plugins = noPrinter
+  val recheckr = noPrinter
+  val refcheck = noPrinter
+  val simplify = noPrinter
+  val staging = noPrinter
+  val subtyping = noPrinter
+  val tailrec = noPrinter
+  val transforms = noPrinter
+  val typr = noPrinter
+  val unapp = noPrinter
+  val variances = noPrinter
+}
diff --git a/tests/pos-with-compiler-cc/dotc/config/Properties.scala b/tests/pos-with-compiler-cc/dotc/config/Properties.scala
new file mode 100644
index 000000000000..1e9cc82112af
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/config/Properties.scala
@@ -0,0 +1,142 @@
+package dotty.tools
+package dotc
+package config
+
+import scala.language.unsafeNulls
+
+import scala.annotation.internal.sharable
+
+import java.io.IOException
+import java.util.jar.Attributes.{ Name => AttributeName }
+import java.nio.charset.StandardCharsets
+
+/** Loads `library.properties` from the jar. */
+object Properties extends PropertiesTrait {
+  protected def propCategory: String = "compiler"
+  protected def pickJarBasedOn: Class[PropertiesTrait] = classOf[PropertiesTrait]
+
+  /** Scala manifest attributes.
+   */
+  @sharable val ScalaCompilerVersion: AttributeName = new AttributeName("Scala-Compiler-Version")
+}
+
+trait PropertiesTrait {
+  protected def propCategory: String      // specializes the remainder of the values
+  protected def pickJarBasedOn: Class[?]  // props file comes from jar containing this
+
+  /** The name of the properties file */
+  protected val propFilename: String = "/" + propCategory + ".properties"
+
+  /** The loaded properties */
+  @sharable protected lazy val scalaProps: java.util.Properties = {
+    val props = new java.util.Properties
+    val stream = pickJarBasedOn getResourceAsStream propFilename
+    if (stream ne null)
+      quietlyDispose(props load stream, stream.close)
+
+    props
+  }
+
+  private def quietlyDispose(action: => Unit, disposal: => Unit) =
+    try     { action }
+    finally
+        try     { disposal }
+        catch   { case _: IOException => }
+
+  def propIsSet(name: String): Boolean                  = System.getProperty(name) != null
+  def propIsSetTo(name: String, value: String): Boolean = propOrNull(name) == value
+  def propOrElse(name: String, alt: String): String     = System.getProperty(name, alt)
+  def propOrEmpty(name: String): String                 = propOrElse(name, "")
+  def propOrNull(name: String): String                  = propOrElse(name, null)
+  def propOrNone(name: String): Option[String]          = Option(propOrNull(name))
+  def propOrFalse(name: String): Boolean                = propOrNone(name) exists (x => List("yes", "on", "true") contains x.toLowerCase)
+  def setProp(name: String, value: String): String      = System.setProperty(name, value)
+  def clearProp(name: String): String                   = System.clearProperty(name)
+
+  def envOrElse(name: String, alt: String): String      = Option(System getenv name) getOrElse alt
+  def envOrNone(name: String): Option[String]           = Option(System getenv name)
+
+  // for values based on propFilename
+  def scalaPropOrElse(name: String, alt: String): String = scalaProps.getProperty(name, alt)
+  def scalaPropOrEmpty(name: String): String             = scalaPropOrElse(name, "")
+  def scalaPropOrNone(name: String): Option[String]      = Option(scalaProps.getProperty(name))
+
+  /** Either the development or release version if known, otherwise
+   *  the empty string.
+   */
+  def versionNumberString: String = scalaPropOrEmpty("version.number")
+
+  /** The version number of the jar this was loaded from,
+   *  or `"(unknown)"` if it cannot be determined.
+   */
+  val simpleVersionString: String = {
+    val v = scalaPropOrElse("version.number", "(unknown)")
+    v + (
+      if (v.contains("SNAPSHOT") || v.contains("NIGHTLY"))
+        "-git-" + scalaPropOrElse("git.hash", "(unknown)")
+      else
+        ""
+    )
+  }
+
+  /** The version number of the jar this was loaded from plus `"version "` prefix,
+   *  or `"version (unknown)"` if it cannot be determined.
+   */
+  val versionString: String = "version " + simpleVersionString
+
+  /** Whether the current version of compiler is experimental
+   *
+   *  1. Snapshot, nightly releases and non-bootstrapped compiler are experimental.
+   *  2. Features supported by experimental versions of the compiler:
+   *     - research plugins
+   */
+  val experimental: Boolean = versionString.contains("SNAPSHOT") || versionString.contains("NIGHTLY") || versionString.contains("nonbootstrapped")
+
+  val copyrightString: String       = scalaPropOrElse("copyright.string", "(c) 2002-2017 LAMP/EPFL")
+
+  /** This is the encoding to use reading in source files, overridden with -encoding
+   *  Note that it uses "prop" i.e. looks in the scala jar, not the system properties.
+   */
+  def sourceEncoding: String        = scalaPropOrElse("file.encoding", StandardCharsets.UTF_8.name)
+  def sourceReader: String          = scalaPropOrElse("source.reader", "scala.tools.nsc.io.SourceReader")
+
+  /** This is the default text encoding, overridden (unreliably) with
+   *  `JAVA_OPTS="-Dfile.encoding=Foo"`
+   */
+  def encodingString: String        = propOrElse("file.encoding", StandardCharsets.UTF_8.name)
+
+  /** The default end of line character.
+   */
+  def lineSeparator: String         = propOrElse("line.separator", "\n")
+
+  /** Various well-known properties.
+   */
+  def javaClassPath: String         = propOrEmpty("java.class.path")
+  def javaHome: String              = propOrEmpty("java.home")
+  def javaVendor: String            = propOrEmpty("java.vendor")
+  def javaVersion: String           = propOrEmpty("java.version")
+  def javaVmInfo: String            = propOrEmpty("java.vm.info")
+  def javaVmName: String            = propOrEmpty("java.vm.name")
+  def javaVmVendor: String          = propOrEmpty("java.vm.vendor")
+  def javaVmVersion: String         = propOrEmpty("java.vm.version")
+  def osName: String                = propOrEmpty("os.name")
+  def scalaHome: String             = propOrEmpty("scala.home")
+  def tmpDir: String                = propOrEmpty("java.io.tmpdir")
+  def userDir: String               = propOrEmpty("user.dir")
+  def userHome: String              = propOrEmpty("user.home")
+  def userName: String              = propOrEmpty("user.name")
+
+  /** Some derived values.
+   */
+  def isWin: Boolean                = osName startsWith "Windows"
+  def isMac: Boolean                = javaVendor startsWith "Apple"
+
+  // This is looking for javac, tools.jar, etc.
+  // Tries JDK_HOME first, then the more common but likely jre JAVA_HOME,
+  // and finally the system property based javaHome.
+  def jdkHome: String               = envOrElse("JDK_HOME", envOrElse("JAVA_HOME", javaHome))
+
+  def versionMsg: String            = "Scala %s %s -- %s".format(propCategory, versionString, copyrightString)
+  def scalaCmd: String              = if (isWin) "scala.bat" else "scala"
+  def scalacCmd: String             = if (isWin) "scalac.bat" else "scalac"
+}
diff --git a/tests/pos-with-compiler-cc/dotc/config/SJSPlatform.scala b/tests/pos-with-compiler-cc/dotc/config/SJSPlatform.scala
new file mode 100644
index 000000000000..0275e0d6a227
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/config/SJSPlatform.scala
@@ -0,0 +1,35 @@
+package dotty.tools.dotc.config
+
+import dotty.tools.dotc.core._
+import Contexts._
+import Symbols._
+
+import dotty.tools.backend.sjs.JSDefinitions
+
+object SJSPlatform {
+  /** The `SJSPlatform` for the current context. */
+  def sjsPlatform(using Context): SJSPlatform =
+    ctx.platform.asInstanceOf[SJSPlatform]
+}
+
+class SJSPlatform()(using Context) extends JavaPlatform {
+
+  /** Scala.js-specific definitions. */
+  val jsDefinitions: JSDefinitions = new JSDefinitions()
+
+  /** Is the SAMType `cls` also a SAM under the rules of the Scala.js back-end? */
+  override def isSam(cls: ClassSymbol)(using Context): Boolean =
+    defn.isFunctionClass(cls)
+      || cls.superClass == jsDefinitions.JSFunctionClass
+
+  /** Is the given class symbol eligible for Java serialization-specific methods?
+   *
+   *  This is not simply false because we still want to add them to Scala classes
+   *  and objects. They might be transitively used by macros and other compile-time
+   *  code. It feels safer to have them be somewhat equivalent to the ones we would
+   *  get in a JVM project. The JVM back-end will slap an extends `java.io.Serializable`
+   *  to them, so we should be consistent and also emit the proper serialization methods.
+   */
+  override def shouldReceiveJavaSerializationMethods(sym: ClassSymbol)(using Context): Boolean =
+    !sym.isSubClass(jsDefinitions.JSAnyClass)
+}
diff --git a/tests/pos-with-compiler-cc/dotc/config/ScalaRelease.scala b/tests/pos-with-compiler-cc/dotc/config/ScalaRelease.scala
new file mode 100644
index 000000000000..407171f1a0dd
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/config/ScalaRelease.scala
@@ -0,0 +1,21 @@
+package dotty.tools.dotc.config
+
+enum ScalaRelease(val majorVersion: Int, val minorVersion: Int) extends Ordered[ScalaRelease]:
+  case Release3_0 extends ScalaRelease(3, 0)
+  case Release3_1 extends ScalaRelease(3, 1)
+  case Release3_2 extends ScalaRelease(3, 2)
+
+  def show = s"$majorVersion.$minorVersion"
+
+  def compare(that: ScalaRelease) =
+    val ord = summon[Ordering[(Int, Int)]]
+    ord.compare((majorVersion, minorVersion), (that.majorVersion, that.minorVersion))
+
+object ScalaRelease:
+  def latest = Release3_1
+
+  def parse(name: String) = name match
+    case "3.0" => Some(Release3_0)
+    case "3.1" => Some(Release3_1)
+    case "3.2" => Some(Release3_2)
+    case _ => None
diff --git a/tests/pos-with-compiler-cc/dotc/config/ScalaSettings.scala b/tests/pos-with-compiler-cc/dotc/config/ScalaSettings.scala
new file mode 100644
index 000000000000..a2dba94ad9fc
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/config/ScalaSettings.scala
@@ -0,0 +1,346 @@
+package dotty.tools.dotc
+package config
+
+import scala.language.unsafeNulls
+
+import dotty.tools.dotc.config.PathResolver.Defaults
+import dotty.tools.dotc.config.Settings.{Setting, SettingGroup}
+import dotty.tools.dotc.config.SourceVersion
+import dotty.tools.dotc.core.Contexts._
+import dotty.tools.dotc.rewrites.Rewrites
+import dotty.tools.io.{AbstractFile, Directory, JDK9Reflectors, PlainDirectory}
+
+import scala.util.chaining._
+
+class ScalaSettings extends SettingGroup with AllScalaSettings
+
+object ScalaSettings:
+  // Keep synchronized with `classfileVersion` in `BCodeIdiomatic`
+  private val minTargetVersion = 8
+  private val maxTargetVersion = 19
+
+  def supportedTargetVersions: List[String] =
+    (minTargetVersion to maxTargetVersion).toList.map(_.toString)
+
+  def supportedReleaseVersions: List[String] =
+    if scala.util.Properties.isJavaAtLeast("9") then
+      val jdkVersion = JDK9Reflectors.runtimeVersionMajor(JDK9Reflectors.runtimeVersion()).intValue()
+      val maxVersion = Math.min(jdkVersion, maxTargetVersion)
+      (minTargetVersion to maxVersion).toList.map(_.toString)
+    else List(minTargetVersion).map(_.toString)
+
+  def supportedScalaReleaseVersions: List[String] =
+    ScalaRelease.values.toList.map(_.show)
+
+  def supportedSourceVersions: List[String] =
+    SourceVersion.values.toList.map(_.toString)
+
+  def defaultClasspath: String = sys.env.getOrElse("CLASSPATH", ".")
+
+  def defaultPageWidth: Int = {
+    val defaultWidth = 80
+    val columnsVar = System.getenv("COLUMNS")
+    if columnsVar != null then columnsVar.toInt
+    else if Properties.isWin then
+      val ansiconVar = System.getenv("ANSICON") // eg. "142x32766 (142x26)"
+      if ansiconVar != null && ansiconVar.matches("[0-9]+x.*") then
+        ansiconVar.substring(0, ansiconVar.indexOf("x")).toInt
+      else defaultWidth
+    else defaultWidth
+  }
+
+trait AllScalaSettings extends CommonScalaSettings, PluginSettings, VerboseSettings, WarningSettings, XSettings, YSettings:
+  self: SettingGroup =>
+
+  /* Path related settings */
+  val semanticdbTarget: Setting[String] = PathSetting("-semanticdb-target", "Specify an alternative output directory for SemanticDB files.", "")
+
+  val source: Setting[String] = ChoiceSetting("-source", "source version", "source version", ScalaSettings.supportedSourceVersions, SourceVersion.defaultSourceVersion.toString, aliases = List("--source"))
+  val uniqid: Setting[Boolean] = BooleanSetting("-uniqid", "Uniquely tag all identifiers in debugging output.", aliases = List("--unique-id"))
+  val rewrite: Setting[Option[Rewrites]] = OptionSetting[Rewrites]("-rewrite", "When used in conjunction with a `...-migration` source version, rewrites sources to migrate to new version.", aliases = List("--rewrite"))
+  val fromTasty: Setting[Boolean] = BooleanSetting("-from-tasty", "Compile classes from tasty files. The arguments are .tasty or .jar files.", aliases = List("--from-tasty"))
+
+  val newSyntax: Setting[Boolean] = BooleanSetting("-new-syntax", "Require `then` and `do` in control expressions.")
+  val oldSyntax: Setting[Boolean] = BooleanSetting("-old-syntax", "Require `(...)` around conditions.")
+  val indent: Setting[Boolean] = BooleanSetting("-indent", "Together with -rewrite, remove {...} syntax when possible due to significant indentation.")
+  val noindent: Setting[Boolean] = BooleanSetting("-no-indent", "Require classical {...} syntax, indentation is not significant.", aliases = List("-noindent"))
+  val YindentColons: Setting[Boolean] = BooleanSetting("-Yindent-colons", "(disabled: use -language:experimental.fewerBraces instead)")
+
+  /* Decompiler settings */
+  val printTasty: Setting[Boolean] = BooleanSetting("-print-tasty", "Prints the raw tasty.", aliases = List("--print-tasty"))
+  val printLines: Setting[Boolean] = BooleanSetting("-print-lines", "Show source code line numbers.", aliases = List("--print-lines"))
+
+  /* Scala.js-related settings */
+  val scalajsGenStaticForwardersForNonTopLevelObjects: Setting[Boolean] = BooleanSetting("-scalajs-genStaticForwardersForNonTopLevelObjects", "Generate static forwarders even for non-top-level objects (Scala.js only)")
+  val scalajsMapSourceURI: Setting[List[String]] = MultiStringSetting("-scalajs-mapSourceURI", "uri1[->uri2]", "rebases source URIs from uri1 to uri2 (or to a relative URI) for source maps (Scala.js only)")
+
+  val projectUrl: Setting[String] = StringSetting (
+    "-project-url",
+    "project repository homepage",
+    "The source repository of your project.",
+    ""
+  )
+
+  val wikiSyntax: Setting[Boolean] = BooleanSetting("-Xwiki-syntax", "Retains the Scala2 behavior of using Wiki Syntax in Scaladoc.")
+
+  val jvmargs  = PrefixSetting("-J<flag>", "-J", "Pass <flag> directly to the runtime system.")
+  val defines  = PrefixSetting("-Dproperty=value", "-D", "Pass -Dproperty=value directly to the runtime system.")
+end AllScalaSettings
+
+/** Settings shared by compiler and scaladoc */
+trait CommonScalaSettings:
+  self: SettingGroup =>
+
+  /* Path related settings */
+  val bootclasspath: Setting[String] = PathSetting("-bootclasspath", "Override location of bootstrap class files.", Defaults.scalaBootClassPath, aliases = List("--boot-class-path"))
+  val extdirs: Setting[String] = PathSetting("-extdirs", "Override location of installed extensions.", Defaults.scalaExtDirs, aliases = List("--extension-directories"))
+  val javabootclasspath: Setting[String] = PathSetting("-javabootclasspath", "Override java boot classpath.", Defaults.javaBootClassPath, aliases = List("--java-boot-class-path"))
+  val javaextdirs: Setting[String] = PathSetting("-javaextdirs", "Override java extdirs classpath.", Defaults.javaExtDirs, aliases = List("--java-extension-directories"))
+  val sourcepath: Setting[String] = PathSetting("-sourcepath", "Specify location(s) of source files.", Defaults.scalaSourcePath, aliases = List("--source-path"))
+  val sourceroot: Setting[String] = PathSetting("-sourceroot", "Specify workspace root directory.", ".")
+
+  val classpath: Setting[String] = PathSetting("-classpath", "Specify where to find user class files.", ScalaSettings.defaultClasspath, aliases = List("-cp", "--class-path"))
+  val outputDir: Setting[AbstractFile] = OutputSetting("-d", "directory|jar", "Destination for generated classfiles.",
+    new PlainDirectory(Directory(".")))
+  val color: Setting[String] = ChoiceSetting("-color", "mode", "Colored output", List("always", "never"/*, "auto"*/), "always"/* "auto"*/, aliases = List("--color"))
+  val verbose: Setting[Boolean] = BooleanSetting("-verbose", "Output messages about what the compiler is doing.", aliases = List("--verbose"))
+  val version: Setting[Boolean] = BooleanSetting("-version", "Print product version and exit.", aliases = List("--version"))
+  val help: Setting[Boolean] = BooleanSetting("-help", "Print a synopsis of standard options.", aliases = List("--help", "-h"))
+  val pageWidth: Setting[Int] = IntSetting("-pagewidth", "Set page width", ScalaSettings.defaultPageWidth, aliases = List("--page-width"))
+  val silentWarnings: Setting[Boolean] = BooleanSetting("-nowarn", "Silence all warnings.", aliases = List("--no-warnings"))
+
+  val javaOutputVersion: Setting[String] = ChoiceSetting("-java-output-version", "version", "Compile code with classes specific to the given version of the Java platform available on the classpath and emit bytecode for this version. Corresponds to -release flag in javac.", ScalaSettings.supportedReleaseVersions, "", aliases = List("-release", "--release"))
+
+  val deprecation: Setting[Boolean] = BooleanSetting("-deprecation", "Emit warning and location for usages of deprecated APIs.", aliases = List("--deprecation"))
+  val feature: Setting[Boolean] = BooleanSetting("-feature", "Emit warning and location for usages of features that should be imported explicitly.", aliases = List("--feature"))
+  val explain: Setting[Boolean] = BooleanSetting("-explain", "Explain errors in more detail.", aliases = List("--explain"))
+  // -explain-types setting is necessary for cross compilation, since it is mentioned in sbt-tpolecat, for instance
+  // it is otherwise subsumed by -explain, and should be dropped as soon as we can.
+  val explainTypes: Setting[Boolean] = BooleanSetting("-explain-types", "Explain type errors in more detail (deprecated, use -explain instead).", aliases = List("--explain-types", "-explaintypes"))
+  val unchecked: Setting[Boolean] = BooleanSetting("-unchecked", "Enable additional warnings where generated code depends on assumptions.", initialValue = true, aliases = List("--unchecked"))
+  val language: Setting[List[String]] = MultiStringSetting("-language", "feature", "Enable one or more language features.", aliases = List("--language"))
+
+  /* Coverage settings */
+  val coverageOutputDir = PathSetting("-coverage-out", "Destination for coverage classfiles and instrumentation data.", "", aliases = List("--coverage-out"))
+
+  /* Other settings */
+  val encoding: Setting[String] = StringSetting("-encoding", "encoding", "Specify character encoding used by source files.", Properties.sourceEncoding, aliases = List("--encoding"))
+  val usejavacp: Setting[Boolean] = BooleanSetting("-usejavacp", "Utilize the java.class.path in classpath resolution.", aliases = List("--use-java-class-path"))
+  val scalajs: Setting[Boolean] = BooleanSetting("-scalajs", "Compile in Scala.js mode (requires scalajs-library.jar on the classpath).", aliases = List("--scalajs"))
+end CommonScalaSettings
+
+/** -P "plugin" settings. Various tools might support plugins. */
+private sealed trait PluginSettings:
+  self: SettingGroup =>
+  val plugin: Setting[List[String]]        = MultiStringSetting  ("-Xplugin", "paths", "Load a plugin from each classpath.")
+  val disable: Setting[List[String]]       = MultiStringSetting  ("-Xplugin-disable", "plugin", "Disable plugins by name.")
+  val require: Setting[List[String]]       = MultiStringSetting  ("-Xplugin-require", "plugin", "Abort if a named plugin is not loaded.")
+  val showPlugins: Setting[Boolean]        = BooleanSetting      ("-Xplugin-list", "Print a synopsis of loaded plugins.")
+  val pluginsDir: Setting[String]          = StringSetting       ("-Xpluginsdir", "path", "Path to search for plugin archives.", Defaults.scalaPluginPath)
+  val pluginOptions: Setting[List[String]] = MultiStringSetting  ("-P", "plugin:opt", "Pass an option to a plugin, e.g. -P:<plugin>:<opt>")
+
+/** -V "Verbose" settings */
+private sealed trait VerboseSettings:
+  self: SettingGroup =>
+  val Vhelp: Setting[Boolean] = BooleanSetting("-V", "Print a synopsis of verbose options.")
+  val Xprint: Setting[List[String]] = PhasesSetting("-Vprint", "Print out program after", aliases = List("-Xprint"))
+  val XshowPhases: Setting[Boolean] = BooleanSetting("-Vphases", "List compiler phases.", aliases = List("-Xshow-phases"))
+
+  val Vprofile: Setting[Boolean] = BooleanSetting("-Vprofile", "Show metrics about sources and internal representations to estimate compile-time complexity.")
+  val VprofileSortedBy = ChoiceSetting("-Vprofile-sorted-by", "key", "Show metrics about sources and internal representations sorted by given column name", List("name", "path", "lines", "tokens", "tasty", "complexity"), "")
+  val VprofileDetails = IntSetting("-Vprofile-details", "Show metrics about sources and internal representations of the most complex methods", 0)
+  val VreplMaxPrintElements: Setting[Int] = IntSetting("-Vrepl-max-print-elements", "Number of elements to be printed before output is truncated.", 1000)
+  val VreplMaxPrintCharacters: Setting[Int] = IntSetting("-Vrepl-max-print-characters", "Number of characters to be printed before output is truncated.", 50000)
+
+/** -W "Warnings" settings
+ */
+private sealed trait WarningSettings:
+  self: SettingGroup =>
+  val Whelp: Setting[Boolean] = BooleanSetting("-W", "Print a synopsis of warning options.")
+  val XfatalWarnings: Setting[Boolean] = BooleanSetting("-Werror", "Fail the compilation if there are any warnings.", aliases = List("-Xfatal-warnings"))
+
+  val Wunused: Setting[List[String]] = MultiChoiceSetting(
+    name = "-Wunused",
+    helpArg = "warning",
+    descr = "Enable or disable specific `unused` warnings",
+    choices = List("nowarn", "all"),
+    default = Nil
+  )
+  object WunusedHas:
+    def allOr(s: String)(using Context) = Wunused.value.pipe(us => us.contains("all") || us.contains(s))
+    def nowarn(using Context) = allOr("nowarn")
+
+  val Wconf: Setting[List[String]] = MultiStringSetting(
+    "-Wconf",
+    "patterns",
+    default = List(),
+    descr =
+      s"""Configure compiler warnings.
+         |Syntax: -Wconf:<filters>:<action>,<filters>:<action>,...
+         |multiple <filters> are combined with &, i.e., <filter>&...&<filter>
+         |
+         |<filter>
+         |  - Any message: any
+         |
+         |  - Message categories: cat=deprecation, cat=feature, cat=unchecked
+         |
+         |  - Message content: msg=regex
+         |    The regex need only match some part of the message, not all of it.
+         |
+         |  - Message id: id=E129
+         |    The message id is printed with the warning.
+         |
+         |  - Message name: name=PureExpressionInStatementPosition
+         |    The message name is printed with the warning in verbose warning mode.
+         |
+         |In verbose warning mode the compiler prints matching filters for warnings.
+         |Verbose mode can be enabled globally using `-Wconf:any:verbose`, or locally
+         |using the @nowarn annotation (example: `@nowarn("v") def test = try 1`).
+         |
+         |<action>
+         |  - error / e
+         |  - warning / w
+         |  - verbose / v (emit warning, show additional help for writing `-Wconf` filters)
+         |  - info / i    (infos are not counted as warnings and not affected by `-Werror`)
+         |  - silent / s
+         |
+         |The default configuration is empty.
+         |
+         |User-defined configurations are added to the left. The leftmost rule matching
+         |a warning message defines the action.
+         |
+         |Examples:
+         |  - change every warning into an error: -Wconf:any:error
+         |  - silence deprecations: -Wconf:cat=deprecation:s
+         |
+         |Note: on the command-line you might need to quote configurations containing `*` or `&`
+         |to prevent the shell from expanding patterns.""".stripMargin,
+  )
+
+/** -X "Extended" or "Advanced" settings */
+private sealed trait XSettings:
+  self: SettingGroup =>
+
+  val Xhelp: Setting[Boolean] = BooleanSetting("-X", "Print a synopsis of advanced options.")
+  val XnoForwarders: Setting[Boolean] = BooleanSetting("-Xno-forwarders", "Do not generate static forwarders in mirror classes.")
+  val XmaxInlines: Setting[Int] = IntSetting("-Xmax-inlines", "Maximal number of successive inlines.", 32)
+  val XmaxInlinedTrees: Setting[Int] = IntSetting("-Xmax-inlined-trees", "Maximal number of inlined trees.", 2_000_000)
+  val Xmigration: Setting[ScalaVersion] = VersionSetting("-Xmigration", "Warn about constructs whose behavior may have changed since version.")
+  val XprintTypes: Setting[Boolean] = BooleanSetting("-Xprint-types", "Print tree types (debugging option).")
+  val XprintDiff: Setting[Boolean] = BooleanSetting("-Xprint-diff", "Print changed parts of the tree since last print.")
+  val XprintDiffDel: Setting[Boolean] = BooleanSetting("-Xprint-diff-del", "Print changed parts of the tree since last print including deleted parts.")
+  val XprintInline: Setting[Boolean] = BooleanSetting("-Xprint-inline", "Show where inlined code comes from.")
+  val XprintSuspension: Setting[Boolean] = BooleanSetting("-Xprint-suspension", "Show when code is suspended until macros are compiled.")
+  val Xprompt: Setting[Boolean] = BooleanSetting("-Xprompt", "Display a prompt after each error (debugging option).")
+  val XreplDisableDisplay: Setting[Boolean] = BooleanSetting("-Xrepl-disable-display", "Do not display definitions in REPL.")
+  val XverifySignatures: Setting[Boolean] = BooleanSetting("-Xverify-signatures", "Verify generic signatures in generated bytecode.")
+  val XignoreScala2Macros: Setting[Boolean] = BooleanSetting("-Xignore-scala2-macros", "Ignore errors when compiling code that calls Scala2 macros, these will fail at runtime.")
+  val XimportSuggestionTimeout: Setting[Int] = IntSetting("-Ximport-suggestion-timeout", "Timeout (in ms) for searching for import suggestions when errors are reported.", 8000)
+  val Xsemanticdb: Setting[Boolean] = BooleanSetting("-Xsemanticdb", "Store information in SemanticDB.", aliases = List("-Ysemanticdb"))
+  val XuncheckedJavaOutputVersion: Setting[String] = ChoiceSetting("-Xunchecked-java-output-version", "target", "Emit bytecode for the specified version of the Java platform. This might produce bytecode that will break at runtime. Corresponds to -target flag in javac. When on JDK 9+, consider -java-output-version as a safer alternative.", ScalaSettings.supportedTargetVersions, "", aliases = List("-Xtarget", "--Xtarget"))
+  val XcheckMacros: Setting[Boolean] = BooleanSetting("-Xcheck-macros", "Check some invariants of macro generated code while expanding macros", aliases = List("--Xcheck-macros"))
+  val XmainClass: Setting[String] = StringSetting("-Xmain-class", "path", "Class for manifest's Main-Class entry (only useful with -d <jar>)", "")
+  val XimplicitSearchLimit: Setting[Int] = IntSetting("-Ximplicit-search-limit", "Maximal number of expressions to be generated in an implicit search", 50000)
+
+  val XmixinForceForwarders = ChoiceSetting(
+    name    = "-Xmixin-force-forwarders",
+    helpArg = "mode",
+    descr   = "Generate forwarder methods in classes inhering concrete methods from traits.",
+    choices = List("true", "junit", "false"),
+    default = "true")
+
+  object mixinForwarderChoices {
+    def isTruthy(using Context) = XmixinForceForwarders.value == "true"
+    def isAtLeastJunit(using Context) = isTruthy || XmixinForceForwarders.value == "junit"
+  }
+
+  val XmacroSettings: Setting[List[String]] = MultiStringSetting("-Xmacro-settings", "setting1,setting2,..settingN", "List of settings which exposed to the macros")
+end XSettings
+
+/** -Y "Forking" as in forked tongue or "Private" settings */
+private sealed trait YSettings:
+  self: SettingGroup =>
+
+  val Yhelp: Setting[Boolean] = BooleanSetting("-Y", "Print a synopsis of private options.")
+  val Ycheck: Setting[List[String]] = PhasesSetting("-Ycheck", "Check the tree at the end of")
+  val YcheckMods: Setting[Boolean] = BooleanSetting("-Ycheck-mods", "Check that symbols and their defining trees have modifiers in sync.")
+  val Ydebug: Setting[Boolean] = BooleanSetting("-Ydebug", "Increase the quantity of debugging output.")
+  val YdebugTrace: Setting[Boolean] = BooleanSetting("-Ydebug-trace", "Trace core operations.")
+  val YdebugFlags: Setting[Boolean] = BooleanSetting("-Ydebug-flags", "Print all flags of definitions.")
+  val YdebugMissingRefs: Setting[Boolean] = BooleanSetting("-Ydebug-missing-refs", "Print a stacktrace when a required symbol is missing.")
+  val YdebugNames: Setting[Boolean] = BooleanSetting("-Ydebug-names", "Show internal representation of names.")
+  val YdebugPos: Setting[Boolean] = BooleanSetting("-Ydebug-pos", "Show full source positions including spans.")
+  val YdebugTreeWithId: Setting[Int] = IntSetting("-Ydebug-tree-with-id", "Print the stack trace when the tree with the given id is created.", Int.MinValue)
+  val YdebugTypeError: Setting[Boolean] = BooleanSetting("-Ydebug-type-error", "Print the stack trace when a TypeError is caught", false)
+  val YdebugError: Setting[Boolean] = BooleanSetting("-Ydebug-error", "Print the stack trace when any error is caught.", false)
+  val YdebugUnpickling: Setting[Boolean] = BooleanSetting("-Ydebug-unpickling", "Print the stack trace when an error occurs when reading Tasty.", false)
+  val YtermConflict: Setting[String] = ChoiceSetting("-Yresolve-term-conflict", "strategy", "Resolve term conflicts", List("package", "object", "error"), "error")
+  val Ylog: Setting[List[String]] = PhasesSetting("-Ylog", "Log operations during")
+  val YlogClasspath: Setting[Boolean] = BooleanSetting("-Ylog-classpath", "Output information about what classpath is being applied.")
+  val YdisableFlatCpCaching: Setting[Boolean] = BooleanSetting("-YdisableFlatCpCaching", "Do not cache flat classpath representation of classpath elements from jars across compiler instances.")
+
+  val Yscala2Unpickler: Setting[String] = StringSetting("-Yscala2-unpickler", "", "Control where we may get Scala 2 symbols from. This is either \"always\", \"never\", or a classpath.", "always")
+
+  val YnoImports: Setting[Boolean] = BooleanSetting("-Yno-imports", "Compile without importing scala.*, java.lang.*, or Predef.")
+  val YnoGenericSig: Setting[Boolean] = BooleanSetting("-Yno-generic-signatures", "Suppress generation of generic signatures for Java.")
+  val YnoPredef: Setting[Boolean] = BooleanSetting("-Yno-predef", "Compile without importing Predef.")
+  val Yskip: Setting[List[String]] = PhasesSetting("-Yskip", "Skip")
+  val Ydumpclasses: Setting[String] = StringSetting("-Ydump-classes", "dir", "Dump the generated bytecode to .class files (useful for reflective compilation that utilizes in-memory classloaders).", "")
+  val YstopAfter: Setting[List[String]] = PhasesSetting("-Ystop-after", "Stop after", aliases = List("-stop")) // backward compat
+  val YstopBefore: Setting[List[String]] = PhasesSetting("-Ystop-before", "Stop before") // stop before erasure as long as we have not debugged it fully
+  val YshowSuppressedErrors: Setting[Boolean] = BooleanSetting("-Yshow-suppressed-errors", "Also show follow-on errors and warnings that are normally suppressed.")
+  val YdetailedStats: Setting[Boolean] = BooleanSetting("-Ydetailed-stats", "Show detailed internal compiler stats (needs Stats.enabled to be set to true).")
+  val YkindProjector: Setting[String] = ChoiceSetting("-Ykind-projector", "[underscores, disable]", "Allow `*` as type lambda placeholder to be compatible with kind projector. When invoked as -Ykind-projector:underscores will repurpose `_` to be a type parameter placeholder, this will disable usage of underscore as a wildcard.", List("disable", "", "underscores"), "disable")
+  val YprintPos: Setting[Boolean] = BooleanSetting("-Yprint-pos", "Show tree positions.")
+  val YprintPosSyms: Setting[Boolean] = BooleanSetting("-Yprint-pos-syms", "Show symbol definitions positions.")
+  val YnoDeepSubtypes: Setting[Boolean] = BooleanSetting("-Yno-deep-subtypes", "Throw an exception on deep subtyping call stacks.")
+  val YnoPatmatOpt: Setting[Boolean] = BooleanSetting("-Yno-patmat-opt", "Disable all pattern matching optimizations.")
+  val YplainPrinter: Setting[Boolean] = BooleanSetting("-Yplain-printer", "Pretty-print using a plain printer.")
+  val YprintSyms: Setting[Boolean] = BooleanSetting("-Yprint-syms", "When printing trees print info in symbols instead of corresponding info in trees.")
+  val YprintDebug: Setting[Boolean] = BooleanSetting("-Yprint-debug", "When printing trees, print some extra information useful for debugging.")
+  val YprintDebugOwners: Setting[Boolean] = BooleanSetting("-Yprint-debug-owners", "When printing trees, print owners of definitions.")
+  val YprintLevel: Setting[Boolean] = BooleanSetting("-Yprint-level", "print nesting levels of symbols and type variables.")
+  val YshowPrintErrors: Setting[Boolean] = BooleanSetting("-Yshow-print-errors", "Don't suppress exceptions thrown during tree printing.")
+  val YtestPickler: Setting[Boolean] = BooleanSetting("-Ytest-pickler", "Self-test for pickling functionality; should be used with -Ystop-after:pickler.")
+  val YcheckReentrant: Setting[Boolean] = BooleanSetting("-Ycheck-reentrant", "Check that compiled program does not contain vars that can be accessed from a global root.")
+  val YdropComments: Setting[Boolean] = BooleanSetting("-Ydrop-docs", "Drop documentation when scanning source files.", aliases = List("-Ydrop-comments"))
+  val YcookComments: Setting[Boolean] = BooleanSetting("-Ycook-docs", "Cook the documentation (type check `@usecase`, etc.)", aliases = List("-Ycook-comments"))
+  val YreadComments: Setting[Boolean] = BooleanSetting("-Yread-docs", "Read documentation from tasty.")
+  val YforceSbtPhases: Setting[Boolean] = BooleanSetting("-Yforce-sbt-phases", "Run the phases used by sbt for incremental compilation (ExtractDependencies and ExtractAPI) even if the compiler is ran outside of sbt, for debugging.")
+  val YdumpSbtInc: Setting[Boolean] = BooleanSetting("-Ydump-sbt-inc", "For every compiled foo.scala, output the API representation and dependencies used for sbt incremental compilation in foo.inc, implies -Yforce-sbt-phases.")
+  val YcheckAllPatmat: Setting[Boolean] = BooleanSetting("-Ycheck-all-patmat", "Check exhaustivity and redundancy of all pattern matching (used for testing the algorithm).")
+  val YretainTrees: Setting[Boolean] = BooleanSetting("-Yretain-trees", "Retain trees for top-level classes, accessible from ClassSymbol#tree")
+  val YshowTreeIds: Setting[Boolean] = BooleanSetting("-Yshow-tree-ids", "Uniquely tag all tree nodes in debugging output.")
+  val YfromTastyIgnoreList: Setting[List[String]] = MultiStringSetting("-Yfrom-tasty-ignore-list", "file", "List of `tasty` files in jar files that will not be loaded when using -from-tasty")
+  val YnoExperimental: Setting[Boolean] = BooleanSetting("-Yno-experimental", "Disable experimental language features")
+
+  val YprofileEnabled: Setting[Boolean] = BooleanSetting("-Yprofile-enabled", "Enable profiling.")
+  val YprofileDestination: Setting[String] = StringSetting("-Yprofile-destination", "file", "Where to send profiling output - specify a file, default is to the console.", "")
+      //.withPostSetHook( _ => YprofileEnabled.value = true )
+  val YprofileExternalTool: Setting[List[String]] = PhasesSetting("-Yprofile-external-tool", "Enable profiling for a phase using an external tool hook. Generally only useful for a single phase.", "typer")
+      //.withPostSetHook( _ => YprofileEnabled.value = true )
+  val YprofileRunGcBetweenPhases: Setting[List[String]] = PhasesSetting("-Yprofile-run-gc", "Run a GC between phases - this allows heap size to be accurate at the expense of more time. Specify a list of phases, or *", "_")
+      //.withPostSetHook( _ => YprofileEnabled.value = true )
+
+  // Experimental language features
+  val YnoKindPolymorphism: Setting[Boolean] = BooleanSetting("-Yno-kind-polymorphism", "Disable kind polymorphism.")
+  val YexplicitNulls: Setting[Boolean] = BooleanSetting("-Yexplicit-nulls", "Make reference types non-nullable. Nullable types can be expressed with unions: e.g. String|Null.")
+  val YcheckInit: Setting[Boolean] = BooleanSetting("-Ysafe-init", "Ensure safe initialization of objects")
+  val YrequireTargetName: Setting[Boolean] = BooleanSetting("-Yrequire-targetName", "Warn if an operator is defined without a @targetName annotation")
+  val YrecheckTest: Setting[Boolean] = BooleanSetting("-Yrecheck-test", "Run basic rechecking (internal test only)")
+  val YccDebug: Setting[Boolean] = BooleanSetting("-Ycc-debug", "Used in conjunction with captureChecking language import, debug info for captured references")
+  val YccNoAbbrev: Setting[Boolean] = BooleanSetting("-Ycc-no-abbrev", "Used in conjunction with captureChecking language import, suppress type abbreviations")
+
+  /** Area-specific debug output */
+  val YexplainLowlevel: Setting[Boolean] = BooleanSetting("-Yexplain-lowlevel", "When explaining type errors, show types at a lower level.")
+  val YnoDoubleBindings: Setting[Boolean] = BooleanSetting("-Yno-double-bindings", "Assert no namedtype is bound twice (should be enabled only if program is error-free).")
+  val YshowVarBounds: Setting[Boolean] = BooleanSetting("-Yshow-var-bounds", "Print type variables with their bounds.")
+
+  val YnoDecodeStacktraces: Setting[Boolean] = BooleanSetting("-Yno-decode-stacktraces", "Show raw StackOverflow stacktraces, instead of decoding them into triggering operations.")
+
+  val Yinstrument: Setting[Boolean] = BooleanSetting("-Yinstrument", "Add instrumentation code that counts allocations and closure creations.")
+  val YinstrumentDefs: Setting[Boolean] = BooleanSetting("-Yinstrument-defs", "Add instrumentation code that counts method calls; needs -Yinstrument to be set, too.")
+
+  val YforceInlineWhileTyping: Setting[Boolean] = BooleanSetting("-Yforce-inline-while-typing", "Make non-transparent inline methods inline when typing. Emulates the old inlining behavior of 3.0.0-M3.")
+end YSettings
+
diff --git a/tests/pos-with-compiler-cc/dotc/config/ScalaVersion.scala b/tests/pos-with-compiler-cc/dotc/config/ScalaVersion.scala
new file mode 100644
index 000000000000..7fdf57478f1a
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/config/ScalaVersion.scala
@@ -0,0 +1,188 @@
+/* @author  James Iry
+ */
+package dotty.tools
+package dotc.config
+
+import scala.language.unsafeNulls
+
+import scala.annotation.internal.sharable
+import scala.util.{Try, Success, Failure}
+
+/**
+ * Represents a single Scala version in a manner that
+ * supports easy comparison and sorting.
+ */
+sealed abstract class ScalaVersion extends Ordered[ScalaVersion] {
+  def unparse: String
+}
+
+/**
+ * A scala version that sorts higher than all actual versions
+ */
+@sharable case object NoScalaVersion extends ScalaVersion {
+  def unparse: String = "none"
+
+  def compare(that: ScalaVersion): Int = that match {
+    case NoScalaVersion => 0
+    case _ => 1
+  }
+}
+
+/**
+ * A specific Scala version, not one of the magic min/max versions. An SpecificScalaVersion
+ * may or may not be a released version - i.e. this same class is used to represent
+ * final, release candidate, milestone, and development builds. The build argument is used
+ * to segregate builds
+ */
+case class SpecificScalaVersion(major: Int, minor: Int, rev: Int, build: ScalaBuild) extends ScalaVersion {
+  def unparse: String = s"${major}.${minor}.${rev}.${build.unparse}"
+
+  def compare(that: ScalaVersion): Int =  that match {
+    case SpecificScalaVersion(thatMajor, thatMinor, thatRev, thatBuild) =>
+      // this could be done more cleanly by importing scala.math.Ordering.Implicits, but we have to do these
+      // comparisons a lot so I'm using brute force direct style code
+      if (major < thatMajor) -1
+      else if (major > thatMajor) 1
+      else if (minor < thatMinor) -1
+      else if (minor > thatMinor) 1
+      else if (rev < thatRev) -1
+      else if (rev > thatRev) 1
+      else build compare thatBuild
+    case AnyScalaVersion => 1
+    case NoScalaVersion => -1
+  }
+}
+
+/**
+ * A Scala version that sorts lower than all actual versions
+ */
+@sharable case object AnyScalaVersion extends ScalaVersion {
+  def unparse: String = "any"
+
+  def compare(that: ScalaVersion): Int = that match {
+    case AnyScalaVersion => 0
+    case _ => -1
+  }
+}
+
+/**
+ * Methods for parsing ScalaVersions
+ */
+@sharable object ScalaVersion {
+  private val dot = "\\."
+  private val dash = "\\-"
+  private def not(s:String) = s"[^${s}]"
+  private val R = s"((${not(dot)}*)(${dot}(${not(dot)}*)(${dot}(${not(dash)}*)(${dash}(.*))?)?)?)".r
+
+  def parse(versionString : String): Try[ScalaVersion] = {
+    def failure = Failure(new NumberFormatException(
+      s"There was a problem parsing ${versionString}. " +
+       "Versions should be in the form major[.minor[.revision]] " +
+       "where each part is a positive number, as in 2.10.1. " +
+       "The minor and revision parts are optional."
+    ))
+
+    def toInt(s: String) = s match {
+      case null | "" => 0
+      case _ => s.toInt
+    }
+
+    def isInt(s: String) = Try(toInt(s)).isSuccess
+
+    import ScalaBuild._
+
+    def toBuild(s: String) = s match {
+      case null | "FINAL" => Final
+      case s if (s.toUpperCase.startsWith("RC") && isInt(s.substring(2))) => RC(toInt(s.substring(2)))
+      case s if (s.toUpperCase.startsWith("M") && isInt(s.substring(1))) => Milestone(toInt(s.substring(1)))
+      case _ => Development(s)
+    }
+
+    try versionString match {
+      case "" | "any" => Success(AnyScalaVersion)
+      case "none" => Success(NoScalaVersion)
+      case R(_, majorS, _, minorS, _, revS, _, buildS) =>
+        Success(SpecificScalaVersion(toInt(majorS), toInt(minorS), toInt(revS), toBuild(buildS)))
+      case _ => failure
+    }
+    catch {
+      case e: NumberFormatException => failure
+    }
+  }
+
+  /**
+   * The version of the compiler running now
+   */
+  val current: ScalaVersion = parse(util.Properties.versionNumberString).get
+}
+
+/**
+ * Represents the data after the dash in major.minor.rev-build
+ */
+abstract class ScalaBuild extends Ordered[ScalaBuild] {
+  /**
+   * Return a version of this build information that can be parsed back into the
+   * same ScalaBuild
+   */
+  def unparse: String
+}
+
+object ScalaBuild {
+
+  /** A development, test, nightly, snapshot or other "unofficial" build
+   */
+  case class Development(id: String) extends ScalaBuild {
+    def unparse: String = s"-${id}"
+
+    def compare(that: ScalaBuild): Int = that match {
+      // sorting two development builds based on id is reasonably valid for two versions created with the same schema
+      // otherwise it's not correct, but since it's impossible to put a total ordering on development build versions
+      // this is a pragmatic compromise
+      case Development(thatId) => id compare thatId
+      // assume a development build is newer than anything else, that's not really true, but good luck
+      // mapping development build versions to other build types
+      case _ => 1
+    }
+  }
+
+  /** A final build
+   */
+  case object Final extends ScalaBuild {
+    def unparse: String = ""
+
+    def compare(that: ScalaBuild): Int = that match {
+      case Final => 0
+      // a final is newer than anything other than a development build or another final
+      case Development(_) => -1
+      case _ => 1
+    }
+  }
+
+  /** A candidate for final release
+   */
+  case class RC(n: Int) extends ScalaBuild {
+    def unparse: String = s"-RC${n}"
+
+    def compare(that: ScalaBuild): Int = that match {
+      // compare two rcs based on their RC numbers
+      case RC(thatN) => n - thatN
+      // an rc is older than anything other than a milestone or another rc
+      case Milestone(_) => 1
+      case _ => -1
+    }
+  }
+
+  /** An intermediate release
+   */
+  case class Milestone(n: Int) extends ScalaBuild {
+    def unparse: String = s"-M${n}"
+
+    def compare(that: ScalaBuild): Int = that match {
+      // compare two milestones based on their milestone numbers
+      case Milestone(thatN) => n - thatN
+      // a milestone is older than anything other than another milestone
+      case _ => -1
+    }
+  }
+}
+
diff --git a/tests/pos-with-compiler-cc/dotc/config/Settings.scala b/tests/pos-with-compiler-cc/dotc/config/Settings.scala
new file mode 100644
index 000000000000..277833afbd5d
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/config/Settings.scala
@@ -0,0 +1,295 @@
+package dotty.tools.dotc
+package config
+
+import scala.language.unsafeNulls
+
+import core.Contexts._
+
+import dotty.tools.io.{AbstractFile, Directory, JarArchive, PlainDirectory}
+
+import annotation.tailrec
+import collection.mutable.ArrayBuffer
+import reflect.ClassTag
+import scala.util.{Success, Failure}
+
+object Settings:
+
+  val BooleanTag: ClassTag[Boolean]      = ClassTag.Boolean
+  val IntTag: ClassTag[Int]              = ClassTag.Int
+  val StringTag: ClassTag[String]        = ClassTag(classOf[String])
+  val ListTag: ClassTag[List[?]]         = ClassTag(classOf[List[?]])
+  val VersionTag: ClassTag[ScalaVersion] = ClassTag(classOf[ScalaVersion])
+  val OptionTag: ClassTag[Option[?]]     = ClassTag(classOf[Option[?]])
+  val OutputTag: ClassTag[AbstractFile]  = ClassTag(classOf[AbstractFile])
+
+  class SettingsState(initialValues: Seq[Any]):
+    private val values = ArrayBuffer(initialValues: _*)
+    private var _wasRead: Boolean = false
+
+    override def toString: String = s"SettingsState(values: ${values.toList})"
+
+    def value(idx: Int): Any =
+      _wasRead = true
+      values(idx)
+
+    def update(idx: Int, x: Any): SettingsState =
+      if (_wasRead) then SettingsState(values.toSeq).update(idx, x)
+      else
+        values(idx) = x
+        this
+  end SettingsState
+
+  case class ArgsSummary(
+    sstate: SettingsState,
+    arguments: List[String],
+    errors: List[String],
+    warnings: List[String]) {
+
+    def fail(msg: String): Settings.ArgsSummary =
+      ArgsSummary(sstate, arguments.tail, errors :+ msg, warnings)
+
+    def warn(msg: String): Settings.ArgsSummary =
+      ArgsSummary(sstate, arguments.tail, errors, warnings :+ msg)
+  }
+
+  case class Setting[T: ClassTag] private[Settings] (
+    name: String,
+    description: String,
+    default: T,
+    helpArg: String = "",
+    choices: Option[Seq[?]] = None,
+    prefix: String = "",
+    aliases: List[String] = Nil,
+    depends: List[(Setting[?], Any)] = Nil,
+    propertyClass: Option[Class[?]] = None)(private[Settings] val idx: Int) {
+
+    private var changed: Boolean = false
+
+    def valueIn(state: SettingsState): T = state.value(idx).asInstanceOf[T]
+
+    def updateIn(state: SettingsState, x: Any): SettingsState = x match
+      case _: T => state.update(idx, x)
+      case _ => throw IllegalArgumentException(s"found: $x of type ${x.getClass.getName}, required: ${implicitly[ClassTag[T]]}")
+
+    def isDefaultIn(state: SettingsState): Boolean = valueIn(state) == default
+
+    def isMultivalue: Boolean = implicitly[ClassTag[T]] == ListTag
+
+    def legalChoices: String =
+      choices match {
+        case Some(xs) if xs.isEmpty => ""
+        case Some(r: Range)         => s"${r.head}..${r.last}"
+        case Some(xs)               => xs.mkString(", ")
+        case None                   => ""
+      }
+
+    def tryToSet(state: ArgsSummary): ArgsSummary = {
+      val ArgsSummary(sstate, arg :: args, errors, warnings) = state: @unchecked
+      def update(value: Any, args: List[String]): ArgsSummary =
+        var dangers = warnings
+        val value1 =
+          if changed && isMultivalue then
+            val value0  = value.asInstanceOf[List[String]]
+            val current = valueIn(sstate).asInstanceOf[List[String]]
+            value0.filter(current.contains).foreach(s => dangers :+= s"Setting $name set to $s redundantly")
+            current ++ value0
+          else
+            if changed then dangers :+= s"Flag $name set repeatedly"
+            value
+        changed = true
+        ArgsSummary(updateIn(sstate, value1), args, errors, dangers)
+      end update
+
+      def fail(msg: String, args: List[String]) =
+        ArgsSummary(sstate, args, errors :+ msg, warnings)
+
+      def missingArg =
+        fail(s"missing argument for option $name", args)
+
+      def setString(argValue: String, args: List[String]) =
+        choices match
+          case Some(xs) if !xs.contains(argValue) =>
+            fail(s"$argValue is not a valid choice for $name", args)
+          case _ =>
+            update(argValue, args)
+
+      def setInt(argValue: String, args: List[String]) =
+        try
+          val x = argValue.toInt
+          choices match
+            case Some(r: Range) if x < r.head || r.last < x =>
+              fail(s"$argValue is out of legal range ${r.head}..${r.last} for $name", args)
+            case Some(xs) if !xs.contains(x) =>
+              fail(s"$argValue is not a valid choice for $name", args)
+            case _ =>
+              update(x, args)
+        catch case _: NumberFormatException =>
+          fail(s"$argValue is not an integer argument for $name", args)
+
+      def doSet(argRest: String) = ((implicitly[ClassTag[T]], args): @unchecked) match {
+        case (BooleanTag, _) =>
+          update(true, args)
+        case (OptionTag, _) =>
+          update(Some(propertyClass.get.getConstructor().newInstance()), args)
+        case (ListTag, _) =>
+          if (argRest.isEmpty) missingArg
+          else
+            val strings = argRest.split(",").toList
+            choices match
+              case Some(valid) => strings.filterNot(valid.contains) match
+                case Nil => update(strings, args)
+                case invalid => fail(s"invalid choice(s) for $name: ${invalid.mkString(",")}", args)
+              case _ => update(strings, args)
+        case (StringTag, _) if argRest.nonEmpty || choices.exists(_.contains("")) =>
+          setString(argRest, args)
+        case (StringTag, arg2 :: args2) =>
+          if (arg2 startsWith "-") missingArg
+          else setString(arg2, args2)
+        case (OutputTag, arg :: args) =>
+          val path = Directory(arg)
+          val isJar = path.extension == "jar"
+          if (!isJar && !path.isDirectory)
+            fail(s"'$arg' does not exist or is not a directory or .jar file", args)
+          else {
+            val output = if (isJar) JarArchive.create(path) else new PlainDirectory(path)
+            update(output, args)
+          }
+        case (IntTag, args) if argRest.nonEmpty =>
+          setInt(argRest, args)
+        case (IntTag, arg2 :: args2) =>
+          setInt(arg2, args2)
+        case (VersionTag, _) =>
+          ScalaVersion.parse(argRest) match {
+            case Success(v) => update(v, args)
+            case Failure(ex) => fail(ex.getMessage, args)
+          }
+        case (_, Nil) =>
+          missingArg
+      }
+
+      def matches(argName: String) = (name :: aliases).exists(_ == argName)
+
+      if (prefix != "" && arg.startsWith(prefix))
+        doSet(arg drop prefix.length)
+      else if (prefix == "" && matches(arg.takeWhile(_ != ':')))
+        doSet(arg.dropWhile(_ != ':').drop(1))
+      else
+        state
+    }
+  }
+
+  object Setting:
+    extension [T](setting: Setting[T])
+      def value(using Context): T = setting.valueIn(ctx.settingsState)
+      def update(x: T)(using Context): SettingsState = setting.updateIn(ctx.settingsState, x)
+      def isDefault(using Context): Boolean = setting.isDefaultIn(ctx.settingsState)
+
+  class SettingGroup {
+
+    private val _allSettings = new ArrayBuffer[Setting[?]]
+    def allSettings: Seq[Setting[?]] = _allSettings.toSeq
+
+    def defaultState: SettingsState = new SettingsState(allSettings map (_.default))
+
+    def userSetSettings(state: SettingsState): Seq[Setting[?]] =
+      allSettings filterNot (_.isDefaultIn(state))
+
+    def toConciseString(state: SettingsState): String =
+      userSetSettings(state).mkString("(", " ", ")")
+
+    private def checkDependencies(state: ArgsSummary): ArgsSummary =
+      userSetSettings(state.sstate).foldLeft(state)(checkDependenciesOfSetting)
+
+    private def checkDependenciesOfSetting(state: ArgsSummary, setting: Setting[?]) =
+      setting.depends.foldLeft(state) { (s, dep) =>
+        val (depSetting, reqValue) = dep
+        if (depSetting.valueIn(state.sstate) == reqValue) s
+        else s.fail(s"incomplete option ${setting.name} (requires ${depSetting.name})")
+      }
+
+    /** Iterates over the arguments applying them to settings where applicable.
+     *  Then verifies setting dependencies are met.
+     *
+     *  This takes a boolean indicating whether to keep
+     *  processing if an argument is seen which is not a command line option.
+     *  This is an expedience for the moment so that you can say
+     *
+     *    scalac -d /tmp foo.scala -optimise
+     *
+     *  while also allowing
+     *
+     *    scala Program opt opt
+     *
+     *  to get their arguments.
+     */
+    @tailrec
+    final def processArguments(state: ArgsSummary, processAll: Boolean, skipped: List[String]): ArgsSummary =
+      def stateWithArgs(args: List[String]) = ArgsSummary(state.sstate, args, state.errors, state.warnings)
+      state.arguments match
+        case Nil =>
+          checkDependencies(stateWithArgs(skipped))
+        case "--" :: args =>
+          checkDependencies(stateWithArgs(skipped ++ args))
+        case x :: _ if x startsWith "-" =>
+          @tailrec def loop(settings: List[Setting[?]]): ArgsSummary = settings match
+            case setting :: settings1 =>
+              val state1 = setting.tryToSet(state)
+              if state1 ne state then state1
+              else loop(settings1)
+            case Nil =>
+              state.warn(s"bad option '$x' was ignored")
+          processArguments(loop(allSettings.toList), processAll, skipped)
+        case arg :: args =>
+          if processAll then processArguments(stateWithArgs(args), processAll, skipped :+ arg)
+          else state
+    end processArguments
+
+    def processArguments(arguments: List[String], processAll: Boolean, settingsState: SettingsState = defaultState): ArgsSummary =
+      processArguments(ArgsSummary(settingsState, arguments, Nil, Nil), processAll, Nil)
+
+    def publish[T](settingf: Int => Setting[T]): Setting[T] = {
+      val setting = settingf(_allSettings.length)
+      _allSettings += setting
+      setting
+    }
+
+    def BooleanSetting(name: String, descr: String, initialValue: Boolean = false, aliases: List[String] = Nil): Setting[Boolean] =
+      publish(Setting(name, descr, initialValue, aliases = aliases))
+
+    def StringSetting(name: String, helpArg: String, descr: String, default: String, aliases: List[String] = Nil): Setting[String] =
+      publish(Setting(name, descr, default, helpArg, aliases = aliases))
+
+    def ChoiceSetting(name: String, helpArg: String, descr: String, choices: List[String], default: String, aliases: List[String] = Nil): Setting[String] =
+      publish(Setting(name, descr, default, helpArg, Some(choices), aliases = aliases))
+
+    def MultiChoiceSetting(name: String, helpArg: String, descr: String, choices: List[String], default: List[String], aliases: List[String] = Nil): Setting[List[String]] =
+      publish(Setting(name, descr, default, helpArg, Some(choices), aliases = aliases))
+
+    def IntSetting(name: String, descr: String, default: Int, aliases: List[String] = Nil): Setting[Int] =
+      publish(Setting(name, descr, default, aliases = aliases))
+
+    def IntChoiceSetting(name: String, descr: String, choices: Seq[Int], default: Int): Setting[Int] =
+      publish(Setting(name, descr, default, choices = Some(choices)))
+
+    def MultiStringSetting(name: String, helpArg: String, descr: String, default: List[String] = Nil, aliases: List[String] = Nil): Setting[List[String]] =
+      publish(Setting(name, descr, default, helpArg, aliases = aliases))
+
+    def OutputSetting(name: String, helpArg: String, descr: String, default: AbstractFile): Setting[AbstractFile] =
+      publish(Setting(name, descr, default, helpArg))
+
+    def PathSetting(name: String, descr: String, default: String, aliases: List[String] = Nil): Setting[String] =
+      publish(Setting(name, descr, default, aliases = aliases))
+
+    def PhasesSetting(name: String, descr: String, default: String = "", aliases: List[String] = Nil): Setting[List[String]] =
+      publish(Setting(name, descr, if (default.isEmpty) Nil else List(default), aliases = aliases))
+
+    def PrefixSetting(name: String, pre: String, descr: String): Setting[List[String]] =
+      publish(Setting(name, descr, Nil, prefix = pre))
+
+    def VersionSetting(name: String, descr: String, default: ScalaVersion = NoScalaVersion): Setting[ScalaVersion] =
+      publish(Setting(name, descr, default))
+
+    def OptionSetting[T: ClassTag](name: String, descr: String, aliases: List[String] = Nil): Setting[Option[T]] =
+      publish(Setting(name, descr, None, propertyClass = Some(implicitly[ClassTag[T]].runtimeClass), aliases = aliases))
+  }
+end Settings
diff --git a/tests/pos-with-compiler-cc/dotc/config/SourceVersion.scala b/tests/pos-with-compiler-cc/dotc/config/SourceVersion.scala
new file mode 100644
index 000000000000..545e2f2d9b42
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/config/SourceVersion.scala
@@ -0,0 +1,31 @@
+package dotty.tools
+package dotc
+package config
+
+import core.Decorators.*
+import util.Property
+
+enum SourceVersion:
+  case `3.0-migration`, `3.0`, `3.1` // Note: do not add `3.1-migration` here, 3.1 is the same language as 3.0.
+  case `3.2-migration`, `3.2`
+  case `future-migration`, `future`
+
+  val isMigrating: Boolean = toString.endsWith("-migration")
+
+  def stable: SourceVersion =
+    if isMigrating then SourceVersion.values(ordinal + 1) else this
+
+  def isAtLeast(v: SourceVersion) = stable.ordinal >= v.ordinal
+
+object SourceVersion extends Property.Key[SourceVersion]:
+  def defaultSourceVersion = `3.2`
+
+  /** language versions that may appear in a language import, are deprecated, but not removed from the standard library. */
+  val illegalSourceVersionNames = List("3.1-migration").map(_.toTermName)
+
+  /** language versions that the compiler recognises. */
+  val validSourceVersionNames = values.toList.map(_.toString.toTermName)
+
+  /** All source versions that can be recognised from a language import. e.g. `import language.3.1` */
+  val allSourceVersionNames = validSourceVersionNames ::: illegalSourceVersionNames
+end SourceVersion
diff --git a/tests/pos-with-compiler-cc/dotc/config/WrappedProperties.scala b/tests/pos-with-compiler-cc/dotc/config/WrappedProperties.scala
new file mode 100644
index 000000000000..5b79432a97e7
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/config/WrappedProperties.scala
@@ -0,0 +1,42 @@
+package dotty.tools
+package dotc
+package config
+
+import scala.language.unsafeNulls
+
+/** For placing a wrapper function around property functions.
+ *  Motivated by places like google app engine throwing exceptions
+ *  on property lookups.
+ */
+trait WrappedProperties extends PropertiesTrait {
+  def wrap[T](body: => T): Option[T]
+
+  protected def propCategory: String     = "wrapped"
+  protected def pickJarBasedOn: Class[?] = this.getClass
+
+  override def propIsSet(name: String): Boolean              = wrap(super.propIsSet(name)) exists (x => x)
+  override def propOrElse(name: String, alt: String): String = wrap(super.propOrElse(name, alt)) getOrElse alt
+  override def setProp(name: String, value: String): String  = wrap(super.setProp(name, value)).orNull
+  override def clearProp(name: String): String               = wrap(super.clearProp(name)).orNull
+  override def envOrElse(name: String, alt: String): String  = wrap(super.envOrElse(name, alt)) getOrElse alt
+  override def envOrNone(name: String): Option[String]       = wrap(super.envOrNone(name)).flatten
+
+  def systemProperties: Iterator[(String, String)] = {
+    import scala.jdk.CollectionConverters._
+    wrap(System.getProperties.asScala.iterator) getOrElse Iterator.empty
+  }
+}
+
+object WrappedProperties {
+  object AccessControl extends WrappedProperties {
+    def wrap[T](body: => T): Option[T] =
+      try Some(body)
+      catch {
+        // the actual exception we are concerned with is AccessControlException,
+        // but that's deprecated on JDK 17, so catching its superclass is a convenient
+        // way to avoid a deprecation warning
+        case _: SecurityException =>
+          None
+      }
+  }
+}
diff --git a/tests/pos-with-compiler-cc/dotc/core/Annotations.scala b/tests/pos-with-compiler-cc/dotc/core/Annotations.scala
new file mode 100644
index 000000000000..d33b1d39942e
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/core/Annotations.scala
@@ -0,0 +1,273 @@
+package dotty.tools
+package dotc
+package core
+
+import Symbols._, Types._, Contexts._, Constants._
+import dotty.tools.dotc.ast.tpd, tpd.*
+import util.Spans.Span
+import printing.{Showable, Printer}
+import printing.Texts.Text
+import annotation.internal.sharable
+import language.experimental.pureFunctions
+
+object Annotations {
+
+  def annotClass(tree: Tree)(using Context) =
+    if (tree.symbol.isConstructor) tree.symbol.owner
+    else tree.tpe.typeSymbol
+
+  abstract class Annotation extends Showable, caps.Pure {
+
+    def tree(using Context): Tree
+
+    def symbol(using Context): Symbol = annotClass(tree)
+
+    def hasSymbol(sym: Symbol)(using Context) = symbol == sym
+
+    def matches(cls: Symbol)(using Context): Boolean = symbol.derivesFrom(cls)
+
+    def appliesToModule: Boolean = true // for now; see remark in SymDenotations
+
+    def derivedAnnotation(tree: Tree)(using Context): Annotation =
+      if (tree eq this.tree) this else Annotation(tree)
+
+    /** All arguments to this annotation in a single flat list */
+    def arguments(using Context): List[Tree] = tpd.allArguments(tree)
+
+    def argument(i: Int)(using Context): Option[Tree] = {
+      val args = arguments
+      if (i < args.length) Some(args(i)) else None
+    }
+    def argumentConstant(i: Int)(using Context): Option[Constant] =
+      for (case ConstantType(c) <- argument(i) map (_.tpe.widenTermRefExpr.normalized)) yield c
+
+    def argumentConstantString(i: Int)(using Context): Option[String] =
+      for (case Constant(s: String) <- argumentConstant(i)) yield s
+
+    /** The tree evaluaton is in progress. */
+    def isEvaluating: Boolean = false
+
+    /** The tree evaluation has finished. */
+    def isEvaluated: Boolean = true
+
+    /** Normally, applies a type map to all tree nodes of this annotation, but can
+     *  be overridden. Returns EmptyAnnotation if type type map produces a range
+     *  type, since ranges cannot be types of trees.
+     */
+    def mapWith(tm: TypeMap)(using Context) =
+      val args = arguments
+      if args.isEmpty then this
+      else
+        val findDiff = new TreeAccumulator[Type]:
+          def apply(x: Type, tree: Tree)(using Context): Type =
+            if tm.isRange(x) then x
+            else
+              val tp1 = tm(tree.tpe)
+              foldOver(if tp1 frozen_=:= tree.tpe then x else tp1, tree)
+        val diff = findDiff(NoType, args)
+        if tm.isRange(diff) then EmptyAnnotation
+        else if diff.exists then derivedAnnotation(tm.mapOver(tree))
+        else this
+
+    /** Does this annotation refer to a parameter of `tl`? */
+    def refersToParamOf(tl: TermLambda)(using Context): Boolean =
+      val args = arguments
+      if args.isEmpty then false
+      else tree.existsSubTree {
+        case id: Ident => id.tpe.stripped match
+          case TermParamRef(tl1, _) => tl eq tl1
+          case _ => false
+        case _ => false
+      }
+
+    /** A string representation of the annotation. Overridden in BodyAnnotation.
+     */
+    def toText(printer: Printer): Text = printer.annotText(this)
+
+    def ensureCompleted(using Context): Unit = tree
+
+    def sameAnnotation(that: Annotation)(using Context): Boolean =
+      symbol == that.symbol && tree.sameTree(that.tree)
+
+    /** Operations for hash-consing, can be overridden */
+    def hash: Int = System.identityHashCode(this)
+    def eql(that: Annotation) = this eq that
+  }
+
+  case class ConcreteAnnotation(t: Tree) extends Annotation:
+    def tree(using Context): Tree = t
+
+  abstract class LazyAnnotation extends Annotation {
+    protected var mySym: Symbol | (Context ?-> Symbol) | Null
+    override def symbol(using parentCtx: Context): Symbol =
+      assert(mySym != null)
+      mySym match {
+        case symFn: (Context ?-> Symbol) @unchecked =>
+          mySym = null
+          mySym = atPhaseBeforeTransforms(symFn)
+            // We should always produce the same annotation tree, no matter when the
+            // annotation is evaluated. Setting the phase to a pre-transformation phase
+            // seems to be enough to ensure this (note that after erasure, `ctx.typer`
+            // will be the Erasure typer, but that doesn't seem to affect the annotation
+            // trees we create, so we leave it as is)
+        case sym: Symbol if sym.defRunId != parentCtx.runId =>
+          mySym = sym.denot.current.symbol
+        case _ =>
+      }
+      mySym.asInstanceOf[Symbol]
+
+    protected var myTree: Tree | (Context ?-> Tree) | Null
+    def tree(using Context): Tree =
+      assert(myTree != null)
+      myTree match {
+        case treeFn: (Context ?-> Tree) @unchecked =>
+          myTree = null
+          myTree = atPhaseBeforeTransforms(treeFn)
+        case _ =>
+      }
+      myTree.asInstanceOf[Tree]
+
+    override def isEvaluating: Boolean = myTree == null
+    override def isEvaluated: Boolean = myTree.isInstanceOf[Tree @unchecked]
+  }
+
+  class DeferredSymAndTree(symFn: Context ?-> Symbol, treeFn: Context ?-> Tree)
+  extends LazyAnnotation:
+    protected var mySym: Symbol | (Context ?-> Symbol) | Null = ctx ?=> symFn(using ctx)
+    protected var myTree: Tree | (Context ?-> Tree) | Null = ctx ?=> treeFn(using ctx)
+
+  /** An annotation indicating the body of a right-hand side,
+   *  typically of an inline method. Treated specially in
+   *  pickling/unpickling and TypeTreeMaps
+   */
+  abstract class BodyAnnotation extends Annotation {
+    override def symbol(using Context): ClassSymbol = defn.BodyAnnot
+    override def derivedAnnotation(tree: Tree)(using Context): Annotation =
+      if (tree eq this.tree) this else ConcreteBodyAnnotation(tree)
+    override def arguments(using Context): List[Tree] = Nil
+    override def ensureCompleted(using Context): Unit = ()
+    override def toText(printer: Printer): Text = "@Body"
+  }
+
+  class ConcreteBodyAnnotation(body: Tree) extends BodyAnnotation {
+    def tree(using Context): Tree = body
+  }
+
+  abstract class LazyBodyAnnotation extends BodyAnnotation {
+    // Copy-pasted from LazyAnnotation to avoid having to turn it into a trait
+    protected var myTree: Tree | (Context ?-> Tree) | Null
+    def tree(using Context): Tree =
+      assert(myTree != null)
+      myTree match {
+        case treeFn: (Context ?-> Tree) @unchecked =>
+          myTree = null
+          myTree = atPhaseBeforeTransforms(treeFn)
+        case _ =>
+      }
+      myTree.asInstanceOf[Tree]
+
+    override def isEvaluating: Boolean = myTree == null
+    override def isEvaluated: Boolean = myTree.isInstanceOf[Tree @unchecked]
+  }
+
+  object LazyBodyAnnotation {
+    def apply(bodyFn: Context ?-> Tree): LazyBodyAnnotation =
+      new LazyBodyAnnotation:
+        protected var myTree: Tree | (Context ?-> Tree) | Null = ctx ?=> bodyFn(using ctx)
+  }
+
+  object Annotation {
+
+    def apply(tree: Tree): ConcreteAnnotation = ConcreteAnnotation(tree)
+
+    def apply(cls: ClassSymbol)(using Context): Annotation =
+      apply(cls, Nil)
+
+    def apply(cls: ClassSymbol, arg: Tree)(using Context): Annotation =
+      apply(cls, arg :: Nil)
+
+    def apply(cls: ClassSymbol, arg1: Tree, arg2: Tree)(using Context): Annotation =
+      apply(cls, arg1 :: arg2 :: Nil)
+
+    def apply(cls: ClassSymbol, args: List[Tree])(using Context): Annotation =
+      apply(cls.typeRef, args)
+
+    def apply(atp: Type, arg: Tree)(using Context): Annotation =
+      apply(atp, arg :: Nil)
+
+    def apply(atp: Type, arg1: Tree, arg2: Tree)(using Context): Annotation =
+      apply(atp, arg1 :: arg2 :: Nil)
+
+    def apply(atp: Type, args: List[Tree])(using Context): Annotation =
+      apply(New(atp, args))
+
+    /** Create an annotation where the tree is computed lazily. */
+    def deferred(sym: Symbol)(treeFn: Context ?-> Tree): Annotation =
+      new LazyAnnotation {
+        protected var myTree: Tree | (Context ?-> Tree) | Null = ctx ?=> treeFn(using ctx)
+        protected var mySym: Symbol | (Context ?-> Symbol) | Null = sym
+      }
+
+    /** Create an annotation where the symbol and the tree are computed lazily. */
+    def deferredSymAndTree(symFn: Context ?-> Symbol)(treeFn: Context ?-> Tree): Annotation =
+      DeferredSymAndTree(symFn, treeFn)
+
+    /** Extractor for child annotations */
+    object Child {
+
+      /** A deferred annotation to the result of a given child computation */
+      def later(delayedSym: Context ?-> Symbol, span: Span)(using Context): Annotation = {
+        def makeChildLater(using Context) = {
+          val sym = delayedSym
+          New(defn.ChildAnnot.typeRef.appliedTo(sym.owner.thisType.select(sym.name, sym)), Nil)
+            .withSpan(span)
+        }
+        deferred(defn.ChildAnnot)(makeChildLater)
+      }
+
+      /** A regular, non-deferred Child annotation */
+      def apply(sym: Symbol, span: Span)(using Context): Annotation = later(sym, span)
+
+      def unapply(ann: Annotation)(using Context): Option[Symbol] =
+        if (ann.symbol == defn.ChildAnnot) {
+          val AppliedType(_, (arg: NamedType) :: Nil) = ann.tree.tpe: @unchecked
+          Some(arg.symbol)
+        }
+        else None
+    }
+
+    def makeSourceFile(path: String)(using Context): Annotation =
+      apply(defn.SourceFileAnnot, Literal(Constant(path)))
+  }
+
+  @sharable val EmptyAnnotation = Annotation(EmptyTree)
+
+  def ThrowsAnnotation(cls: ClassSymbol)(using Context): Annotation = {
+    val tref = cls.typeRef
+    Annotation(defn.ThrowsAnnot.typeRef.appliedTo(tref), Ident(tref))
+  }
+
+  /** Extracts the type of the thrown exception from an annotation.
+   *
+   *  Supports both "old-style" `@throws(classOf[Exception])`
+   *  as well as "new-style" `@throws[Exception]("cause")` annotations.
+   */
+  object ThrownException {
+    def unapply(a: Annotation)(using Context): Option[Type] =
+      if (a.symbol ne defn.ThrowsAnnot)
+        None
+      else a.argumentConstant(0) match {
+        // old-style: @throws(classOf[Exception]) (which is throws[T](classOf[Exception]))
+        case Some(Constant(tpe: Type)) =>
+          Some(tpe)
+        // new-style: @throws[Exception], @throws[Exception]("cause")
+        case _ =>
+          stripApply(a.tree) match {
+            case TypeApply(_, List(tpt)) =>
+              Some(tpt.tpe)
+            case _ =>
+              None
+          }
+      }
+  }
+}
diff --git a/tests/pos-with-compiler-cc/dotc/core/Atoms.scala b/tests/pos-with-compiler-cc/dotc/core/Atoms.scala
new file mode 100644
index 000000000000..bcaaf6794107
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/core/Atoms.scala
@@ -0,0 +1,36 @@
+package dotty.tools
+package dotc
+package core
+
+import Types._
+
+/** Indicates the singleton types that a type must or may consist of.
+ *  @param lo   The lower bound: singleton types in this set are guaranteed
+ *              to be in the carrier type.
+ *  @param hi   The upper bound: all singleton types in the carrier type are
+ *              guaranteed to be in this set
+ *  If the underlying type of a singleton type is another singleton type,
+ *  only the latter type ends up in the sets.
+ */
+enum Atoms:
+  case Range(lo: Set[Type], hi: Set[Type])
+  case Unknown
+
+  def & (that: Atoms): Atoms = this match
+    case Range(lo1, hi1) =>
+      that match
+        case Range(lo2, hi2) => Range(lo1 & lo2, hi1 & hi2)
+        case Unknown => Range(Set.empty, hi1)
+    case Unknown =>
+      that match
+        case Range(lo2, hi2) => Range(Set.empty, hi2)
+        case Unknown => Unknown
+
+  def | (that: Atoms): Atoms = this match
+    case Range(lo1, hi1) =>
+      that match
+        case Range(lo2, hi2) => Range(lo1 | lo2, hi1 | hi2)
+        case Unknown => Unknown
+    case Unknown => Unknown
+
+end Atoms
diff --git a/tests/pos-with-compiler-cc/dotc/core/CheckRealizable.scala b/tests/pos-with-compiler-cc/dotc/core/CheckRealizable.scala
new file mode 100644
index 000000000000..a61701eee2d7
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/core/CheckRealizable.scala
@@ -0,0 +1,215 @@
+package dotty.tools
+package dotc
+package core
+
+import Contexts._, Types._, Symbols._, Names._, Flags._
+import Denotations.SingleDenotation
+import Decorators._
+import collection.mutable
+import config.SourceVersion.future
+import config.Feature.sourceVersion
+
+/** Realizability status */
+object CheckRealizable {
+
+  sealed abstract class Realizability(val msg: String) {
+    def andAlso(other: => Realizability): Realizability =
+      if (this == Realizable) other else this
+    def mapError(f: Realizability => Realizability): Realizability =
+      if (this == Realizable) this else f(this)
+  }
+
+  object Realizable extends Realizability("")
+
+  object NotConcrete extends Realizability(" is not a concrete type")
+
+  class NotFinal(sym: Symbol)(using Context)
+  extends Realizability(i" refers to nonfinal $sym")
+
+  class HasProblemBounds(name: Name, info: Type)(using Context)
+  extends Realizability(i" has a member $name with possibly conflicting bounds ${info.bounds.lo} <: ... <: ${info.bounds.hi}")
+
+  class HasProblemBaseArg(typ: Type, argBounds: TypeBounds)(using Context)
+  extends Realizability(i" has a base type $typ with possibly conflicting parameter bounds ${argBounds.lo} <: ... <: ${argBounds.hi}")
+
+  class HasProblemBase(base1: Type, base2: Type)(using Context)
+  extends Realizability(i" has conflicting base types $base1 and $base2")
+
+  class HasProblemField(fld: SingleDenotation, problem: Realizability)(using Context)
+  extends Realizability(i" has a member $fld which is not a legal path\nsince ${fld.symbol.name}: ${fld.info}${problem.msg}")
+
+  class ProblemInUnderlying(tp: Type, problem: Realizability)(using Context)
+  extends Realizability(i"s underlying type ${tp}${problem.msg}") {
+    assert(problem != Realizable)
+  }
+
+  def realizability(tp: Type)(using Context): Realizability =
+    new CheckRealizable().realizability(tp)
+
+  def boundsRealizability(tp: Type)(using Context): Realizability =
+    new CheckRealizable().boundsRealizability(tp)
+
+  private val LateInitializedFlags = Lazy | Erased
+}
+
+/** Compute realizability status.
+  *
+  * A type T is realizable iff it is inhabited by non-null values. This ensures that its type members have good bounds
+  * (in the sense from DOT papers). A type projection T#L is legal if T is realizable, and can be understood as
+  * Scala 2's `v.L forSome { val v: T }`.
+  *
+  * In general, a realizable type can have multiple inhabitants, hence it need not be stable (in the sense of
+  * Type.isStable).
+  */
+class CheckRealizable(using Context) {
+  import CheckRealizable._
+
+  /** A set of all fields that have already been checked. Used
+   *  to avoid infinite recursions when analyzing recursive types.
+   */
+  private val checkedFields: mutable.Set[Symbol] = mutable.LinkedHashSet[Symbol]()
+
+  /** Is symbol's definitition a lazy or erased val?
+   *  (note we exclude modules here, because their realizability is ensured separately)
+   */
+  private def isLateInitialized(sym: Symbol) = sym.isOneOf(LateInitializedFlags, butNot = Module)
+
+  /** The realizability status of given type `tp`*/
+  def realizability(tp: Type): Realizability = tp.dealias match {
+    /*
+     * A `TermRef` for a path `p` is realizable if
+     * - `p`'s type is stable and realizable, or
+     * - its underlying path is idempotent (that is, *stable*), total, and not null.
+     * We don't check yet the "not null" clause: that will require null-safety checking.
+     *
+     * We assume that stability of tp.prefix is checked elsewhere, since that's necessary for the path to be legal in
+     * the first place.
+     */
+    case tp: TermRef =>
+      val sym = tp.symbol
+      lazy val tpInfoRealizable = realizability(tp.info)
+      if (sym.is(StableRealizable)) realizability(tp.prefix)
+      else {
+        val r =
+          if (sym.isStableMember && !isLateInitialized(sym))
+            // it's realizable because we know that a value of type `tp` has been created at run-time
+            Realizable
+          else if (!sym.isEffectivelyFinal)
+            // it's potentially not realizable since it might be overridden with a member of nonrealizable type
+            new NotFinal(sym)
+          else
+            // otherwise we need to look at the info to determine realizability
+            // roughly: it's realizable if the info does not have bad bounds
+            tpInfoRealizable.mapError(r => new ProblemInUnderlying(tp, r))
+        r andAlso {
+          if (sym.isStableMember) sym.setFlag(StableRealizable) // it's known to be stable and realizable
+          realizability(tp.prefix)
+        } mapError { r =>
+          // A mutable path is in fact stable and realizable if it has a realizable singleton type.
+          if (tp.info.isStable && tpInfoRealizable == Realizable) {
+            sym.setFlag(StableRealizable)
+            Realizable
+          }
+          else r
+        }
+      }
+    case _: SingletonType | NoPrefix =>
+      Realizable
+    case tp =>
+      def isConcrete(tp: Type): Boolean = tp.dealias match {
+        case tp: TypeRef => tp.symbol.isClass
+        case tp: TypeParamRef => false
+        case tp: TypeProxy => isConcrete(tp.underlying)
+        case tp: AndType => isConcrete(tp.tp1) && isConcrete(tp.tp2)
+        case tp: OrType  => isConcrete(tp.tp1) && isConcrete(tp.tp2)
+        case _ => false
+      }
+      if (!isConcrete(tp)) NotConcrete
+      else boundsRealizability(tp).andAlso(memberRealizability(tp))
+  }
+
+  private def refinedNames(tp: Type): Set[Name] = tp.dealias match {
+    case tp: RefinedType => refinedNames(tp.parent) + tp.refinedName
+    case tp: AndType => refinedNames(tp.tp1) ++ refinedNames(tp.tp2)
+    case tp: OrType  => refinedNames(tp.tp1) ++ refinedNames(tp.tp2)
+    case tp: TypeProxy => refinedNames(tp.superType)
+    case _ => Set.empty
+  }
+
+  /** `Realizable` if `tp` has good bounds, a `HasProblem...` instance
+   *  pointing to a bad bounds member otherwise. "Has good bounds" means:
+   *
+   *    - all type members have good bounds (except for opaque helpers)
+   *    - all refinements of the underlying type have good bounds (except for opaque companions)
+   *    - all base types are class types, and if their arguments are wildcards
+   *      they have good bounds.
+   *    - base types do not appear in multiple instances with different arguments.
+   *      (depending on the simplification scheme for AndTypes employed, this could
+   *       also lead to base types with bad bounds).
+   */
+  private def boundsRealizability(tp: Type) = {
+
+    val memberProblems = withMode(Mode.CheckBoundsOrSelfType) {
+      for {
+        mbr <- tp.nonClassTypeMembers
+        if !(mbr.info.loBound <:< mbr.info.hiBound)
+      }
+      yield new HasProblemBounds(mbr.name, mbr.info)
+    }
+
+    val refinementProblems = withMode(Mode.CheckBoundsOrSelfType) {
+      for {
+        name <- refinedNames(tp)
+        if (name.isTypeName)
+        mbr <- tp.member(name).alternatives
+        if !(mbr.info.loBound <:< mbr.info.hiBound)
+      }
+      yield
+        new HasProblemBounds(name, mbr.info)
+    }
+
+    def baseTypeProblems(base: Type) = base match {
+      case AndType(base1, base2) =>
+        new HasProblemBase(base1, base2) :: Nil
+      case base =>
+        base.argInfos.collect {
+          case bounds @ TypeBounds(lo, hi) if !(lo <:< hi) =>
+            new HasProblemBaseArg(base, bounds)
+        }
+    }
+    val baseProblems =
+      tp.baseClasses.map(_.baseTypeOf(tp)).flatMap(baseTypeProblems)
+
+    baseProblems.foldLeft(
+      refinementProblems.foldLeft(
+        memberProblems.foldLeft(
+          Realizable: Realizability)(_ andAlso _))(_ andAlso _))(_ andAlso _)
+  }
+
+  /** `Realizable` if all of `tp`'s non-strict fields have realizable types,
+   *  a `HasProblemField` instance pointing to a bad field otherwise.
+   */
+  private def memberRealizability(tp: Type) = {
+    def checkField(sofar: Realizability, fld: SingleDenotation): Realizability =
+      sofar andAlso {
+        if (checkedFields.contains(fld.symbol) || fld.symbol.isOneOf(Private | Mutable | LateInitializedFlags))
+          // if field is private it cannot be part of a visible path
+          // if field is mutable it cannot be part of a path
+          // if field is lazy or erased it does not need to be initialized when the owning object is
+          // so in all cases the field does not influence realizability of the enclosing object.
+          Realizable
+        else {
+          checkedFields += fld.symbol
+          realizability(fld.info).mapError(r => new HasProblemField(fld, r))
+        }
+      }
+    if sourceVersion.isAtLeast(future) then
+      // check fields only from version 3.x.
+      // Reason: An embedded field could well be nullable, which means it
+      // should not be part of a path and need not be checked; but we cannot recognize
+      // this situation until we have a typesystem that tracks nullability.
+      tp.fields.foldLeft(Realizable: Realizability)(checkField)
+    else
+      Realizable
+  }
+}
diff --git a/tests/pos-with-compiler-cc/dotc/core/Comments.scala b/tests/pos-with-compiler-cc/dotc/core/Comments.scala
new file mode 100644
index 000000000000..1b20b75ad8ac
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/core/Comments.scala
@@ -0,0 +1,462 @@
+package dotty.tools
+package dotc
+package core
+
+import scala.language.unsafeNulls
+
+import ast.{ untpd, tpd }
+import Symbols._, Contexts._
+import util.{SourceFile, ReadOnlyMap}
+import util.Spans._
+import util.CommentParsing._
+import util.Property.Key
+import parsing.Parsers.Parser
+import reporting.ProperDefinitionNotFound
+
+object Comments {
+  val ContextDoc: Key[ContextDocstrings] = new Key[ContextDocstrings]
+
+  /** Decorator for getting docbase out of context */
+  given CommentsContext: AnyRef with
+    extension (c: Context) def docCtx: Option[ContextDocstrings] = c.property(ContextDoc)
+
+  /** Context for Docstrings, contains basic functionality for getting
+    * docstrings via `Symbol` and expanding templates
+    */
+  class ContextDocstrings {
+
+    private val _docstrings: MutableSymbolMap[Comment] = MutableSymbolMap[Comment](512) // FIXME: 2nd [Comment] needed or "not a class type"
+
+    val templateExpander: CommentExpander = new CommentExpander
+
+    def docstrings: ReadOnlyMap[Symbol, Comment] = _docstrings
+
+    def docstring(sym: Symbol): Option[Comment] = _docstrings.get(sym)
+
+    def addDocstring(sym: Symbol, doc: Option[Comment]): Unit =
+      doc.foreach(d => _docstrings.update(sym, d))
+  }
+
+  /**
+   * A `Comment` contains the unformatted docstring, it's position and potentially more
+   * information that is populated when the comment is "cooked".
+   *
+   * @param span     The position span of this `Comment`.
+   * @param raw      The raw comment, as seen in the source code, without any expansion.
+   * @param expanded If this comment has been expanded, it's expansion, otherwise `None`.
+   * @param usecases The usecases for this comment.
+   */
+  final case class Comment(
+    span: Span,
+    raw: String,
+    expanded: Option[String],
+    usecases: List[UseCase],
+    variables: Map[String, String],
+  ) {
+
+    /** Has this comment been cooked or expanded? */
+    def isExpanded: Boolean = expanded.isDefined
+
+    /** The body of this comment, without the `@usecase` and `@define` sections, after expansion. */
+    lazy val expandedBody: Option[String] =
+      expanded.map(removeSections(_, "@usecase", "@define"))
+
+    val isDocComment: Boolean = Comment.isDocComment(raw)
+
+    /**
+     * Expands this comment by giving its content to `f`, and then parsing the `@usecase` sections.
+     * Typically, `f` will take care of expanding the variables.
+     *
+     * @param f The expansion function.
+     * @return The expanded comment, with the `usecases` populated.
+     */
+    def expand(f: String => String)(using Context): Comment = {
+      val expandedComment = f(raw)
+      val useCases = Comment.parseUsecases(expandedComment, span)
+      Comment(span, raw, Some(expandedComment), useCases, Map.empty)
+    }
+  }
+
+  object Comment {
+
+    def isDocComment(comment: String): Boolean = comment.startsWith("/**")
+
+    def apply(span: Span, raw: String): Comment =
+      Comment(span, raw, None, Nil, Map.empty)
+
+    private def parseUsecases(expandedComment: String, span: Span)(using Context): List[UseCase] =
+      if (!isDocComment(expandedComment))
+        Nil
+      else
+        tagIndex(expandedComment)
+          .filter { startsWithTag(expandedComment, _, "@usecase") }
+          .map { case (start, end) => decomposeUseCase(expandedComment, span, start, end) }
+
+    /** Turns a usecase section into a UseCase, with code changed to:
+     *  {{{
+     *  // From:
+     *  def foo: A
+     *  // To:
+     *  def foo: A = ???
+     *  }}}
+     */
+    private def decomposeUseCase(body: String, span: Span, start: Int, end: Int)(using Context): UseCase = {
+      def subPos(start: Int, end: Int) =
+        if (span == NoSpan) NoSpan
+        else {
+          val start1 = span.start + start
+          val end1 = span.end + end
+          span withStart start1 withPoint start1 withEnd end1
+        }
+
+      val codeStart = skipWhitespace(body, start + "@usecase".length)
+      val codeEnd   = skipToEol(body, codeStart)
+      val code      = body.substring(codeStart, codeEnd) + " = ???"
+      val codePos   = subPos(codeStart, codeEnd)
+
+      UseCase(code, codePos)
+    }
+  }
+
+  final case class UseCase(code: String, codePos: Span, untpdCode: untpd.Tree, tpdCode: Option[tpd.DefDef]) {
+    def typed(tpdCode: tpd.DefDef): UseCase = copy(tpdCode = Some(tpdCode))
+  }
+
+  object UseCase {
+    def apply(code: String, codePos: Span)(using Context): UseCase = {
+      val tree = {
+        val tree = new Parser(SourceFile.virtual("<usecase>", code)).localDef(codePos.start)
+        tree match {
+          case tree: untpd.DefDef =>
+            val newName = ctx.compilationUnit.freshNames.newName(tree.name, NameKinds.DocArtifactName)
+            untpd.cpy.DefDef(tree)(name = newName)
+          case _ =>
+            report.error(ProperDefinitionNotFound(), ctx.source.atSpan(codePos))
+            tree
+        }
+      }
+      UseCase(code, codePos, tree, None)
+    }
+  }
+
+  /**
+   * Port of DocComment.scala from nsc
+   * @author Martin Odersky
+   * @author Felix Mulder
+   */
+  class CommentExpander {
+    import dotc.config.Printers.scaladoc
+    import scala.collection.mutable
+
+    def expand(sym: Symbol, site: Symbol)(using Context): String = {
+      val parent = if (site != NoSymbol) site else sym
+      defineVariables(parent)
+      expandedDocComment(sym, parent)
+    }
+
+    /** The cooked doc comment of symbol `sym` after variable expansion, or "" if missing.
+     *
+     *  @param sym  The symbol for which doc comment is returned
+     *  @param site The class for which doc comments are generated
+     *  @throws ExpansionLimitExceeded  when more than 10 successive expansions
+     *                                  of the same string are done, which is
+     *                                  interpreted as a recursive variable definition.
+     */
+    def expandedDocComment(sym: Symbol, site: Symbol, docStr: String = "")(using Context): String = {
+      // when parsing a top level class or module, use the (module-)class itself to look up variable definitions
+      val parent = if ((sym.is(Flags.Module) || sym.isClass) && site.is(Flags.Package)) sym
+                   else site
+      expandVariables(cookedDocComment(sym, docStr), sym, parent)
+    }
+
+    private def template(raw: String): String =
+      removeSections(raw, "@define")
+
+    private def defines(raw: String): List[String] = {
+      val sections = tagIndex(raw)
+      val defines = sections filter { startsWithTag(raw, _, "@define") }
+      val usecases = sections filter { startsWithTag(raw, _, "@usecase") }
+      val end = startTag(raw, (defines ::: usecases).sortBy(_._1))
+
+      defines map { case (start, end) => raw.substring(start, end) }
+    }
+
+    private def replaceInheritDocToInheritdoc(docStr: String): String  =
+      docStr.replaceAll("""\{@inheritDoc\p{Zs}*\}""", "@inheritdoc")
+
+    /** The cooked doc comment of an overridden symbol */
+    protected def superComment(sym: Symbol)(using Context): Option[String] =
+      allInheritedOverriddenSymbols(sym).iterator map (x => cookedDocComment(x)) find (_ != "")
+
+    private val cookedDocComments = MutableSymbolMap[String]()
+
+    /** The raw doc comment of symbol `sym`, minus usecase and define sections, augmented by
+     *  missing sections of an inherited doc comment.
+     *  If a symbol does not have a doc comment but some overridden version of it does,
+     *  the doc comment of the overridden version is copied instead.
+     */
+    def cookedDocComment(sym: Symbol, docStr: String = "")(using Context): String = cookedDocComments.getOrElseUpdate(sym, {
+      var ownComment =
+        if (docStr.length == 0) ctx.docCtx.flatMap(_.docstring(sym).map(c => template(c.raw))).getOrElse("")
+        else template(docStr)
+      ownComment = replaceInheritDocToInheritdoc(ownComment)
+
+      superComment(sym) match {
+        case None =>
+          // SI-8210 - The warning would be false negative when this symbol is a setter
+          if (ownComment.indexOf("@inheritdoc") != -1 && ! sym.isSetter)
+            scaladoc.println(s"${sym.span}: the comment for ${sym} contains @inheritdoc, but no parent comment is available to inherit from.")
+          ownComment.replace("@inheritdoc", "<invalid inheritdoc annotation>")
+        case Some(sc) =>
+          if (ownComment == "") sc
+          else expandInheritdoc(sc, merge(sc, ownComment, sym), sym)
+      }
+    })
+
+    private def isMovable(str: String, sec: (Int, Int)): Boolean =
+      startsWithTag(str, sec, "@param") ||
+      startsWithTag(str, sec, "@tparam") ||
+      startsWithTag(str, sec, "@return")
+
+    def merge(src: String, dst: String, sym: Symbol, copyFirstPara: Boolean = false): String = {
+      val srcSections  = tagIndex(src)
+      val dstSections  = tagIndex(dst)
+      val srcParams    = paramDocs(src, "@param", srcSections)
+      val dstParams    = paramDocs(dst, "@param", dstSections)
+      val srcTParams   = paramDocs(src, "@tparam", srcSections)
+      val dstTParams   = paramDocs(dst, "@tparam", dstSections)
+      val out          = new StringBuilder
+      var copied       = 0
+      var tocopy       = startTag(dst, dstSections dropWhile (!isMovable(dst, _)))
+
+      if (copyFirstPara) {
+        val eop = // end of comment body (first para), which is delimited by blank line, or tag, or end of comment
+          (findNext(src, 0)(src.charAt(_) == '\n')) min startTag(src, srcSections)
+        out append src.substring(0, eop).trim
+        copied = 3
+        tocopy = 3
+      }
+
+      def mergeSection(srcSec: Option[(Int, Int)], dstSec: Option[(Int, Int)]) = dstSec match {
+        case Some((start, end)) =>
+          if (end > tocopy) tocopy = end
+        case None =>
+          srcSec match {
+            case Some((start1, end1)) =>
+              out append dst.substring(copied, tocopy).trim
+              out append "\n"
+              copied = tocopy
+              out append src.substring(start1, end1).trim
+            case None =>
+          }
+      }
+
+      //TODO: enable this once you know how to get `sym.paramss`
+      /*
+      for (params <- sym.paramss; param <- params)
+        mergeSection(srcParams get param.name.toString, dstParams get param.name.toString)
+      for (tparam <- sym.typeParams)
+        mergeSection(srcTParams get tparam.name.toString, dstTParams get tparam.name.toString)
+
+      mergeSection(returnDoc(src, srcSections), returnDoc(dst, dstSections))
+      mergeSection(groupDoc(src, srcSections), groupDoc(dst, dstSections))
+      */
+
+      if (out.length == 0) dst
+      else {
+        out append dst.substring(copied)
+        out.toString
+      }
+    }
+
+    /**
+     * Expand inheritdoc tags
+     *  - for the main comment we transform the inheritdoc into the super variable,
+     *  and the variable expansion can expand it further
+     *  - for the param, tparam and throws sections we must replace comments on the spot
+     *
+     * This is done separately, for two reasons:
+     * 1. It takes longer to run compared to merge
+     * 2. The inheritdoc annotation should not be used very often, as building the comment from pieces severely
+     * impacts performance
+     *
+     * @param parent The source (or parent) comment
+     * @param child  The child (overriding member or usecase) comment
+     * @param sym    The child symbol
+     * @return       The child comment with the inheritdoc sections expanded
+     */
+    def expandInheritdoc(parent: String, child: String, sym: Symbol): String =
+      if (child.indexOf("@inheritdoc") == -1)
+        child
+      else {
+        val parentSections    = tagIndex(parent)
+        val childSections     = tagIndex(child)
+        val parentTagMap      = sectionTagMap(parent, parentSections)
+        val parentNamedParams = Map() +
+          ("@param"  -> paramDocs(parent, "@param", parentSections)) +
+          ("@tparam" -> paramDocs(parent, "@tparam", parentSections)) +
+          ("@throws" -> paramDocs(parent, "@throws", parentSections))
+
+        val out         = new StringBuilder
+
+        def replaceInheritdoc(childSection: String, parentSection: => String) =
+          if (childSection.indexOf("@inheritdoc") == -1)
+            childSection
+          else
+            childSection.replace("@inheritdoc", parentSection)
+
+        def getParentSection(section: (Int, Int)): String = {
+
+          def getSectionHeader = extractSectionTag(child, section) match {
+            case param@("@param"|"@tparam"|"@throws")  => param + " "  + extractSectionParam(child, section)
+            case other     => other
+          }
+
+          def sectionString(param: String, paramMap: Map[String, (Int, Int)]): String =
+            paramMap.get(param) match {
+              case Some(section) =>
+                // Cleanup the section tag and parameter
+                val sectionTextBounds = extractSectionText(parent, section)
+                cleanupSectionText(parent.substring(sectionTextBounds._1, sectionTextBounds._2))
+              case None =>
+                scaladoc.println(s"""${sym.span}: the """" + getSectionHeader + "\" annotation of the " + sym +
+                    " comment contains @inheritdoc, but the corresponding section in the parent is not defined.")
+                "<invalid inheritdoc annotation>"
+            }
+
+          child.substring(section._1, section._1 + 7) match {
+            case param@("@param "|"@tparam"|"@throws") =>
+              sectionString(extractSectionParam(child, section), parentNamedParams(param.trim))
+            case _                                     =>
+              sectionString(extractSectionTag(child, section), parentTagMap)
+          }
+        }
+
+        def mainComment(str: String, sections: List[(Int, Int)]): String =
+          if (str.trim.length > 3)
+            str.trim.substring(3, startTag(str, sections))
+          else
+            ""
+
+        // Append main comment
+        out.append("/**")
+        out.append(replaceInheritdoc(mainComment(child, childSections), mainComment(parent, parentSections)))
+
+        // Append sections
+        for (section <- childSections)
+          out.append(replaceInheritdoc(child.substring(section._1, section._2), getParentSection(section)))
+
+        out.append("*/")
+        out.toString
+      }
+
+    protected def expandVariables(initialStr: String, sym: Symbol, site: Symbol)(using Context): String = {
+      val expandLimit = 10
+
+      def expandInternal(str: String, depth: Int): String = {
+        if (depth >= expandLimit)
+          throw new ExpansionLimitExceeded(str)
+
+        val out         = new StringBuilder
+        var copied, idx = 0
+        // excluding variables written as \$foo so we can use them when
+        // necessary to document things like Symbol#decode
+        def isEscaped = idx > 0 && str.charAt(idx - 1) == '\\'
+        while (idx < str.length)
+          if ((str charAt idx) != '$' || isEscaped)
+            idx += 1
+          else {
+            val vstart = idx
+            idx = skipVariable(str, idx + 1)
+            def replaceWith(repl: String) = {
+              out append str.substring(copied, vstart)
+              out append repl
+              copied = idx
+            }
+            variableName(str.substring(vstart + 1, idx)) match {
+              case "super"    =>
+                superComment(sym) foreach { sc =>
+                  val superSections = tagIndex(sc)
+                  replaceWith(sc.substring(3, startTag(sc, superSections)))
+                  for (sec @ (start, end) <- superSections)
+                    if (!isMovable(sc, sec)) out append sc.substring(start, end)
+                }
+              case "" => idx += 1
+              case vname  =>
+                lookupVariable(vname, site) match {
+                  case Some(replacement) => replaceWith(replacement)
+                  case None              =>
+                    scaladoc.println(s"Variable $vname undefined in comment for $sym in $site")
+                }
+            }
+          }
+        if (out.length == 0) str
+        else {
+          out append str.substring(copied)
+          expandInternal(out.toString, depth + 1)
+        }
+      }
+
+      // We suppressed expanding \$ throughout the recursion, and now we
+      // need to replace \$ with $ so it looks as intended.
+      expandInternal(initialStr, 0).replace("""\$""", "$")
+    }
+
+    def defineVariables(sym: Symbol)(using Context): Unit = {
+      val Trim = "(?s)^[\\s&&[^\n\r]]*(.*?)\\s*$".r
+
+      val raw = ctx.docCtx.flatMap(_.docstring(sym).map(_.raw)).getOrElse("")
+      defs(sym) ++= defines(raw).map {
+        str => {
+          val start = skipWhitespace(str, "@define".length)
+          val (key, value) = str.splitAt(skipVariable(str, start))
+          key.drop(start) -> value
+        }
+      } map {
+        case (key, Trim(value)) =>
+          variableName(key) -> value.replaceAll("\\s+\\*+$", "")
+      }
+    }
+
+    /** Maps symbols to the variable -> replacement maps that are defined
+     *  in their doc comments
+     */
+    private val defs = mutable.HashMap[Symbol, Map[String, String]]() withDefaultValue Map()
+
+    /** Lookup definition of variable.
+     *
+     *  @param vble  The variable for which a definition is searched
+     *  @param site  The class for which doc comments are generated
+     */
+    def lookupVariable(vble: String, site: Symbol)(using Context): Option[String] = site match {
+      case NoSymbol => None
+      case _        =>
+        val searchList =
+          if (site.flags.is(Flags.Module)) site :: site.info.baseClasses
+          else site.info.baseClasses
+
+        searchList collectFirst { case x if defs(x) contains vble => defs(x)(vble) } match {
+          case Some(str) if str startsWith "$" => lookupVariable(str.tail, site)
+          case res                             => res orElse lookupVariable(vble, site.owner)
+        }
+    }
+
+    /** The position of the raw doc comment of symbol `sym`, or NoPosition if missing
+     *  If a symbol does not have a doc comment but some overridden version of it does,
+     *  the position of the doc comment of the overridden version is returned instead.
+     */
+    def docCommentPos(sym: Symbol)(using Context): Span =
+      ctx.docCtx.flatMap(_.docstring(sym).map(_.span)).getOrElse(NoSpan)
+
+    /** A version which doesn't consider self types, as a temporary measure:
+     *  an infinite loop has broken out between superComment and cookedDocComment
+     *  since r23926.
+     */
+    private def allInheritedOverriddenSymbols(sym: Symbol)(using Context): List[Symbol] =
+      if (!sym.owner.isClass) Nil
+      else sym.allOverriddenSymbols.toList.filter(_ != NoSymbol) //TODO: could also be `sym.owner.allOverrid..`
+      //else sym.owner.ancestors map (sym overriddenSymbol _) filter (_ != NoSymbol)
+
+    class ExpansionLimitExceeded(str: String) extends Exception
+  }
+}
diff --git a/tests/pos-with-compiler-cc/dotc/core/Constants.scala b/tests/pos-with-compiler-cc/dotc/core/Constants.scala
new file mode 100644
index 000000000000..f45e9e5217de
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/core/Constants.scala
@@ -0,0 +1,261 @@
+package dotty.tools
+package dotc
+package core
+
+import Types._, Symbols._, Contexts._
+import printing.Printer
+import printing.Texts.Text
+
+object Constants {
+
+  inline val NoTag      = 0
+  inline val UnitTag    = 1
+  inline val BooleanTag = 2
+  inline val ByteTag    = 3
+  inline val ShortTag   = 4
+  inline val CharTag    = 5
+  inline val IntTag     = 6
+  inline val LongTag    = 7
+  inline val FloatTag   = 8
+  inline val DoubleTag  = 9
+  inline val StringTag  = 10
+  inline val NullTag    = 11
+  inline val ClazzTag   = 12
+
+  class Constant(val value: Any, val tag: Int) extends printing.Showable with Product1[Any] {
+    import java.lang.Double.doubleToRawLongBits
+    import java.lang.Float.floatToRawIntBits
+
+    def isByteRange: Boolean     = isIntRange && Byte.MinValue <= intValue && intValue <= Byte.MaxValue
+    def isShortRange: Boolean    = isIntRange && Short.MinValue <= intValue && intValue <= Short.MaxValue
+    def isCharRange: Boolean     = isIntRange && Char.MinValue <= intValue && intValue <= Char.MaxValue
+    def isIntRange: Boolean      = ByteTag <= tag && tag <= IntTag
+    def isLongRange: Boolean     = ByteTag <= tag && tag <= LongTag
+    def isFloatRange: Boolean    = ByteTag <= tag && tag <= FloatTag
+    def isNumeric: Boolean       = ByteTag <= tag && tag <= DoubleTag
+    def isNonUnitAnyVal: Boolean = BooleanTag <= tag && tag <= DoubleTag
+    def isAnyVal: Boolean        = UnitTag <= tag && tag <= DoubleTag
+
+    def tpe(using Context): Type = tag match {
+      case UnitTag        => defn.UnitType
+      case BooleanTag     => defn.BooleanType
+      case ByteTag        => defn.ByteType
+      case ShortTag       => defn.ShortType
+      case CharTag        => defn.CharType
+      case IntTag         => defn.IntType
+      case LongTag        => defn.LongType
+      case FloatTag       => defn.FloatType
+      case DoubleTag      => defn.DoubleType
+      case StringTag      => defn.StringType
+      case NullTag        => defn.NullType
+      case ClazzTag       => defn.ClassType(typeValue)
+    }
+
+    /** We need the equals method to take account of tags as well as values.
+     */
+    override def equals(other: Any): Boolean = other match {
+      case that: Constant =>
+        this.tag == that.tag && equalHashValue == that.equalHashValue
+      case _ => false
+    }
+
+    def isNaN: Boolean = value match {
+      case f: Float  => f.isNaN
+      case d: Double => d.isNaN
+      case _ => false
+    }
+
+    def booleanValue: Boolean =
+      if (tag == BooleanTag) value.asInstanceOf[Boolean]
+      else throw new Error("value " + value + " is not a boolean")
+
+    def byteValue: Byte = tag match {
+      case ByteTag   => value.asInstanceOf[Byte]
+      case ShortTag  => value.asInstanceOf[Short].toByte
+      case CharTag   => value.asInstanceOf[Char].toByte
+      case IntTag    => value.asInstanceOf[Int].toByte
+      case LongTag   => value.asInstanceOf[Long].toByte
+      case FloatTag  => value.asInstanceOf[Float].toByte
+      case DoubleTag => value.asInstanceOf[Double].toByte
+      case _         => throw new Error("value " + value + " is not a Byte")
+    }
+
+    def shortValue: Short = tag match {
+      case ByteTag   => value.asInstanceOf[Byte].toShort
+      case ShortTag  => value.asInstanceOf[Short]
+      case CharTag   => value.asInstanceOf[Char].toShort
+      case IntTag    => value.asInstanceOf[Int].toShort
+      case LongTag   => value.asInstanceOf[Long].toShort
+      case FloatTag  => value.asInstanceOf[Float].toShort
+      case DoubleTag => value.asInstanceOf[Double].toShort
+      case _         => throw new Error("value " + value + " is not a Short")
+    }
+
+    def charValue: Char = tag match {
+      case ByteTag   => value.asInstanceOf[Byte].toChar
+      case ShortTag  => value.asInstanceOf[Short].toChar
+      case CharTag   => value.asInstanceOf[Char]
+      case IntTag    => value.asInstanceOf[Int].toChar
+      case LongTag   => value.asInstanceOf[Long].toChar
+      case FloatTag  => value.asInstanceOf[Float].toChar
+      case DoubleTag => value.asInstanceOf[Double].toChar
+      case _         => throw new Error("value " + value + " is not a Char")
+    }
+
+    def intValue: Int = tag match {
+      case ByteTag   => value.asInstanceOf[Byte].toInt
+      case ShortTag  => value.asInstanceOf[Short].toInt
+      case CharTag   => value.asInstanceOf[Char].toInt
+      case IntTag    => value.asInstanceOf[Int]
+      case LongTag   => value.asInstanceOf[Long].toInt
+      case FloatTag  => value.asInstanceOf[Float].toInt
+      case DoubleTag => value.asInstanceOf[Double].toInt
+      case _         => throw new Error("value " + value + " is not an Int")
+    }
+
+    def longValue: Long = tag match {
+      case ByteTag   => value.asInstanceOf[Byte].toLong
+      case ShortTag  => value.asInstanceOf[Short].toLong
+      case CharTag   => value.asInstanceOf[Char].toLong
+      case IntTag    => value.asInstanceOf[Int].toLong
+      case LongTag   => value.asInstanceOf[Long]
+      case FloatTag  => value.asInstanceOf[Float].toLong
+      case DoubleTag => value.asInstanceOf[Double].toLong
+      case _         => throw new Error("value " + value + " is not a Long")
+    }
+
+    def floatValue: Float = tag match {
+      case ByteTag   => value.asInstanceOf[Byte].toFloat
+      case ShortTag  => value.asInstanceOf[Short].toFloat
+      case CharTag   => value.asInstanceOf[Char].toFloat
+      case IntTag    => value.asInstanceOf[Int].toFloat
+      case LongTag   => value.asInstanceOf[Long].toFloat
+      case FloatTag  => value.asInstanceOf[Float]
+      case DoubleTag => value.asInstanceOf[Double].toFloat
+      case _         => throw new Error("value " + value + " is not a Float")
+    }
+
+    def doubleValue: Double = tag match {
+      case ByteTag   => value.asInstanceOf[Byte].toDouble
+      case ShortTag  => value.asInstanceOf[Short].toDouble
+      case CharTag   => value.asInstanceOf[Char].toDouble
+      case IntTag    => value.asInstanceOf[Int].toDouble
+      case LongTag   => value.asInstanceOf[Long].toDouble
+      case FloatTag  => value.asInstanceOf[Float].toDouble
+      case DoubleTag => value.asInstanceOf[Double]
+      case _         => throw new Error("value " + value + " is not a Double")
+    }
+
+    /** Convert constant value to conform to given type.
+     */
+    def convertTo(pt: Type)(using Context): Constant | Null = {
+      def classBound(pt: Type): Type = pt.dealias.stripTypeVar match {
+        case tref: TypeRef if !tref.symbol.isClass && tref.info.exists =>
+          classBound(tref.info.bounds.lo)
+        case param: TypeParamRef =>
+          ctx.typerState.constraint.entry(param) match {
+            case TypeBounds(lo, hi) =>
+              if (hi.classSymbol.isPrimitiveValueClass) hi //constrain further with high bound
+              else classBound(lo)
+            case NoType => classBound(param.binder.paramInfos(param.paramNum).lo)
+            case inst => classBound(inst)
+          }
+        case pt => pt
+      }
+      pt match
+        case ConstantType(value) if value == this => this
+        case _: SingletonType => null
+        case _ =>
+          val target = classBound(pt).typeSymbol
+          if (target == tpe.typeSymbol)
+            this
+          else if ((target == defn.ByteClass) && isByteRange)
+            Constant(byteValue)
+          else if (target == defn.ShortClass && isShortRange)
+            Constant(shortValue)
+          else if (target == defn.CharClass && isCharRange)
+            Constant(charValue)
+          else if (target == defn.IntClass && isIntRange)
+            Constant(intValue)
+          else if (target == defn.LongClass && isLongRange)
+            Constant(longValue)
+          else if (target == defn.FloatClass && isFloatRange)
+            Constant(floatValue)
+          else if (target == defn.DoubleClass && isNumeric)
+            Constant(doubleValue)
+          else
+            null
+    }
+
+    def stringValue: String = value.toString
+
+    def toText(printer: Printer): Text = printer.toText(this)
+
+    def typeValue: Type     = value.asInstanceOf[Type]
+
+    /**
+     * Consider two `NaN`s to be identical, despite non-equality
+     * Consider -0d to be distinct from 0d, despite equality
+     *
+     * We use the raw versions (i.e. `floatToRawIntBits` rather than `floatToIntBits`)
+     * to avoid treating different encodings of `NaN` as the same constant.
+     * You probably can't express different `NaN` varieties as compile time
+     * constants in regular Scala code, but it is conceivable that you could
+     * conjure them with a macro.
+     */
+    private def equalHashValue: Any = value match {
+      case f: Float  => floatToRawIntBits(f)
+      case d: Double => doubleToRawLongBits(d)
+      case v         => v
+    }
+
+    override def hashCode: Int = {
+      import scala.util.hashing.MurmurHash3._
+      val seed = 17
+      var h = seed
+      h = mix(h, tag.##) // include tag in the hash, otherwise 0, 0d, 0L, 0f collide.
+      h = mix(h, equalHashValue.##)
+      finalizeHash(h, length = 2)
+    }
+
+    override def toString: String = s"Constant($value)"
+    def canEqual(x: Any): Boolean = true
+    def get: Any                  = value
+    def isEmpty: Boolean          = false
+    def _1: Any                   = value
+  }
+
+  object Constant {
+    def apply(x: Null): Constant         = new Constant(x, NullTag)
+    def apply(x: Unit): Constant         = new Constant(x, UnitTag)
+    def apply(x: Boolean): Constant      = new Constant(x, BooleanTag)
+    def apply(x: Byte): Constant         = new Constant(x, ByteTag)
+    def apply(x: Short): Constant        = new Constant(x, ShortTag)
+    def apply(x: Int): Constant          = new Constant(x, IntTag)
+    def apply(x: Long): Constant         = new Constant(x, LongTag)
+    def apply(x: Float): Constant        = new Constant(x, FloatTag)
+    def apply(x: Double): Constant       = new Constant(x, DoubleTag)
+    def apply(x: String): Constant       = new Constant(x, StringTag)
+    def apply(x: Char): Constant         = new Constant(x, CharTag)
+    def apply(x: Type): Constant         = new Constant(x, ClazzTag)
+    def apply(value: Any): Constant      =
+      new Constant(value,
+        value match {
+          case null            => NullTag
+          case x: Unit         => UnitTag
+          case x: Boolean      => BooleanTag
+          case x: Byte         => ByteTag
+          case x: Short        => ShortTag
+          case x: Int          => IntTag
+          case x: Long         => LongTag
+          case x: Float        => FloatTag
+          case x: Double       => DoubleTag
+          case x: String       => StringTag
+          case x: Char         => CharTag
+          case x: Type         => ClazzTag
+        }
+      )
+
+    def unapply(c: Constant): Constant = c
+  }
+}
diff --git a/tests/pos-with-compiler-cc/dotc/core/Constraint.scala b/tests/pos-with-compiler-cc/dotc/core/Constraint.scala
new file mode 100644
index 000000000000..07b6e71cdcc9
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/core/Constraint.scala
@@ -0,0 +1,196 @@
+package dotty.tools
+package dotc
+package core
+
+import Types._, Contexts._
+import printing.Showable
+
+/** Constraint over undetermined type parameters. Constraints are built
+ *  over values of the following types:
+ *
+ *   - TypeLambda    A constraint constrains the type parameters of a set of TypeLambdas
+ *   - TypeParamRef  The parameters of the constrained type lambdas
+ *   - TypeVar       Every constrained parameter might be associated with a TypeVar
+ *                   that has the TypeParamRef as origin.
+ */
+abstract class Constraint extends Showable {
+
+  type This <: Constraint
+
+  /** Does the constraint's domain contain the type parameters of `tl`? */
+  def contains(tl: TypeLambda): Boolean
+
+  /** Does the constraint's domain contain the type parameter `param`? */
+  def contains(param: TypeParamRef): Boolean
+
+  /** Does this constraint contain the type variable `tvar` and is it uninstantiated? */
+  def contains(tvar: TypeVar): Boolean
+
+  /** The constraint entry for given type parameter `param`, or NoType if `param` is not part of
+   *  the constraint domain. Note: Low level, implementation dependent.
+   */
+  def entry(param: TypeParamRef): Type
+
+  /** The type variable corresponding to parameter `param`, or
+   *  NoType, if `param` is not in constrained or is not paired with a type variable.
+   */
+  def typeVarOfParam(param: TypeParamRef): Type
+
+  /** Is it known that `param1 <:< param2`? */
+  def isLess(param1: TypeParamRef, param2: TypeParamRef): Boolean
+
+  /** The parameters that are known to be smaller wrt <: than `param` */
+  def lower(param: TypeParamRef): List[TypeParamRef]
+
+  /** The parameters that are known to be greater wrt <: than `param` */
+  def upper(param: TypeParamRef): List[TypeParamRef]
+
+  /** The lower dominator set.
+   *
+   * This is like `lower`, except that each parameter returned is no smaller than every other returned parameter.
+   */
+  def minLower(param: TypeParamRef): List[TypeParamRef]
+
+  /** The upper dominator set.
+   *
+   * This is like `upper`, except that each parameter returned is no greater than every other returned parameter.
+   */
+  def minUpper(param: TypeParamRef): List[TypeParamRef]
+
+  /** lower(param) \ lower(butNot) */
+  def exclusiveLower(param: TypeParamRef, butNot: TypeParamRef): List[TypeParamRef]
+
+  /** upper(param) \ upper(butNot) */
+  def exclusiveUpper(param: TypeParamRef, butNot: TypeParamRef): List[TypeParamRef]
+
+  /** The constraint bounds for given type parameter `param`.
+   *  Poly params that are known to be smaller or greater than `param`
+   *  are not contained in the return bounds.
+   *  @pre `param` is not part of the constraint domain.
+   */
+  def nonParamBounds(param: TypeParamRef)(using Context): TypeBounds
+
+  /** A new constraint which is derived from this constraint by adding
+   *  entries for all type parameters of `poly`.
+   *  @param tvars   A list of type variables associated with the params,
+   *                 or Nil if the constraint will just be checked for
+   *                 satisfiability but will solved to give instances of
+   *                 type variables.
+   */
+  def add(poly: TypeLambda, tvars: List[TypeVar])(using Context): This
+
+  /** A new constraint which is derived from this constraint by updating
+   *  the entry for parameter `param` to `tp`.
+   *  `tp` can be one of the following:
+   *
+   *   - A TypeBounds value, indicating new constraint bounds
+   *   - Another type, indicating a solution for the parameter
+   *
+   * @pre  `this contains param`.
+   */
+  def updateEntry(param: TypeParamRef, tp: Type)(using Context): This
+
+  /** A constraint that includes the relationship `p1 <: p2`.
+   *  `<:` relationships between parameters ("edges") are propagated, but
+   *  non-parameter bounds are left alone.
+   *
+   *  @param direction  Must be set to `KeepParam1` or `KeepParam2` when
+   *                    `p2 <: p1` is already true depending on which parameter
+   *                    the caller intends to keep. This will avoid propagating
+   *                    bounds that will be redundant after `p1` and `p2` are
+   *                    unified.
+   */
+  def addLess(p1: TypeParamRef, p2: TypeParamRef,
+    direction: UnificationDirection = UnificationDirection.NoUnification)(using Context): This
+
+  /** A new constraint which is derived from this constraint by removing
+   *  the type parameter `param` from the domain and replacing all top-level occurrences
+   *  of the parameter elsewhere in the constraint by type `tp`, or a conservative
+   *  approximation of it if that is needed to avoid cycles.
+   *  Occurrences nested inside a refinement or prefix are not affected.
+   */
+  def replace(param: TypeParamRef, tp: Type)(using Context): This
+
+  /** Is entry associated with `tl` removable? This is the case if
+   *  all type parameters of the entry are associated with type variables
+   *  which have their `inst` fields set.
+   */
+  def isRemovable(tl: TypeLambda): Boolean
+
+  /** A new constraint with all entries coming from `tl` removed. */
+  def remove(tl: TypeLambda)(using Context): This
+
+  /** A new constraint with entry `from` replaced with `to`
+   *  Rerences to `from` from within other constraint bounds are updated to `to`.
+   *  Type variables are left alone.
+   */
+  def subst(from: TypeLambda, to: TypeLambda)(using Context): This
+
+  /** Is `tv` marked as hard in the constraint? */
+  def isHard(tv: TypeVar): Boolean
+  
+  /** The same as this constraint, but with `tv` marked as hard. */
+  def withHard(tv: TypeVar)(using Context): This
+
+  /** Gives for each instantiated type var that does not yet have its `inst` field
+   *  set, the instance value stored in the constraint. Storing instances in constraints
+   *  is done only in a temporary way for contexts that may be retracted
+   *  without also retracting the type var as a whole.
+   */
+  def instType(tvar: TypeVar): Type
+
+  /** The given `tl` in case it is not contained in this constraint,
+   *  a fresh copy of `tl` otherwise.
+   */
+  def ensureFresh(tl: TypeLambda)(using Context): TypeLambda
+
+  /** The type lambdas constrained by this constraint */
+  def domainLambdas: List[TypeLambda]
+
+  /** The type lambda parameters constrained by this constraint */
+  def domainParams: List[TypeParamRef]
+
+  /** Check whether predicate holds for all parameters in constraint */
+  def forallParams(p: TypeParamRef => Boolean): Boolean
+
+  /** Perform operation `op` on all typevars that do not have their `inst` field set. */
+  def foreachTypeVar(op: TypeVar => Unit): Unit
+
+  /** The uninstantiated typevars of this constraint, which still have a bounds constraint
+   */
+  def uninstVars: collection.Seq[TypeVar]
+
+  /** Whether `tl` is present in both `this` and `that` but is associated with
+   *  different TypeVars there, meaning that the constraints cannot be merged.
+   */
+  def hasConflictingTypeVarsFor(tl: TypeLambda, that: Constraint): Boolean
+
+  /** Check that no constrained parameter contains itself as a bound */
+  def checkNonCyclic()(using Context): this.type
+
+  /** Does `param` occur at the toplevel in `tp` ?
+   *  Toplevel means: the type itself or a factor in some
+   *  combination of `&` or `|` types.
+   */
+  def occursAtToplevel(param: TypeParamRef, tp: Type)(using Context): Boolean
+
+  /** Check that constraint only refers to TypeParamRefs bound by itself */
+  def checkClosed()(using Context): Unit
+
+  /** Check that every typevar om this constraint has as origin a type parameter
+   *  of athe type lambda that is associated with the typevar itself.
+   */
+  def checkConsistentVars()(using Context): Unit
+}
+
+/** When calling `Constraint#addLess(p1, p2, ...)`, the caller might end up
+ *  unifying one parameter with the other, this enum lets `addLess` know which
+ *  direction the unification will take.
+ */
+enum UnificationDirection:
+  /** Neither p1 nor p2 will be instantiated. */
+  case NoUnification
+  /** `p2 := p1`, p1 left uninstantiated. */
+  case KeepParam1
+  /** `p1 := p2`, p2 left uninstantiated. */
+  case KeepParam2
diff --git a/tests/pos-with-compiler-cc/dotc/core/ConstraintHandling.scala b/tests/pos-with-compiler-cc/dotc/core/ConstraintHandling.scala
new file mode 100644
index 000000000000..a3d8cabba971
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/core/ConstraintHandling.scala
@@ -0,0 +1,879 @@
+package dotty.tools
+package dotc
+package core
+
+import Types._
+import Contexts._
+import Symbols._
+import Decorators._
+import Flags._
+import config.Config
+import config.Printers.typr
+import typer.ProtoTypes.{newTypeVar, representedParamRef}
+import UnificationDirection.*
+import NameKinds.AvoidNameKind
+import util.SimpleIdentitySet
+import NullOpsDecorator.stripNull
+
+/** Methods for adding constraints and solving them.
+ *
+ * What goes into a Constraint as opposed to a ConstrainHandler?
+ *
+ * Constraint code is purely functional: Operations get constraints and produce new ones.
+ * Constraint code does not have access to a type-comparer. Anything regarding lubs and glbs has to be done
+ * elsewhere.
+ *
+ * By comparison: Constraint handlers are parts of type comparers and can use their functionality.
+ * Constraint handlers update the current constraint as a side effect.
+ */
+trait ConstraintHandling {
+
+  def constr: config.Printers.Printer = config.Printers.constr
+
+  protected def isSub(tp1: Type, tp2: Type)(using Context): Boolean
+  protected def isSame(tp1: Type, tp2: Type)(using Context): Boolean
+
+  protected def constraint: Constraint
+  protected def constraint_=(c: Constraint): Unit
+
+  private var addConstraintInvocations = 0
+
+  /** If the constraint is frozen we cannot add new bounds to the constraint. */
+  protected var frozenConstraint: Boolean = false
+
+  /** Potentially a type lambda that is still instantiatable, even though the constraint
+   *  is generally frozen.
+   */
+  protected var caseLambda: Type = NoType
+
+  /** If set, align arguments `S1`, `S2`when taking the glb
+   *  `T1 { X = S1 } & T2 { X = S2 }` of a constraint upper bound for some type parameter.
+   *  Aligning means computing `S1 =:= S2` which may change the current constraint.
+   *  See note in TypeComparer#distributeAnd.
+   */
+  protected var homogenizeArgs: Boolean = false
+
+  /** We are currently comparing type lambdas. Used as a flag for
+   *  optimization: when `false`, no need to do an expensive `pruneLambdaParams`
+   */
+  protected var comparedTypeLambdas: Set[TypeLambda] = Set.empty
+
+  /** Used for match type reduction: If false, we don't recognize an abstract type
+   *  to be a subtype type of any of its base classes. This is in place only at the
+   *  toplevel; it is turned on again when we add parts of the scrutinee to the constraint.
+   */
+  protected var canWidenAbstract: Boolean = true
+
+  protected var myNecessaryConstraintsOnly = false
+  /** When collecting the constraints needed for a particular subtyping
+   *  judgment to be true, we sometimes need to approximate the constraint
+   *  set (see `TypeComparer#either` for example).
+   *
+   *  Normally, this means adding extra constraints which may not be necessary
+   *  for the subtyping judgment to be true, but if this variable is set to true
+   *  we will instead under-approximate and keep only the constraints that must
+   *  always be present for the subtyping judgment to hold.
+   *
+   *  This is needed for GADT bounds inference to be sound, but it is also used
+   *  when constraining a method call based on its expected type to avoid adding
+   *  constraints that would later prevent us from typechecking method
+   *  arguments, see or-inf.scala and and-inf.scala for examples.
+   */
+  protected def necessaryConstraintsOnly(using Context): Boolean =
+    ctx.mode.is(Mode.GadtConstraintInference) || myNecessaryConstraintsOnly
+
+  /** If `trustBounds = false` we perform comparisons in a pessimistic way as follows:
+   *  Given an abstract type `A >: L <: H`, a subtype comparison of any type
+   *  with `A` will compare against both `L` and `H`. E.g.
+   *
+   *     T <:< A   if T <:< L and T <:< H
+   *     A <:< T   if L <:< T and H <:< T
+   *
+   *  This restricted form makes sure we don't "forget"  types when forming
+   *  unions and intersections with abstract types that have bad bounds. E.g.
+   *  the following example from neg/i8900.scala that @smarter came up with:
+   *  We have a type variable X with constraints
+   *
+   *     X >: 1, X >: x.M
+   *
+   *  where `x` is a locally nested variable and `x.M` has bad bounds
+   *
+   *     x.M >: Int | String <: Int & String
+   *
+   *  If we trust bounds, then the lower bound of `X` is `x.M` since `x.M >: 1`.
+   *  Then even if we correct levels on instantiation to eliminate the local `x`,
+   *  it is alreay too late, we'd get `Int & String` as instance, which does not
+   *  satisfy the original constraint `X >: 1`.
+   *
+   *  But if `trustBounds` is false, we do not conclude the `x.M >: 1` since
+   *  we compare both bounds and the upper bound `Int & String` is not a supertype
+   *  of `1`. So the lower bound is `1 | x.M` and when we level-avoid that we
+   *  get `1 | Int & String`, which simplifies to `Int`.
+   */
+  private var myTrustBounds = true
+
+  inline def withUntrustedBounds(op: => Type): Type =
+    val saved = myTrustBounds
+    myTrustBounds = false
+    try op finally myTrustBounds = saved
+
+  def trustBounds: Boolean =
+    !Config.checkLevelsOnInstantiation || myTrustBounds
+
+  def checkReset() =
+    assert(addConstraintInvocations == 0)
+    assert(frozenConstraint == false)
+    assert(caseLambda == NoType)
+    assert(homogenizeArgs == false)
+    assert(comparedTypeLambdas == Set.empty)
+
+  def nestingLevel(param: TypeParamRef)(using Context) = constraint.typeVarOfParam(param) match
+    case tv: TypeVar => tv.nestingLevel
+    case _ =>
+      // This should only happen when reducing match types (in
+      // TrackingTypeComparer#matchCases) or in uncommitable TyperStates (as
+      // asserted in ProtoTypes.constrained) and is special-cased in `levelOK`
+      // below.
+      Int.MaxValue
+
+  /** Is `level` <= `maxLevel` or legal in the current context? */
+  def levelOK(level: Int, maxLevel: Int)(using Context): Boolean =
+    level <= maxLevel
+    || ctx.isAfterTyper || !ctx.typerState.isCommittable // Leaks in these cases shouldn't break soundness
+    || level == Int.MaxValue // See `nestingLevel` above.
+    || !Config.checkLevelsOnConstraints
+
+  /** If `param` is nested deeper than `maxLevel`, try to instantiate it to a
+   *  fresh type variable of level `maxLevel` and return the new variable.
+   *  If this isn't possible, throw a TypeError.
+   */
+  def atLevel(maxLevel: Int, param: TypeParamRef)(using Context): TypeParamRef =
+    if levelOK(nestingLevel(param), maxLevel) then
+      return param
+    LevelAvoidMap(0, maxLevel)(param) match
+      case freshVar: TypeVar => freshVar.origin
+      case _ => throw new TypeError(
+        i"Could not decrease the nesting level of ${param} from ${nestingLevel(param)} to $maxLevel in $constraint")
+
+  def nonParamBounds(param: TypeParamRef)(using Context): TypeBounds = constraint.nonParamBounds(param)
+
+  /** The full lower bound of `param` includes both the `nonParamBounds` and the
+   *  params in the constraint known to be `<: param`, except that
+   *  params with a `nestingLevel` higher than `param` will be instantiated
+   *  to a fresh param at a legal level. See the documentation of `TypeVar`
+   *  for details.
+   */
+  def fullLowerBound(param: TypeParamRef)(using Context): Type =
+    val maxLevel = nestingLevel(param)
+    var loParams = constraint.minLower(param)
+    if maxLevel != Int.MaxValue then
+      loParams = loParams.mapConserve(atLevel(maxLevel, _))
+    loParams.foldLeft(nonParamBounds(param).lo)(_ | _)
+
+  /** The full upper bound of `param`, see the documentation of `fullLowerBounds` above. */
+  def fullUpperBound(param: TypeParamRef)(using Context): Type =
+    val maxLevel = nestingLevel(param)
+    var hiParams = constraint.minUpper(param)
+    if maxLevel != Int.MaxValue then
+      hiParams = hiParams.mapConserve(atLevel(maxLevel, _))
+    hiParams.foldLeft(nonParamBounds(param).hi)(_ & _)
+
+  /** Full bounds of `param`, including other lower/upper params.
+    *
+    * Note that underlying operations perform subtype checks - for this reason, recursing on `fullBounds`
+    * of some param when comparing types might lead to infinite recursion. Consider `bounds` instead.
+    */
+  def fullBounds(param: TypeParamRef)(using Context): TypeBounds =
+    nonParamBounds(param).derivedTypeBounds(fullLowerBound(param), fullUpperBound(param))
+
+  /** An approximating map that prevents types nested deeper than maxLevel as
+   *  well as WildcardTypes from leaking into the constraint.
+   */
+  class LevelAvoidMap(topLevelVariance: Int, maxLevel: Int)(using Context) extends TypeOps.AvoidMap:
+    variance = topLevelVariance
+
+    def toAvoid(tp: NamedType): Boolean =
+      tp.prefix == NoPrefix && !tp.symbol.isStatic && !levelOK(tp.symbol.nestingLevel, maxLevel)
+
+    /** Return a (possibly fresh) type variable of a level no greater than `maxLevel` which is:
+     *  - lower-bounded by `tp` if variance >= 0
+     *  - upper-bounded by `tp` if variance <= 0
+     *  If this isn't possible, return the empty range.
+     */
+    def legalVar(tp: TypeVar): Type =
+      val oldParam = tp.origin
+      val nameKind =
+        if variance > 0 then AvoidNameKind.UpperBound
+        else if variance < 0 then AvoidNameKind.LowerBound
+        else AvoidNameKind.BothBounds
+
+      /** If it exists, return the first param in the list created in a previous call to `legalVar(tp)`
+       *  with the appropriate level and variance.
+       */
+      def findParam(params: List[TypeParamRef]): Option[TypeParamRef] =
+        params.find(p =>
+          nestingLevel(p) <= maxLevel && representedParamRef(p) == oldParam &&
+          (p.paramName.is(AvoidNameKind.BothBounds) ||
+           variance != 0 && p.paramName.is(nameKind)))
+
+      // First, check if we can reuse an existing parameter, this is more than an optimization
+      // since it avoids an infinite loop in tests/pos/i8900-cycle.scala
+      findParam(constraint.lower(oldParam)).orElse(findParam(constraint.upper(oldParam))) match
+        case Some(param) =>
+          constraint.typeVarOfParam(param)
+        case _ =>
+          // Otherwise, try to return a fresh type variable at `maxLevel` with
+          // the appropriate constraints.
+          val name = nameKind(oldParam.paramName.toTermName).toTypeName
+          val freshVar = newTypeVar(TypeBounds.upper(tp.topType), name,
+            nestingLevel = maxLevel, represents = oldParam)
+          val ok =
+            if variance < 0 then
+              addLess(freshVar.origin, oldParam)
+            else if variance > 0 then
+              addLess(oldParam, freshVar.origin)
+            else
+              unify(freshVar.origin, oldParam)
+          if ok then freshVar else emptyRange
+    end legalVar
+
+    override def apply(tp: Type): Type = tp match
+      case tp: TypeVar if !tp.isInstantiated && !levelOK(tp.nestingLevel, maxLevel) =>
+        legalVar(tp)
+      // TypeParamRef can occur in tl bounds
+      case tp: TypeParamRef =>
+        constraint.typeVarOfParam(tp) match
+          case tvar: TypeVar =>
+            apply(tvar)
+          case _ => super.apply(tp)
+      case _ =>
+        super.apply(tp)
+
+    override def mapWild(t: WildcardType) =
+      if ctx.mode.is(Mode.TypevarsMissContext) then super.mapWild(t)
+      else
+        val tvar = newTypeVar(apply(t.effectiveBounds).toBounds, nestingLevel = maxLevel)
+        tvar
+  end LevelAvoidMap
+
+  /** Approximate `rawBound` if needed to make it a legal bound of `param` by
+   *  avoiding wildcards and types with a level strictly greater than its
+   *  `nestingLevel`.
+   *
+   *  Note that level-checking must be performed here and cannot be delayed
+   *  until instantiation because if we allow level-incorrect bounds, then we
+   *  might end up reasoning with bad bounds outside of the scope where they are
+   *  defined. This can lead to level-correct but unsound instantiations as
+   *  demonstrated by tests/neg/i8900.scala.
+   */
+  protected def legalBound(param: TypeParamRef, rawBound: Type, isUpper: Boolean)(using Context): Type =
+    // Over-approximate for soundness.
+    var variance = if isUpper then -1 else 1
+    // ...unless we can only infer necessary constraints, in which case we
+    // flip the variance to under-approximate.
+    if necessaryConstraintsOnly then variance = -variance
+
+    val approx = new LevelAvoidMap(variance, nestingLevel(param)):
+      override def legalVar(tp: TypeVar): Type =
+        // `legalVar` will create a type variable whose bounds depend on
+        // `variance`, but whether the variance is positive or negative,
+        // we can still infer necessary constraints since just creating a
+        // type variable doesn't reduce the set of possible solutions.
+        // Therefore, we can safely "unflip" the variance flipped above.
+        // This is necessary for i8900-unflip.scala to typecheck.
+        val v = if necessaryConstraintsOnly then -this.variance else this.variance
+        atVariance(v)(super.legalVar(tp))
+    approx(rawBound)
+  end legalBound
+
+  protected def addOneBound(param: TypeParamRef, rawBound: Type, isUpper: Boolean)(using Context): Boolean =
+    if !constraint.contains(param) then true
+    else if !isUpper && param.occursIn(rawBound) then
+      // We don't allow recursive lower bounds when defining a type,
+      // so we shouldn't allow them as constraints either.
+      false
+    else
+      val bound = legalBound(param, rawBound, isUpper)
+      val oldBounds @ TypeBounds(lo, hi) = constraint.nonParamBounds(param)
+      val equalBounds = (if isUpper then lo else hi) eq bound
+      if equalBounds && !bound.existsPart(_ eq param, StopAt.Static) then
+        // The narrowed bounds are equal and not recursive,
+        // so we can remove `param` from the constraint.
+        constraint = constraint.replace(param, bound)
+        true
+      else
+        // Narrow one of the bounds of type parameter `param`
+        // If `isUpper` is true, ensure that `param <: `bound`, otherwise ensure
+        // that `param >: bound`.
+        val narrowedBounds =
+          val saved = homogenizeArgs
+          homogenizeArgs = Config.alignArgsInAnd
+          try
+            withUntrustedBounds(
+              if isUpper then oldBounds.derivedTypeBounds(lo, hi & bound)
+              else oldBounds.derivedTypeBounds(lo | bound, hi))
+          finally
+            homogenizeArgs = saved
+        //println(i"narrow bounds for $param from $oldBounds to $narrowedBounds")
+        val c1 = constraint.updateEntry(param, narrowedBounds)
+        (c1 eq constraint)
+        || {
+          constraint = c1
+          val TypeBounds(lo, hi) = constraint.entry(param): @unchecked
+          isSub(lo, hi)
+        }
+  end addOneBound
+
+  protected def addBoundTransitively(param: TypeParamRef, rawBound: Type, isUpper: Boolean)(using Context): Boolean =
+
+    /** Adjust the bound `tp` in the following ways:
+     *
+     *   1. Toplevel occurrences of TypeRefs that are instantiated in the current
+     *      constraint are also dereferenced.
+     *   2. Toplevel occurrences of ExprTypes lead to a `NoType` return, which
+     *      causes the addOneBound operation to fail.
+     *
+     *   An occurrence is toplevel if it is the bound itself, or a term in some
+     *   combination of `&` or `|` types.
+     */
+    def adjust(tp: Type): Type = tp match
+      case tp: AndOrType =>
+        val p1 = adjust(tp.tp1)
+        val p2 = adjust(tp.tp2)
+        if p1.exists && p2.exists then tp.derivedAndOrType(p1, p2) else NoType
+      case tp: TypeVar if constraint.contains(tp.origin) =>
+        adjust(tp.underlying)
+      case tp: ExprType =>
+        // ExprTypes are not value types, so type parameters should not
+        // be instantiated to ExprTypes. A scenario where such an attempted
+        // instantiation can happen is if we unify (=> T) => () with A => ()
+        // where A is a TypeParamRef. See the comment on EtaExpansion.etaExpand
+        // why types such as (=> T) => () can be constructed and i7969.scala
+        // as a test where this happens.
+        // Note that scalac by contrast allows such instantiations. But letting
+        // type variables be ExprTypes has its own problems (e.g. you can't write
+        // the resulting types down) and is largely unknown terrain.
+        NoType
+      case _ =>
+        tp
+
+    def description = i"constraint $param ${if isUpper then "<:" else ":>"} $rawBound to\n$constraint"
+    constr.println(i"adding $description$location")
+    if isUpper && rawBound.isRef(defn.NothingClass) && ctx.typerState.isGlobalCommittable then
+      def msg = i"!!! instantiated to Nothing: $param, constraint = $constraint"
+      if Config.failOnInstantiationToNothing
+      then assert(false, msg)
+      else report.log(msg)
+    def others = if isUpper then constraint.lower(param) else constraint.upper(param)
+    val bound = adjust(rawBound)
+    bound.exists
+    && addOneBound(param, bound, isUpper) && others.forall(addOneBound(_, bound, isUpper))
+        .showing(i"added $description = $result$location", constr)
+  end addBoundTransitively
+
+  protected def addLess(p1: TypeParamRef, p2: TypeParamRef)(using Context): Boolean = {
+    def description = i"ordering $p1 <: $p2 to\n$constraint"
+    val res =
+      if (constraint.isLess(p2, p1)) unify(p2, p1)
+      else {
+        val down1 = p1 :: constraint.exclusiveLower(p1, p2)
+        val up2 = p2 :: constraint.exclusiveUpper(p2, p1)
+        val lo1 = constraint.nonParamBounds(p1).lo
+        val hi2 = constraint.nonParamBounds(p2).hi
+        constr.println(i"adding $description down1 = $down1, up2 = $up2$location")
+        constraint = constraint.addLess(p1, p2)
+        down1.forall(addOneBound(_, hi2, isUpper = true)) &&
+        up2.forall(addOneBound(_, lo1, isUpper = false))
+      }
+    constr.println(i"added $description = $res$location")
+    res
+  }
+
+  def location(using Context) = "" // i"in ${ctx.typerState.stateChainStr}" // use for debugging
+
+  /** Unify p1 with p2: one parameter will be kept in the constraint, the
+   *  other will be removed and its bounds transferred to the remaining one.
+   *
+   *  If p1 and p2 have different `nestingLevel`, the parameter with the lowest
+   *  level will be kept and the transferred bounds from the other parameter
+   *  will be adjusted for level-correctness.
+   */
+  private def unify(p1: TypeParamRef, p2: TypeParamRef)(using Context): Boolean = {
+    constr.println(s"unifying $p1 $p2")
+    if !constraint.isLess(p1, p2) then
+      constraint = constraint.addLess(p1, p2)
+
+    val level1 = nestingLevel(p1)
+    val level2 = nestingLevel(p2)
+    val pKept    = if level1 <= level2 then p1 else p2
+    val pRemoved = if level1 <= level2 then p2 else p1
+
+    val down = constraint.exclusiveLower(p2, p1)
+    val up = constraint.exclusiveUpper(p1, p2)
+
+    constraint = constraint.addLess(p2, p1, direction = if pKept eq p1 then KeepParam2 else KeepParam1)
+
+    val boundKept    = constraint.nonParamBounds(pKept).substParam(pRemoved, pKept)
+    var boundRemoved = constraint.nonParamBounds(pRemoved).substParam(pRemoved, pKept)
+
+    if level1 != level2 then
+      boundRemoved = LevelAvoidMap(-1, math.min(level1, level2))(boundRemoved)
+      val TypeBounds(lo, hi) = boundRemoved: @unchecked
+      // After avoidance, the interval might be empty, e.g. in
+      // tests/pos/i8900-promote.scala:
+      //     >: x.type <: Singleton
+      // becomes:
+      //     >: Int <: Singleton
+      // In that case, we can still get a legal constraint
+      // by replacing the lower-bound to get:
+      //     >: Int & Singleton <: Singleton
+      if !isSub(lo, hi) then
+        boundRemoved = TypeBounds(lo & hi, hi)
+
+    val newBounds = (boundKept & boundRemoved).bounds
+    constraint = constraint.updateEntry(pKept, newBounds).replace(pRemoved, pKept)
+
+    val lo = newBounds.lo
+    val hi = newBounds.hi
+    isSub(lo, hi) &&
+    down.forall(addOneBound(_, hi, isUpper = true)) &&
+    up.forall(addOneBound(_, lo, isUpper = false))
+  }
+
+  protected def isSubType(tp1: Type, tp2: Type, whenFrozen: Boolean)(using Context): Boolean =
+    if (whenFrozen)
+      isSubTypeWhenFrozen(tp1, tp2)
+    else
+      isSub(tp1, tp2)
+
+  inline final def inFrozenConstraint[T](op: => T): T = {
+    val savedFrozen = frozenConstraint
+    val savedLambda = caseLambda
+    frozenConstraint = true
+    caseLambda = NoType
+    try op
+    finally {
+      frozenConstraint = savedFrozen
+      caseLambda = savedLambda
+    }
+  }
+
+  final def isSubTypeWhenFrozen(tp1: Type, tp2: Type)(using Context): Boolean = inFrozenConstraint(isSub(tp1, tp2))
+  final def isSameTypeWhenFrozen(tp1: Type, tp2: Type)(using Context): Boolean = inFrozenConstraint(isSame(tp1, tp2))
+
+  /** Test whether the lower bounds of all parameters in this
+   *  constraint are a solution to the constraint.
+   */
+  protected final def isSatisfiable(using Context): Boolean =
+    constraint.forallParams { param =>
+      val TypeBounds(lo, hi) = constraint.entry(param): @unchecked
+      isSub(lo, hi) || {
+        report.log(i"sub fail $lo <:< $hi")
+        false
+      }
+    }
+
+  /** Fix instance type `tp` by avoidance  so that it does not contain references
+   *  to types at level > `maxLevel`.
+   *  @param tp         the type to be fixed
+   *  @param fromBelow  whether type was obtained from lower bound
+   *  @param maxLevel   the maximum level of references allowed
+   *  @param param      the parameter that was instantiated
+   */
+  private def fixLevels(tp: Type, fromBelow: Boolean, maxLevel: Int, param: TypeParamRef)(using Context) =
+
+    def needsFix(tp: NamedType) =
+      (tp.prefix eq NoPrefix) && tp.symbol.nestingLevel > maxLevel
+
+    /** An accumulator that determines whether levels need to be fixed
+     *  and computes on the side sets of nested type variables that need
+     *  to be instantiated.
+     */
+    def needsLeveling = new TypeAccumulator[Boolean]:
+      if !fromBelow then variance = -1
+
+      def apply(need: Boolean, tp: Type) =
+        need || tp.match
+          case tp: NamedType =>
+            needsFix(tp)
+            || !stopBecauseStaticOrLocal(tp) && apply(need, tp.prefix)
+          case tp: TypeVar =>
+            val inst = tp.instanceOpt
+            if inst.exists then apply(need, inst)
+            else if tp.nestingLevel > maxLevel then
+              // Change the nesting level of inner type variable to `maxLevel`.
+              // This means that the type variable will be instantiated later to a
+              // less nested type. If there are other references to the same type variable
+              // that do not come from the type undergoing `fixLevels`, this could lead
+              // to coarser types than intended. An alternative is to instantiate the
+              // type variable right away, but this also loses information. See
+              // i15934.scala for a test where the current strategey works but an early instantiation
+              // of `tp` would fail.
+              constr.println(i"widening nesting level of type variable $tp from ${tp.nestingLevel} to $maxLevel")
+              ctx.typerState.setNestingLevel(tp, maxLevel)
+              true
+            else false
+          case _ =>
+            foldOver(need, tp)
+    end needsLeveling
+
+    def levelAvoid = new TypeOps.AvoidMap:
+      if !fromBelow then variance = -1
+      def toAvoid(tp: NamedType) = needsFix(tp)
+
+    if Config.checkLevelsOnInstantiation && !ctx.isAfterTyper && needsLeveling(false, tp) then
+      typr.println(i"instance $tp for $param needs leveling to $maxLevel")
+      levelAvoid(tp)
+    else tp
+  end fixLevels
+
+  /** Solve constraint set for given type parameter `param`.
+   *  If `fromBelow` is true the parameter is approximated by its lower bound,
+   *  otherwise it is approximated by its upper bound, unless the upper bound
+   *  contains a reference to the parameter itself (such occurrences can arise
+   *  for F-bounded types, `addOneBound` ensures that they never occur in the
+   *  lower bound).
+   *  The solved type is not allowed to contain references to types nested deeper
+   *  than `maxLevel`.
+   *  Wildcard types in bounds are approximated by their upper or lower bounds.
+   *  The constraint is left unchanged.
+   *  @return the instantiating type
+   *  @pre `param` is in the constraint's domain.
+   */
+  final def approximation(param: TypeParamRef, fromBelow: Boolean, maxLevel: Int)(using Context): Type =
+    constraint.entry(param) match
+      case entry: TypeBounds =>
+        val useLowerBound = fromBelow || param.occursIn(entry.hi)
+        val rawInst = withUntrustedBounds(
+          if useLowerBound then fullLowerBound(param) else fullUpperBound(param))
+        val levelInst = fixLevels(rawInst, fromBelow, maxLevel, param)
+        if levelInst ne rawInst then
+          typr.println(i"level avoid for $maxLevel: $rawInst --> $levelInst")
+        typr.println(i"approx $param, from below = $fromBelow, inst = $levelInst")
+        levelInst
+      case inst =>
+        assert(inst.exists, i"param = $param\nconstraint = $constraint")
+        inst
+  end approximation
+
+  /** If `tp` is an intersection such that some operands are transparent trait instances
+   *  and others are not, replace as many transparent trait instances as possible with Any
+   *  as long as the result is still a subtype of `bound`. But fall back to the
+   *  original type if the resulting widened type is a supertype of all dropped
+   *  types (since in this case the type was not a true intersection of transparent traits
+   *  and other types to start with).
+   */
+  def dropTransparentTraits(tp: Type, bound: Type)(using Context): Type =
+    var kept: Set[Type] = Set()      // types to keep since otherwise bound would not fit
+    var dropped: List[Type] = List() // the types dropped so far, last one on top
+
+    def dropOneTransparentTrait(tp: Type): Type =
+      val tpd = tp.dealias
+      if tpd.typeSymbol.isTransparentTrait && !tpd.isLambdaSub && !kept.contains(tpd) then
+        dropped = tpd :: dropped
+        defn.AnyType
+      else tpd match
+        case AndType(tp1, tp2) =>
+          val tp1w = dropOneTransparentTrait(tp1)
+          if tp1w ne tp1 then tp1w & tp2
+          else
+            val tp2w = dropOneTransparentTrait(tp2)
+            if tp2w ne tp2 then tp1 & tp2w
+            else tpd
+        case _ =>
+          tp
+
+    def recur(tp: Type): Type =
+      val tpw = dropOneTransparentTrait(tp)
+      if tpw eq tp then tp
+      else if tpw <:< bound then recur(tpw)
+      else
+        kept += dropped.head
+        dropped = dropped.tail
+        recur(tp)
+
+    val saved = ctx.typerState.snapshot()
+    val tpw = recur(tp)
+    if (tpw eq tp) || dropped.forall(_ frozen_<:< tpw) then
+      // Rollback any constraint change that would lead to `tp` no longer
+      // being a valid solution.
+      ctx.typerState.resetTo(saved)
+      tp
+    else
+      tpw
+  end dropTransparentTraits
+
+  /** If `tp` is an applied match type alias which is also an unreducible application
+   *  of a higher-kinded type to a wildcard argument, widen to the match type's bound,
+   *  in order to avoid an unreducible application of higher-kinded type ... in inferred type"
+   *  error in PostTyper. Fixes #11246.
+   */
+  def widenIrreducible(tp: Type)(using Context): Type = tp match
+    case tp @ AppliedType(tycon, _) if tycon.isLambdaSub && tp.hasWildcardArg =>
+      tp.superType match
+        case MatchType(bound, _, _) => bound
+        case _ => tp
+    case _ =>
+      tp
+
+  /** Widen inferred type `inst` with upper `bound`, according to the following rules:
+   *   1. If `inst` is a singleton type, or a union containing some singleton types,
+   *      widen (all) the singleton type(s), provided the result is a subtype of `bound`.
+   *      (i.e. `inst.widenSingletons <:< bound` succeeds with satisfiable constraint)
+   *   2a. If `inst` is a union type and `widenUnions` is true, approximate the union type
+   *      from above by an intersection of all common base types, provided the result
+   *      is a subtype of `bound`.
+   *   2b. If `inst` is a union type and `widenUnions` is false, turn it into a hard
+   *      union type (except for unions | Null, which are kept in the state they were).
+   *   3. Widen some irreducible applications of higher-kinded types to wildcard arguments
+   *      (see @widenIrreducible).
+   *   4. Drop transparent traits from intersections (see @dropTransparentTraits).
+   *
+   *  Don't do these widenings if `bound` is a subtype of `scala.Singleton`.
+   *  Also, if the result of these widenings is a TypeRef to a module class,
+   *  and this type ref is different from `inst`, replace by a TermRef to
+   *  its source module instead.
+   *
+   * At this point we also drop the @Repeated annotation to avoid inferring type arguments with it,
+   * as those could leak the annotation to users (see run/inferred-repeated-result).
+   */
+  def widenInferred(inst: Type, bound: Type, widenUnions: Boolean)(using Context): Type =
+    def widenOr(tp: Type) =
+      if widenUnions then
+        val tpw = tp.widenUnion
+        if (tpw ne tp) && (tpw <:< bound) then tpw else tp
+      else tp.hardenUnions
+
+    def widenSingle(tp: Type) =
+      val tpw = tp.widenSingletons
+      if (tpw ne tp) && (tpw <:< bound) then tpw else tp
+
+    def isSingleton(tp: Type): Boolean = tp match
+      case WildcardType(optBounds) => optBounds.exists && isSingleton(optBounds.bounds.hi)
+      case _ => isSubTypeWhenFrozen(tp, defn.SingletonType)
+
+    val wideInst =
+      if isSingleton(bound) then inst
+      else dropTransparentTraits(widenIrreducible(widenOr(widenSingle(inst))), bound)
+    wideInst match
+      case wideInst: TypeRef if wideInst.symbol.is(Module) =>
+        TermRef(wideInst.prefix, wideInst.symbol.sourceModule)
+      case _ =>
+        wideInst.dropRepeatedAnnot
+  end widenInferred
+
+  /** Convert all toplevel union types in `tp` to hard unions */
+  extension (tp: Type) private def hardenUnions(using Context): Type = tp.widen match
+    case tp: AndType =>
+      tp.derivedAndType(tp.tp1.hardenUnions, tp.tp2.hardenUnions)
+    case tp: RefinedType =>
+      tp.derivedRefinedType(tp.parent.hardenUnions, tp.refinedName, tp.refinedInfo)
+    case tp: RecType =>
+      tp.rebind(tp.parent.hardenUnions)
+    case tp: HKTypeLambda =>
+      tp.derivedLambdaType(resType = tp.resType.hardenUnions)
+    case tp: OrType =>
+      val tp1 = tp.stripNull
+      if tp1 ne tp then tp.derivedOrType(tp1.hardenUnions, defn.NullType)
+      else tp.derivedOrType(tp.tp1.hardenUnions, tp.tp2.hardenUnions, soft = false)
+    case _ =>
+      tp
+
+  /** The instance type of `param` in the current constraint (which contains `param`).
+   *  If `fromBelow` is true, the instance type is the lub of the parameter's
+   *  lower bounds; otherwise it is the glb of its upper bounds. However,
+   *  a lower bound instantiation can be a singleton type only if the upper bound
+   *  is also a singleton type.
+   *  The instance type is not allowed to contain references to types nested deeper
+   *  than `maxLevel`.
+   */
+  def instanceType(param: TypeParamRef, fromBelow: Boolean, widenUnions: Boolean, maxLevel: Int)(using Context): Type = {
+    val approx = approximation(param, fromBelow, maxLevel).simplified
+    if fromBelow then
+      val widened = widenInferred(approx, param, widenUnions)
+      // Widening can add extra constraints, in particular the widened type might
+      // be a type variable which is now instantiated to `param`, and therefore
+      // cannot be used as an instantiation of `param` without creating a loop.
+      // If that happens, we run `instanceType` again to find a new instantation.
+      // (we do not check for non-toplevel occurences: those should never occur
+      // since `addOneBound` disallows recursive lower bounds).
+      if constraint.occursAtToplevel(param, widened) then
+        instanceType(param, fromBelow, widenUnions, maxLevel)
+      else
+        widened
+    else
+      approx
+  }
+
+  /** Constraint `c1` subsumes constraint `c2`, if under `c2` as constraint we have
+   *  for all poly params `p` defined in `c2` as `p >: L2 <: U2`:
+   *
+   *     c1 defines p with bounds p >: L1 <: U1, and
+   *     L2 <: L1, and
+   *     U1 <: U2
+   *
+   *  Both `c1` and `c2` are required to derive from constraint `pre`, without adding
+   *  any new type variables but possibly narrowing already registered ones with further bounds.
+   */
+  protected final def subsumes(c1: Constraint, c2: Constraint, pre: Constraint)(using Context): Boolean =
+    if (c2 eq pre) true
+    else if (c1 eq pre) false
+    else {
+      val saved = constraint
+      try
+        // We iterate over params of `pre`, instead of `c2` as the documentation may suggest.
+        // As neither `c1` nor `c2` can have more params than `pre`, this only matters in one edge case.
+        // Constraint#forallParams only iterates over params that can be directly constrained.
+        // If `c2` has, compared to `pre`, instantiated a param and we iterated over params of `c2`,
+        // we could miss that param being instantiated to an incompatible type in `c1`.
+        pre.forallParams(p =>
+          c1.entry(p).exists
+          && c2.upper(p).forall(c1.isLess(p, _))
+          && isSubTypeWhenFrozen(c1.nonParamBounds(p), c2.nonParamBounds(p))
+        )
+      finally constraint = saved
+    }
+
+  /** The current bounds of type parameter `param` */
+  def bounds(param: TypeParamRef)(using Context): TypeBounds = {
+    val e = constraint.entry(param)
+    if (e.exists) e.bounds
+    else {
+      // TODO: should we change the type of paramInfos to nullable?
+      val pinfos: List[param.binder.PInfo] | Null = param.binder.paramInfos
+      if (pinfos != null) pinfos(param.paramNum) // pinfos == null happens in pos/i536.scala
+      else TypeBounds.empty
+    }
+  }
+
+  /** Add type lambda `tl`, possibly with type variables `tvars`, to current constraint
+   *  and propagate all bounds.
+   *  @param tvars   See Constraint#add
+   */
+  def addToConstraint(tl: TypeLambda, tvars: List[TypeVar])(using Context): Boolean =
+    checkPropagated(i"initialized $tl") {
+      constraint = constraint.add(tl, tvars)
+      tl.paramRefs.forall { param =>
+        val lower = constraint.lower(param)
+        val upper = constraint.upper(param)
+        constraint.entry(param) match {
+          case bounds: TypeBounds =>
+            if lower.nonEmpty && !bounds.lo.isRef(defn.NothingClass)
+               || upper.nonEmpty && !bounds.hi.isAny
+            then constr.println(i"INIT*** $tl")
+            lower.forall(addOneBound(_, bounds.hi, isUpper = true)) &&
+              upper.forall(addOneBound(_, bounds.lo, isUpper = false))
+          case x =>
+            // Happens if param was already solved while processing earlier params of the same TypeLambda.
+            // See #4720.
+            true
+        }
+      }
+    }
+
+  /** Can `param` be constrained with new bounds? */
+  final def canConstrain(param: TypeParamRef): Boolean =
+    (!frozenConstraint || (caseLambda `eq` param.binder)) && constraint.contains(param)
+
+  /** Is `param` assumed to be a sub- and super-type of any other type?
+   *  This holds if `TypeVarsMissContext` is set unless `param` is a part
+   *  of a MatchType that is currently normalized.
+   */
+  final def assumedTrue(param: TypeParamRef)(using Context): Boolean =
+    ctx.mode.is(Mode.TypevarsMissContext) && (caseLambda `ne` param.binder)
+
+  /** Add constraint `param <: bound` if `fromBelow` is false, `param >: bound` otherwise.
+   *  `bound` is assumed to be in normalized form, as specified in `firstTry` and
+   *  `secondTry` of `TypeComparer`. In particular, it should not be an alias type,
+   *  lazy ref, typevar, wildcard type, error type. In addition, upper bounds may
+   *  not be AndTypes and lower bounds may not be OrTypes. This is assured by the
+   *  way isSubType is organized.
+   */
+  protected def addConstraint(param: TypeParamRef, bound: Type, fromBelow: Boolean)(using Context): Boolean =
+    if !bound.isValueTypeOrLambda then return false
+
+    /** When comparing lambdas we might get constraints such as
+     *  `A <: X0` or `A = List[X0]` where `A` is a constrained parameter
+     *  and `X0` is a lambda parameter. The constraint for `A` is not allowed
+     *  to refer to such a lambda parameter because the lambda parameter is
+     *  not visible where `A` is defined. Consequently, we need to
+     *  approximate the bound so that the lambda parameter does not appear in it.
+     *  If `tp` is an upper bound, we need to approximate with something smaller,
+     *  otherwise something larger.
+     *  Test case in pos/i94-nada.scala. This test crashes with an illegal instance
+     *  error in Test2 when the rest of the SI-2712 fix is applied but `pruneLambdaParams` is
+     *  missing.
+     */
+    def avoidLambdaParams(tp: Type) =
+      if comparedTypeLambdas.nonEmpty then
+        val approx = new ApproximatingTypeMap {
+          if (!fromBelow) variance = -1
+          def apply(t: Type): Type = t match {
+            case t @ TypeParamRef(tl: TypeLambda, n) if comparedTypeLambdas contains tl =>
+              val bounds = tl.paramInfos(n)
+              range(bounds.lo, bounds.hi)
+            case tl: TypeLambda =>
+              val saved = comparedTypeLambdas
+              comparedTypeLambdas -= tl
+              try mapOver(tl)
+              finally comparedTypeLambdas = saved
+            case _ =>
+              mapOver(t)
+          }
+        }
+        approx(tp)
+      else tp
+
+    def addParamBound(bound: TypeParamRef) =
+      constraint.entry(param) match {
+        case _: TypeBounds =>
+          if (fromBelow) addLess(bound, param) else addLess(param, bound)
+        case tp =>
+          if (fromBelow) isSub(bound, tp) else isSub(tp, bound)
+      }
+
+    def kindCompatible(tp1: Type, tp2: Type): Boolean =
+      val tparams1 = tp1.typeParams
+      val tparams2 = tp2.typeParams
+      tparams1.corresponds(tparams2)((p1, p2) => kindCompatible(p1.paramInfo, p2.paramInfo))
+      && (tparams1.isEmpty || kindCompatible(tp1.hkResult, tp2.hkResult))
+      || tp1.hasAnyKind
+      || tp2.hasAnyKind
+
+    def description = i"constr $param ${if (fromBelow) ">:" else "<:"} $bound:\n$constraint"
+
+    //checkPropagated(s"adding $description")(true) // DEBUG in case following fails
+    checkPropagated(s"added $description") {
+      addConstraintInvocations += 1
+      val saved = canWidenAbstract
+      canWidenAbstract = true
+      try bound match
+        case bound: TypeParamRef if constraint contains bound =>
+          addParamBound(bound)
+        case _ =>
+          val pbound = avoidLambdaParams(bound)
+          kindCompatible(param, pbound) && addBoundTransitively(param, pbound, !fromBelow)
+      finally
+        canWidenAbstract = saved
+        addConstraintInvocations -= 1
+    }
+  end addConstraint
+
+  /** Check that constraint is fully propagated. See comment in Config.checkConstraintsPropagated */
+  def checkPropagated(msg: => String)(result: Boolean)(using Context): Boolean = {
+    if (Config.checkConstraintsPropagated && result && addConstraintInvocations == 0)
+      inFrozenConstraint {
+        for (p <- constraint.domainParams) {
+          def check(cond: => Boolean, q: TypeParamRef, ordering: String, explanation: String): Unit =
+            assert(cond, i"propagation failure for $p $ordering $q: $explanation\n$msg")
+          for (u <- constraint.upper(p))
+            check(bounds(p).hi <:< bounds(u).hi, u, "<:", "upper bound not propagated")
+          for (l <- constraint.lower(p)) {
+            check(bounds(l).lo <:< bounds(p).hi, l, ">:", "lower bound not propagated")
+            check(constraint.isLess(l, p), l, ">:", "reverse ordering (<:) missing")
+          }
+        }
+      }
+    result
+  }
+}
diff --git a/tests/pos-with-compiler-cc/dotc/core/ConstraintRunInfo.scala b/tests/pos-with-compiler-cc/dotc/core/ConstraintRunInfo.scala
new file mode 100644
index 000000000000..d2b1246a8149
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/core/ConstraintRunInfo.scala
@@ -0,0 +1,23 @@
+package dotty.tools.dotc
+package core
+
+import Contexts._
+import config.Printers.{default, typr}
+
+trait ConstraintRunInfo { self: Run =>
+  private var maxSize = 0
+  private var maxConstraint: Constraint | Null = _
+  def recordConstraintSize(c: Constraint, size: Int): Unit =
+    if (size > maxSize) {
+      maxSize = size
+      maxConstraint = c
+    }
+  def printMaxConstraint()(using Context): Unit =
+    if maxSize > 0 then
+      val printer = if ctx.settings.YdetailedStats.value then default else typr
+      printer.println(s"max constraint size: $maxSize")
+      try printer.println(s"max constraint = ${maxConstraint.nn.show}")
+      catch case ex: StackOverflowError => printer.println("max constraint cannot be printed due to stack overflow")
+
+  protected def reset(): Unit = maxConstraint = null
+}
diff --git a/tests/pos-with-compiler-cc/dotc/core/ContextOps.scala b/tests/pos-with-compiler-cc/dotc/core/ContextOps.scala
new file mode 100644
index 000000000000..aa85f714a8e5
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/core/ContextOps.scala
@@ -0,0 +1,113 @@
+package dotty.tools.dotc
+package core
+
+import Contexts._, Symbols._, Types._, Flags._
+import Denotations._, SymDenotations._
+import Names.Name, StdNames.nme
+import ast.untpd
+
+/** Extension methods for contexts where we want to keep the ctx.<methodName> syntax */
+object ContextOps:
+
+  extension (ctx: Context)
+
+    /** Enter symbol into current class, if current class is owner of current context,
+    *  or into current scope, if not. Should always be called instead of scope.enter
+    *  in order to make sure that updates to class members are reflected in
+    *  finger prints.
+    */
+    def enter(sym: Symbol): Symbol = inContext(ctx) {
+      ctx.owner match
+        case cls: ClassSymbol => cls.classDenot.enter(sym)
+        case _ => ctx.scope.openForMutations.enter(sym)
+      sym
+    }
+
+    /** The denotation with the given `name` and all `required` flags in current context
+     */
+    def denotNamed(name: Name, required: FlagSet = EmptyFlags, excluded: FlagSet = EmptyFlags): Denotation =
+      inContext(ctx) {
+        if (ctx.owner.isClass)
+          if (ctx.outer.owner == ctx.owner) { // inner class scope; check whether we are referring to self
+            if (ctx.scope.size == 1) {
+              val elem = ctx.scope.lastEntry.nn
+              if (elem.name == name) return elem.sym.denot // return self
+            }
+            val pre = ctx.owner.thisType
+            if ctx.isJava then javaFindMember(name, pre, required, excluded)
+            else pre.findMember(name, pre, required, excluded)
+          }
+          else // we are in the outermost context belonging to a class; self is invisible here. See inClassContext.
+            ctx.owner.findMember(name, ctx.owner.thisType, required, excluded)
+        else
+          ctx.scope.denotsNamed(name).filterWithFlags(required, excluded).toDenot(NoPrefix)
+      }
+
+    final def javaFindMember(name: Name, pre: Type, required: FlagSet = EmptyFlags, excluded: FlagSet = EmptyFlags): Denotation =
+      assert(ctx.isJava)
+      inContext(ctx) {
+
+        val preSym = pre.typeSymbol
+
+        // 1. Try to search in current type and parents.
+        val directSearch = pre.findMember(name, pre, required, excluded)
+
+        // 2. Try to search in companion class if current is an object.
+        def searchCompanionClass = if preSym.is(Flags.Module) then
+          preSym.companionClass.thisType.findMember(name, pre, required, excluded)
+          else NoDenotation
+
+        // 3. Try to search in companion objects of super classes.
+        // In Java code, static inner classes, which we model as members of the companion object,
+        // can be referenced from an ident in a subclass or by a selection prefixed by the subclass.
+        def searchSuperCompanionObjects =
+          val toSearch = if preSym.is(Flags.Module) then
+            if preSym.companionClass.exists then
+              preSym.companionClass.asClass.baseClasses
+            else Nil
+          else
+            preSym.asClass.baseClasses
+
+          toSearch.iterator.map { bc =>
+            val pre1 = bc.companionModule.namedType
+            pre1.findMember(name, pre1, required, excluded)
+          }.find(_.exists).getOrElse(NoDenotation)
+
+        if preSym.isClass then
+          directSearch orElse searchCompanionClass orElse searchSuperCompanionObjects
+        else
+          directSearch
+      }
+
+    /** A fresh local context with given tree and owner.
+    *  Owner might not exist (can happen for self valdefs), in which case
+    *  no owner is set in result context
+    */
+    def localContext(tree: untpd.Tree, owner: Symbol): FreshContext = inContext(ctx) {
+      val freshCtx = ctx.fresh.setTree(tree)
+      if owner.exists then freshCtx.setOwner(owner) else freshCtx
+    }
+
+    /** Context where `sym` is defined, assuming we are in a nested context. */
+    def defContext(sym: Symbol): Context = inContext(ctx) {
+      ctx.outersIterator
+        .dropWhile(_.owner != sym)
+        .dropWhile(_.owner == sym)
+        .next()
+    }
+
+    /** A new context for the interior of a class */
+    def inClassContext(selfInfo: TypeOrSymbol): Context = inContext(ctx) {
+      val localCtx: Context = ctx.fresh.setNewScope
+      selfInfo match {
+        case sym: Symbol if sym.exists && sym.name != nme.WILDCARD => localCtx.scope.openForMutations.enter(sym)
+        case _ =>
+      }
+      localCtx
+    }
+
+    def packageContext(tree: untpd.PackageDef, pkg: Symbol): Context = inContext(ctx) {
+      if (pkg.is(Package)) ctx.fresh.setOwner(pkg.moduleClass).setTree(tree)
+      else ctx
+    }
+end ContextOps
diff --git a/tests/pos-with-compiler-cc/dotc/core/Contexts.scala b/tests/pos-with-compiler-cc/dotc/core/Contexts.scala
new file mode 100644
index 000000000000..68620c6d3fe7
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/core/Contexts.scala
@@ -0,0 +1,1000 @@
+package dotty.tools
+package dotc
+package core
+
+import interfaces.CompilerCallback
+import Decorators._
+import Periods._
+import Names._
+import Phases._
+import Types._
+import Symbols._
+import Scopes._
+import Uniques._
+import ast.Trees._
+import ast.untpd
+import util.{NoSource, SimpleIdentityMap, SourceFile, HashSet, ReusableInstance}
+import typer.{Implicits, ImportInfo, SearchHistory, SearchRoot, TypeAssigner, Typer, Nullables}
+import inlines.Inliner
+import Nullables._
+import Implicits.ContextualImplicits
+import config.Settings._
+import config.Config
+import reporting._
+import io.{AbstractFile, NoAbstractFile, PlainFile, Path}
+import scala.io.Codec
+import collection.mutable
+import printing._
+import config.{JavaPlatform, SJSPlatform, Platform, ScalaSettings}
+import classfile.ReusableDataReader
+import StdNames.nme
+
+import scala.annotation.internal.sharable
+
+import DenotTransformers.DenotTransformer
+import dotty.tools.dotc.profile.Profiler
+import util.Property.Key
+import util.Store
+import xsbti.AnalysisCallback
+import plugins._
+import java.util.concurrent.atomic.AtomicInteger
+import java.nio.file.InvalidPathException
+import language.experimental.pureFunctions
+
+object Contexts {
+
+  private val (compilerCallbackLoc, store1) = Store.empty.newLocation[CompilerCallback]()
+  private val (sbtCallbackLoc,      store2) = store1.newLocation[AnalysisCallback]()
+  private val (printerFnLoc,        store3) = store2.newLocation[Context -> Printer](new RefinedPrinter(_))
+  private val (settingsStateLoc,    store4) = store3.newLocation[SettingsState]()
+  private val (compilationUnitLoc,  store5) = store4.newLocation[CompilationUnit]()
+  private val (runLoc,              store6) = store5.newLocation[Run | Null]()
+  private val (profilerLoc,         store7) = store6.newLocation[Profiler]()
+  private val (notNullInfosLoc,     store8) = store7.newLocation[List[NotNullInfo]]()
+  private val (importInfoLoc,       store9) = store8.newLocation[ImportInfo | Null]()
+  private val (typeAssignerLoc,    store10) = store9.newLocation[TypeAssigner](TypeAssigner)
+
+  private val initialStore = store10
+
+  /** The current context */
+  inline def ctx(using ctx: Context): Context = ctx
+
+  /** Run `op` with given context */
+  inline def inContext[T](c: Context)(inline op: Context ?=> T): T =
+    op(using c)
+
+  /** Execute `op` at given period */
+  inline def atPeriod[T](pd: Period)(inline op: Context ?=> T)(using Context): T =
+    op(using ctx.fresh.setPeriod(pd))
+
+  /** Execute `op` at given phase id */
+  inline def atPhase[T](pid: PhaseId)(inline op: Context ?=> T)(using Context): T =
+    op(using ctx.withPhase(pid))
+
+  /** Execute `op` at given phase */
+  inline def atPhase[T](phase: Phase)(inline op: Context ?=> T)(using Context): T =
+    op(using ctx.withPhase(phase))
+
+  inline def atNextPhase[T](inline op: Context ?=> T)(using Context): T =
+    atPhase(ctx.phase.next)(op)
+
+  /** Execute `op` at the current phase if it's before the first transform phase,
+   *  otherwise at the last phase before the first transform phase.
+   *
+   *  Note: this should be used instead of `atPhaseNoLater(ctx.picklerPhase)`
+   *  because the later won't work if the `Pickler` phase is not present (for example,
+   *  when using `QuoteCompiler`).
+   */
+  inline def atPhaseBeforeTransforms[T](inline op: Context ?=> T)(using Context): T =
+    atPhaseNoLater(firstTransformPhase.prev)(op)
+
+  inline def atPhaseNoLater[T](limit: Phase)(inline op: Context ?=> T)(using Context): T =
+    op(using if !limit.exists || ctx.phase <= limit then ctx else ctx.withPhase(limit))
+
+  inline def atPhaseNoEarlier[T](limit: Phase)(inline op: Context ?=> T)(using Context): T =
+    op(using if !limit.exists || limit <= ctx.phase then ctx else ctx.withPhase(limit))
+
+  inline def inMode[T](mode: Mode)(inline op: Context ?=> T)(using ctx: Context): T =
+    op(using if mode != ctx.mode then ctx.fresh.setMode(mode) else ctx)
+
+  inline def withMode[T](mode: Mode)(inline op: Context ?=> T)(using ctx: Context): T =
+    inMode(ctx.mode | mode)(op)
+
+  inline def withoutMode[T](mode: Mode)(inline op: Context ?=> T)(using ctx: Context): T =
+    inMode(ctx.mode &~ mode)(op)
+
+  /** A context is passed basically everywhere in dotc.
+   *  This is convenient but carries the risk of captured contexts in
+   *  objects that turn into space leaks. To combat this risk, here are some
+   *  conventions to follow:
+   *
+   *    - Never let an implicit context be an argument of a class whose instances
+   *      live longer than the context.
+   *    - Classes that need contexts for their initialization take an explicit parameter
+   *      named `initctx`. They pass initctx to all positions where it is needed
+   *      (and these positions should all be part of the intialization sequence of the class).
+   *    - Classes that need contexts that survive initialization are instead passed
+   *      a "condensed context", typically named `cctx` (or they create one). Condensed contexts
+   *      just add some basic information to the context base without the
+   *      risk of capturing complete trees.
+   *    - To make sure these rules are kept, it would be good to do a sanity
+   *      check using bytecode inspection with javap or scalap: Keep track
+   *      of all class fields of type context; allow them only in whitelisted
+   *      classes (which should be short-lived).
+   */
+  abstract class Context(val base: ContextBase) { thiscontext =>
+
+    given Context = this
+
+    /** All outer contexts, ending in `base.initialCtx` and then `NoContext` */
+    def outersIterator: Iterator[Context] = new Iterator[Context] {
+      var current = thiscontext
+      def hasNext = current != NoContext
+      def next = { val c = current; current = current.outer; c }
+    }
+
+    /** The outer context */
+    private var _outer: Context = _
+    protected def outer_=(outer: Context): Unit = _outer = outer
+    final def outer: Context = _outer
+
+    /** The current context */
+    private var _period: Period = _
+    protected def period_=(period: Period): Unit = {
+      assert(period.firstPhaseId == period.lastPhaseId, period)
+      _period = period
+    }
+    final def period: Period = _period
+
+    /** The scope nesting level */
+    private var _mode: Mode = _
+    protected def mode_=(mode: Mode): Unit = _mode = mode
+    final def mode: Mode = _mode
+
+    /** The current owner symbol */
+    private var _owner: Symbol = _
+    protected def owner_=(owner: Symbol): Unit = _owner = owner
+    final def owner: Symbol = _owner
+
+    /** The current tree */
+    private var _tree: Tree[? >: Untyped]= _
+    protected def tree_=(tree: Tree[? >: Untyped]): Unit = _tree = tree
+    final def tree: Tree[? >: Untyped] = _tree
+
+    /** The current scope */
+    private var _scope: Scope = _
+    protected def scope_=(scope: Scope): Unit = _scope = scope
+    final def scope: Scope = _scope
+
+    /** The current typerstate */
+    private var _typerState: TyperState = _
+    protected def typerState_=(typerState: TyperState): Unit = _typerState = typerState
+    final def typerState: TyperState = _typerState
+
+    /** The current bounds in force for type parameters appearing in a GADT */
+    private var _gadt: GadtConstraint = _
+    protected def gadt_=(gadt: GadtConstraint): Unit = _gadt = gadt
+    final def gadt: GadtConstraint = _gadt
+
+    /** The history of implicit searches that are currently active */
+    private var _searchHistory: SearchHistory = _
+    protected def searchHistory_= (searchHistory: SearchHistory): Unit = _searchHistory = searchHistory
+    final def searchHistory: SearchHistory = _searchHistory
+
+    /** The current source file */
+    private var _source: SourceFile = _
+    protected def source_=(source: SourceFile): Unit = _source = source
+    final def source: SourceFile = _source
+
+    /** A map in which more contextual properties can be stored
+     *  Typically used for attributes that are read and written only in special situations.
+     */
+    private var _moreProperties: Map[Key[Any], Any] = _
+    protected def moreProperties_=(moreProperties: Map[Key[Any], Any]): Unit = _moreProperties = moreProperties
+    final def moreProperties: Map[Key[Any], Any] = _moreProperties
+
+    def property[T](key: Key[T]): Option[T] =
+      moreProperties.get(key).asInstanceOf[Option[T]]
+
+    /** A store that can be used by sub-components.
+     *  Typically used for attributes that are defined only once per compilation unit.
+     *  Access to store entries is much faster than access to properties, and only
+     *  slightly slower than a normal field access would be.
+     */
+    private var _store: Store = _
+    protected def store_=(store: Store): Unit = _store = store
+    final def store: Store = _store
+
+    /** The compiler callback implementation, or null if no callback will be called. */
+    def compilerCallback: CompilerCallback = store(compilerCallbackLoc)
+
+    /** The sbt callback implementation if we are run from sbt, null otherwise */
+    def sbtCallback: AnalysisCallback = store(sbtCallbackLoc)
+
+    /** The current plain printer */
+    def printerFn: Context -> Printer = store(printerFnLoc)
+
+    /** A function creating a printer */
+    def printer: Printer =
+      val pr = printerFn(this)
+      if this.settings.YplainPrinter.value then pr.plain else pr
+
+    /** The current settings values */
+    def settingsState: SettingsState = store(settingsStateLoc)
+
+    /** The current compilation unit */
+    def compilationUnit: CompilationUnit = store(compilationUnitLoc)
+
+    /** The current compiler-run */
+    def run: Run | Null = store(runLoc)
+
+    /**  The current compiler-run profiler */
+    def profiler: Profiler = store(profilerLoc)
+
+    /** The paths currently known to be not null */
+    def notNullInfos: List[NotNullInfo] = store(notNullInfosLoc)
+
+    /** The currently active import info */
+    def importInfo: ImportInfo | Null = store(importInfoLoc)
+
+    /** The current type assigner or typer */
+    def typeAssigner: TypeAssigner = store(typeAssignerLoc)
+
+    /** The new implicit references that are introduced by this scope */
+    protected var implicitsCache: ContextualImplicits | Null = null
+    def implicits: ContextualImplicits = {
+      if (implicitsCache == null)
+        implicitsCache = {
+          val implicitRefs: List[ImplicitRef] =
+            if (isClassDefContext)
+              try owner.thisType.implicitMembers
+              catch {
+                case ex: CyclicReference => Nil
+              }
+            else if (isImportContext) importInfo.nn.importedImplicits
+            else if (isNonEmptyScopeContext) scope.implicitDecls
+            else Nil
+          val outerImplicits =
+            if (isImportContext && importInfo.nn.unimported.exists)
+              outer.implicits exclude importInfo.nn.unimported
+            else
+              outer.implicits
+          if (implicitRefs.isEmpty) outerImplicits
+          else new ContextualImplicits(implicitRefs, outerImplicits, isImportContext)(this)
+        }
+      implicitsCache.nn
+    }
+
+    /** Either the current scope, or, if the current context owner is a class,
+     *  the declarations of the current class.
+     */
+    def effectiveScope(using Context): Scope =
+      val myOwner: Symbol | Null = owner
+      if myOwner != null && myOwner.isClass then myOwner.asClass.unforcedDecls
+      else scope
+
+    def nestingLevel: Int = effectiveScope.nestingLevel
+
+    /** Sourcefile corresponding to given abstract file, memoized */
+    def getSource(file: AbstractFile, codec: -> Codec = Codec(settings.encoding.value)) = {
+      util.Stats.record("Context.getSource")
+      base.sources.getOrElseUpdate(file, SourceFile(file, codec))
+    }
+
+    /** SourceFile with given path name, memoized */
+    def getSource(path: TermName): SourceFile = getFile(path) match
+      case NoAbstractFile => NoSource
+      case file => getSource(file)
+
+    /** SourceFile with given path, memoized */
+    def getSource(path: String): SourceFile = getSource(path.toTermName)
+
+    /** AbstraFile with given path name, memoized */
+    def getFile(name: TermName): AbstractFile = base.files.get(name) match
+      case Some(file) =>
+        file
+      case None =>
+        try
+          val file = new PlainFile(Path(name.toString))
+          base.files(name) = file
+          file
+        catch
+          case ex: InvalidPathException =>
+            report.error(s"invalid file path: ${ex.getMessage}")
+            NoAbstractFile
+
+    /** AbstractFile with given path, memoized */
+    def getFile(name: String): AbstractFile = getFile(name.toTermName)
+
+
+    private var related: SimpleIdentityMap[Phase | SourceFile, Context] | Null = null
+
+    private def lookup(key: Phase | SourceFile): Context | Null =
+      util.Stats.record("Context.related.lookup")
+      if related == null then
+        related = SimpleIdentityMap.empty
+        null
+      else
+        related.nn(key)
+
+    private def withPhase(phase: Phase, pid: PhaseId): Context =
+      util.Stats.record("Context.withPhase")
+      val curId = phaseId
+      if curId == pid then
+        this
+      else
+        var ctx1 = lookup(phase)
+        if ctx1 == null then
+          util.Stats.record("Context.withPhase.new")
+          ctx1 = fresh.setPhase(pid)
+          related = related.nn.updated(phase, ctx1)
+        ctx1
+
+    final def withPhase(phase: Phase): Context = withPhase(phase, phase.id)
+    final def withPhase(pid: PhaseId): Context = withPhase(base.phases(pid), pid)
+
+    final def withSource(source: SourceFile): Context =
+      util.Stats.record("Context.withSource")
+      if this.source eq source then
+        this
+      else
+        var ctx1 = lookup(source)
+        if ctx1 == null then
+          util.Stats.record("Context.withSource.new")
+          val ctx2 = fresh.setSource(source)
+          if ctx2.compilationUnit eq NoCompilationUnit then
+            // `source` might correspond to a file not necessarily
+            // in the current project (e.g. when inlining library code),
+            // so set `mustExist` to false.
+            ctx2.setCompilationUnit(CompilationUnit(source, mustExist = false))
+          ctx1 = ctx2
+          related = related.nn.updated(source, ctx2)
+        ctx1
+
+    // `creationTrace`-related code. To enable, uncomment the code below and the
+    // call to `setCreationTrace()` in this file.
+    /*
+    /** If -Ydebug is on, the top of the stack trace where this context
+     *  was created, otherwise `null`.
+     */
+    private var creationTrace: Array[StackTraceElement] = _
+
+    private def setCreationTrace() =
+      creationTrace = (new Throwable).getStackTrace().take(20)
+
+    /** Print all enclosing context's creation stacktraces */
+    def printCreationTraces() = {
+      println("=== context creation trace =======")
+      for (ctx <- outersIterator) {
+        println(s">>>>>>>>> $ctx")
+        if (ctx.creationTrace != null) println(ctx.creationTrace.mkString("\n"))
+      }
+      println("=== end context creation trace ===")
+    }
+    */
+
+    /** The current reporter */
+    def reporter: Reporter = typerState.reporter
+
+    final def phase: Phase = base.phases(period.firstPhaseId)
+    final def runId = period.runId
+    final def phaseId = period.phaseId
+
+    final def lastPhaseId = base.phases.length - 1
+
+    /** Does current phase use an erased types interpretation? */
+    final def erasedTypes = phase.erasedTypes
+
+    /** Are we in a Java compilation unit? */
+    final def isJava: Boolean = compilationUnit.isJava
+
+    /** Is current phase after TyperPhase? */
+    final def isAfterTyper = base.isAfterTyper(phase)
+    final def isTyper = base.isTyper(phase)
+
+    /** Is this a context for the members of a class definition? */
+    def isClassDefContext: Boolean =
+      owner.isClass && (owner ne outer.owner)
+
+    /** Is this a context that introduces an import clause? */
+    def isImportContext: Boolean =
+      (this ne NoContext)
+      && (outer ne NoContext)
+      && (this.importInfo nen outer.importInfo)
+
+    /** Is this a context that introduces a non-empty scope? */
+    def isNonEmptyScopeContext: Boolean =
+      (this.scope ne outer.scope) && !this.scope.isEmpty
+
+    /** Is this a context for typechecking an inlined body? */
+    def isInlineContext: Boolean =
+      typer.isInstanceOf[Inliner#InlineTyper]
+
+    /** The next outer context whose tree is a template or package definition
+     *  Note: Currently unused
+    def enclTemplate: Context = {
+      var c = this
+      while (c != NoContext && !c.tree.isInstanceOf[Template[?]] && !c.tree.isInstanceOf[PackageDef[?]])
+        c = c.outer
+      c
+    }*/
+
+    /** The context for a supercall. This context is used for elaborating
+     *  the parents of a class and their arguments.
+     *  The context is computed from the current class context. It has
+     *
+     *  - as owner: The primary constructor of the class
+     *  - as outer context: The context enclosing the class context
+     *  - as scope: The parameter accessors in the class context
+     *
+     *  The reasons for this peculiar choice of attributes are as follows:
+     *
+     *  - The constructor must be the owner, because that's where any local methods or closures
+     *    should go.
+     *  - The context may not see any class members (inherited or defined), and should
+     *    instead see definitions defined in the outer context which might be shadowed by
+     *    such class members. That's why the outer context must be the outer context of the class.
+     *  - At the same time the context should see the parameter accessors of the current class,
+     *    that's why they get added to the local scope. An alternative would have been to have the
+     *    context see the constructor parameters instead, but then we'd need a final substitution step
+     *    from constructor parameters to class parameter accessors.
+     */
+    def superCallContext: Context = {
+      val locals = newScopeWith(owner.typeParams ++ owner.asClass.paramAccessors: _*)
+      superOrThisCallContext(owner.primaryConstructor, locals)
+    }
+
+    /** The context for the arguments of a this(...) constructor call.
+     *  The context is computed from the local auxiliary constructor context.
+     *  It has
+     *
+     *   - as owner: The auxiliary constructor
+     *   - as outer context: The context enclosing the enclosing class context
+     *   - as scope: The parameters of the auxiliary constructor.
+     */
+    def thisCallArgContext: Context = {
+      val constrCtx = outersIterator.dropWhile(_.outer.owner == owner).next()
+      superOrThisCallContext(owner, constrCtx.scope)
+        .setTyperState(typerState)
+        .setGadt(gadt)
+        .fresh
+        .setScope(this.scope)
+    }
+
+    /** The super- or this-call context with given owner and locals. */
+    private def superOrThisCallContext(owner: Symbol, locals: Scope): FreshContext = {
+      var classCtx = outersIterator.dropWhile(!_.isClassDefContext).next()
+      classCtx.outer.fresh.setOwner(owner)
+        .setScope(locals)
+        .setMode(classCtx.mode)
+    }
+
+    /** The context of expression `expr` seen as a member of a statement sequence */
+    def exprContext(stat: Tree[? >: Untyped], exprOwner: Symbol): Context =
+      if (exprOwner == this.owner) this
+      else if (untpd.isSuperConstrCall(stat) && this.owner.isClass) superCallContext
+      else fresh.setOwner(exprOwner)
+
+    /** A new context that summarizes an import statement */
+    def importContext(imp: Import[?], sym: Symbol): FreshContext =
+       fresh.setImportInfo(ImportInfo(sym, imp.selectors, imp.expr))
+
+    /** Is the debug option set? */
+    def debug: Boolean = base.settings.Ydebug.value
+
+    /** Is the verbose option set? */
+    def verbose: Boolean = base.settings.verbose.value
+
+    /** Should use colors when printing? */
+    def useColors: Boolean =
+      base.settings.color.value == "always"
+
+    /** Is the explicit nulls option set? */
+    def explicitNulls: Boolean = base.settings.YexplicitNulls.value
+
+    /** Initialize all context fields, except typerState, which has to be set separately
+     *  @param  outer   The outer context
+     *  @param  origin  The context from which fields are copied
+     */
+    private[Contexts] def init(outer: Context, origin: Context): this.type = {
+      _outer = outer
+      _period = origin.period
+      _mode = origin.mode
+      _owner = origin.owner
+      _tree = origin.tree
+      _scope = origin.scope
+      _gadt = origin.gadt
+      _searchHistory = origin.searchHistory
+      _source = origin.source
+      _moreProperties = origin.moreProperties
+      _store = origin.store
+      this
+    }
+
+    def reuseIn(outer: Context): this.type =
+      implicitsCache = null
+      related = null
+      init(outer, outer)
+
+    /** A fresh clone of this context embedded in this context. */
+    def fresh: FreshContext = freshOver(this)
+
+    /** A fresh clone of this context embedded in the specified `outer` context. */
+    def freshOver(outer: Context): FreshContext =
+      util.Stats.record("Context.fresh")
+      FreshContext(base).init(outer, this).setTyperState(this.typerState)
+
+    final def withOwner(owner: Symbol): Context =
+      if (owner ne this.owner) fresh.setOwner(owner) else this
+
+    final def withTyperState(typerState: TyperState): Context =
+      if typerState ne this.typerState then fresh.setTyperState(typerState) else this
+
+    final def withUncommittedTyperState: Context =
+      withTyperState(typerState.uncommittedAncestor)
+
+    final def withProperty[T](key: Key[T], value: Option[T]): Context =
+      if (property(key) == value) this
+      else value match {
+        case Some(v) => fresh.setProperty(key, v)
+        case None => fresh.dropProperty(key)
+      }
+
+    def typer: Typer = this.typeAssigner match {
+      case typer: Typer => typer
+      case _ => new Typer
+    }
+
+    override def toString: String =
+      def iinfo(using Context) =
+        val info = ctx.importInfo
+        if (info == null) "" else i"${info.selectors}%, %"
+      def cinfo(using Context) =
+        val core = s"  owner = ${ctx.owner}, scope = ${ctx.scope}, import = $iinfo"
+        if (ctx ne NoContext) && (ctx.implicits ne ctx.outer.implicits) then
+          s"$core, implicits = ${ctx.implicits}"
+        else
+          core
+      s"""Context(
+         |${outersIterator.map(ctx => cinfo(using ctx)).mkString("\n\n")})""".stripMargin
+
+    def settings: ScalaSettings            = base.settings
+    def definitions: Definitions           = base.definitions
+    def platform: Platform                 = base.platform
+    def pendingUnderlying: util.HashSet[Type]      = base.pendingUnderlying
+    def uniqueNamedTypes: Uniques.NamedTypeUniques = base.uniqueNamedTypes
+    def uniques: util.WeakHashSet[Type]            = base.uniques
+
+    def initialize()(using Context): Unit = base.initialize()
+  }
+
+  /** A condensed context provides only a small memory footprint over
+   *  a Context base, and therefore can be stored without problems in
+   *  long-lived objects.
+  abstract class CondensedContext extends Context {
+    override def condensed = this
+  }
+  */
+
+  /** A fresh context allows selective modification
+   *  of its attributes using the with... methods.
+   */
+  class FreshContext(base: ContextBase) extends Context(base) {
+    def setPeriod(period: Period): this.type =
+      util.Stats.record("Context.setPeriod")
+      this.period = period
+      this
+    def setMode(mode: Mode): this.type =
+      util.Stats.record("Context.setMode")
+      this.mode = mode
+      this
+    def setOwner(owner: Symbol): this.type =
+      util.Stats.record("Context.setOwner")
+      assert(owner != NoSymbol)
+      this.owner = owner
+      this
+    def setTree(tree: Tree[? >: Untyped]): this.type =
+      util.Stats.record("Context.setTree")
+      this.tree = tree
+      this
+    def setScope(scope: Scope): this.type = { this.scope = scope; this }
+    def setNewScope: this.type =
+      util.Stats.record("Context.setScope")
+      this.scope = newScope
+      this
+    def setTyperState(typerState: TyperState): this.type = { this.typerState = typerState; this }
+    def setNewTyperState(): this.type = setTyperState(typerState.fresh(committable = true))
+    def setExploreTyperState(): this.type = setTyperState(typerState.fresh(committable = false))
+    def setReporter(reporter: Reporter): this.type = setTyperState(typerState.fresh().setReporter(reporter))
+    def setTyper(typer: Typer): this.type = { this.scope = typer.scope; setTypeAssigner(typer) }
+    def setGadt(gadt: GadtConstraint): this.type =
+      util.Stats.record("Context.setGadt")
+      this.gadt = gadt
+      this
+    def setFreshGADTBounds: this.type = setGadt(gadt.fresh)
+    def setSearchHistory(searchHistory: SearchHistory): this.type =
+      util.Stats.record("Context.setSearchHistory")
+      this.searchHistory = searchHistory
+      this
+    def setSource(source: SourceFile): this.type =
+      util.Stats.record("Context.setSource")
+      this.source = source
+      this
+    private def setMoreProperties(moreProperties: Map[Key[Any], Any]): this.type =
+      util.Stats.record("Context.setMoreProperties")
+      this.moreProperties = moreProperties
+      this
+    private def setStore(store: Store): this.type =
+      util.Stats.record("Context.setStore")
+      this.store = store
+      this
+    def setImplicits(implicits: ContextualImplicits): this.type = { this.implicitsCache = implicits; this }
+
+    def setCompilationUnit(compilationUnit: CompilationUnit): this.type = {
+      setSource(compilationUnit.source)
+      updateStore(compilationUnitLoc, compilationUnit)
+    }
+
+    def setCompilerCallback(callback: CompilerCallback): this.type = updateStore(compilerCallbackLoc, callback)
+    def setSbtCallback(callback: AnalysisCallback): this.type = updateStore(sbtCallbackLoc, callback)
+    def setPrinterFn(printer: Context -> Printer): this.type = updateStore(printerFnLoc, printer)
+    def setSettings(settingsState: SettingsState): this.type = updateStore(settingsStateLoc, settingsState)
+    def setRun(run: Run | Null): this.type = updateStore(runLoc, run)
+    def setProfiler(profiler: Profiler): this.type = updateStore(profilerLoc, profiler)
+    def setNotNullInfos(notNullInfos: List[NotNullInfo]): this.type = updateStore(notNullInfosLoc, notNullInfos)
+    def setImportInfo(importInfo: ImportInfo): this.type =
+      importInfo.mentionsFeature(nme.unsafeNulls) match
+        case Some(true) =>
+          setMode(this.mode &~ Mode.SafeNulls)
+        case Some(false) if ctx.settings.YexplicitNulls.value =>
+          setMode(this.mode | Mode.SafeNulls)
+        case _ =>
+      updateStore(importInfoLoc, importInfo)
+    def setTypeAssigner(typeAssigner: TypeAssigner): this.type = updateStore(typeAssignerLoc, typeAssigner)
+
+    def setProperty[T](key: Key[T], value: T): this.type =
+      setMoreProperties(moreProperties.updated(key, value))
+
+    def dropProperty(key: Key[?]): this.type =
+      setMoreProperties(moreProperties - key)
+
+    def addLocation[T](initial: T): Store.Location[T] = {
+      val (loc, store1) = store.newLocation(initial)
+      setStore(store1)
+      loc
+    }
+
+    def addLocation[T](): Store.Location[T] = {
+      val (loc, store1) = store.newLocation[T]()
+      setStore(store1)
+      loc
+    }
+
+    def updateStore[T](loc: Store.Location[T], value: T): this.type =
+      setStore(store.updated(loc, value))
+
+    def setPhase(pid: PhaseId): this.type = setPeriod(Period(runId, pid))
+    def setPhase(phase: Phase): this.type = setPeriod(Period(runId, phase.start, phase.end))
+
+    def setSetting[T](setting: Setting[T], value: T): this.type =
+      setSettings(setting.updateIn(settingsState, value))
+
+    def setDebug: this.type = setSetting(base.settings.Ydebug, true)
+  }
+
+  given ops: AnyRef with
+    extension (c: Context)
+      def addNotNullInfo(info: NotNullInfo) =
+        c.withNotNullInfos(c.notNullInfos.extendWith(info))
+
+      def addNotNullRefs(refs: Set[TermRef]) =
+        c.addNotNullInfo(NotNullInfo(refs, Set()))
+
+      def withNotNullInfos(infos: List[NotNullInfo]): Context =
+        if c.notNullInfos eq infos then c else c.fresh.setNotNullInfos(infos)
+
+      def relaxedOverrideContext: Context =
+        c.withModeBits(c.mode &~ Mode.SafeNulls | Mode.RelaxedOverriding)
+  end ops
+
+  // TODO: Fix issue when converting ModeChanges and FreshModeChanges to extension givens
+  extension (c: Context) {
+    final def withModeBits(mode: Mode): Context =
+      if (mode != c.mode) c.fresh.setMode(mode) else c
+
+    final def addMode(mode: Mode): Context = withModeBits(c.mode | mode)
+    final def retractMode(mode: Mode): Context = withModeBits(c.mode &~ mode)
+  }
+
+  extension (c: FreshContext) {
+    final def addMode(mode: Mode): c.type = c.setMode(c.mode | mode)
+    final def retractMode(mode: Mode): c.type = c.setMode(c.mode &~ mode)
+  }
+
+  private def exploreCtx(using Context): FreshContext =
+    util.Stats.record("explore")
+    val base = ctx.base
+    import base._
+    val nestedCtx =
+      if exploresInUse < exploreContexts.size then
+        exploreContexts(exploresInUse).reuseIn(ctx)
+      else
+        val ts = TyperState()
+          .setReporter(ExploringReporter())
+          .setCommittable(false)
+        val c = FreshContext(ctx.base).init(ctx, ctx).setTyperState(ts)
+        exploreContexts += c
+        c
+    exploresInUse += 1
+    val nestedTS = nestedCtx.typerState
+    nestedTS.init(ctx.typerState, ctx.typerState.constraint)
+    nestedCtx
+
+  private def wrapUpExplore(ectx: Context) =
+    ectx.reporter.asInstanceOf[ExploringReporter].reset()
+    ectx.base.exploresInUse -= 1
+
+  inline def explore[T](inline op: Context ?=> T)(using Context): T =
+    val ectx = exploreCtx
+    try op(using ectx) finally wrapUpExplore(ectx)
+
+  inline def exploreInFreshCtx[T](inline op: FreshContext ?=> T)(using Context): T =
+    val ectx = exploreCtx
+    try op(using ectx) finally wrapUpExplore(ectx)
+
+  private def changeOwnerCtx(owner: Symbol)(using Context): Context =
+    val base = ctx.base
+    import base._
+    val nestedCtx =
+      if changeOwnersInUse < changeOwnerContexts.size then
+        changeOwnerContexts(changeOwnersInUse).reuseIn(ctx)
+      else
+        val c = FreshContext(ctx.base).init(ctx, ctx)
+        changeOwnerContexts += c
+        c
+    changeOwnersInUse += 1
+    nestedCtx.setOwner(owner).setTyperState(ctx.typerState)
+
+  /** Run `op` in current context, with a mode is temporarily set as specified.
+   */
+  inline def runWithOwner[T](owner: Symbol)(inline op: Context ?=> T)(using Context): T =
+    if Config.reuseOwnerContexts then
+      try op(using changeOwnerCtx(owner))
+      finally ctx.base.changeOwnersInUse -= 1
+    else
+      op(using ctx.fresh.setOwner(owner))
+
+  /** The type comparer of the kind created by `maker` to be used.
+   *  This is the currently active type comparer CMP if
+   *   - CMP is associated with the current context, and
+   *   - CMP is of the kind created by maker or maker creates a plain type comparer.
+   *  Note: plain TypeComparers always take on the kind of the outer comparer if they are in the same context.
+   *  In other words: tracking or explaining is a sticky property in the same context.
+   */
+  private def comparer(using Context): TypeComparer =
+    util.Stats.record("comparing")
+    val base = ctx.base
+    if base.comparersInUse > 0
+       && (base.comparers(base.comparersInUse - 1).comparerContext eq ctx)
+    then
+      base.comparers(base.comparersInUse - 1).currentInstance
+    else
+      val result =
+        if base.comparersInUse < base.comparers.size then
+          base.comparers(base.comparersInUse)
+        else
+          val result = TypeComparer(ctx)
+          base.comparers += result
+          result
+      base.comparersInUse += 1
+      result.init(ctx)
+      result
+
+  inline def comparing[T](inline op: TypeComparer => T)(using Context): T =
+    util.Stats.record("comparing")
+    val saved = ctx.base.comparersInUse
+    try op(comparer)
+    finally ctx.base.comparersInUse = saved
+  end comparing
+
+  /** A class defining the initial context with given context base
+   *  and set of possible settings.
+   */
+  private class InitialContext(base: ContextBase, settingsGroup: SettingGroup) extends FreshContext(base) {
+    outer = NoContext
+    period = InitialPeriod
+    mode = Mode.None
+    typerState = TyperState.initialState()
+    owner = NoSymbol
+    tree = untpd.EmptyTree
+    moreProperties = Map(MessageLimiter -> DefaultMessageLimiter())
+    scope = EmptyScope
+    source = NoSource
+    store = initialStore
+      .updated(settingsStateLoc, settingsGroup.defaultState)
+      .updated(notNullInfosLoc, Nil)
+      .updated(compilationUnitLoc, NoCompilationUnit)
+    searchHistory = new SearchRoot
+    gadt = GadtConstraint.empty
+  }
+
+  @sharable object NoContext extends Context((null: ContextBase | Null).uncheckedNN) {
+    source = NoSource
+    override val implicits: ContextualImplicits = new ContextualImplicits(Nil, null, false)(this: @unchecked)
+  }
+
+  /** A context base defines state and associated methods that exist once per
+   *  compiler run.
+   */
+  class ContextBase extends ContextState
+                       with Phases.PhasesBase
+                       with Plugins {
+
+    /** The applicable settings */
+    val settings: ScalaSettings = new ScalaSettings
+
+    /** The initial context */
+    val initialCtx: Context = new InitialContext(this, settings)
+
+    /** The platform, initialized by `initPlatform()`. */
+    private var _platform: Platform | Null = _
+
+    /** The platform */
+    def platform: Platform = {
+      val p = _platform
+      if p == null then
+        throw new IllegalStateException(
+            "initialize() must be called before accessing platform")
+      p
+    }
+
+    protected def newPlatform(using Context): Platform =
+      if (settings.scalajs.value) new SJSPlatform
+      else new JavaPlatform
+
+    /** The loader that loads the members of _root_ */
+    def rootLoader(root: TermSymbol)(using Context): SymbolLoader = platform.rootLoader(root)
+
+    /** The standard definitions */
+    val definitions: Definitions = new Definitions
+
+    // Set up some phases to get started */
+    usePhases(List(SomePhase))
+
+    /** Initializes the `ContextBase` with a starting context.
+     *  This initializes the `platform` and the `definitions`.
+     */
+    def initialize()(using Context): Unit = {
+      _platform = newPlatform
+      definitions.init()
+    }
+
+    def fusedContaining(p: Phase): Phase =
+      allPhases.find(_.period.containsPhaseId(p.id)).getOrElse(NoPhase)
+  }
+
+  /** The essential mutable state of a context base, collected into a common class */
+  class ContextState {
+    // Symbols state
+
+    /** Counter for unique symbol ids */
+    private var _nextSymId: Int = 0
+    def nextSymId: Int = { _nextSymId += 1; _nextSymId }
+
+    /** Sources and Files that were loaded */
+    val sources: util.HashMap[AbstractFile, SourceFile] = util.HashMap[AbstractFile, SourceFile]()
+    val files: util.HashMap[TermName, AbstractFile] = util.HashMap()
+
+    // Types state
+    /** A table for hash consing unique types */
+    private[core] val uniques: Uniques = Uniques()
+
+    /** A table for hash consing unique applied types */
+    private[dotc] val uniqueAppliedTypes: AppliedUniques = AppliedUniques()
+
+    /** A table for hash consing unique named types */
+    private[core] val uniqueNamedTypes: NamedTypeUniques = NamedTypeUniques()
+
+    var emptyTypeBounds: TypeBounds | Null = null
+    var emptyWildcardBounds: WildcardType | Null = null
+
+    /** Number of findMember calls on stack */
+    private[core] var findMemberCount: Int = 0
+
+    /** List of names which have a findMemberCall on stack,
+     *  after Config.LogPendingFindMemberThreshold is reached.
+     */
+    private[core] var pendingMemberSearches: List[Name] = Nil
+
+    /** The number of recursive invocation of underlying on a NamedType
+     *  during a controlled operation.
+     */
+    private[core] var underlyingRecursions: Int = 0
+
+    /** The set of named types on which a currently active invocation
+     *  of underlying during a controlled operation exists. */
+    private[core] val pendingUnderlying: util.HashSet[Type] = util.HashSet[Type]()
+
+    /** A map from ErrorType to associated message. We use this map
+     *  instead of storing messages directly in ErrorTypes in order
+     *  to avoid space leaks - the message usually captures a context.
+     */
+    private[core] val errorTypeMsg: mutable.Map[Types.ErrorType, Message] = mutable.Map()
+
+    // Phases state
+
+    private[core] var phasesPlan: List[List[Phase]] = _
+
+    /** Phases by id */
+    private[dotc] var phases: Array[Phase] = _
+
+    /** Phases with consecutive Transforms grouped into a single phase, Empty array if fusion is disabled */
+    private[core] var fusedPhases: Array[Phase] = Array.empty[Phase]
+
+    /** Next denotation transformer id */
+    private[core] var nextDenotTransformerId: Array[Int] = _
+
+    private[core] var denotTransformers: Array[DenotTransformer] = _
+
+    /** Flag to suppress inlining, set after overflow */
+    private[dotc] var stopInlining: Boolean = false
+
+    /** A variable that records that some error was reported in a globally committable context.
+     *  The error will not necessarlily be emitted, since it could still be that
+     *  the enclosing context will be aborted. The variable is used as a smoke test
+     *  to turn off assertions that might be wrong if the program is erroneous. To
+     *  just test for `ctx.reporter.errorsReported` is not always enough, since it
+     *  could be that the context in which the assertion is tested is a completer context
+     *  that's different from the context where the error was reported. See i13218.scala
+     *  for a test.
+     */
+    private[dotc] var errorsToBeReported = false
+
+    // Reporters state
+    private[dotc] var indent: Int = 0
+
+    protected[dotc] val indentTab: String = "  "
+
+    private[Contexts] val exploreContexts = new mutable.ArrayBuffer[FreshContext]
+    private[Contexts] var exploresInUse: Int = 0
+
+    private[Contexts] val changeOwnerContexts = new mutable.ArrayBuffer[FreshContext]
+    private[Contexts] var changeOwnersInUse: Int = 0
+
+    private[Contexts] val comparers = new mutable.ArrayBuffer[TypeComparer]
+    private[Contexts] var comparersInUse: Int = 0
+
+    private var charArray = new Array[Char](256)
+
+    private[core] val reusableDataReader = ReusableInstance(new ReusableDataReader())
+
+    private[dotc] var wConfCache: (List[String], WConf) = _
+
+    def sharedCharArray(len: Int): Array[Char] =
+      while len > charArray.length do
+        charArray = new Array[Char](charArray.length * 2)
+      charArray
+
+    def reset(): Unit =
+      uniques.clear()
+      uniqueAppliedTypes.clear()
+      uniqueNamedTypes.clear()
+      emptyTypeBounds = null
+      emptyWildcardBounds = null
+      errorsToBeReported = false
+      errorTypeMsg.clear()
+      sources.clear()
+      files.clear()
+      comparers.clear()  // forces re-evaluation of top and bottom classes in TypeComparer
+
+    // Test that access is single threaded
+
+    /** The thread on which `checkSingleThreaded was invoked last */
+    @sharable private var thread: Thread | Null = null
+
+    /** Check that we are on the same thread as before */
+    def checkSingleThreaded(): Unit =
+      if (thread == null) thread = Thread.currentThread()
+      else assert(thread == Thread.currentThread(), "illegal multithreaded access to ContextBase")
+  }
+}
diff --git a/tests/pos-with-compiler-cc/dotc/core/Decorators.scala b/tests/pos-with-compiler-cc/dotc/core/Decorators.scala
new file mode 100644
index 000000000000..679e22b48c9e
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/core/Decorators.scala
@@ -0,0 +1,312 @@
+package dotty.tools
+package dotc
+package core
+
+import scala.annotation.tailrec
+import scala.collection.mutable.ListBuffer
+import scala.util.control.NonFatal
+
+import Contexts._, Names._, Phases._, Symbols._
+import printing.{ Printer, Showable }, printing.Formatting._, printing.Texts._
+import transform.MegaPhase
+import reporting.{Message, NoExplanation}
+import language.experimental.pureFunctions
+
+/** This object provides useful implicit decorators for types defined elsewhere */
+object Decorators {
+
+  /** Extension methods for toType/TermName methods on PreNames.
+   */
+  extension (pn: PreName)
+    def toTermName: TermName = pn match
+      case s: String => termName(s)
+      case n: Name => n.toTermName
+    def toTypeName: TypeName = pn match
+      case s: String => typeName(s)
+      case n: Name => n.toTypeName
+
+  extension (s: String)
+    def splitWhere(f: Char => Boolean, doDropIndex: Boolean): Option[(String, String)] =
+      def splitAt(idx: Int, doDropIndex: Boolean): Option[(String, String)] =
+        if (idx == -1) None
+        else Some((s.take(idx), s.drop(if (doDropIndex) idx + 1 else idx)))
+      splitAt(s.indexWhere(f), doDropIndex)
+
+    /** Create a term name from a string slice, using a common buffer.
+     *  This avoids some allocation relative to `termName(s)`
+     */
+    def sliceToTermName(start: Int, end: Int)(using Context): SimpleName =
+      val len = end - start
+      val chars = ctx.base.sharedCharArray(len)
+      s.getChars(start, end, chars, 0)
+      termName(chars, 0, len)
+
+    def sliceToTypeName(start: Int, end: Int)(using Context): TypeName =
+      sliceToTermName(start, end).toTypeName
+
+    def concat(name: Name)(using Context): SimpleName = name match
+      case name: SimpleName =>
+        val len = s.length + name.length
+        var chars = ctx.base.sharedCharArray(len)
+        s.getChars(0, s.length, chars, 0)
+        if name.length != 0 then name.getChars(0, name.length, chars, s.length)
+        termName(chars, 0, len)
+      case name: TypeName => s.concat(name.toTermName)
+      case _ => termName(s.concat(name.toString).nn)
+
+    def indented(width: Int): String =
+      val padding = " " * width
+      padding + s.replace("\n", "\n" + padding)
+  end extension
+
+  extension (str: -> String)
+    def toMessage: Message = reporting.NoExplanation(str)
+
+  /** Implements a findSymbol method on iterators of Symbols that
+   *  works like find but avoids Option, replacing None with NoSymbol.
+   */
+  extension (it: Iterator[Symbol])
+    final def findSymbol(p: Symbol => Boolean): Symbol = {
+      while (it.hasNext) {
+        val sym = it.next()
+        if (p(sym)) return sym
+      }
+      NoSymbol
+    }
+
+  inline val MaxFilterRecursions = 10
+
+  /** Implements filterConserve, zipWithConserve methods
+   *  on lists that avoid duplication of list nodes where feasible.
+   */
+  implicit class ListDecorator[T](val xs: List[T]) extends AnyVal {
+
+    final def mapconserve[U](f: T => U): List[U] = {
+      @tailrec
+      def loop(mapped: ListBuffer[U] | Null, unchanged: List[U], pending: List[T]): List[U] =
+        if (pending.isEmpty)
+          if (mapped == null) unchanged
+          else mapped.prependToList(unchanged)
+        else {
+          val head0 = pending.head
+          val head1 = f(head0)
+
+          if (head1.asInstanceOf[AnyRef] eq head0.asInstanceOf[AnyRef])
+            loop(mapped, unchanged, pending.tail)
+          else {
+            val b = if (mapped == null) new ListBuffer[U] else mapped
+            var xc = unchanged
+            while (xc ne pending) {
+              b += xc.head
+              xc = xc.tail
+            }
+            b += head1
+            val tail0 = pending.tail
+            loop(b, tail0.asInstanceOf[List[U]], tail0)
+          }
+        }
+      loop(null, xs.asInstanceOf[List[U]], xs)
+    }
+
+    /** Like `xs filter p` but returns list `xs` itself  - instead of a copy -
+     *  if `p` is true for all elements.
+     */
+    def filterConserve(p: T => Boolean): List[T] =
+
+      def addAll(buf: ListBuffer[T], from: List[T], until: List[T]): ListBuffer[T] =
+        if from eq until then buf else addAll(buf += from.head, from.tail, until)
+
+      def loopWithBuffer(buf: ListBuffer[T], xs: List[T]): List[T] = xs match
+        case x :: xs1 =>
+          if p(x) then buf += x
+          loopWithBuffer(buf, xs1)
+        case nil => buf.toList
+
+      def loop(keep: List[T], explore: List[T], keepCount: Int, recCount: Int): List[T] =
+        explore match
+          case x :: rest =>
+            if p(x) then
+              loop(keep, rest, keepCount + 1, recCount)
+            else if keepCount <= 3 && recCount <= MaxFilterRecursions then
+              val rest1 = loop(rest, rest, 0, recCount + 1)
+              keepCount match
+                case 0 => rest1
+                case 1 => keep.head :: rest1
+                case 2 => keep.head :: keep.tail.head :: rest1
+                case 3 => val tl = keep.tail; keep.head :: tl.head :: tl.tail.head :: rest1
+            else
+              loopWithBuffer(addAll(new ListBuffer[T], keep, explore), rest)
+          case nil =>
+            keep
+
+      loop(xs, xs, 0, 0)
+    end filterConserve
+
+    /** Like `xs.lazyZip(ys).map(f)`, but returns list `xs` itself
+     *  - instead of a copy - if function `f` maps all elements of
+     *  `xs` to themselves. Also, it is required that `ys` is at least
+     *  as long as `xs`.
+     */
+    def zipWithConserve[U, V <: T](ys: List[U])(f: (T, U) => V): List[V] =
+      if (xs.isEmpty || ys.isEmpty) Nil
+      else {
+        val x1 = f(xs.head, ys.head)
+        val xs1 = xs.tail.zipWithConserve(ys.tail)(f)
+        if (x1.asInstanceOf[AnyRef] eq xs.head.asInstanceOf[AnyRef]) && (xs1 eq xs.tail)
+          then xs.asInstanceOf[List[V]]
+        else x1 :: xs1
+      }
+
+    /** Like `xs.lazyZip(xs.indices).map(f)`, but returns list `xs` itself
+     *  - instead of a copy - if function `f` maps all elements of
+     *  `xs` to themselves.
+     */
+    def mapWithIndexConserve[U <: T](f: (T, Int) => U): List[U] =
+
+      @tailrec
+      def addAll(buf: ListBuffer[T], from: List[T], until: List[T]): ListBuffer[T] =
+        if from eq until then buf else addAll(buf += from.head, from.tail, until)
+
+      @tailrec
+      def loopWithBuffer(buf: ListBuffer[U], explore: List[T], idx: Int): List[U] = explore match
+        case Nil       => buf.toList
+        case t :: rest => loopWithBuffer(buf += f(t, idx), rest, idx + 1)
+
+      @tailrec
+      def loop(keep: List[T], explore: List[T], idx: Int): List[U] = explore match
+        case Nil => keep.asInstanceOf[List[U]]
+        case t :: rest =>
+          val u = f(t, idx)
+          if u.asInstanceOf[AnyRef] eq t.asInstanceOf[AnyRef] then
+            loop(keep, rest, idx + 1)
+          else
+            val buf = addAll(new ListBuffer[T], keep, explore).asInstanceOf[ListBuffer[U]]
+            loopWithBuffer(buf += u, rest, idx + 1)
+
+      loop(xs, xs, 0)
+    end mapWithIndexConserve
+
+    /** True if two lists have the same length.  Since calling length on linear sequences
+     *  is Θ(n), it is an inadvisable way to test length equality.  This method is Θ(n min m).
+     */
+    final def hasSameLengthAs[U](ys: List[U]): Boolean = {
+      @tailrec def loop(xs: List[T], ys: List[U]): Boolean =
+        if (xs.isEmpty) ys.isEmpty
+        else ys.nonEmpty && loop(xs.tail, ys.tail)
+      loop(xs, ys)
+    }
+
+    @tailrec final def eqElements(ys: List[AnyRef]): Boolean = xs match {
+      case x :: _ =>
+        ys match {
+          case y :: _ =>
+            x.asInstanceOf[AnyRef].eq(y) &&
+            xs.tail.eqElements(ys.tail)
+          case _ => false
+        }
+      case nil => ys.isEmpty
+    }
+
+    /** Union on lists seen as sets */
+    def | (ys: List[T]): List[T] = xs ::: (ys filterNot (xs contains _))
+
+    /** Intersection on lists seen as sets */
+    def & (ys: List[T]): List[T] = xs filter (ys contains _)
+  }
+
+  extension [T, U](xss: List[List[T]])
+    def nestedMap(f: T => U): List[List[U]] = xss match
+      case xs :: xss1 => xs.map(f) :: xss1.nestedMap(f)
+      case nil => Nil
+    def nestedMapConserve(f: T => U): List[List[U]] =
+      xss.mapconserve(_.mapconserve(f))
+    def nestedZipWithConserve(yss: List[List[U]])(f: (T, U) => T): List[List[T]] =
+      xss.zipWithConserve(yss)((xs, ys) => xs.zipWithConserve(ys)(f))
+    def nestedExists(p: T => Boolean): Boolean = xss match
+      case xs :: xss1 => xs.exists(p) || xss1.nestedExists(p)
+      case nil => false
+  end extension
+
+  extension (text: Text)
+    def show(using Context): String = text.mkString(ctx.settings.pageWidth.value, ctx.settings.printLines.value)
+
+  /** Test whether a list of strings representing phases contains
+   *  a given phase. See [[config.CompilerCommand#explainAdvanced]] for the
+   *  exact meaning of "contains" here.
+   */
+   extension (names: List[String])
+    def containsPhase(phase: Phase): Boolean =
+      names.nonEmpty && {
+        phase match {
+          case phase: MegaPhase => phase.miniPhases.exists(x => names.containsPhase(x))
+          case _ =>
+            names exists { name =>
+              name == "all" || {
+                val strippedName = name.stripSuffix("+")
+                val logNextPhase = name != strippedName
+                phase.phaseName.startsWith(strippedName) ||
+                  (logNextPhase && phase.prev.phaseName.startsWith(strippedName))
+              }
+            }
+        }
+      }
+
+  extension [T](x: T)
+    def showing[U](
+        op: WrappedResult[U] ?=> String,
+        printer: config.Printers.Printer = config.Printers.default)(using c: Conversion[T, U] | Null = null): T = {
+      // either the use of `$result` was driven by the expected type of `Shown`
+      // which led to the summoning of `Conversion[T, Shown]` (which we'll invoke)
+      // or no such conversion was found so we'll consume the result as it is instead
+      val obj = if c == null then x.asInstanceOf[U] else c(x)
+      printer.println(op(using WrappedResult(obj)))
+      x
+    }
+
+    /** Instead of `toString` call `show` on `Showable` values, falling back to `toString` if an exception is raised. */
+    def tryToShow(using Context): String = x match
+      case x: Showable =>
+        try x.show
+        catch
+          case ex: CyclicReference => "... (caught cyclic reference) ..."
+          case NonFatal(ex)
+              if !ctx.mode.is(Mode.PrintShowExceptions) && !ctx.settings.YshowPrintErrors.value =>
+            val msg = ex match { case te: TypeError => te.toMessage case _ => ex.getMessage }
+            s"[cannot display due to $msg, raw string = $x]"
+      case _ => String.valueOf(x).nn
+
+  extension [T](x: T)
+    def assertingErrorsReported(using Context): T = {
+      assert(ctx.reporter.errorsReported)
+      x
+    }
+    def assertingErrorsReported(msg: => String)(using Context): T = {
+      assert(ctx.reporter.errorsReported, msg)
+      x
+    }
+
+  extension [T <: AnyRef](xs: ::[T])
+    def derivedCons(x1: T, xs1: List[T]) =
+      if (xs.head eq x1) && (xs.tail eq xs1) then xs else x1 :: xs1
+
+  extension (sc: StringContext)
+    /** General purpose string formatting */
+    def i(args: Shown*)(using Context): String =
+      new StringFormatter(sc).assemble(args)
+
+    /** Formatting for error messages: Like `i` but suppress follow-on
+     *  error messages after the first one if some of their arguments are "non-sensical".
+     */
+    def em(args: Shown*)(using Context): String =
+      forErrorMessages(new StringFormatter(sc).assemble(args))
+
+    /** Formatting with added explanations: Like `em`, but add explanations to
+     *  give more info about type variables and to disambiguate where needed.
+     */
+    def ex(args: Shown*)(using Context): String =
+      explained(new StringFormatter(sc).assemble(args))
+
+  extension [T <: AnyRef](arr: Array[T])
+    def binarySearch(x: T | Null): Int = java.util.Arrays.binarySearch(arr.asInstanceOf[Array[Object | Null]], x)
+
+}
diff --git a/tests/pos-with-compiler-cc/dotc/core/Definitions.scala b/tests/pos-with-compiler-cc/dotc/core/Definitions.scala
new file mode 100644
index 000000000000..e68dc9102961
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/core/Definitions.scala
@@ -0,0 +1,2379 @@
+package dotty.tools
+package dotc
+package core
+
+import scala.annotation.{threadUnsafe => tu}
+import Types._, Contexts._, Symbols._, SymDenotations._, StdNames._, Names._, Phases._
+import Flags._, Scopes._, Decorators._, NameOps._, Periods._, NullOpsDecorator._
+import unpickleScala2.Scala2Unpickler.ensureConstructor
+import scala.collection.mutable
+import collection.mutable
+import Denotations.{SingleDenotation, staticRef}
+import util.{SimpleIdentityMap, SourceFile, NoSource}
+import typer.ImportInfo.RootRef
+import Comments.CommentsContext
+import Comments.Comment
+import util.Spans.NoSpan
+import config.Feature
+import Symbols.requiredModuleRef
+import cc.{CapturingType, CaptureSet, EventuallyCapturingType}
+
+import scala.annotation.tailrec
+import language.experimental.pureFunctions
+
+object Definitions {
+
+  /** The maximum number of elements in a tuple or product.
+   *  This should be removed once we go to hlists.
+   */
+  val MaxTupleArity: Int = 22
+
+  /** The maximum arity N of a function type that's implemented
+   *  as a trait `scala.FunctionN`. Functions of higher arity are possible,
+   *  but are mapped in erasure to functions taking a single parameter of type
+   *  Object[].
+   *  The limit 22 is chosen for Scala2x interop. It could be something
+   *  else without affecting the set of programs that can be compiled.
+   */
+  val MaxImplementedFunctionArity: Int = MaxTupleArity
+}
+
+/** A class defining symbols and types of standard definitions
+ *
+ */
+class Definitions {
+  import Definitions._
+
+  private var initCtx: Context = _
+  private given currentContext[Dummy_so_its_a_def]: Context = initCtx
+
+  private def newPermanentSymbol[N <: Name](owner: Symbol, name: N, flags: FlagSet, info: Type) =
+    newSymbol(owner, name, flags | Permanent, info)
+
+  private def newPermanentClassSymbol(owner: Symbol, name: TypeName, flags: FlagSet, infoFn: ClassSymbol => Type) =
+    newClassSymbol(owner, name, flags | Permanent | NoInits | Open, infoFn)
+
+  private def enterCompleteClassSymbol(owner: Symbol, name: TypeName, flags: FlagSet, parents: List[TypeRef]): ClassSymbol =
+    enterCompleteClassSymbol(owner, name, flags, parents, newScope(owner.nestingLevel + 1))
+
+  private def enterCompleteClassSymbol(owner: Symbol, name: TypeName, flags: FlagSet, parents: List[TypeRef], decls: Scope) =
+    newCompleteClassSymbol(owner, name, flags | Permanent | NoInits | Open, parents, decls).entered
+
+  private def enterTypeField(cls: ClassSymbol, name: TypeName, flags: FlagSet, scope: MutableScope) =
+    scope.enter(newPermanentSymbol(cls, name, flags, TypeBounds.empty))
+
+  private def enterTypeParam(cls: ClassSymbol, name: TypeName, flags: FlagSet, scope: MutableScope) =
+    enterTypeField(cls, name, flags | ClassTypeParamCreationFlags, scope)
+
+  private def enterSyntheticTypeParam(cls: ClassSymbol, paramFlags: FlagSet, scope: MutableScope, suffix: String = "T0") =
+    enterTypeParam(cls, suffix.toTypeName, paramFlags, scope)
+
+  // NOTE: Ideally we would write `parentConstrs: => Type*` but SIP-24 is only
+  // implemented in Dotty and not in Scala 2.
+  // See <http://docs.scala-lang.org/sips/pending/repeated-byname.html>.
+  private def enterSpecialPolyClass(name: TypeName, paramFlags: FlagSet, parentConstrs: -> Seq[Type]): ClassSymbol = {
+    val completer = new LazyType {
+      def complete(denot: SymDenotation)(using Context): Unit = {
+        val cls = denot.asClass.classSymbol
+        val paramDecls = newScope
+        val typeParam = enterSyntheticTypeParam(cls, paramFlags, paramDecls)
+        def instantiate(tpe: Type) =
+          if (tpe.typeParams.nonEmpty) tpe.appliedTo(typeParam.typeRef)
+          else tpe
+        val parents = parentConstrs.toList map instantiate
+        denot.info = ClassInfo(ScalaPackageClass.thisType, cls, parents, paramDecls)
+      }
+    }
+    newPermanentClassSymbol(ScalaPackageClass, name, Artifact, completer).entered
+  }
+
+  /** The trait FunctionN, ContextFunctionN, ErasedFunctionN or ErasedContextFunction, for some N
+   *  @param  name   The name of the trait to be created
+   *
+   *  FunctionN traits follow this template:
+   *
+   *      trait FunctionN[-T0,...-T{N-1}, +R] extends Object {
+   *        def apply($x0: T0, ..., $x{N_1}: T{N-1}): R
+   *      }
+   *
+   *  That is, they follow the template given for Function2..Function22 in the
+   *  standard library, but without `tupled` and `curried` methods and without
+   *  a `toString`.
+   *
+   *  ContextFunctionN traits follow this template:
+   *
+   *      trait ContextFunctionN[-T0,...,-T{N-1}, +R] extends Object {
+   *        def apply(using $x0: T0, ..., $x{N_1}: T{N-1}): R
+   *      }
+   *
+   *  ErasedFunctionN traits follow this template:
+   *
+   *      trait ErasedFunctionN[-T0,...,-T{N-1}, +R] extends Object {
+   *        def apply(erased $x0: T0, ..., $x{N_1}: T{N-1}): R
+   *      }
+   *
+   *  ErasedContextFunctionN traits follow this template:
+   *
+   *      trait ErasedContextFunctionN[-T0,...,-T{N-1}, +R] extends Object {
+   *        def apply(using erased $x0: T0, ..., $x{N_1}: T{N-1}): R
+   *      }
+   *
+   *  ErasedFunctionN and ErasedContextFunctionN erase to Function0.
+   *
+   *  ImpureXYZFunctionN follow this template:
+   *
+   *      type ImpureXYZFunctionN[-T0,...,-T{N-1}, +R] = {*} XYZFunctionN[T0,...,T{N-1}, R]
+   */
+  private def newFunctionNType(name: TypeName): Symbol = {
+    val impure = name.startsWith("Impure")
+    val completer = new LazyType {
+      def complete(denot: SymDenotation)(using Context): Unit = {
+        val arity = name.functionArity
+        if impure then
+          val argParamNames = List.tabulate(arity)(tpnme.syntheticTypeParamName)
+          val argVariances = List.fill(arity)(Contravariant)
+          val underlyingName = name.asSimpleName.drop(6)
+          val underlyingClass = ScalaPackageVal.requiredClass(underlyingName)
+          denot.info = TypeAlias(
+            HKTypeLambda(argParamNames :+ "R".toTypeName, argVariances :+ Covariant)(
+              tl => List.fill(arity + 1)(TypeBounds.empty),
+              tl => CapturingType(underlyingClass.typeRef.appliedTo(tl.paramRefs),
+                CaptureSet.universal)
+            ))
+        else
+          val cls = denot.asClass.classSymbol
+          val decls = newScope
+          val paramNamePrefix = tpnme.scala ++ str.NAME_JOIN ++ name ++ str.EXPAND_SEPARATOR
+          val argParamRefs = List.tabulate(arity) { i =>
+            enterTypeParam(cls, paramNamePrefix ++ "T" ++ (i + 1).toString, Contravariant, decls).typeRef
+          }
+          val resParamRef = enterTypeParam(cls, paramNamePrefix ++ "R", Covariant, decls).typeRef
+          val methodType = MethodType.companion(
+            isContextual = name.isContextFunction,
+            isImplicit = false,
+            isErased = name.isErasedFunction)
+          decls.enter(newMethod(cls, nme.apply, methodType(argParamRefs, resParamRef), Deferred))
+          denot.info =
+            ClassInfo(ScalaPackageClass.thisType, cls, ObjectType :: Nil, decls)
+      }
+    }
+    if impure then
+      newPermanentSymbol(ScalaPackageClass, name, EmptyFlags, completer)
+    else
+      newPermanentClassSymbol(ScalaPackageClass, name, Trait | NoInits, completer)
+  }
+
+  private def newMethod(cls: ClassSymbol, name: TermName, info: Type, flags: FlagSet = EmptyFlags): TermSymbol =
+    newPermanentSymbol(cls, name, flags | Method, info).asTerm
+
+  private def enterMethod(cls: ClassSymbol, name: TermName, info: Type, flags: FlagSet = EmptyFlags): TermSymbol =
+    newMethod(cls, name, info, flags).entered
+
+  private def enterPermanentSymbol(name: Name, info: Type, flags: FlagSet = EmptyFlags): Symbol =
+    val sym = newPermanentSymbol(ScalaPackageClass, name, flags, info)
+    ScalaPackageClass.currentPackageDecls.enter(sym)
+    sym
+
+  private def enterAliasType(name: TypeName, tpe: Type, flags: FlagSet = EmptyFlags): TypeSymbol =
+    enterPermanentSymbol(name, TypeAlias(tpe), flags).asType
+
+  private def enterBinaryAlias(name: TypeName, op: (Type, Type) => Type): TypeSymbol =
+    enterAliasType(name,
+      HKTypeLambda(TypeBounds.empty :: TypeBounds.empty :: Nil)(
+      tl => op(tl.paramRefs(0), tl.paramRefs(1))))
+
+  private def enterPolyMethod(cls: ClassSymbol, name: TermName, typeParamCount: Int,
+                    resultTypeFn: PolyType -> Type,
+                    flags: FlagSet = EmptyFlags,
+                    bounds: TypeBounds = TypeBounds.empty,
+                    useCompleter: Boolean = false) = {
+    val tparamNames = PolyType.syntheticParamNames(typeParamCount)
+    val tparamInfos = tparamNames map (_ => bounds)
+    def ptype = PolyType(tparamNames)(_ => tparamInfos, resultTypeFn)
+    val info =
+      if (useCompleter)
+        new LazyType {
+          def complete(denot: SymDenotation)(using Context): Unit =
+            denot.info = ptype
+        }
+      else ptype
+    enterMethod(cls, name, info, flags)
+  }
+
+  private def enterT1ParameterlessMethod(cls: ClassSymbol, name: TermName, resultTypeFn: PolyType -> Type, flags: FlagSet) =
+    enterPolyMethod(cls, name, 1, resultTypeFn, flags)
+
+  private def mkArityArray(name: String, arity: Int, countFrom: Int): Array[TypeRef | Null] = {
+    val arr = new Array[TypeRef | Null](arity + 1)
+    for (i <- countFrom to arity) arr(i) = requiredClassRef(name + i)
+    arr
+  }
+
+  private def completeClass(cls: ClassSymbol, ensureCtor: Boolean = true): ClassSymbol = {
+    if (ensureCtor) ensureConstructor(cls, cls.denot.asClass, EmptyScope)
+    if (cls.linkedClass.exists) cls.linkedClass.markAbsent()
+    cls
+  }
+
+  @tu lazy val RootClass: ClassSymbol = newPackageSymbol(
+    NoSymbol, nme.ROOT, (root, rootcls) => ctx.base.rootLoader(root)).moduleClass.asClass
+  @tu lazy val RootPackage: TermSymbol = newSymbol(
+    NoSymbol, nme.ROOTPKG, PackageCreationFlags, TypeRef(NoPrefix, RootClass))
+
+  @tu lazy val EmptyPackageVal: TermSymbol = newPackageSymbol(
+    RootClass, nme.EMPTY_PACKAGE, (emptypkg, emptycls) => ctx.base.rootLoader(emptypkg)).entered
+  @tu lazy val EmptyPackageClass: ClassSymbol = EmptyPackageVal.moduleClass.asClass
+
+  /** A package in which we can place all methods and types that are interpreted specially by the compiler */
+  @tu lazy val OpsPackageVal: TermSymbol = newCompletePackageSymbol(RootClass, nme.OPS_PACKAGE).entered
+  @tu lazy val OpsPackageClass: ClassSymbol = OpsPackageVal.moduleClass.asClass
+
+  @tu lazy val ScalaPackageVal: TermSymbol = requiredPackage(nme.scala)
+  @tu lazy val ScalaMathPackageVal: TermSymbol = requiredPackage("scala.math")
+  @tu lazy val ScalaPackageClass: ClassSymbol = {
+    val cls = ScalaPackageVal.moduleClass.asClass
+    cls.info.decls.openForMutations.useSynthesizer(
+      name =>
+        if (name.isTypeName && name.isSyntheticFunction) newFunctionNType(name.asTypeName)
+        else NoSymbol)
+    cls
+  }
+  @tu lazy val ScalaPackageObject: Symbol = requiredModule("scala.package")
+  @tu lazy val ScalaRuntimePackageVal: TermSymbol = requiredPackage("scala.runtime")
+  @tu lazy val ScalaRuntimePackageClass: ClassSymbol = ScalaRuntimePackageVal.moduleClass.asClass
+  @tu lazy val JavaPackageVal: TermSymbol = requiredPackage(nme.java)
+  @tu lazy val JavaPackageClass: ClassSymbol = JavaPackageVal.moduleClass.asClass
+  @tu lazy val JavaLangPackageVal: TermSymbol = requiredPackage(jnme.JavaLang)
+  @tu lazy val JavaLangPackageClass: ClassSymbol = JavaLangPackageVal.moduleClass.asClass
+
+  // fundamental modules
+  @tu lazy val SysPackage : Symbol = requiredModule("scala.sys.package")
+    @tu lazy val Sys_error: Symbol = SysPackage.moduleClass.requiredMethod(nme.error)
+
+  @tu lazy val ScalaXmlPackageClass: Symbol = getPackageClassIfDefined("scala.xml")
+
+  @tu lazy val CompiletimePackageClass: Symbol = requiredPackage("scala.compiletime").moduleClass
+    @tu lazy val Compiletime_codeOf: Symbol = CompiletimePackageClass.requiredMethod("codeOf")
+    @tu lazy val Compiletime_erasedValue  : Symbol = CompiletimePackageClass.requiredMethod("erasedValue")
+    @tu lazy val Compiletime_uninitialized: Symbol = CompiletimePackageClass.requiredMethod("uninitialized")
+    @tu lazy val Compiletime_error        : Symbol = CompiletimePackageClass.requiredMethod(nme.error)
+    @tu lazy val Compiletime_requireConst : Symbol = CompiletimePackageClass.requiredMethod("requireConst")
+    @tu lazy val Compiletime_constValue   : Symbol = CompiletimePackageClass.requiredMethod("constValue")
+    @tu lazy val Compiletime_constValueOpt: Symbol = CompiletimePackageClass.requiredMethod("constValueOpt")
+    @tu lazy val Compiletime_summonFrom   : Symbol = CompiletimePackageClass.requiredMethod("summonFrom")
+    @tu lazy val Compiletime_summonInline   : Symbol = CompiletimePackageClass.requiredMethod("summonInline")
+  @tu lazy val CompiletimeTestingPackage: Symbol = requiredPackage("scala.compiletime.testing")
+    @tu lazy val CompiletimeTesting_typeChecks: Symbol = CompiletimeTestingPackage.requiredMethod("typeChecks")
+    @tu lazy val CompiletimeTesting_typeCheckErrors: Symbol = CompiletimeTestingPackage.requiredMethod("typeCheckErrors")
+    @tu lazy val CompiletimeTesting_ErrorClass: ClassSymbol = requiredClass("scala.compiletime.testing.Error")
+    @tu lazy val CompiletimeTesting_Error: Symbol = requiredModule("scala.compiletime.testing.Error")
+      @tu lazy val CompiletimeTesting_Error_apply = CompiletimeTesting_Error.requiredMethod(nme.apply)
+    @tu lazy val CompiletimeTesting_ErrorKind: Symbol = requiredModule("scala.compiletime.testing.ErrorKind")
+      @tu lazy val CompiletimeTesting_ErrorKind_Parser: Symbol = CompiletimeTesting_ErrorKind.requiredMethod("Parser")
+      @tu lazy val CompiletimeTesting_ErrorKind_Typer: Symbol = CompiletimeTesting_ErrorKind.requiredMethod("Typer")
+  @tu lazy val CompiletimeOpsPackage: Symbol = requiredPackage("scala.compiletime.ops")
+    @tu lazy val CompiletimeOpsAnyModuleClass: Symbol = requiredModule("scala.compiletime.ops.any").moduleClass
+    @tu lazy val CompiletimeOpsIntModuleClass: Symbol = requiredModule("scala.compiletime.ops.int").moduleClass
+    @tu lazy val CompiletimeOpsLongModuleClass: Symbol = requiredModule("scala.compiletime.ops.long").moduleClass
+    @tu lazy val CompiletimeOpsFloatModuleClass: Symbol = requiredModule("scala.compiletime.ops.float").moduleClass
+    @tu lazy val CompiletimeOpsDoubleModuleClass: Symbol = requiredModule("scala.compiletime.ops.double").moduleClass
+    @tu lazy val CompiletimeOpsStringModuleClass: Symbol = requiredModule("scala.compiletime.ops.string").moduleClass
+    @tu lazy val CompiletimeOpsBooleanModuleClass: Symbol = requiredModule("scala.compiletime.ops.boolean").moduleClass
+
+  /** Note: We cannot have same named methods defined in Object and Any (and AnyVal, for that matter)
+   *  because after erasure the Any and AnyVal references get remapped to the Object methods
+   *  which would result in a double binding assertion failure.
+   * Instead we do the following:
+   *
+   *  - Have some methods exist only in Any, and remap them with the Erasure denotation
+   *    transformer to be owned by Object.
+   *  - Have other methods exist only in Object.
+   * To achieve this, we synthesize all Any and Object methods; Object methods no longer get
+   * loaded from a classfile.
+   */
+  @tu lazy val AnyClass: ClassSymbol = completeClass(enterCompleteClassSymbol(ScalaPackageClass, tpnme.Any, Abstract, Nil), ensureCtor = false)
+  def AnyType: TypeRef = AnyClass.typeRef
+  @tu lazy val MatchableClass: ClassSymbol = completeClass(enterCompleteClassSymbol(ScalaPackageClass, tpnme.Matchable, Trait, AnyType :: Nil), ensureCtor = false)
+  def MatchableType: TypeRef = MatchableClass.typeRef
+  @tu lazy val AnyValClass: ClassSymbol =
+    val res = completeClass(enterCompleteClassSymbol(ScalaPackageClass, tpnme.AnyVal, Abstract, List(AnyType, MatchableType)))
+    // Mark companion as absent, so that class does not get re-completed
+    val companion = ScalaPackageVal.info.decl(nme.AnyVal).symbol
+    companion.moduleClass.markAbsent()
+    companion.markAbsent()
+    res
+
+  def AnyValType: TypeRef = AnyValClass.typeRef
+
+    @tu lazy val Any_== : TermSymbol          = enterMethod(AnyClass, nme.EQ, methOfAny(BooleanType), Final)
+    @tu lazy val Any_!= : TermSymbol          = enterMethod(AnyClass, nme.NE, methOfAny(BooleanType), Final)
+    @tu lazy val Any_equals: TermSymbol       = enterMethod(AnyClass, nme.equals_, methOfAny(BooleanType))
+    @tu lazy val Any_hashCode: TermSymbol     = enterMethod(AnyClass, nme.hashCode_, MethodType(Nil, IntType))
+    @tu lazy val Any_toString: TermSymbol     = enterMethod(AnyClass, nme.toString_, MethodType(Nil, StringType))
+    @tu lazy val Any_## : TermSymbol          = enterMethod(AnyClass, nme.HASHHASH, ExprType(IntType), Final)
+    @tu lazy val Any_isInstanceOf: TermSymbol = enterT1ParameterlessMethod(AnyClass, nme.isInstanceOf_, _ => BooleanType, Final)
+    @tu lazy val Any_asInstanceOf: TermSymbol = enterT1ParameterlessMethod(AnyClass, nme.asInstanceOf_, _.paramRefs(0), Final)
+    @tu lazy val Any_typeTest: TermSymbol     = enterT1ParameterlessMethod(AnyClass, nme.isInstanceOfPM, _ => BooleanType, Final | SyntheticArtifact)
+    @tu lazy val Any_typeCast: TermSymbol     = enterT1ParameterlessMethod(AnyClass, nme.asInstanceOfPM, _.paramRefs(0), Final | SyntheticArtifact | StableRealizable)
+      // generated by pattern matcher and explicit nulls, eliminated by erasure
+
+    /** def getClass[A >: this.type](): Class[? <: A] */
+    @tu lazy val Any_getClass: TermSymbol =
+        enterPolyMethod(
+          AnyClass, nme.getClass_, 1,
+          pt => MethodType(Nil, ClassClass.typeRef.appliedTo(TypeBounds.upper(pt.paramRefs(0)))),
+          Final,
+          bounds = TypeBounds.lower(AnyClass.thisType))
+
+    def AnyMethods: List[TermSymbol] = List(Any_==, Any_!=, Any_equals, Any_hashCode,
+      Any_toString, Any_##, Any_getClass, Any_isInstanceOf, Any_asInstanceOf, Any_typeTest, Any_typeCast)
+
+  @tu lazy val ObjectClass: ClassSymbol = {
+    val cls = requiredClass("java.lang.Object")
+    assert(!cls.isCompleted, "race for completing java.lang.Object")
+    cls.info = ClassInfo(cls.owner.thisType, cls, List(AnyType, MatchableType), newScope)
+    cls.setFlag(NoInits | JavaDefined)
+
+    ensureConstructor(cls, cls.denot.asClass, EmptyScope)
+    val companion = JavaLangPackageVal.info.decl(nme.Object).symbol.asTerm
+    NamerOps.makeConstructorCompanion(companion, cls)
+    cls
+  }
+  def ObjectType: TypeRef = ObjectClass.typeRef
+
+  /** A type alias of Object used to represent any reference to Object in a Java
+   *  signature, the secret sauce is that subtype checking treats it specially:
+   *
+   *    tp <:< FromJavaObject
+   *
+   *  is equivalent to:
+   *
+   *    tp <:< Any
+   *
+   *  This is useful to avoid usability problems when interacting with Java
+   *  code where Object is the top type. This is safe because this type will
+   *  only appear in signatures of Java definitions in positions where `Object`
+   *  might appear, let's enumerate all possible cases this gives us:
+   *
+   *  1. At the top level:
+   *
+   *       // A.java
+   *       void meth1(Object arg) {}
+   *       <T> void meth2(T arg) {} // T implicitly extends Object
+   *
+   *       // B.scala
+   *       meth1(1) // OK
+   *       meth2(1) // OK
+   *
+   *     This is safe even though Int is not a subtype of Object, because Erasure
+   *     will detect the mismatch and box the value type.
+   *
+   *  2. In a class type parameter:
+   *
+   *       // A.java
+   *       void meth3(scala.List<Object> arg) {}
+   *       <T> void meth4(scala.List<T> arg) {}
+   *
+   *       // B.scala
+   *       meth3(List[Int](1)) // OK
+   *       meth4(List[Int](1)) // OK
+   *
+   *     At erasure, type parameters are removed and value types are boxed.
+   *
+   *  3. As the type parameter of an array:
+   *
+   *       // A.java
+   *       void meth5(Object[] arg) {}
+   *       <T> void meth6(T[] arg) {}
+   *
+   *       // B.scala
+   *       meth5(Array[Int](1)) // error: Array[Int] is not a subtype of Array[Object]
+   *       meth6(Array[Int](1)) // error: Array[Int] is not a subtype of Array[T & Object]
+   *
+   *
+   *     This is a bit more subtle: at erasure, Arrays keep their type parameter,
+   *     and primitive Arrays are not subtypes of reference Arrays on the JVM,
+   *     so we can't pass an Array of Int where a reference Array is expected.
+   *     Array is invariant in Scala, so `meth5` is safe even if we use `FromJavaObject`,
+   *     but generic Arrays are treated specially: we always add `& Object` (and here
+   *     we mean the normal java.lang.Object type) to these types when they come from
+   *     Java signatures (see `translateJavaArrayElementType`), this ensure that `meth6`
+   *     is safe to use.
+   *
+   *  4. As the repeated argument of a varargs method:
+   *
+   *       // A.java
+   *       void meth7(Object... args) {}
+   *       <T> void meth8(T... args) {}
+   *
+   *       // B.scala
+   *       meth7(1) // OK (creates a reference array)
+   *       meth8(1) // OK (creates a primitive array and copies it into a reference array at Erasure)
+   *       val ai = Array[Int](1)
+   *       meth7(ai: _*) // OK (will copy the array at Erasure)
+   *       meth8(ai: _*) // OK (will copy the array at Erasure)
+   *
+   *     Java repeated arguments are erased to arrays, so it would be safe to treat
+   *     them in the same way: add an `& Object` to the parameter type to disallow
+   *     passing primitives, but that would be very inconvenient as it is common to
+   *     want to pass a primitive to an Object repeated argument (e.g.
+   *     `String.format("foo: %d", 1)`). So instead we type them _without_ adding the
+   *     `& Object` and let `ElimRepeated` and `Erasure` take care of doing any necessary adaptation
+   *     (note that adapting a primitive array to a reference array requires
+   *     copying the whole array, so this transformation only preserves semantics
+   *     if the callee does not try to mutate the varargs array which is a reasonable
+   *     assumption to make).
+   *
+   *
+   *  This mechanism is similar to `ObjectTpeJavaRef` in Scala 2, except that we
+   *  create a new symbol with its own name, this is needed because this type
+   *  can show up in inferred types and therefore needs to be preserved when
+   *  pickling so that unpickled trees pass `-Ycheck`.
+   *
+   *  Note that by default we pretty-print `FromJavaObject` as `Object` or simply omit it
+   *  if it's the sole upper-bound of a type parameter, use `-Yprint-debug` to explicitly
+   *  display it.
+   */
+  @tu lazy val FromJavaObjectSymbol: TypeSymbol =
+    newPermanentSymbol(OpsPackageClass, tpnme.FromJavaObject, JavaDefined, TypeAlias(ObjectType)).entered
+  def FromJavaObjectType: TypeRef = FromJavaObjectSymbol.typeRef
+
+  @tu lazy val AnyRefAlias: TypeSymbol = enterAliasType(tpnme.AnyRef, ObjectType)
+  def AnyRefType: TypeRef = AnyRefAlias.typeRef
+
+    @tu lazy val Object_eq: TermSymbol = enterMethod(ObjectClass, nme.eq, methOfAnyRef(BooleanType), Final)
+    @tu lazy val Object_ne: TermSymbol = enterMethod(ObjectClass, nme.ne, methOfAnyRef(BooleanType), Final)
+    @tu lazy val Object_synchronized: TermSymbol = enterPolyMethod(ObjectClass, nme.synchronized_, 1,
+        pt => MethodType(List(pt.paramRefs(0)), pt.paramRefs(0)), Final)
+    @tu lazy val Object_clone: TermSymbol = enterMethod(ObjectClass, nme.clone_, MethodType(Nil, ObjectType), Protected)
+    @tu lazy val Object_finalize: TermSymbol = enterMethod(ObjectClass, nme.finalize_, MethodType(Nil, UnitType), Protected)
+    @tu lazy val Object_notify: TermSymbol = enterMethod(ObjectClass, nme.notify_, MethodType(Nil, UnitType), Final)
+    @tu lazy val Object_notifyAll: TermSymbol = enterMethod(ObjectClass, nme.notifyAll_, MethodType(Nil, UnitType), Final)
+    @tu lazy val Object_wait: TermSymbol = enterMethod(ObjectClass, nme.wait_, MethodType(Nil, UnitType), Final)
+    @tu lazy val Object_waitL: TermSymbol = enterMethod(ObjectClass, nme.wait_, MethodType(LongType :: Nil, UnitType), Final)
+    @tu lazy val Object_waitLI: TermSymbol = enterMethod(ObjectClass, nme.wait_, MethodType(LongType :: IntType :: Nil, UnitType), Final)
+
+    def ObjectMethods: List[TermSymbol] = List(Object_eq, Object_ne, Object_synchronized, Object_clone,
+        Object_finalize, Object_notify, Object_notifyAll, Object_wait, Object_waitL, Object_waitLI)
+
+  /** Methods in Object and Any that do not have a side effect */
+  @tu lazy val pureMethods: List[TermSymbol] = List(Any_==, Any_!=, Any_equals, Any_hashCode,
+    Any_toString, Any_##, Any_getClass, Any_isInstanceOf, Any_typeTest, Object_eq, Object_ne)
+
+  @tu lazy val AnyKindClass: ClassSymbol = {
+    val cls = newCompleteClassSymbol(ScalaPackageClass, tpnme.AnyKind, AbstractFinal | Permanent, Nil, newScope(0))
+    if (!ctx.settings.YnoKindPolymorphism.value)
+      // Enable kind-polymorphism by exposing scala.AnyKind
+      cls.entered
+    cls
+  }
+  def AnyKindType: TypeRef = AnyKindClass.typeRef
+
+  @tu lazy val andType: TypeSymbol = enterBinaryAlias(tpnme.AND, AndType(_, _))
+  @tu lazy val orType: TypeSymbol = enterBinaryAlias(tpnme.OR, OrType(_, _, soft = false))
+
+  /** Method representing a throw */
+  @tu lazy val throwMethod: TermSymbol = enterMethod(OpsPackageClass, nme.THROWkw,
+      MethodType(List(ThrowableType), NothingType))
+
+  @tu lazy val NothingClass: ClassSymbol = enterCompleteClassSymbol(
+    ScalaPackageClass, tpnme.Nothing, AbstractFinal, List(AnyType))
+  def NothingType: TypeRef = NothingClass.typeRef
+  @tu lazy val NullClass: ClassSymbol = {
+    // When explicit-nulls is enabled, Null becomes a direct subtype of Any and Matchable
+    val parents = if ctx.explicitNulls then AnyType :: MatchableType :: Nil else ObjectType :: Nil
+    enterCompleteClassSymbol(ScalaPackageClass, tpnme.Null, AbstractFinal, parents)
+  }
+  def NullType: TypeRef = NullClass.typeRef
+
+  @tu lazy val InvokerModule = requiredModule("scala.runtime.coverage.Invoker")
+  @tu lazy val InvokedMethodRef = InvokerModule.requiredMethodRef("invoked")
+
+  @tu lazy val ImplicitScrutineeTypeSym =
+    newPermanentSymbol(ScalaPackageClass, tpnme.IMPLICITkw, EmptyFlags, TypeBounds.empty).entered
+  def ImplicitScrutineeTypeRef: TypeRef = ImplicitScrutineeTypeSym.typeRef
+
+  @tu lazy val ScalaPredefModule: Symbol = requiredModule("scala.Predef")
+    @tu lazy val Predef_conforms : Symbol = ScalaPredefModule.requiredMethod(nme.conforms_)
+    @tu lazy val Predef_classOf  : Symbol = ScalaPredefModule.requiredMethod(nme.classOf)
+    @tu lazy val Predef_identity : Symbol = ScalaPredefModule.requiredMethod(nme.identity)
+    @tu lazy val Predef_undefined: Symbol = ScalaPredefModule.requiredMethod(nme.???)
+  @tu lazy val ScalaPredefModuleClass: ClassSymbol = ScalaPredefModule.moduleClass.asClass
+
+  @tu lazy val SubTypeClass: ClassSymbol = requiredClass("scala.<:<")
+  @tu lazy val SubType_refl: Symbol = SubTypeClass.companionModule.requiredMethod(nme.refl)
+
+  @tu lazy val DummyImplicitClass: ClassSymbol = requiredClass("scala.DummyImplicit")
+
+  @tu lazy val ScalaRuntimeModule: Symbol = requiredModule("scala.runtime.ScalaRunTime")
+    def runtimeMethodRef(name: PreName): TermRef = ScalaRuntimeModule.requiredMethodRef(name)
+    def ScalaRuntime_drop: Symbol = runtimeMethodRef(nme.drop).symbol
+    @tu lazy val ScalaRuntime__hashCode: Symbol = ScalaRuntimeModule.requiredMethod(nme._hashCode_)
+    @tu lazy val ScalaRuntime_toArray: Symbol = ScalaRuntimeModule.requiredMethod(nme.toArray)
+    @tu lazy val ScalaRuntime_toObjectArray: Symbol = ScalaRuntimeModule.requiredMethod(nme.toObjectArray)
+
+  @tu lazy val BoxesRunTimeModule: Symbol = requiredModule("scala.runtime.BoxesRunTime")
+    @tu lazy val BoxesRunTimeModule_externalEquals: Symbol = BoxesRunTimeModule.info.decl(nme.equals_).suchThat(toDenot(_).info.firstParamTypes.size == 2).symbol
+  @tu lazy val ScalaStaticsModule: Symbol = requiredModule("scala.runtime.Statics")
+    def staticsMethodRef(name: PreName): TermRef = ScalaStaticsModule.requiredMethodRef(name)
+    def staticsMethod(name: PreName): TermSymbol = ScalaStaticsModule.requiredMethod(name)
+
+  @tu lazy val DottyArraysModule: Symbol = requiredModule("scala.runtime.Arrays")
+    def newGenericArrayMethod(using Context): TermSymbol = DottyArraysModule.requiredMethod("newGenericArray")
+    def newArrayMethod(using Context): TermSymbol = DottyArraysModule.requiredMethod("newArray")
+
+  def getWrapVarargsArrayModule: Symbol = ScalaRuntimeModule
+
+  // The set of all wrap{X, Ref}Array methods, where X is a value type
+  val WrapArrayMethods: PerRun[collection.Set[Symbol]] = new PerRun({
+    val methodNames = ScalaValueTypes.map(ast.tpd.wrapArrayMethodName) `union` Set(nme.wrapRefArray)
+    methodNames.map(getWrapVarargsArrayModule.requiredMethod(_))
+  })
+
+  @tu lazy val ListClass: Symbol       = requiredClass("scala.collection.immutable.List")
+  @tu lazy val ListModule: Symbol      = requiredModule("scala.collection.immutable.List")
+  @tu lazy val NilModule: Symbol       = requiredModule("scala.collection.immutable.Nil")
+  @tu lazy val ConsClass: Symbol       = requiredClass("scala.collection.immutable.::")
+  @tu lazy val SeqFactoryClass: Symbol = requiredClass("scala.collection.SeqFactory")
+
+  @tu lazy val SingletonClass: ClassSymbol =
+    // needed as a synthetic class because Scala 2.x refers to it in classfiles
+    // but does not define it as an explicit class.
+    enterCompleteClassSymbol(
+      ScalaPackageClass, tpnme.Singleton, PureInterfaceCreationFlags | Final,
+      List(AnyType), EmptyScope)
+  @tu lazy val SingletonType: TypeRef = SingletonClass.typeRef
+
+  @tu lazy val CollectionSeqType: TypeRef = requiredClassRef("scala.collection.Seq")
+  @tu lazy val SeqType: TypeRef = requiredClassRef("scala.collection.immutable.Seq")
+  def SeqClass(using Context): ClassSymbol = SeqType.symbol.asClass
+    @tu lazy val Seq_apply        : Symbol = SeqClass.requiredMethod(nme.apply)
+    @tu lazy val Seq_head         : Symbol = SeqClass.requiredMethod(nme.head)
+    @tu lazy val Seq_drop         : Symbol = SeqClass.requiredMethod(nme.drop)
+    @tu lazy val Seq_lengthCompare: Symbol = SeqClass.requiredMethod(nme.lengthCompare, List(IntType))
+    @tu lazy val Seq_length       : Symbol = SeqClass.requiredMethod(nme.length)
+    @tu lazy val Seq_toSeq        : Symbol = SeqClass.requiredMethod(nme.toSeq)
+  @tu lazy val SeqModule: Symbol = requiredModule("scala.collection.immutable.Seq")
+
+
+  @tu lazy val StringOps: Symbol = requiredClass("scala.collection.StringOps")
+    @tu lazy val StringOps_format: Symbol  = StringOps.requiredMethod(nme.format)
+
+  @tu lazy val ArrayType: TypeRef = requiredClassRef("scala.Array")
+  def ArrayClass(using Context): ClassSymbol = ArrayType.symbol.asClass
+    @tu lazy val Array_apply     : Symbol = ArrayClass.requiredMethod(nme.apply)
+    @tu lazy val Array_update    : Symbol = ArrayClass.requiredMethod(nme.update)
+    @tu lazy val Array_length    : Symbol = ArrayClass.requiredMethod(nme.length)
+    @tu lazy val Array_clone     : Symbol = ArrayClass.requiredMethod(nme.clone_)
+    @tu lazy val ArrayConstructor: Symbol = ArrayClass.requiredMethod(nme.CONSTRUCTOR)
+
+  @tu lazy val ArrayModule: Symbol = requiredModule("scala.Array")
+  def ArrayModuleClass: Symbol = ArrayModule.moduleClass
+
+  @tu lazy val IArrayModule: Symbol = requiredModule("scala.IArray")
+  def IArrayModuleClass: Symbol = IArrayModule.moduleClass
+
+  @tu lazy val UnitType: TypeRef = valueTypeRef("scala.Unit", java.lang.Void.TYPE, UnitEnc, nme.specializedTypeNames.Void)
+  def UnitClass(using Context): ClassSymbol = UnitType.symbol.asClass
+  def UnitModuleClass(using Context): Symbol = UnitType.symbol.asClass.linkedClass
+  @tu lazy val BooleanType: TypeRef = valueTypeRef("scala.Boolean", java.lang.Boolean.TYPE, BooleanEnc, nme.specializedTypeNames.Boolean)
+  def BooleanClass(using Context): ClassSymbol = BooleanType.symbol.asClass
+    @tu lazy val Boolean_!  : Symbol = BooleanClass.requiredMethod(nme.UNARY_!)
+    @tu lazy val Boolean_&& : Symbol = BooleanClass.requiredMethod(nme.ZAND) // ### harmonize required... calls
+    @tu lazy val Boolean_|| : Symbol = BooleanClass.requiredMethod(nme.ZOR)
+    @tu lazy val Boolean_== : Symbol =
+      BooleanClass.info.member(nme.EQ).suchThat(_.info.firstParamTypes match {
+        case List(pt) => pt.isRef(BooleanClass)
+        case _ => false
+      }).symbol
+    @tu lazy val Boolean_!= : Symbol =
+      BooleanClass.info.member(nme.NE).suchThat(_.info.firstParamTypes match {
+        case List(pt) => pt.isRef(BooleanClass)
+        case _ => false
+      }).symbol
+
+  @tu lazy val ByteType: TypeRef = valueTypeRef("scala.Byte", java.lang.Byte.TYPE, ByteEnc, nme.specializedTypeNames.Byte)
+  def ByteClass(using Context): ClassSymbol = ByteType.symbol.asClass
+  @tu lazy val ShortType: TypeRef = valueTypeRef("scala.Short", java.lang.Short.TYPE, ShortEnc, nme.specializedTypeNames.Short)
+  def ShortClass(using Context): ClassSymbol = ShortType.symbol.asClass
+  @tu lazy val CharType: TypeRef = valueTypeRef("scala.Char", java.lang.Character.TYPE, CharEnc, nme.specializedTypeNames.Char)
+  def CharClass(using Context): ClassSymbol = CharType.symbol.asClass
+  @tu lazy val IntType: TypeRef = valueTypeRef("scala.Int", java.lang.Integer.TYPE, IntEnc, nme.specializedTypeNames.Int)
+  def IntClass(using Context): ClassSymbol = IntType.symbol.asClass
+    @tu lazy val Int_-  : Symbol = IntClass.requiredMethod(nme.MINUS, List(IntType))
+    @tu lazy val Int_+  : Symbol = IntClass.requiredMethod(nme.PLUS, List(IntType))
+    @tu lazy val Int_/  : Symbol = IntClass.requiredMethod(nme.DIV, List(IntType))
+    @tu lazy val Int_*  : Symbol = IntClass.requiredMethod(nme.MUL, List(IntType))
+    @tu lazy val Int_== : Symbol = IntClass.requiredMethod(nme.EQ, List(IntType))
+    @tu lazy val Int_>= : Symbol = IntClass.requiredMethod(nme.GE, List(IntType))
+    @tu lazy val Int_<= : Symbol = IntClass.requiredMethod(nme.LE, List(IntType))
+  @tu lazy val LongType: TypeRef = valueTypeRef("scala.Long", java.lang.Long.TYPE, LongEnc, nme.specializedTypeNames.Long)
+  def LongClass(using Context): ClassSymbol = LongType.symbol.asClass
+    @tu lazy val Long_+ : Symbol = LongClass.requiredMethod(nme.PLUS, List(LongType))
+    @tu lazy val Long_* : Symbol = LongClass.requiredMethod(nme.MUL, List(LongType))
+    @tu lazy val Long_/ : Symbol = LongClass.requiredMethod(nme.DIV, List(LongType))
+
+  @tu lazy val FloatType: TypeRef = valueTypeRef("scala.Float", java.lang.Float.TYPE, FloatEnc, nme.specializedTypeNames.Float)
+  def FloatClass(using Context): ClassSymbol = FloatType.symbol.asClass
+  @tu lazy val DoubleType: TypeRef = valueTypeRef("scala.Double", java.lang.Double.TYPE, DoubleEnc, nme.specializedTypeNames.Double)
+  def DoubleClass(using Context): ClassSymbol = DoubleType.symbol.asClass
+
+  @tu lazy val BoxedUnitClass: ClassSymbol = requiredClass("scala.runtime.BoxedUnit")
+    def BoxedUnit_UNIT(using Context): TermSymbol = BoxedUnitClass.linkedClass.requiredValue("UNIT")
+    def BoxedUnit_TYPE(using Context): TermSymbol = BoxedUnitClass.linkedClass.requiredValue("TYPE")
+
+  @tu lazy val BoxedBooleanClass: ClassSymbol = requiredClass("java.lang.Boolean")
+  @tu lazy val BoxedByteClass   : ClassSymbol = requiredClass("java.lang.Byte")
+  @tu lazy val BoxedShortClass  : ClassSymbol = requiredClass("java.lang.Short")
+  @tu lazy val BoxedCharClass   : ClassSymbol = requiredClass("java.lang.Character")
+  @tu lazy val BoxedIntClass    : ClassSymbol = requiredClass("java.lang.Integer")
+  @tu lazy val BoxedLongClass   : ClassSymbol = requiredClass("java.lang.Long")
+  @tu lazy val BoxedFloatClass  : ClassSymbol = requiredClass("java.lang.Float")
+  @tu lazy val BoxedDoubleClass : ClassSymbol = requiredClass("java.lang.Double")
+
+  @tu lazy val BoxedBooleanModule: TermSymbol = requiredModule("java.lang.Boolean")
+  @tu lazy val BoxedByteModule   : TermSymbol = requiredModule("java.lang.Byte")
+  @tu lazy val BoxedShortModule  : TermSymbol = requiredModule("java.lang.Short")
+  @tu lazy val BoxedCharModule   : TermSymbol = requiredModule("java.lang.Character")
+  @tu lazy val BoxedIntModule    : TermSymbol = requiredModule("java.lang.Integer")
+  @tu lazy val BoxedLongModule   : TermSymbol = requiredModule("java.lang.Long")
+  @tu lazy val BoxedFloatModule  : TermSymbol = requiredModule("java.lang.Float")
+  @tu lazy val BoxedDoubleModule : TermSymbol = requiredModule("java.lang.Double")
+  @tu lazy val BoxedUnitModule   : TermSymbol = requiredModule("java.lang.Void")
+
+  @tu lazy val ByNameParamClass2x: ClassSymbol = enterSpecialPolyClass(tpnme.BYNAME_PARAM_CLASS, Covariant, Seq(AnyType))
+
+  @tu lazy val RepeatedParamClass: ClassSymbol = enterSpecialPolyClass(tpnme.REPEATED_PARAM_CLASS, Covariant, Seq(ObjectType, SeqType))
+
+  // fundamental classes
+  @tu lazy val StringClass: ClassSymbol = requiredClass("java.lang.String")
+  def StringType: Type = StringClass.typeRef
+  @tu lazy val StringModule: Symbol = StringClass.linkedClass
+    @tu lazy val String_+ : TermSymbol = enterMethod(StringClass, nme.raw.PLUS, methOfAny(StringType), Final)
+    @tu lazy val String_valueOf_Object: Symbol = StringModule.info.member(nme.valueOf).suchThat(_.info.firstParamTypes match {
+      case List(pt) => pt.isAny || pt.stripNull.isAnyRef
+      case _ => false
+    }).symbol
+
+  @tu lazy val JavaCloneableClass: ClassSymbol        = requiredClass("java.lang.Cloneable")
+  @tu lazy val NullPointerExceptionClass: ClassSymbol = requiredClass("java.lang.NullPointerException")
+  @tu lazy val IndexOutOfBoundsException: ClassSymbol = requiredClass("java.lang.IndexOutOfBoundsException")
+  @tu lazy val ClassClass: ClassSymbol                = requiredClass("java.lang.Class")
+  @tu lazy val BoxedNumberClass: ClassSymbol          = requiredClass("java.lang.Number")
+  @tu lazy val ClassCastExceptionClass: ClassSymbol   = requiredClass("java.lang.ClassCastException")
+    @tu lazy val ClassCastExceptionClass_stringConstructor: TermSymbol  = ClassCastExceptionClass.info.member(nme.CONSTRUCTOR).suchThat(_.info.firstParamTypes match {
+      case List(pt) =>
+        pt.stripNull.isRef(StringClass)
+      case _ => false
+    }).symbol.asTerm
+  @tu lazy val ArithmeticExceptionClass: ClassSymbol  = requiredClass("java.lang.ArithmeticException")
+    @tu lazy val ArithmeticExceptionClass_stringConstructor: TermSymbol  = ArithmeticExceptionClass.info.member(nme.CONSTRUCTOR).suchThat(_.info.firstParamTypes match {
+      case List(pt) =>
+        pt.stripNull.isRef(StringClass)
+      case _ => false
+    }).symbol.asTerm
+
+  @tu lazy val JavaSerializableClass: ClassSymbol     = requiredClass("java.io.Serializable")
+
+  @tu lazy val ComparableClass: ClassSymbol           = requiredClass("java.lang.Comparable")
+
+  @tu lazy val SystemClass: ClassSymbol               = requiredClass("java.lang.System")
+  @tu lazy val SystemModule: Symbol              = SystemClass.linkedClass
+
+  @tu lazy val NoSuchElementExceptionClass = requiredClass("java.util.NoSuchElementException")
+  def NoSuchElementExceptionType = NoSuchElementExceptionClass.typeRef
+  @tu lazy val IllegalArgumentExceptionClass = requiredClass("java.lang.IllegalArgumentException")
+  def IllegalArgumentExceptionType = IllegalArgumentExceptionClass.typeRef
+
+  // in scalac modified to have Any as parent
+
+  @tu lazy val ThrowableType: TypeRef             = requiredClassRef("java.lang.Throwable")
+  def ThrowableClass(using Context): ClassSymbol  = ThrowableType.symbol.asClass
+  @tu lazy val ExceptionClass: ClassSymbol        = requiredClass("java.lang.Exception")
+  @tu lazy val RuntimeExceptionClass: ClassSymbol = requiredClass("java.lang.RuntimeException")
+
+  @tu lazy val SerializableType: TypeRef       = JavaSerializableClass.typeRef
+  def SerializableClass(using Context): ClassSymbol = SerializableType.symbol.asClass
+
+  @tu lazy val JavaBigIntegerClass: ClassSymbol = requiredClass("java.math.BigInteger")
+  @tu lazy val JavaBigDecimalClass: ClassSymbol = requiredClass("java.math.BigDecimal")
+  @tu lazy val JavaCalendarClass: ClassSymbol = requiredClass("java.util.Calendar")
+  @tu lazy val JavaDateClass: ClassSymbol = requiredClass("java.util.Date")
+  @tu lazy val JavaFormattableClass: ClassSymbol = requiredClass("java.util.Formattable")
+
+  @tu lazy val JavaEnumClass: ClassSymbol = {
+    val cls = requiredClass("java.lang.Enum")
+    // jl.Enum has a single constructor protected(name: String, ordinal: Int).
+    // We remove the arguments from the primary constructor, and enter
+    // a new constructor symbol with 2 arguments, so that both
+    // `X extends jl.Enum[X]` and `X extends jl.Enum[X](name, ordinal)`
+    // pass typer and go through jl.Enum-specific checks in RefChecks.
+    cls.infoOrCompleter match {
+      case completer: ClassfileLoader =>
+        cls.info = new ClassfileLoader(completer.classfile) {
+          override def complete(root: SymDenotation)(using Context): Unit = {
+            super.complete(root)
+            val constr = cls.primaryConstructor
+            val noArgInfo = constr.info match {
+              case info: PolyType =>
+                info.resType match {
+                  case meth: MethodType =>
+                    info.derivedLambdaType(
+                      resType = meth.derivedLambdaType(
+                      paramNames = Nil, paramInfos = Nil))
+                }
+            }
+            val argConstr = constr.copy().entered
+            constr.info = noArgInfo
+            constr.termRef.recomputeDenot()
+          }
+        }
+        cls
+    }
+  }
+  def JavaEnumType = JavaEnumClass.typeRef
+
+  @tu lazy val StringBuilderClass: ClassSymbol = requiredClass("scala.collection.mutable.StringBuilder")
+  @tu lazy val MatchErrorClass   : ClassSymbol = requiredClass("scala.MatchError")
+  @tu lazy val ConversionClass   : ClassSymbol = requiredClass("scala.Conversion").typeRef.symbol.asClass
+
+  @tu lazy val StringAddClass    : ClassSymbol = requiredClass("scala.runtime.StringAdd")
+    @tu lazy val StringAdd_+ : Symbol = StringAddClass.requiredMethod(nme.raw.PLUS)
+
+  @tu lazy val StringContextClass: ClassSymbol = requiredClass("scala.StringContext")
+    @tu lazy val StringContext_s  : Symbol = StringContextClass.requiredMethod(nme.s)
+    @tu lazy val StringContext_raw: Symbol = StringContextClass.requiredMethod(nme.raw_)
+    @tu lazy val StringContext_f  : Symbol = StringContextClass.requiredMethod(nme.f)
+    @tu lazy val StringContext_parts: Symbol = StringContextClass.requiredMethod(nme.parts)
+  @tu lazy val StringContextModule: Symbol = StringContextClass.companionModule
+    @tu lazy val StringContextModule_apply: Symbol = StringContextModule.requiredMethod(nme.apply)
+    @tu lazy val StringContextModule_standardInterpolator: Symbol = StringContextModule.requiredMethod(nme.standardInterpolator)
+    @tu lazy val StringContextModule_processEscapes: Symbol = StringContextModule.requiredMethod(nme.processEscapes)
+
+  @tu lazy val PartialFunctionClass: ClassSymbol = requiredClass("scala.PartialFunction")
+    @tu lazy val PartialFunction_isDefinedAt: Symbol = PartialFunctionClass.requiredMethod(nme.isDefinedAt)
+    @tu lazy val PartialFunction_applyOrElse: Symbol = PartialFunctionClass.requiredMethod(nme.applyOrElse)
+
+  @tu lazy val AbstractPartialFunctionClass: ClassSymbol = requiredClass("scala.runtime.AbstractPartialFunction")
+  @tu lazy val FunctionXXLClass: ClassSymbol = requiredClass("scala.runtime.FunctionXXL")
+  @tu lazy val ScalaSymbolClass: ClassSymbol = requiredClass("scala.Symbol")
+  @tu lazy val DynamicClass: ClassSymbol = requiredClass("scala.Dynamic")
+  @tu lazy val OptionClass: ClassSymbol = requiredClass("scala.Option")
+  @tu lazy val SomeClass: ClassSymbol = requiredClass("scala.Some")
+  @tu lazy val NoneModule: Symbol = requiredModule("scala.None")
+
+  @tu lazy val EnumClass: ClassSymbol = requiredClass("scala.reflect.Enum")
+    @tu lazy val Enum_ordinal: Symbol = EnumClass.requiredMethod(nme.ordinal)
+
+  @tu lazy val EnumValueSerializationProxyClass: ClassSymbol = requiredClass("scala.runtime.EnumValueSerializationProxy")
+    @tu lazy val EnumValueSerializationProxyConstructor: TermSymbol =
+      EnumValueSerializationProxyClass.requiredMethod(nme.CONSTRUCTOR, List(ClassType(TypeBounds.empty), IntType))
+
+  @tu lazy val ProductClass: ClassSymbol = requiredClass("scala.Product")
+    @tu lazy val Product_canEqual          : Symbol = ProductClass.requiredMethod(nme.canEqual_)
+    @tu lazy val Product_productArity      : Symbol = ProductClass.requiredMethod(nme.productArity)
+    @tu lazy val Product_productElement    : Symbol = ProductClass.requiredMethod(nme.productElement)
+    @tu lazy val Product_productElementName: Symbol = ProductClass.requiredMethod(nme.productElementName)
+    @tu lazy val Product_productPrefix     : Symbol = ProductClass.requiredMethod(nme.productPrefix)
+
+  @tu lazy val IteratorClass: ClassSymbol = requiredClass("scala.collection.Iterator")
+  def IteratorModule(using Context): Symbol = IteratorClass.companionModule
+
+  @tu lazy val ModuleSerializationProxyClass: ClassSymbol = requiredClass("scala.runtime.ModuleSerializationProxy")
+    @tu lazy val ModuleSerializationProxyConstructor: TermSymbol =
+      ModuleSerializationProxyClass.requiredMethod(nme.CONSTRUCTOR, List(ClassType(TypeBounds.empty)))
+
+  @tu lazy val MirrorClass: ClassSymbol = requiredClass("scala.deriving.Mirror")
+  @tu lazy val Mirror_ProductClass: ClassSymbol = requiredClass("scala.deriving.Mirror.Product")
+    @tu lazy val Mirror_Product_fromProduct: Symbol = Mirror_ProductClass.requiredMethod(nme.fromProduct)
+  @tu lazy val Mirror_SumClass: ClassSymbol = requiredClass("scala.deriving.Mirror.Sum")
+  @tu lazy val Mirror_SingletonClass: ClassSymbol = requiredClass("scala.deriving.Mirror.Singleton")
+  @tu lazy val Mirror_SingletonProxyClass: ClassSymbol = requiredClass("scala.deriving.Mirror.SingletonProxy")
+
+  @tu lazy val LanguageModule: Symbol = requiredModule("scala.language")
+  @tu lazy val LanguageModuleClass: Symbol = LanguageModule.moduleClass.asClass
+  @tu lazy val LanguageExperimentalModule: Symbol = requiredModule("scala.language.experimental")
+  @tu lazy val LanguageDeprecatedModule: Symbol = requiredModule("scala.language.deprecated")
+  @tu lazy val NonLocalReturnControlClass: ClassSymbol = requiredClass("scala.runtime.NonLocalReturnControl")
+  @tu lazy val SelectableClass: ClassSymbol = requiredClass("scala.Selectable")
+  @tu lazy val WithoutPreciseParameterTypesClass: Symbol = requiredClass("scala.Selectable.WithoutPreciseParameterTypes")
+
+  @tu lazy val ManifestClass: ClassSymbol = requiredClass("scala.reflect.Manifest")
+  @tu lazy val ManifestFactoryModule: Symbol = requiredModule("scala.reflect.ManifestFactory")
+  @tu lazy val ClassManifestFactoryModule: Symbol = requiredModule("scala.reflect.ClassManifestFactory")
+  @tu lazy val OptManifestClass: ClassSymbol = requiredClass("scala.reflect.OptManifest")
+  @tu lazy val NoManifestModule: Symbol = requiredModule("scala.reflect.NoManifest")
+
+  @tu lazy val ReflectPackageClass: Symbol = requiredPackage("scala.reflect.package").moduleClass
+  @tu lazy val ClassTagClass: ClassSymbol = requiredClass("scala.reflect.ClassTag")
+  @tu lazy val ClassTagModule: Symbol = ClassTagClass.companionModule
+    @tu lazy val ClassTagModule_apply: Symbol = ClassTagModule.requiredMethod(nme.apply)
+
+  @tu lazy val TypeTestClass: ClassSymbol = requiredClass("scala.reflect.TypeTest")
+    @tu lazy val TypeTest_unapply: Symbol = TypeTestClass.requiredMethod(nme.unapply)
+  @tu lazy val TypeTestModule_identity: Symbol = TypeTestClass.companionModule.requiredMethod(nme.identity)
+
+  @tu lazy val QuotedExprClass: ClassSymbol = requiredClass("scala.quoted.Expr")
+
+  @tu lazy val QuotesClass: ClassSymbol = requiredClass("scala.quoted.Quotes")
+    @tu lazy val Quotes_reflect: Symbol = QuotesClass.requiredValue("reflect")
+      @tu lazy val Quotes_reflect_asTerm: Symbol = Quotes_reflect.requiredMethod("asTerm")
+      @tu lazy val Quotes_reflect_Apply: Symbol = Quotes_reflect.requiredValue("Apply")
+        @tu lazy val Quotes_reflect_Apply_apply: Symbol = Quotes_reflect_Apply.requiredMethod(nme.apply)
+      @tu lazy val Quotes_reflect_TypeApply: Symbol = Quotes_reflect.requiredValue("TypeApply")
+        @tu lazy val Quotes_reflect_TypeApply_apply: Symbol = Quotes_reflect_TypeApply.requiredMethod(nme.apply)
+      @tu lazy val Quotes_reflect_Assign: Symbol = Quotes_reflect.requiredValue("Assign")
+        @tu lazy val Quotes_reflect_Assign_apply: Symbol = Quotes_reflect_Assign.requiredMethod(nme.apply)
+      @tu lazy val Quotes_reflect_Inferred: Symbol = Quotes_reflect.requiredValue("Inferred")
+        @tu lazy val Quotes_reflect_Inferred_apply: Symbol = Quotes_reflect_Inferred.requiredMethod(nme.apply)
+      @tu lazy val Quotes_reflect_Literal: Symbol = Quotes_reflect.requiredValue("Literal")
+      @tu lazy val Quotes_reflect_Literal_apply: Symbol = Quotes_reflect_Literal.requiredMethod(nme.apply)
+      @tu lazy val Quotes_reflect_TreeMethods: Symbol = Quotes_reflect.requiredMethod("TreeMethods")
+        @tu lazy val Quotes_reflect_TreeMethods_asExpr: Symbol = Quotes_reflect_TreeMethods.requiredMethod("asExpr")
+      @tu lazy val Quotes_reflect_TypeRepr: Symbol = Quotes_reflect.requiredValue("TypeRepr")
+        @tu lazy val Quotes_reflect_TypeRepr_of: Symbol = Quotes_reflect_TypeRepr.requiredMethod("of")
+        @tu lazy val Quotes_reflect_TypeRepr_typeConstructorOf: Symbol = Quotes_reflect_TypeRepr.requiredMethod("typeConstructorOf")
+      @tu lazy val Quotes_reflect_TypeReprMethods: Symbol = Quotes_reflect.requiredValue("TypeReprMethods")
+        @tu lazy val Quotes_reflect_TypeReprMethods_asType: Symbol = Quotes_reflect_TypeReprMethods.requiredMethod("asType")
+      @tu lazy val Quotes_reflect_TypeTreeType: Symbol = Quotes_reflect.requiredType("TypeTree")
+      @tu lazy val Quotes_reflect_TermType: Symbol = Quotes_reflect.requiredType("Term")
+      @tu lazy val Quotes_reflect_BooleanConstant: Symbol = Quotes_reflect.requiredValue("BooleanConstant")
+      @tu lazy val Quotes_reflect_ByteConstant: Symbol = Quotes_reflect.requiredValue("ByteConstant")
+      @tu lazy val Quotes_reflect_ShortConstant: Symbol = Quotes_reflect.requiredValue("ShortConstant")
+      @tu lazy val Quotes_reflect_IntConstant: Symbol = Quotes_reflect.requiredValue("IntConstant")
+      @tu lazy val Quotes_reflect_LongConstant: Symbol = Quotes_reflect.requiredValue("LongConstant")
+      @tu lazy val Quotes_reflect_FloatConstant: Symbol = Quotes_reflect.requiredValue("FloatConstant")
+      @tu lazy val Quotes_reflect_DoubleConstant: Symbol = Quotes_reflect.requiredValue("DoubleConstant")
+      @tu lazy val Quotes_reflect_CharConstant: Symbol = Quotes_reflect.requiredValue("CharConstant")
+      @tu lazy val Quotes_reflect_StringConstant: Symbol = Quotes_reflect.requiredValue("StringConstant")
+      @tu lazy val Quotes_reflect_UnitConstant: Symbol = Quotes_reflect.requiredValue("UnitConstant")
+      @tu lazy val Quotes_reflect_NullConstant: Symbol = Quotes_reflect.requiredValue("NullConstant")
+      @tu lazy val Quotes_reflect_ClassOfConstant: Symbol = Quotes_reflect.requiredValue("ClassOfConstant")
+
+
+  @tu lazy val QuoteUnpicklerClass: ClassSymbol = requiredClass("scala.quoted.runtime.QuoteUnpickler")
+    @tu lazy val QuoteUnpickler_unpickleExprV2: Symbol = QuoteUnpicklerClass.requiredMethod("unpickleExprV2")
+    @tu lazy val QuoteUnpickler_unpickleTypeV2: Symbol = QuoteUnpicklerClass.requiredMethod("unpickleTypeV2")
+
+  @tu lazy val QuoteMatchingClass: ClassSymbol = requiredClass("scala.quoted.runtime.QuoteMatching")
+    @tu lazy val QuoteMatching_ExprMatch: Symbol = QuoteMatchingClass.requiredMethod("ExprMatch")
+    @tu lazy val QuoteMatching_TypeMatch: Symbol = QuoteMatchingClass.requiredMethod("TypeMatch")
+
+  @tu lazy val ToExprModule: Symbol = requiredModule("scala.quoted.ToExpr")
+    @tu lazy val ToExprModule_BooleanToExpr: Symbol = ToExprModule.requiredMethod("BooleanToExpr")
+    @tu lazy val ToExprModule_ByteToExpr: Symbol = ToExprModule.requiredMethod("ByteToExpr")
+    @tu lazy val ToExprModule_ShortToExpr: Symbol = ToExprModule.requiredMethod("ShortToExpr")
+    @tu lazy val ToExprModule_IntToExpr: Symbol = ToExprModule.requiredMethod("IntToExpr")
+    @tu lazy val ToExprModule_LongToExpr: Symbol = ToExprModule.requiredMethod("LongToExpr")
+    @tu lazy val ToExprModule_FloatToExpr: Symbol = ToExprModule.requiredMethod("FloatToExpr")
+    @tu lazy val ToExprModule_DoubleToExpr: Symbol = ToExprModule.requiredMethod("DoubleToExpr")
+    @tu lazy val ToExprModule_CharToExpr: Symbol = ToExprModule.requiredMethod("CharToExpr")
+    @tu lazy val ToExprModule_StringToExpr: Symbol = ToExprModule.requiredMethod("StringToExpr")
+
+  @tu lazy val QuotedRuntimeModule: Symbol = requiredModule("scala.quoted.runtime.Expr")
+    @tu lazy val QuotedRuntime_exprQuote  : Symbol = QuotedRuntimeModule.requiredMethod("quote")
+    @tu lazy val QuotedRuntime_exprSplice : Symbol = QuotedRuntimeModule.requiredMethod("splice")
+    @tu lazy val QuotedRuntime_exprNestedSplice : Symbol = QuotedRuntimeModule.requiredMethod("nestedSplice")
+
+  @tu lazy val QuotedRuntime_SplicedTypeAnnot: ClassSymbol = requiredClass("scala.quoted.runtime.SplicedType")
+
+  @tu lazy val QuotedRuntimePatterns: Symbol = requiredModule("scala.quoted.runtime.Patterns")
+    @tu lazy val QuotedRuntimePatterns_patternHole: Symbol = QuotedRuntimePatterns.requiredMethod("patternHole")
+    @tu lazy val QuotedRuntimePatterns_patternHigherOrderHole: Symbol = QuotedRuntimePatterns.requiredMethod("patternHigherOrderHole")
+    @tu lazy val QuotedRuntimePatterns_higherOrderHole: Symbol = QuotedRuntimePatterns.requiredMethod("higherOrderHole")
+    @tu lazy val QuotedRuntimePatterns_patternTypeAnnot: ClassSymbol = QuotedRuntimePatterns.requiredClass("patternType")
+    @tu lazy val QuotedRuntimePatterns_fromAboveAnnot: ClassSymbol = QuotedRuntimePatterns.requiredClass("fromAbove")
+
+  @tu lazy val QuotedTypeClass: ClassSymbol = requiredClass("scala.quoted.Type")
+    @tu lazy val QuotedType_splice: Symbol = QuotedTypeClass.requiredType(tpnme.Underlying)
+
+  @tu lazy val QuotedTypeModule: Symbol = QuotedTypeClass.companionModule
+    @tu lazy val QuotedTypeModule_of: Symbol = QuotedTypeModule.requiredMethod("of")
+
+  @tu lazy val CanEqualClass: ClassSymbol = getClassIfDefined("scala.Eql").orElse(requiredClass("scala.CanEqual")).asClass
+    def CanEqual_canEqualAny(using Context): TermSymbol =
+      val methodName = if CanEqualClass.name == tpnme.Eql then nme.eqlAny else nme.canEqualAny
+      CanEqualClass.companionModule.requiredMethod(methodName)
+
+  @tu lazy val CanThrowClass: ClassSymbol = requiredClass("scala.CanThrow")
+  @tu lazy val throwsAlias: Symbol = ScalaRuntimePackageVal.requiredType(tpnme.THROWS)
+
+  @tu lazy val TypeBoxClass: ClassSymbol = requiredClass("scala.runtime.TypeBox")
+    @tu lazy val TypeBox_CAP: TypeSymbol = TypeBoxClass.requiredType(tpnme.CAP)
+
+  @tu lazy val MatchCaseClass: ClassSymbol = requiredClass("scala.runtime.MatchCase")
+  @tu lazy val NotGivenClass: ClassSymbol = requiredClass("scala.util.NotGiven")
+    @tu lazy val NotGiven_value: Symbol = NotGivenClass.companionModule.requiredMethod(nme.value)
+
+  @tu lazy val ValueOfClass: ClassSymbol = requiredClass("scala.ValueOf")
+
+  @tu lazy val FromDigitsClass: ClassSymbol           = requiredClass("scala.util.FromDigits")
+  @tu lazy val FromDigits_WithRadixClass: ClassSymbol = requiredClass("scala.util.FromDigits.WithRadix")
+  @tu lazy val FromDigits_DecimalClass: ClassSymbol   = requiredClass("scala.util.FromDigits.Decimal")
+  @tu lazy val FromDigits_FloatingClass: ClassSymbol  = requiredClass("scala.util.FromDigits.Floating")
+
+  @tu lazy val XMLTopScopeModule: Symbol = requiredModule("scala.xml.TopScope")
+
+  @tu lazy val MainAnnotationClass: ClassSymbol = requiredClass("scala.annotation.MainAnnotation")
+  @tu lazy val MainAnnotationInfo: ClassSymbol = requiredClass("scala.annotation.MainAnnotation.Info")
+  @tu lazy val MainAnnotationParameter: ClassSymbol = requiredClass("scala.annotation.MainAnnotation.Parameter")
+  @tu lazy val MainAnnotationParameterAnnotation: ClassSymbol = requiredClass("scala.annotation.MainAnnotation.ParameterAnnotation")
+  @tu lazy val MainAnnotationCommand: ClassSymbol = requiredClass("scala.annotation.MainAnnotation.Command")
+
+  @tu lazy val CommandLineParserModule: Symbol = requiredModule("scala.util.CommandLineParser")
+    @tu lazy val CLP_ParseError: ClassSymbol = CommandLineParserModule.requiredClass("ParseError").typeRef.symbol.asClass
+    @tu lazy val CLP_parseArgument: Symbol = CommandLineParserModule.requiredMethod("parseArgument")
+    @tu lazy val CLP_parseRemainingArguments: Symbol = CommandLineParserModule.requiredMethod("parseRemainingArguments")
+    @tu lazy val CLP_showError: Symbol = CommandLineParserModule.requiredMethod("showError")
+
+  @tu lazy val TupleTypeRef: TypeRef = requiredClassRef("scala.Tuple")
+  def TupleClass(using Context): ClassSymbol = TupleTypeRef.symbol.asClass
+    @tu lazy val Tuple_cons: Symbol = TupleClass.requiredMethod("*:")
+  @tu lazy val EmptyTupleModule: Symbol = requiredModule("scala.EmptyTuple")
+  @tu lazy val NonEmptyTupleTypeRef: TypeRef = requiredClassRef("scala.NonEmptyTuple")
+  def NonEmptyTupleClass(using Context): ClassSymbol = NonEmptyTupleTypeRef.symbol.asClass
+    lazy val NonEmptyTuple_tail: Symbol = NonEmptyTupleClass.requiredMethod("tail")
+  @tu lazy val PairClass: ClassSymbol = requiredClass("scala.*:")
+
+  @tu lazy val TupleXXLClass: ClassSymbol = requiredClass("scala.runtime.TupleXXL")
+  def TupleXXLModule(using Context): Symbol = TupleXXLClass.companionModule
+
+    def TupleXXL_fromIterator(using Context): Symbol = TupleXXLModule.requiredMethod("fromIterator")
+
+  @tu lazy val RuntimeTupleMirrorTypeRef: TypeRef = requiredClassRef("scala.runtime.TupleMirror")
+
+  @tu lazy val RuntimeTuplesModule: Symbol = requiredModule("scala.runtime.Tuples")
+  @tu lazy val RuntimeTuplesModuleClass: Symbol = RuntimeTuplesModule.moduleClass
+    @tu lazy val RuntimeTuples_consIterator: Symbol = RuntimeTuplesModule.requiredMethod("consIterator")
+    @tu lazy val RuntimeTuples_concatIterator: Symbol = RuntimeTuplesModule.requiredMethod("concatIterator")
+    @tu lazy val RuntimeTuples_apply: Symbol = RuntimeTuplesModule.requiredMethod("apply")
+    @tu lazy val RuntimeTuples_cons: Symbol = RuntimeTuplesModule.requiredMethod("cons")
+    @tu lazy val RuntimeTuples_size: Symbol = RuntimeTuplesModule.requiredMethod("size")
+    @tu lazy val RuntimeTuples_tail: Symbol = RuntimeTuplesModule.requiredMethod("tail")
+    @tu lazy val RuntimeTuples_concat: Symbol = RuntimeTuplesModule.requiredMethod("concat")
+    @tu lazy val RuntimeTuples_toArray: Symbol = RuntimeTuplesModule.requiredMethod("toArray")
+    @tu lazy val RuntimeTuples_productToArray: Symbol = RuntimeTuplesModule.requiredMethod("productToArray")
+    @tu lazy val RuntimeTuples_isInstanceOfTuple: Symbol = RuntimeTuplesModule.requiredMethod("isInstanceOfTuple")
+    @tu lazy val RuntimeTuples_isInstanceOfEmptyTuple: Symbol = RuntimeTuplesModule.requiredMethod("isInstanceOfEmptyTuple")
+    @tu lazy val RuntimeTuples_isInstanceOfNonEmptyTuple: Symbol = RuntimeTuplesModule.requiredMethod("isInstanceOfNonEmptyTuple")
+
+  @tu lazy val TupledFunctionTypeRef: TypeRef = requiredClassRef("scala.util.TupledFunction")
+  def TupledFunctionClass(using Context): ClassSymbol = TupledFunctionTypeRef.symbol.asClass
+  def RuntimeTupleFunctionsModule(using Context): Symbol = requiredModule("scala.runtime.TupledFunctions")
+
+  @tu lazy val CapsModule: Symbol = requiredModule("scala.caps")
+    @tu lazy val captureRoot: TermSymbol = CapsModule.requiredValue("*")
+    @tu lazy val CapsUnsafeModule: Symbol = requiredModule("scala.caps.unsafe")
+    @tu lazy val Caps_unsafeBox: Symbol = CapsUnsafeModule.requiredMethod("unsafeBox")
+    @tu lazy val Caps_unsafeUnbox: Symbol = CapsUnsafeModule.requiredMethod("unsafeUnbox")
+    @tu lazy val Caps_unsafeBoxFunArg: Symbol = CapsUnsafeModule.requiredMethod("unsafeBoxFunArg")
+
+  // Annotation base classes
+  @tu lazy val AnnotationClass: ClassSymbol = requiredClass("scala.annotation.Annotation")
+  @tu lazy val ClassfileAnnotationClass: ClassSymbol = requiredClass("scala.annotation.ClassfileAnnotation")
+  @tu lazy val StaticAnnotationClass: ClassSymbol = requiredClass("scala.annotation.StaticAnnotation")
+  @tu lazy val RefiningAnnotationClass: ClassSymbol = requiredClass("scala.annotation.RefiningAnnotation")
+
+  // Annotation classes
+  @tu lazy val AnnotationDefaultAnnot: ClassSymbol = requiredClass("scala.annotation.internal.AnnotationDefault")
+  @tu lazy val BeanPropertyAnnot: ClassSymbol = requiredClass("scala.beans.BeanProperty")
+  @tu lazy val BooleanBeanPropertyAnnot: ClassSymbol = requiredClass("scala.beans.BooleanBeanProperty")
+  @tu lazy val BodyAnnot: ClassSymbol = requiredClass("scala.annotation.internal.Body")
+  @tu lazy val CapabilityAnnot: ClassSymbol = requiredClass("scala.annotation.capability")
+  @tu lazy val ChildAnnot: ClassSymbol = requiredClass("scala.annotation.internal.Child")
+  @tu lazy val ContextResultCountAnnot: ClassSymbol = requiredClass("scala.annotation.internal.ContextResultCount")
+  @tu lazy val ProvisionalSuperClassAnnot: ClassSymbol = requiredClass("scala.annotation.internal.ProvisionalSuperClass")
+  @tu lazy val DeprecatedAnnot: ClassSymbol = requiredClass("scala.deprecated")
+  @tu lazy val DeprecatedOverridingAnnot: ClassSymbol = requiredClass("scala.deprecatedOverriding")
+  @tu lazy val ImplicitAmbiguousAnnot: ClassSymbol = requiredClass("scala.annotation.implicitAmbiguous")
+  @tu lazy val ImplicitNotFoundAnnot: ClassSymbol = requiredClass("scala.annotation.implicitNotFound")
+  @tu lazy val InlineParamAnnot: ClassSymbol = requiredClass("scala.annotation.internal.InlineParam")
+  @tu lazy val ErasedParamAnnot: ClassSymbol = requiredClass("scala.annotation.internal.ErasedParam")
+  @tu lazy val InvariantBetweenAnnot: ClassSymbol = requiredClass("scala.annotation.internal.InvariantBetween")
+  @tu lazy val MainAnnot: ClassSymbol = requiredClass("scala.main")
+  @tu lazy val MappedAlternativeAnnot: ClassSymbol = requiredClass("scala.annotation.internal.MappedAlternative")
+  @tu lazy val MigrationAnnot: ClassSymbol = requiredClass("scala.annotation.migration")
+  @tu lazy val NowarnAnnot: ClassSymbol = requiredClass("scala.annotation.nowarn")
+  @tu lazy val TransparentTraitAnnot: ClassSymbol = requiredClass("scala.annotation.transparentTrait")
+  @tu lazy val NativeAnnot: ClassSymbol = requiredClass("scala.native")
+  @tu lazy val RepeatedAnnot: ClassSymbol = requiredClass("scala.annotation.internal.Repeated")
+  @tu lazy val SourceFileAnnot: ClassSymbol = requiredClass("scala.annotation.internal.SourceFile")
+  @tu lazy val ScalaSignatureAnnot: ClassSymbol = requiredClass("scala.reflect.ScalaSignature")
+  @tu lazy val ScalaLongSignatureAnnot: ClassSymbol = requiredClass("scala.reflect.ScalaLongSignature")
+  @tu lazy val ScalaStrictFPAnnot: ClassSymbol = requiredClass("scala.annotation.strictfp")
+  @tu lazy val ScalaStaticAnnot: ClassSymbol = requiredClass("scala.annotation.static")
+  @tu lazy val SerialVersionUIDAnnot: ClassSymbol = requiredClass("scala.SerialVersionUID")
+  @tu lazy val TailrecAnnot: ClassSymbol = requiredClass("scala.annotation.tailrec")
+  @tu lazy val ThreadUnsafeAnnot: ClassSymbol = requiredClass("scala.annotation.threadUnsafe")
+  @tu lazy val ConstructorOnlyAnnot: ClassSymbol = requiredClass("scala.annotation.constructorOnly")
+  @tu lazy val CompileTimeOnlyAnnot: ClassSymbol = requiredClass("scala.annotation.compileTimeOnly")
+  @tu lazy val SwitchAnnot: ClassSymbol = requiredClass("scala.annotation.switch")
+  @tu lazy val ExperimentalAnnot: ClassSymbol = requiredClass("scala.annotation.experimental")
+  @tu lazy val ThrowsAnnot: ClassSymbol = requiredClass("scala.throws")
+  @tu lazy val TransientAnnot: ClassSymbol = requiredClass("scala.transient")
+  @tu lazy val UncheckedAnnot: ClassSymbol = requiredClass("scala.unchecked")
+  @tu lazy val UncheckedStableAnnot: ClassSymbol = requiredClass("scala.annotation.unchecked.uncheckedStable")
+  @tu lazy val UncheckedVarianceAnnot: ClassSymbol = requiredClass("scala.annotation.unchecked.uncheckedVariance")
+  @tu lazy val VolatileAnnot: ClassSymbol = requiredClass("scala.volatile")
+  @tu lazy val WithPureFunsAnnot: ClassSymbol = requiredClass("scala.annotation.internal.WithPureFuns")
+  @tu lazy val FieldMetaAnnot: ClassSymbol = requiredClass("scala.annotation.meta.field")
+  @tu lazy val GetterMetaAnnot: ClassSymbol = requiredClass("scala.annotation.meta.getter")
+  @tu lazy val ParamMetaAnnot: ClassSymbol = requiredClass("scala.annotation.meta.param")
+  @tu lazy val SetterMetaAnnot: ClassSymbol = requiredClass("scala.annotation.meta.setter")
+  @tu lazy val ShowAsInfixAnnot: ClassSymbol = requiredClass("scala.annotation.showAsInfix")
+  @tu lazy val FunctionalInterfaceAnnot: ClassSymbol = requiredClass("java.lang.FunctionalInterface")
+  @tu lazy val TargetNameAnnot: ClassSymbol = requiredClass("scala.annotation.targetName")
+  @tu lazy val VarargsAnnot: ClassSymbol = requiredClass("scala.annotation.varargs")
+  @tu lazy val SinceAnnot: ClassSymbol = requiredClass("scala.annotation.since")
+  @tu lazy val RequiresCapabilityAnnot: ClassSymbol = requiredClass("scala.annotation.internal.requiresCapability")
+  @tu lazy val RetainsAnnot: ClassSymbol = requiredClass("scala.annotation.retains")
+  @tu lazy val RetainsByNameAnnot: ClassSymbol = requiredClass("scala.annotation.retainsByName")
+
+  @tu lazy val JavaRepeatableAnnot: ClassSymbol = requiredClass("java.lang.annotation.Repeatable")
+
+  // A list of meta-annotations that are relevant for fields and accessors
+  @tu lazy val FieldAccessorMetaAnnots: Set[Symbol] =
+    Set(FieldMetaAnnot, GetterMetaAnnot, ParamMetaAnnot, SetterMetaAnnot)
+
+  // A list of annotations that are commonly used to indicate that a field/method argument or return
+  // type is not null. These annotations are used by the nullification logic in JavaNullInterop to
+  // improve the precision of type nullification.
+  // We don't require that any of these annotations be present in the class path, but we want to
+  // create Symbols for the ones that are present, so they can be checked during nullification.
+  @tu lazy val NotNullAnnots: List[ClassSymbol] = getClassesIfDefined(
+    "javax.annotation.Nonnull" ::
+    "javax.validation.constraints.NotNull" ::
+    "androidx.annotation.NonNull" ::
+    "android.support.annotation.NonNull" ::
+    "android.annotation.NonNull" ::
+    "com.android.annotations.NonNull" ::
+    "org.eclipse.jdt.annotation.NonNull" ::
+    "edu.umd.cs.findbugs.annotations.NonNull" ::
+    "org.checkerframework.checker.nullness.qual.NonNull" ::
+    "org.checkerframework.checker.nullness.compatqual.NonNullDecl" ::
+    "org.jetbrains.annotations.NotNull" ::
+    "org.springframework.lang.NonNull" ::
+    "org.springframework.lang.NonNullApi" ::
+    "org.springframework.lang.NonNullFields" ::
+    "lombok.NonNull" ::
+    "reactor.util.annotation.NonNull" ::
+    "reactor.util.annotation.NonNullApi" ::
+    "io.reactivex.annotations.NonNull" :: Nil)
+
+  // convenient one-parameter method types
+  def methOfAny(tp: Type): MethodType = MethodType(List(AnyType), tp)
+  def methOfAnyVal(tp: Type): MethodType = MethodType(List(AnyValType), tp)
+  def methOfAnyRef(tp: Type): MethodType = MethodType(List(ObjectType), tp)
+
+  // Derived types
+
+  def RepeatedParamType: TypeRef = RepeatedParamClass.typeRef
+
+  def ClassType(arg: Type)(using Context): Type = {
+    val ctype = ClassClass.typeRef
+    if (ctx.phase.erasedTypes) ctype else ctype.appliedTo(arg)
+  }
+
+  /** The enumeration type, goven a value of the enumeration */
+  def EnumType(sym: Symbol)(using Context): TypeRef =
+    // given (in java): "class A { enum E { VAL1 } }"
+    //  - sym: the symbol of the actual enumeration value (VAL1)
+    //  - .owner: the ModuleClassSymbol of the enumeration (object E)
+    //  - .linkedClass: the ClassSymbol of the enumeration (class E)
+    sym.owner.linkedClass.typeRef
+
+  object FunctionOf {
+    def apply(args: List[Type], resultType: Type, isContextual: Boolean = false, isErased: Boolean = false)(using Context): Type =
+      FunctionType(args.length, isContextual, isErased).appliedTo(args ::: resultType :: Nil)
+    def unapply(ft: Type)(using Context): Option[(List[Type], Type, Boolean, Boolean)] = {
+      val tsym = ft.typeSymbol
+      if isFunctionClass(tsym) && ft.isRef(tsym) then
+        val targs = ft.dealias.argInfos
+        if (targs.isEmpty) None
+        else Some(targs.init, targs.last, tsym.name.isContextFunction, tsym.name.isErasedFunction)
+      else None
+    }
+  }
+
+  object PartialFunctionOf {
+    def apply(arg: Type, result: Type)(using Context): Type =
+      PartialFunctionClass.typeRef.appliedTo(arg :: result :: Nil)
+    def unapply(pft: Type)(using Context): Option[(Type, List[Type])] =
+      if (pft.isRef(PartialFunctionClass)) {
+        val targs = pft.dealias.argInfos
+        if (targs.length == 2) Some((targs.head, targs.tail)) else None
+      }
+      else None
+  }
+
+  object ArrayOf {
+    def apply(elem: Type)(using Context): Type =
+      if (ctx.erasedTypes) JavaArrayType(elem)
+      else ArrayType.appliedTo(elem :: Nil)
+    def unapply(tp: Type)(using Context): Option[Type] = tp.dealias match {
+      case AppliedType(at, arg :: Nil) if at.isRef(ArrayType.symbol) => Some(arg)
+      case JavaArrayType(tp) if ctx.erasedTypes => Some(tp)
+      case _ => None
+    }
+  }
+
+  object MatchCase {
+    def apply(pat: Type, body: Type)(using Context): Type =
+      MatchCaseClass.typeRef.appliedTo(pat, body)
+    def unapply(tp: Type)(using Context): Option[(Type, Type)] = tp match {
+      case AppliedType(tycon, pat :: body :: Nil) if tycon.isRef(MatchCaseClass) =>
+        Some((pat, body))
+      case _ =>
+        None
+    }
+    def isInstance(tp: Type)(using Context): Boolean = tp match {
+      case AppliedType(tycon: TypeRef, _) =>
+        tycon.name == tpnme.MatchCase && // necessary pre-filter to avoid forcing symbols
+        tycon.isRef(MatchCaseClass)
+      case _ => false
+    }
+  }
+
+  /** An extractor for multi-dimensional arrays.
+   *  Note that this will also extract the high bound if an
+   *  element type is a wildcard upper-bounded by an array. E.g.
+   *
+   *     Array[? <: Array[? <: Number]]
+   *
+   *  would match
+   *
+   *     MultiArrayOf(<? <: Number>, 2)
+   */
+  object MultiArrayOf {
+    def apply(elem: Type, ndims: Int)(using Context): Type =
+      if (ndims == 0) elem else ArrayOf(apply(elem, ndims - 1))
+    def unapply(tp: Type)(using Context): Option[(Type, Int)] = tp match {
+      case ArrayOf(elemtp) =>
+        def recur(elemtp: Type): Option[(Type, Int)] = elemtp.dealias match {
+          case tp @ TypeBounds(lo, hi @ MultiArrayOf(finalElemTp, n)) =>
+            Some(finalElemTp, n)
+          case MultiArrayOf(finalElemTp, n) => Some(finalElemTp, n + 1)
+          case _ => Some(elemtp, 1)
+        }
+        recur(elemtp)
+      case _ =>
+        None
+    }
+  }
+
+  /** Extractor for context function types representing by-name parameters, of the form
+   *  `() ?=> T`.
+   *  Under purefunctions, this becomes `() ?-> T` or `{r1, ..., rN} () ?-> T`.
+   */
+  object ByNameFunction:
+    def apply(tp: Type)(using Context): Type = tp match
+      case tp @ EventuallyCapturingType(tp1, refs) if tp.annot.symbol == RetainsByNameAnnot =>
+        CapturingType(apply(tp1), refs)
+      case _ =>
+        defn.ContextFunction0.typeRef.appliedTo(tp :: Nil)
+    def unapply(tp: Type)(using Context): Option[Type] = tp match
+      case tp @ AppliedType(tycon, arg :: Nil) if defn.isByNameFunctionClass(tycon.typeSymbol) =>
+        Some(arg)
+      case tp @ AnnotatedType(parent, _) =>
+        unapply(parent)
+      case _ =>
+        None
+
+  final def isByNameFunctionClass(sym: Symbol): Boolean =
+    sym eq ContextFunction0
+
+  def isByNameFunction(tp: Type)(using Context): Boolean = tp match
+    case ByNameFunction(_) => true
+    case _ => false
+
+  final def isCompiletime_S(sym: Symbol)(using Context): Boolean =
+    sym.name == tpnme.S && sym.owner == CompiletimeOpsIntModuleClass
+
+  private val compiletimePackageAnyTypes: Set[Name] = Set(
+    tpnme.Equals, tpnme.NotEquals, tpnme.IsConst, tpnme.ToString
+  )
+  private val compiletimePackageNumericTypes: Set[Name] = Set(
+    tpnme.Plus, tpnme.Minus, tpnme.Times, tpnme.Div, tpnme.Mod,
+    tpnme.Lt, tpnme.Gt, tpnme.Ge, tpnme.Le,
+    tpnme.Abs, tpnme.Negate, tpnme.Min, tpnme.Max
+  )
+  private val compiletimePackageIntTypes: Set[Name] = compiletimePackageNumericTypes ++ Set[Name](
+    tpnme.ToString, // ToString is moved to ops.any and deprecated for ops.int
+    tpnme.NumberOfLeadingZeros, tpnme.ToLong, tpnme.ToFloat, tpnme.ToDouble,
+    tpnme.Xor, tpnme.BitwiseAnd, tpnme.BitwiseOr, tpnme.ASR, tpnme.LSL, tpnme.LSR
+  )
+  private val compiletimePackageLongTypes: Set[Name] = compiletimePackageNumericTypes ++ Set[Name](
+    tpnme.NumberOfLeadingZeros, tpnme.ToInt, tpnme.ToFloat, tpnme.ToDouble,
+    tpnme.Xor, tpnme.BitwiseAnd, tpnme.BitwiseOr, tpnme.ASR, tpnme.LSL, tpnme.LSR
+  )
+  private val compiletimePackageFloatTypes: Set[Name] = compiletimePackageNumericTypes ++ Set[Name](
+    tpnme.ToInt, tpnme.ToLong, tpnme.ToDouble
+  )
+  private val compiletimePackageDoubleTypes: Set[Name] = compiletimePackageNumericTypes ++ Set[Name](
+    tpnme.ToInt, tpnme.ToLong, tpnme.ToFloat
+  )
+  private val compiletimePackageBooleanTypes: Set[Name] = Set(tpnme.Not, tpnme.Xor, tpnme.And, tpnme.Or)
+  private val compiletimePackageStringTypes: Set[Name] = Set(
+    tpnme.Plus, tpnme.Length, tpnme.Substring, tpnme.Matches, tpnme.CharAt
+  )
+  private val compiletimePackageOpTypes: Set[Name] =
+    Set(tpnme.S)
+    ++ compiletimePackageAnyTypes
+    ++ compiletimePackageIntTypes
+    ++ compiletimePackageLongTypes
+    ++ compiletimePackageFloatTypes
+    ++ compiletimePackageDoubleTypes
+    ++ compiletimePackageBooleanTypes
+    ++ compiletimePackageStringTypes
+
+  final def isCompiletimeAppliedType(sym: Symbol)(using Context): Boolean =
+    compiletimePackageOpTypes.contains(sym.name)
+    && (
+         isCompiletime_S(sym)
+      || sym.owner == CompiletimeOpsAnyModuleClass && compiletimePackageAnyTypes.contains(sym.name)
+      || sym.owner == CompiletimeOpsIntModuleClass && compiletimePackageIntTypes.contains(sym.name)
+      || sym.owner == CompiletimeOpsLongModuleClass && compiletimePackageLongTypes.contains(sym.name)
+      || sym.owner == CompiletimeOpsFloatModuleClass && compiletimePackageFloatTypes.contains(sym.name)
+      || sym.owner == CompiletimeOpsDoubleModuleClass && compiletimePackageDoubleTypes.contains(sym.name)
+      || sym.owner == CompiletimeOpsBooleanModuleClass && compiletimePackageBooleanTypes.contains(sym.name)
+      || sym.owner == CompiletimeOpsStringModuleClass && compiletimePackageStringTypes.contains(sym.name)
+    )
+
+  // ----- Scala-2 library patches --------------------------------------
+
+  /** The `scala.runtime.stdLibPacthes` package contains objects
+   *  that contain defnitions that get added as members to standard library
+   *  objects with the same name.
+   */
+  @tu lazy val StdLibPatchesPackage: TermSymbol = requiredPackage("scala.runtime.stdLibPatches")
+  @tu private lazy val ScalaPredefModuleClassPatch: Symbol = getModuleIfDefined("scala.runtime.stdLibPatches.Predef").moduleClass
+  @tu private lazy val LanguageModuleClassPatch: Symbol = getModuleIfDefined("scala.runtime.stdLibPatches.language").moduleClass
+
+  /** If `sym` is a patched library class, the source file of its patch class,
+   *  otherwise `NoSource`
+   */
+  def patchSource(sym: Symbol)(using Context): SourceFile =
+    if sym == ScalaPredefModuleClass then ScalaPredefModuleClassPatch.source
+    else if sym == LanguageModuleClass then LanguageModuleClassPatch.source
+    else NoSource
+
+  /** A finalizer that patches standard library classes.
+   *  It copies all non-private, non-synthetic definitions from `patchCls`
+   *  to `denot` while changing their owners to `denot`. Before that it deletes
+   *  any definitions of `denot` that have the same name as one of the copied
+   *  definitions.
+   *
+   *  If an object is present in both the original class and the patch class,
+   *  it is not overwritten. Instead its members are copied recursively.
+   *
+   *  To avpid running into cycles on bootstrap, patching happens only if `patchCls`
+   *  is read from a classfile.
+   */
+  def patchStdLibClass(denot: ClassDenotation)(using Context): Unit =
+    def patch2(denot: ClassDenotation, patchCls: Symbol): Unit =
+      val scope = denot.info.decls.openForMutations
+
+      def recurse(patch: Symbol) = patch.is(Module) && scope.lookup(patch.name).exists
+
+      def makeClassSymbol(patch: Symbol, parents: List[Type], selfInfo: TypeOrSymbol) =
+        newClassSymbol(
+          owner = denot.symbol,
+          name = patch.name.asTypeName,
+          flags = patch.flags,
+          // need to rebuild a fresh ClassInfo
+          infoFn = cls => ClassInfo(
+            prefix = denot.symbol.thisType,
+            cls = cls,
+            declaredParents = parents, // assume parents in patch don't refer to symbols in the patch
+            decls = newScope,
+            selfInfo =
+              if patch.is(Module)
+              then TermRef(denot.symbol.thisType, patch.name.sourceModuleName)
+              else selfInfo // assume patch self type annotation does not refer to symbols in the patch
+          ),
+          privateWithin = patch.privateWithin,
+          coord = denot.symbol.coord,
+          assocFile = denot.symbol.associatedFile
+        )
+
+      def makeNonClassSymbol(patch: Symbol) =
+        if patch.is(Inline) then
+          // Inline symbols contain trees in annotations, which is coupled
+          // with the underlying symbol.
+          // Changing owner for inline symbols is a simple workaround.
+          patch.denot = patch.denot.copySymDenotation(owner = denot.symbol)
+          patch
+        else
+          // change `info` which might contain reference to the patch
+          patch.copy(
+            owner = denot.symbol,
+            info =
+              if patch.is(Module)
+              then TypeRef(denot.symbol.thisType, patch.name.moduleClassName)
+              else patch.info // assume non-object info does not refer to symbols in the patch
+          )
+
+      if patchCls.exists then
+        val patches = patchCls.info.decls.filter(patch =>
+          !patch.isConstructor && !patch.isOneOf(PrivateOrSynthetic))
+        for patch <- patches if !recurse(patch) do
+          val e = scope.lookupEntry(patch.name)
+          if e != null then scope.unlink(e)
+        for patch <- patches do
+          patch.ensureCompleted()
+          if !recurse(patch) then
+            val sym =
+              patch.info match
+              case ClassInfo(_, _, parents, _, selfInfo) =>
+                makeClassSymbol(patch, parents, selfInfo)
+              case _ =>
+                makeNonClassSymbol(patch)
+              end match
+            sym.annotations = patch.annotations
+            scope.enter(sym)
+          if patch.isClass then
+            patch2(scope.lookup(patch.name).asClass, patch)
+
+    def patchWith(patchCls: Symbol) =
+      denot.sourceModule.info = denot.typeRef // we run into a cyclic reference when patching if this line is omitted
+      patch2(denot, patchCls)
+
+    if denot.name == tpnme.Predef.moduleClassName && denot.symbol == ScalaPredefModuleClass then
+      patchWith(ScalaPredefModuleClassPatch)
+    else if denot.name == tpnme.language.moduleClassName && denot.symbol == LanguageModuleClass then
+      patchWith(LanguageModuleClassPatch)
+  end patchStdLibClass
+
+  // ----- Symbol sets ---------------------------------------------------
+
+  @tu lazy val topClasses: Set[Symbol] = Set(AnyClass, MatchableClass, ObjectClass, AnyValClass)
+
+  @tu lazy val untestableClasses: Set[Symbol] = Set(NothingClass, NullClass, SingletonClass)
+
+  @tu lazy val AbstractFunctionType: Array[TypeRef] = mkArityArray("scala.runtime.AbstractFunction", MaxImplementedFunctionArity, 0).asInstanceOf[Array[TypeRef]]
+  val AbstractFunctionClassPerRun: PerRun[Array[Symbol]] = new PerRun(AbstractFunctionType.map(_.symbol.asClass))
+  def AbstractFunctionClass(n: Int)(using Context): Symbol = AbstractFunctionClassPerRun()(using ctx)(n)
+
+  @tu lazy val caseClassSynthesized: List[Symbol] = List(
+    Any_hashCode, Any_equals, Any_toString, Product_canEqual, Product_productArity,
+    Product_productPrefix, Product_productElement, Product_productElementName)
+
+  val LazyHolder: PerRun[Map[Symbol, Symbol]] = new PerRun({
+    def holderImpl(holderType: String) = requiredClass("scala.runtime." + holderType)
+    Map[Symbol, Symbol](
+      IntClass     -> holderImpl("LazyInt"),
+      LongClass    -> holderImpl("LazyLong"),
+      BooleanClass -> holderImpl("LazyBoolean"),
+      FloatClass   -> holderImpl("LazyFloat"),
+      DoubleClass  -> holderImpl("LazyDouble"),
+      ByteClass    -> holderImpl("LazyByte"),
+      CharClass    -> holderImpl("LazyChar"),
+      ShortClass   -> holderImpl("LazyShort")
+    )
+    .withDefaultValue(holderImpl("LazyRef"))
+  })
+
+  @tu lazy val TupleType: Array[TypeRef | Null] = mkArityArray("scala.Tuple", MaxTupleArity, 1)
+
+  def isSpecializedTuple(cls: Symbol)(using Context): Boolean =
+    cls.isClass && TupleSpecializedClasses.exists(tupleCls => cls.name.isSpecializedNameOf(tupleCls.name))
+
+  def SpecializedTuple(base: Symbol, args: List[Type])(using Context): Symbol =
+    base.owner.requiredClass(base.name.specializedName(args))
+
+  /** Cached function types of arbitary arities.
+   *  Function types are created on demand with newFunctionNTrait, which is
+   *  called from a synthesizer installed in ScalaPackageClass.
+   */
+  private class FunType(prefix: String):
+    private var classRefs: Array[TypeRef | Null] = new Array(22)
+    def apply(n: Int): TypeRef =
+      while n >= classRefs.length do
+        val classRefs1 = new Array[TypeRef | Null](classRefs.length * 2)
+        Array.copy(classRefs, 0, classRefs1, 0, classRefs.length)
+        classRefs = classRefs1
+      val funName = s"scala.$prefix$n"
+      if classRefs(n) == null then
+        classRefs(n) =
+          if prefix.startsWith("Impure")
+          then staticRef(funName.toTypeName).symbol.typeRef
+          else requiredClassRef(funName)
+      classRefs(n).nn
+  end FunType
+
+  private def funTypeIdx(isContextual: Boolean, isErased: Boolean, isImpure: Boolean): Int =
+      (if isContextual then 1 else 0)
+    + (if isErased     then 2 else 0)
+    + (if isImpure     then 4 else 0)
+
+  private val funTypeArray: IArray[FunType] =
+    val arr = Array.ofDim[FunType](8)
+    val choices = List(false, true)
+    for contxt <- choices; erasd <- choices; impure <- choices do
+      var str = "Function"
+      if contxt then str = "Context" + str
+      if erasd then str = "Erased" + str
+      if impure then str = "Impure" + str
+      arr(funTypeIdx(contxt, erasd, impure)) = FunType(str)
+    IArray.unsafeFromArray(arr)
+
+  def FunctionSymbol(n: Int, isContextual: Boolean = false, isErased: Boolean = false, isImpure: Boolean = false)(using Context): Symbol =
+    funTypeArray(funTypeIdx(isContextual, isErased, isImpure))(n).symbol
+
+  @tu lazy val Function0_apply: Symbol = Function0.requiredMethod(nme.apply)
+  @tu lazy val ContextFunction0_apply: Symbol = ContextFunction0.requiredMethod(nme.apply)
+
+  @tu lazy val Function0: Symbol = FunctionSymbol(0)
+  @tu lazy val Function1: Symbol = FunctionSymbol(1)
+  @tu lazy val Function2: Symbol = FunctionSymbol(2)
+  @tu lazy val ContextFunction0: Symbol = FunctionSymbol(0, isContextual = true)
+
+  def FunctionType(n: Int, isContextual: Boolean = false, isErased: Boolean = false, isImpure: Boolean = false)(using Context): TypeRef =
+    FunctionSymbol(n, isContextual && !ctx.erasedTypes, isErased, isImpure).typeRef
+
+  lazy val PolyFunctionClass = requiredClass("scala.PolyFunction")
+  def PolyFunctionType = PolyFunctionClass.typeRef
+
+  /** If `cls` is a class in the scala package, its name, otherwise EmptyTypeName */
+  def scalaClassName(cls: Symbol)(using Context): TypeName = cls.denot match
+    case clsd: ClassDenotation if clsd.owner eq ScalaPackageClass =>
+      clsd.name.asInstanceOf[TypeName]
+    case _ =>
+      EmptyTypeName
+
+  /** If type `ref` refers to a class in the scala package, its name, otherwise EmptyTypeName */
+  def scalaClassName(ref: Type)(using Context): TypeName = scalaClassName(ref.classSymbol)
+
+  private def isVarArityClass(cls: Symbol, prefix: String) =
+    cls.isClass
+    && cls.owner.eq(ScalaPackageClass)
+    && cls.name.testSimple(name =>
+      name.startsWith(prefix)
+      && name.length > prefix.length
+      && digitsOnlyAfter(name, prefix.length))
+
+  private def digitsOnlyAfter(name: SimpleName, idx: Int): Boolean =
+    idx == name.length || name(idx).isDigit && digitsOnlyAfter(name, idx + 1)
+
+  def isBottomClass(cls: Symbol): Boolean =
+    if ctx.mode.is(Mode.SafeNulls) && !ctx.phase.erasedTypes
+    then cls == NothingClass
+    else isBottomClassAfterErasure(cls)
+
+  def isBottomClassAfterErasure(cls: Symbol): Boolean = cls == NothingClass || cls == NullClass
+
+  /** Is any function class where
+   *   - FunctionXXL
+   *   - FunctionN for N >= 0
+   *   - ContextFunctionN for N >= 0
+   *   - ErasedFunctionN for N > 0
+   *   - ErasedContextFunctionN for N > 0
+   */
+  def isFunctionClass(cls: Symbol): Boolean = scalaClassName(cls).isFunction
+
+  /** Is a function class, or an impure function type alias */
+  def isFunctionSymbol(sym: Symbol): Boolean =
+    sym.isType && (sym.owner eq ScalaPackageClass) && sym.name.isFunction
+
+  /** Is a function class where
+   *    - FunctionN for N >= 0 and N != XXL
+   */
+  def isPlainFunctionClass(cls: Symbol) = isVarArityClass(cls, str.Function)
+
+  /** Is an context function class.
+   *   - ContextFunctionN for N >= 0
+   *   - ErasedContextFunctionN for N > 0
+   */
+  def isContextFunctionClass(cls: Symbol): Boolean = scalaClassName(cls).isContextFunction
+
+  /** Is an erased function class.
+   *   - ErasedFunctionN for N > 0
+   *   - ErasedContextFunctionN for N > 0
+   */
+  def isErasedFunctionClass(cls: Symbol): Boolean = scalaClassName(cls).isErasedFunction
+
+  /** Is either FunctionXXL or  a class that will be erased to FunctionXXL
+   *   - FunctionXXL
+   *   - FunctionN for N >= 22
+   *   - ContextFunctionN for N >= 22
+   */
+  def isXXLFunctionClass(cls: Symbol): Boolean = {
+    val name = scalaClassName(cls)
+    (name eq tpnme.FunctionXXL) || name.functionArity > MaxImplementedFunctionArity
+  }
+
+  /** Is a synthetic function class
+   *    - FunctionN for N > 22
+   *    - ContextFunctionN for N >= 0
+   *    - ErasedFunctionN for N > 0
+   *    - ErasedContextFunctionN for N > 0
+   */
+  def isSyntheticFunctionClass(cls: Symbol): Boolean = scalaClassName(cls).isSyntheticFunction
+
+  def isAbstractFunctionClass(cls: Symbol): Boolean = isVarArityClass(cls, str.AbstractFunction)
+  def isTupleClass(cls: Symbol): Boolean = isVarArityClass(cls, str.Tuple)
+  def isProductClass(cls: Symbol): Boolean = isVarArityClass(cls, str.Product)
+
+  def isBoxedUnitClass(cls: Symbol): Boolean =
+    cls.isClass && (cls.owner eq ScalaRuntimePackageClass) && cls.name == tpnme.BoxedUnit
+
+  /** Returns the erased type of the function class `cls`
+   *    - FunctionN for N > 22 becomes FunctionXXL
+   *    - FunctionN for 22 > N >= 0 remains as FunctionN
+   *    - ContextFunctionN for N > 22 becomes FunctionXXL
+   *    - ContextFunctionN for N <= 22 becomes FunctionN
+   *    - ErasedFunctionN becomes Function0
+   *    - ImplicitErasedFunctionN becomes Function0
+   *    - anything else becomes a NoType
+   */
+  def functionTypeErasure(cls: Symbol): Type =
+    val arity = scalaClassName(cls).functionArity
+    if cls.name.isErasedFunction then FunctionType(0)
+    else if arity > 22 then FunctionXXLClass.typeRef
+    else if arity >= 0 then FunctionType(arity)
+    else NoType
+
+  private val JavaImportFns: List[RootRef] = List(
+    RootRef(() => JavaLangPackageVal.termRef)
+  )
+
+  private val ScalaImportFns: List[RootRef] =
+    JavaImportFns :+
+    RootRef(() => ScalaPackageVal.termRef)
+
+  private val PredefImportFns: RootRef =
+    RootRef(() => ScalaPredefModule.termRef, isPredef=true)
+
+  @tu private lazy val JavaRootImportFns: List[RootRef] =
+    if ctx.settings.YnoImports.value then Nil
+    else JavaImportFns
+
+  @tu private lazy val ScalaRootImportFns: List[RootRef] =
+    if ctx.settings.YnoImports.value then Nil
+    else if ctx.settings.YnoPredef.value then ScalaImportFns
+    else ScalaImportFns :+ PredefImportFns
+
+  @tu private lazy val JavaRootImportTypes: List[TermRef] = JavaRootImportFns.map(_.refFn())
+  @tu private lazy val ScalaRootImportTypes: List[TermRef] = ScalaRootImportFns.map(_.refFn())
+  @tu private lazy val JavaUnqualifiedOwnerTypes: Set[NamedType] = unqualifiedTypes(JavaRootImportTypes)
+  @tu private lazy val ScalaUnqualifiedOwnerTypes: Set[NamedType] = unqualifiedTypes(ScalaRootImportTypes)
+
+  /** Are we compiling a java source file? */
+  private def isJavaContext(using Context): Boolean =
+    ctx.compilationUnit.isJava
+
+  private def unqualifiedTypes(refs: List[TermRef]) =
+    val types = refs.toSet[NamedType]
+    types ++ types.map(_.symbol.moduleClass.typeRef)
+
+  /** Lazy references to the root imports */
+  def rootImportFns(using Context): List[RootRef] =
+    if isJavaContext then JavaRootImportFns
+    else ScalaRootImportFns
+
+  /** Root types imported by default */
+  def rootImportTypes(using Context): List[TermRef] =
+    if isJavaContext then JavaRootImportTypes
+    else ScalaRootImportTypes
+
+  /** Modules whose members are in the default namespace and their module classes */
+  def unqualifiedOwnerTypes(using Context): Set[NamedType] =
+    if isJavaContext then JavaUnqualifiedOwnerTypes
+    else ScalaUnqualifiedOwnerTypes
+
+  /** Names of the root import symbols that can be hidden by other imports */
+  @tu lazy val ShadowableImportNames: Set[TermName] = Set("Predef".toTermName)
+
+  /** Class symbols for which no class exist at runtime */
+  @tu lazy val NotRuntimeClasses: Set[Symbol] = Set(AnyClass, MatchableClass, AnyValClass, NullClass, NothingClass)
+
+  @tu lazy val SpecialClassTagClasses: Set[Symbol] = Set(UnitClass, AnyClass, AnyValClass)
+
+  @tu lazy val SpecialManifestClasses: Set[Symbol] = Set(AnyClass, AnyValClass, ObjectClass, NullClass, NothingClass)
+
+  /** Classes that are known not to have an initializer irrespective of
+   *  whether NoInits is set. Note: FunctionXXLClass is in this set
+   *  because if it is compiled by Scala2, it does not get a NoInit flag.
+   *  But since it is introduced only at erasure, there's no chance
+   *  for augmentScala2Traits to do anything on a class that inherits it. So
+   *  it also misses an implementation class, which means that the usual scheme
+   *  of calling a superclass init in the implementation class of a Scala2
+   *  trait gets screwed up. Therefore, it is mandatory that FunctionXXL
+   *  is treated as a NoInit trait.
+   */
+  @tu lazy val NoInitClasses: Set[Symbol] = NotRuntimeClasses + FunctionXXLClass
+
+  def isPolymorphicAfterErasure(sym: Symbol): Boolean =
+     (sym eq Any_isInstanceOf) || (sym eq Any_asInstanceOf) || (sym eq Object_synchronized)
+
+  /** Is this type a `TupleN` type?
+   *
+   * @return true if the dealiased type of `tp` is `TupleN[T1, T2, ..., Tn]`
+   */
+  def isTupleNType(tp: Type)(using Context): Boolean = {
+    val tp1 = tp.dealias
+    val arity = tp1.argInfos.length
+    arity <= MaxTupleArity && {
+      val tupletp = TupleType(arity)
+      tupletp != null && tp1.isRef(tupletp.symbol)
+    }
+  }
+
+  def tupleType(elems: List[Type]): Type = {
+    val arity = elems.length
+    if 0 < arity && arity <= MaxTupleArity then
+      val tupletp = TupleType(arity)
+      if tupletp != null then tupletp.appliedTo(elems)
+      else TypeOps.nestedPairs(elems)
+    else TypeOps.nestedPairs(elems)
+  }
+
+  def tupleTypes(tp: Type, bound: Int = Int.MaxValue)(using Context): Option[List[Type]] = {
+    @tailrec def rec(tp: Type, acc: List[Type], bound: Int): Option[List[Type]] = tp.normalized.dealias match {
+      case _ if bound < 0 => Some(acc.reverse)
+      case tp: AppliedType if PairClass == tp.classSymbol => rec(tp.args(1), tp.args.head :: acc, bound - 1)
+      case tp: AppliedType if isTupleNType(tp) => Some(acc.reverse ::: tp.args)
+      case tp: TermRef if tp.symbol == defn.EmptyTupleModule => Some(acc.reverse)
+      case _ => None
+    }
+    rec(tp.stripTypeVar, Nil, bound)
+  }
+
+  def isProductSubType(tp: Type)(using Context): Boolean = tp.derivesFrom(ProductClass)
+
+  /** Is `tp` (an alias) of either a scala.FunctionN or a scala.ContextFunctionN
+   *  instance?
+   */
+  def isNonRefinedFunction(tp: Type)(using Context): Boolean =
+    val arity = functionArity(tp)
+    val sym = tp.dealias.typeSymbol
+
+    arity >= 0
+    && isFunctionClass(sym)
+    && tp.isRef(
+        FunctionType(arity, sym.name.isContextFunction, sym.name.isErasedFunction).typeSymbol,
+        skipRefined = false)
+  end isNonRefinedFunction
+
+  /** Is `tp` a representation of a (possibly dependent) function type or an alias of such? */
+  def isFunctionType(tp: Type)(using Context): Boolean =
+    isNonRefinedFunction(tp.dropDependentRefinement)
+
+  def isFunctionOrPolyType(tp: Type)(using Context): Boolean =
+    isFunctionType(tp) || (tp.typeSymbol eq defn.PolyFunctionClass)
+
+  private def withSpecMethods(cls: ClassSymbol, bases: List[Name], paramTypes: Set[TypeRef]) =
+    for base <- bases; tp <- paramTypes do
+      cls.enter(newSymbol(cls, base.specializedName(List(tp)), Method, ExprType(tp)))
+    cls
+
+  @tu lazy val Tuple1: ClassSymbol = withSpecMethods(requiredClass("scala.Tuple1"), List(nme._1), Tuple1SpecializedParamTypes)
+  @tu lazy val Tuple2: ClassSymbol = withSpecMethods(requiredClass("scala.Tuple2"), List(nme._1, nme._2), Tuple2SpecializedParamTypes)
+
+  @tu lazy val TupleSpecializedClasses: Set[Symbol]               = Set(Tuple1, Tuple2)
+  @tu lazy val Tuple1SpecializedParamTypes: Set[TypeRef]          = Set(IntType, LongType, DoubleType)
+  @tu lazy val Tuple2SpecializedParamTypes: Set[TypeRef]          = Set(IntType, LongType, DoubleType, CharType, BooleanType)
+  @tu lazy val Tuple1SpecializedParamClasses: PerRun[Set[Symbol]] = new PerRun(Tuple1SpecializedParamTypes.map(_.symbol))
+  @tu lazy val Tuple2SpecializedParamClasses: PerRun[Set[Symbol]] = new PerRun(Tuple2SpecializedParamTypes.map(_.symbol))
+
+  // Specialized type parameters defined for scala.Function{0,1,2}.
+  @tu lazy val Function1SpecializedParamTypes: collection.Set[TypeRef] =
+    Set(IntType, LongType, FloatType, DoubleType)
+  @tu lazy val Function2SpecializedParamTypes: collection.Set[TypeRef] =
+    Set(IntType, LongType, DoubleType)
+  @tu lazy val Function0SpecializedReturnTypes: collection.Set[TypeRef] =
+    ScalaNumericValueTypeList.toSet + UnitType + BooleanType
+  @tu lazy val Function1SpecializedReturnTypes: collection.Set[TypeRef] =
+    Set(UnitType, BooleanType, IntType, FloatType, LongType, DoubleType)
+  @tu lazy val Function2SpecializedReturnTypes: collection.Set[TypeRef] =
+    Function1SpecializedReturnTypes
+
+  @tu lazy val Function1SpecializedParamClasses: PerRun[collection.Set[Symbol]] =
+    new PerRun(Function1SpecializedParamTypes.map(_.symbol))
+  @tu lazy val Function2SpecializedParamClasses: PerRun[collection.Set[Symbol]] =
+    new PerRun(Function2SpecializedParamTypes.map(_.symbol))
+  @tu lazy val Function0SpecializedReturnClasses: PerRun[collection.Set[Symbol]] =
+    new PerRun(Function0SpecializedReturnTypes.map(_.symbol))
+  @tu lazy val Function1SpecializedReturnClasses: PerRun[collection.Set[Symbol]] =
+    new PerRun(Function1SpecializedReturnTypes.map(_.symbol))
+  @tu lazy val Function2SpecializedReturnClasses: PerRun[collection.Set[Symbol]] =
+    new PerRun(Function2SpecializedReturnTypes.map(_.symbol))
+
+  def isSpecializableTuple(base: Symbol, args: List[Type])(using Context): Boolean =
+    args.length <= 2 && base.isClass && TupleSpecializedClasses.exists(base.asClass.derivesFrom) && args.match
+      case List(x)    => Tuple1SpecializedParamClasses().contains(x.classSymbol)
+      case List(x, y) => Tuple2SpecializedParamClasses().contains(x.classSymbol) && Tuple2SpecializedParamClasses().contains(y.classSymbol)
+      case _          => false
+    && base.owner.denot.info.member(base.name.specializedName(args)).exists // when dotc compiles the stdlib there are no specialised classes
+
+  def isSpecializableFunction(cls: ClassSymbol, paramTypes: List[Type], retType: Type)(using Context): Boolean =
+    paramTypes.length <= 2
+    && (cls.derivesFrom(FunctionSymbol(paramTypes.length)) || isByNameFunctionClass(cls))
+    && isSpecializableFunctionSAM(paramTypes, retType)
+
+  /** If the Single Abstract Method of a Function class has this type, is it specializable? */
+  def isSpecializableFunctionSAM(paramTypes: List[Type], retType: Type)(using Context): Boolean =
+    paramTypes.length <= 2 && (paramTypes match {
+      case Nil =>
+        Function0SpecializedReturnClasses().contains(retType.typeSymbol)
+      case List(paramType0) =>
+        Function1SpecializedParamClasses().contains(paramType0.typeSymbol) &&
+        Function1SpecializedReturnClasses().contains(retType.typeSymbol)
+      case List(paramType0, paramType1) =>
+        Function2SpecializedParamClasses().contains(paramType0.typeSymbol) &&
+        Function2SpecializedParamClasses().contains(paramType1.typeSymbol) &&
+        Function2SpecializedReturnClasses().contains(retType.typeSymbol)
+      case _ =>
+        false
+    })
+
+  @tu lazy val Function0SpecializedApplyNames: collection.Set[TermName] =
+    for r <- Function0SpecializedReturnTypes
+    yield nme.apply.specializedFunction(r, Nil).asTermName
+
+  @tu lazy val Function1SpecializedApplyNames: collection.Set[TermName] =
+    for
+      r  <- Function1SpecializedReturnTypes
+      t1 <- Function1SpecializedParamTypes
+    yield
+      nme.apply.specializedFunction(r, List(t1)).asTermName
+
+  @tu lazy val Function2SpecializedApplyNames: collection.Set[TermName] =
+    for
+      r  <- Function2SpecializedReturnTypes
+      t1 <- Function2SpecializedParamTypes
+      t2 <- Function2SpecializedParamTypes
+    yield
+      nme.apply.specializedFunction(r, List(t1, t2)).asTermName
+
+  @tu lazy val FunctionSpecializedApplyNames: collection.Set[Name] =
+    Function0SpecializedApplyNames ++ Function1SpecializedApplyNames ++ Function2SpecializedApplyNames
+
+  def functionArity(tp: Type)(using Context): Int = tp.dropDependentRefinement.dealias.argInfos.length - 1
+
+  /** Return underlying context function type (i.e. instance of an ContextFunctionN class)
+   *  or NoType if none exists. The following types are considered as underlying types:
+   *   - the alias of an alias type
+   *   - the instance or origin of a TypeVar (i.e. the result of a stripTypeVar)
+   *   - the upper bound of a TypeParamRef in the current constraint
+   */
+  def asContextFunctionType(tp: Type)(using Context): Type =
+    tp.stripTypeVar.dealias match
+      case tp1: TypeParamRef if ctx.typerState.constraint.contains(tp1) =>
+        asContextFunctionType(TypeComparer.bounds(tp1).hiBound)
+      case tp1 =>
+        if tp1.typeSymbol.name.isContextFunction && isFunctionType(tp1) then tp1
+        else NoType
+
+  /** Is `tp` an context function type? */
+  def isContextFunctionType(tp: Type)(using Context): Boolean =
+    asContextFunctionType(tp).exists
+
+  /** An extractor for context function types `As ?=> B`, possibly with
+   *  dependent refinements. Optionally returns a triple consisting of the argument
+   *  types `As`, the result type `B` and a whether the type is an erased context function.
+   */
+  object ContextFunctionType:
+    def unapply(tp: Type)(using Context): Option[(List[Type], Type, Boolean)] =
+      if ctx.erasedTypes then
+        atPhase(erasurePhase)(unapply(tp))
+      else
+        val tp1 = asContextFunctionType(tp)
+        if tp1.exists then
+          val args = tp1.dropDependentRefinement.argInfos
+          Some((args.init, args.last, tp1.typeSymbol.name.isErasedFunction))
+        else None
+
+  def isErasedFunctionType(tp: Type)(using Context): Boolean =
+    tp.dealias.typeSymbol.name.isErasedFunction && isFunctionType(tp)
+
+  /** A whitelist of Scala-2 classes that are known to be pure */
+  def isAssuredNoInits(sym: Symbol): Boolean =
+    (sym `eq` SomeClass) || isTupleClass(sym)
+
+  /** If `cls` is Tuple1..Tuple22, add the corresponding *: type as last parent to `parents` */
+  def adjustForTuple(cls: ClassSymbol, tparams: List[TypeSymbol], parents: List[Type]): List[Type] = {
+    if !isTupleClass(cls) then parents
+    else if tparams.isEmpty then parents :+ TupleTypeRef
+    else
+      assert(parents.head.typeSymbol == ObjectClass)
+      TypeOps.nestedPairs(tparams.map(_.typeRef)) :: parents.tail
+  }
+
+  /** If it is BoxedUnit, remove `java.io.Serializable` from `parents`. */
+  def adjustForBoxedUnit(cls: ClassSymbol, parents: List[Type]): List[Type] =
+    if (isBoxedUnitClass(cls)) parents.filter(_.typeSymbol != JavaSerializableClass)
+    else parents
+
+  private val HasProblematicGetClass: Set[Name] = Set(
+    tpnme.AnyVal, tpnme.Byte, tpnme.Short, tpnme.Char, tpnme.Int, tpnme.Long, tpnme.Float, tpnme.Double,
+    tpnme.Unit, tpnme.Boolean)
+
+  /** When typing a primitive value class or AnyVal, we ignore the `getClass`
+   *  member: it's supposed to be an override of the `getClass` defined on `Any`,
+   *  but in dotty `Any#getClass` is polymorphic so it ends up being an overload.
+   *  This is especially problematic because it means that when writing:
+   *
+   *    1.asInstanceOf[Int & AnyRef].getClass
+   *
+   *  the `getClass` that returns `Class[Int]` defined in Int can be selected,
+   *  but this call is specified to return `classOf[Integer]`, see
+   *  tests/run/t5568.scala.
+   *
+   *  FIXME: remove all the `getClass` methods defined in the standard library
+   *  so we don't have to hot-patch it like this.
+   */
+  def hasProblematicGetClass(className: Name): Boolean =
+    HasProblematicGetClass.contains(className)
+
+  /** Is synthesized symbol with alphanumeric name allowed to be used as an infix operator? */
+  def isInfix(sym: Symbol)(using Context): Boolean =
+    (sym eq Object_eq) || (sym eq Object_ne)
+
+  @tu lazy val assumedTransparentTraits =
+    Set[Symbol](ComparableClass, ProductClass, SerializableClass,
+      // add these for now, until we had a chance to retrofit 2.13 stdlib
+      // we should do a more through sweep through it then.
+      requiredClass("scala.collection.SortedOps"),
+      requiredClass("scala.collection.StrictOptimizedSortedSetOps"),
+      requiredClass("scala.collection.generic.DefaultSerializable"),
+      requiredClass("scala.collection.generic.IsIterable"),
+      requiredClass("scala.collection.generic.IsIterableOnce"),
+      requiredClass("scala.collection.generic.IsMap"),
+      requiredClass("scala.collection.generic.IsSeq"),
+      requiredClass("scala.collection.generic.Subtractable"),
+      requiredClass("scala.collection.immutable.StrictOptimizedSeqOps")
+    )
+
+  // ----- primitive value class machinery ------------------------------------------
+
+  class PerRun[T](generate: Context ?=> T) {
+    private var current: RunId = NoRunId
+    private var cached: T = _
+    def apply()(using Context): T = {
+      if (current != ctx.runId) {
+        cached = generate
+        current = ctx.runId
+      }
+      cached
+    }
+  }
+
+  @tu lazy val ScalaNumericValueTypeList: List[TypeRef] = List(
+    ByteType, ShortType, CharType, IntType, LongType, FloatType, DoubleType)
+
+  @tu private lazy val ScalaNumericValueTypes: collection.Set[TypeRef] = ScalaNumericValueTypeList.toSet
+  @tu private lazy val ScalaValueTypes: collection.Set[TypeRef] = ScalaNumericValueTypes `union` Set(UnitType, BooleanType)
+
+  val ScalaNumericValueClasses: PerRun[collection.Set[Symbol]] = new PerRun(ScalaNumericValueTypes.map(_.symbol))
+  val ScalaValueClasses: PerRun[collection.Set[Symbol]]        = new PerRun(ScalaValueTypes.map(_.symbol))
+
+  val ScalaBoxedClasses: PerRun[collection.Set[Symbol]] = new PerRun(
+    Set(BoxedByteClass, BoxedShortClass, BoxedCharClass, BoxedIntClass, BoxedLongClass, BoxedFloatClass, BoxedDoubleClass, BoxedUnitClass, BoxedBooleanClass)
+  )
+
+  private val valueTypeEnc = mutable.Map[TypeName, PrimitiveClassEnc]()
+  private val typeTags = mutable.Map[TypeName, Name]().withDefaultValue(nme.specializedTypeNames.Object)
+
+//  private val unboxedTypeRef = mutable.Map[TypeName, TypeRef]()
+//  private val javaTypeToValueTypeRef = mutable.Map[Class[?], TypeRef]()
+//  private val valueTypeNamesToJavaType = mutable.Map[TypeName, Class[?]]()
+
+  private def valueTypeRef(name: String, jtype: Class[?], enc: Int, tag: Name): TypeRef = {
+    val vcls = requiredClassRef(name)
+    valueTypeEnc(vcls.name) = enc
+    typeTags(vcls.name) = tag
+//    unboxedTypeRef(boxed.name) = vcls
+//    javaTypeToValueTypeRef(jtype) = vcls
+//    valueTypeNamesToJavaType(vcls.name) = jtype
+    vcls
+  }
+
+  /** The type of the boxed class corresponding to primitive value type `tp`. */
+  def boxedType(tp: Type)(using Context): TypeRef = {
+    val cls = tp.classSymbol
+    if (cls eq ByteClass)         BoxedByteClass
+    else if (cls eq ShortClass)   BoxedShortClass
+    else if (cls eq CharClass)    BoxedCharClass
+    else if (cls eq IntClass)     BoxedIntClass
+    else if (cls eq LongClass)    BoxedLongClass
+    else if (cls eq FloatClass)   BoxedFloatClass
+    else if (cls eq DoubleClass)  BoxedDoubleClass
+    else if (cls eq UnitClass)    BoxedUnitClass
+    else if (cls eq BooleanClass) BoxedBooleanClass
+    else sys.error(s"Not a primitive value type: $tp")
+  }.typeRef
+
+  def unboxedType(tp: Type)(using Context): TypeRef = {
+    val cls = tp.classSymbol
+    if (cls eq BoxedByteClass)         ByteType
+    else if (cls eq BoxedShortClass)   ShortType
+    else if (cls eq BoxedCharClass)    CharType
+    else if (cls eq BoxedIntClass)     IntType
+    else if (cls eq BoxedLongClass)    LongType
+    else if (cls eq BoxedFloatClass)   FloatType
+    else if (cls eq BoxedDoubleClass)  DoubleType
+    else if (cls eq BoxedUnitClass)    UnitType
+    else if (cls eq BoxedBooleanClass) BooleanType
+    else sys.error(s"Not a boxed primitive value type: $tp")
+  }
+
+  /** The JVM tag for `tp` if it's a primitive, `java.lang.Object` otherwise. */
+  def typeTag(tp: Type)(using Context): Name = typeTags(scalaClassName(tp))
+
+//  /** The `Class[?]` of a primitive value type name */
+//  def valueTypeNameToJavaType(name: TypeName)(using Context): Option[Class[?]] =
+//    valueTypeNamesToJavaType.get(if (name.firstPart eq nme.scala) name.lastPart.toTypeName else name)
+
+  type PrimitiveClassEnc = Int
+
+  val ByteEnc: Int = 2
+  val ShortEnc: Int = ByteEnc * 3
+  val CharEnc: Int = 5
+  val IntEnc: Int = ShortEnc * CharEnc
+  val LongEnc: Int = IntEnc * 7
+  val FloatEnc: Int = LongEnc * 11
+  val DoubleEnc: Int = FloatEnc * 13
+  val BooleanEnc: Int = 17
+  val UnitEnc: Int = 19
+
+  def isValueSubType(tref1: TypeRef, tref2: TypeRef)(using Context): Boolean =
+    valueTypeEnc(tref2.name) % valueTypeEnc(tref1.name) == 0
+  def isValueSubClass(sym1: Symbol, sym2: Symbol): Boolean =
+    valueTypeEnc(sym2.asClass.name) % valueTypeEnc(sym1.asClass.name) == 0
+
+  @tu lazy val specialErasure: SimpleIdentityMap[Symbol, ClassSymbol] =
+    SimpleIdentityMap.empty[Symbol]
+      .updated(AnyClass, ObjectClass)
+      .updated(MatchableClass, ObjectClass)
+      .updated(AnyValClass, ObjectClass)
+      .updated(SingletonClass, ObjectClass)
+      .updated(TupleClass, ProductClass)
+      .updated(NonEmptyTupleClass, ProductClass)
+      .updated(PairClass, ObjectClass)
+
+  // ----- Initialization ---------------------------------------------------
+
+  /** Lists core classes that don't have underlying bytecode, but are synthesized on-the-fly in every reflection universe */
+  @tu lazy val syntheticScalaClasses: List[TypeSymbol] =
+    List(
+      AnyClass,
+      MatchableClass,
+      AnyRefAlias,
+      AnyKindClass,
+      andType,
+      orType,
+      RepeatedParamClass,
+      ByNameParamClass2x,
+      AnyValClass,
+      NullClass,
+      NothingClass,
+      SingletonClass)
+
+  @tu lazy val syntheticCoreClasses: List[Symbol] = syntheticScalaClasses ++ List(
+    EmptyPackageVal,
+    OpsPackageClass)
+
+  /** Lists core methods that don't have underlying bytecode, but are synthesized on-the-fly in every reflection universe */
+  @tu lazy val syntheticCoreMethods: List[TermSymbol] =
+    AnyMethods ++ ObjectMethods ++ List(String_+, throwMethod)
+
+  @tu lazy val reservedScalaClassNames: Set[Name] = syntheticScalaClasses.map(_.name).toSet
+
+  private var isInitialized = false
+
+  def init()(using Context): Unit = {
+    this.initCtx = ctx
+    if (!isInitialized) {
+      // force initialization of every symbol that is synthesized or hijacked by the compiler
+      val forced =
+        syntheticCoreClasses ++ syntheticCoreMethods ++ ScalaValueClasses() :+ JavaEnumClass
+      isInitialized = true
+    }
+    addSyntheticSymbolsComments
+  }
+
+  def addSyntheticSymbolsComments(using Context): Unit =
+    def add(sym: Symbol, doc: String) = ctx.docCtx.foreach(_.addDocstring(sym, Some(Comment(NoSpan, doc))))
+
+    add(AnyClass,
+    """/** Class `Any` is the root of the Scala class hierarchy.  Every class in a Scala
+      | *  execution environment inherits directly or indirectly from this class.
+      | *
+      | * Starting with Scala 2.10 it is possible to directly extend `Any` using ''universal traits''.
+      | * A ''universal trait'' is a trait that extends `Any`, only has `def`s as members, and does no initialization.
+      | *
+      | * The main use case for universal traits is to allow basic inheritance of methods for [[scala.AnyVal value classes]].
+      | * For example,
+      | *
+      | * {{{
+      | *     trait Printable extends Any {
+      | *       def print(): Unit = println(this)
+      | *     }
+      | *     class Wrapper(val underlying: Int) extends AnyVal with Printable
+      | *
+      | *     val w = new Wrapper(3)
+      | *     w.print()
+      | * }}}
+      | *
+      | * See the [[https://docs.scala-lang.org/overviews/core/value-classes.html Value Classes and Universal Traits]] for more
+      | * details on the interplay of universal traits and value classes.
+      | */
+    """.stripMargin)
+
+    add(Any_==,
+    """/** Test two objects for equality.
+      | *  The expression `x == that` is equivalent to `if (x eq null) that eq null else x.equals(that)`.
+      | *
+      | *  @param  that  the object to compare against this object for equality.
+      | *  @return       `true` if the receiver object is equivalent to the argument; `false` otherwise.
+      | */
+    """.stripMargin)
+
+    add(Any_!=,
+    """/** Test two objects for inequality.
+      | *
+      | *  @param  that  the object to compare against this object for equality.
+      | *  @return       `true` if !(this == that), `false` otherwise.
+      | */
+    """.stripMargin)
+
+    add(Any_equals,
+    """/** Compares the receiver object (`this`) with the argument object (`that`) for equivalence.
+      | *
+      | *  Any implementation of this method should be an [[https://en.wikipedia.org/wiki/Equivalence_relation equivalence relation]]:
+      | *
+      | *  - It is reflexive: for any instance `x` of type `Any`, `x.equals(x)` should return `true`.
+      | *  - It is symmetric: for any instances `x` and `y` of type `Any`, `x.equals(y)` should return `true` if and
+      | *    only if `y.equals(x)` returns `true`.
+      | *  - It is transitive: for any instances `x`, `y`, and `z` of type `Any` if `x.equals(y)` returns `true` and
+      | *    `y.equals(z)` returns `true`, then `x.equals(z)` should return `true`.
+      | *
+      | *  If you override this method, you should verify that your implementation remains an equivalence relation.
+      | *  Additionally, when overriding this method it is usually necessary to override `hashCode` to ensure that
+      | *  objects which are "equal" (`o1.equals(o2)` returns `true`) hash to the same [[scala.Int]].
+      | *  (`o1.hashCode.equals(o2.hashCode)`).
+      | *
+      | *  @param  that    the object to compare against this object for equality.
+      | *  @return         `true` if the receiver object is equivalent to the argument; `false` otherwise.
+      | */
+    """.stripMargin)
+
+    add(Any_hashCode,
+    """/** Calculate a hash code value for the object.
+      | *
+      | *  The default hashing algorithm is platform dependent.
+      | *
+      | *  Note that it is allowed for two objects to have identical hash codes (`o1.hashCode.equals(o2.hashCode)`) yet
+      | *  not be equal (`o1.equals(o2)` returns `false`).  A degenerate implementation could always return `0`.
+      | *  However, it is required that if two objects are equal (`o1.equals(o2)` returns `true`) that they have
+      | *  identical hash codes (`o1.hashCode.equals(o2.hashCode)`).  Therefore, when overriding this method, be sure
+      | *  to verify that the behavior is consistent with the `equals` method.
+      | *
+      | *  @return   the hash code value for this object.
+      | */
+    """.stripMargin)
+
+    add(Any_toString,
+    """/** Returns a string representation of the object.
+      | *
+      | *  The default representation is platform dependent.
+      | *
+      | *  @return a string representation of the object.
+      | */
+    """.stripMargin)
+
+    add(Any_##,
+    """/** Equivalent to `x.hashCode` except for boxed numeric types and `null`.
+      | *  For numerics, it returns a hash value which is consistent
+      | *  with value equality: if two value type instances compare
+      | *  as true, then ## will produce the same hash value for each
+      | *  of them.
+      | *  For `null` returns a hashcode where `null.hashCode` throws a
+      | *  `NullPointerException`.
+      | *
+      | *  @return   a hash value consistent with ==
+      | */
+    """.stripMargin)
+
+    add(Any_isInstanceOf,
+    """/** Test whether the dynamic type of the receiver object is `T0`.
+      | *
+      | *  Note that the result of the test is modulo Scala's erasure semantics.
+      | *  Therefore the expression `1.isInstanceOf[String]` will return `false`, while the
+      | *  expression `List(1).isInstanceOf[List[String]]` will return `true`.
+      | *  In the latter example, because the type argument is erased as part of compilation it is
+      | *  not possible to check whether the contents of the list are of the specified type.
+      | *
+      | *  @return `true` if the receiver object is an instance of erasure of type `T0`; `false` otherwise.
+      | */
+    """.stripMargin)
+
+    add(Any_asInstanceOf,
+    """/** Cast the receiver object to be of type `T0`.
+      | *
+      | *  Note that the success of a cast at runtime is modulo Scala's erasure semantics.
+      | *  Therefore the expression `1.asInstanceOf[String]` will throw a `ClassCastException` at
+      | *  runtime, while the expression `List(1).asInstanceOf[List[String]]` will not.
+      | *  In the latter example, because the type argument is erased as part of compilation it is
+      | *  not possible to check whether the contents of the list are of the requested type.
+      | *
+      | *  @throws ClassCastException if the receiver object is not an instance of the erasure of type `T0`.
+      | *  @return the receiver object.
+      | */
+    """.stripMargin)
+
+    add(Any_getClass,
+    """/** Returns the runtime class representation of the object.
+      | *
+      | *  @return a class object corresponding to the runtime type of the receiver.
+      | */
+    """.stripMargin)
+
+    add(MatchableClass,
+    """/** The base trait of types that can be safely pattern matched against.
+      | *
+      | *   See [[https://docs.scala-lang.org/scala3/reference/other-new-features/matchable.html]].
+      | */
+    """.stripMargin)
+
+    add(AnyRefAlias,
+    """/** Class `AnyRef` is the root class of all ''reference types''.
+      | *  All types except the value types descend from this class.
+      | */
+    """.stripMargin)
+
+    add(Object_eq,
+    """/** Tests whether the argument (`that`) is a reference to the receiver object (`this`).
+      | *
+      | *  The `eq` method implements an [[https://en.wikipedia.org/wiki/Equivalence_relation equivalence relation]] on
+      | *  non-null instances of `AnyRef`, and has three additional properties:
+      | *
+      | *   - It is consistent: for any non-null instances `x` and `y` of type `AnyRef`, multiple invocations of
+      | *     `x.eq(y)` consistently returns `true` or consistently returns `false`.
+      | *   - For any non-null instance `x` of type `AnyRef`, `x.eq(null)` and `null.eq(x)` returns `false`.
+      | *   - `null.eq(null)` returns `true`.
+      | *
+      | *  When overriding the `equals` or `hashCode` methods, it is important to ensure that their behavior is
+      | *  consistent with reference equality.  Therefore, if two objects are references to each other (`o1 eq o2`), they
+      | *  should be equal to each other (`o1 == o2`) and they should hash to the same value (`o1.hashCode == o2.hashCode`).
+      | *
+      | *  @param  that    the object to compare against this object for reference equality.
+      | *  @return         `true` if the argument is a reference to the receiver object; `false` otherwise.
+      | */
+    """.stripMargin)
+
+    add(Object_ne,
+    """/** Equivalent to `!(this eq that)`.
+      | *
+      | *  @param  that    the object to compare against this object for reference equality.
+      | *  @return         `true` if the argument is not a reference to the receiver object; `false` otherwise.
+      | */
+    """.stripMargin)
+
+    add(Object_synchronized,
+    """/** Executes the code in `body` with an exclusive lock on `this`.
+      | *
+      | *  @param    body    the code to execute
+      | *  @return           the result of `body`
+      | */
+    """.stripMargin)
+
+    add(Object_clone,
+    """/** Create a copy of the receiver object.
+      | *
+      | *  The default implementation of the `clone` method is platform dependent.
+      | *
+      | *  @note   not specified by SLS as a member of AnyRef
+      | *  @return a copy of the receiver object.
+      | */
+    """.stripMargin)
+
+    add(Object_finalize,
+    """/** Called by the garbage collector on the receiver object when there
+      | *  are no more references to the object.
+      | *
+      | *  The details of when and if the `finalize` method is invoked, as
+      | *  well as the interaction between `finalize` and non-local returns
+      | *  and exceptions, are all platform dependent.
+      | *
+      | *  @note   not specified by SLS as a member of AnyRef
+      | */
+    """.stripMargin)
+
+    add(Object_notify,
+    """/** Wakes up a single thread that is waiting on the receiver object's monitor.
+      | *
+      | *  @note   not specified by SLS as a member of AnyRef
+      | */
+    """.stripMargin)
+
+    add(Object_notifyAll,
+    """/** Wakes up all threads that are waiting on the receiver object's monitor.
+      | *
+      | *  @note   not specified by SLS as a member of AnyRef
+      | */
+    """.stripMargin)
+
+    add(Object_wait,
+    """/** See [[https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html#wait--]].
+      | *
+      | *  @note   not specified by SLS as a member of AnyRef
+      | */
+    """.stripMargin)
+
+    add(Object_waitL,
+    """/** See [[https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html#wait-long-]].
+      | *
+      | * @param timeout the maximum time to wait in milliseconds.
+      | * @note not specified by SLS as a member of AnyRef
+      | */
+    """.stripMargin)
+
+    add(Object_waitLI,
+    """/** See [[https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html#wait-long-int-]]
+      | *
+      | * @param timeout the maximum time to wait in milliseconds.
+      | * @param nanos   additional time, in nanoseconds range 0-999999.
+      | * @note not specified by SLS as a member of AnyRef
+      | */
+    """.stripMargin)
+
+    add(AnyKindClass,
+    """/** The super-type of all types.
+      | *
+      | *   See [[https://docs.scala-lang.org/scala3/reference/other-new-features/kind-polymorphism.html]].
+      | */
+    """.stripMargin)
+
+    add(andType,
+    """/** The intersection of two types.
+      | *
+      | *   See [[https://docs.scala-lang.org/scala3/reference/new-types/intersection-types.html]].
+      | */
+    """.stripMargin)
+
+    add(orType,
+    """/** The union of two types.
+      | *
+      | *   See [[https://docs.scala-lang.org/scala3/reference/new-types/union-types.html]].
+      | */
+    """.stripMargin)
+
+    add(AnyValClass,
+    """/** `AnyVal` is the root class of all ''value types'', which describe values
+      | *  not implemented as objects in the underlying host system. Value classes
+      | *  are specified in Scala Language Specification, section 12.2.
+      | *
+      | *  The standard implementation includes nine `AnyVal` subtypes:
+      | *
+      | *  [[scala.Double]], [[scala.Float]], [[scala.Long]], [[scala.Int]], [[scala.Char]],
+      | *  [[scala.Short]], and [[scala.Byte]] are the ''numeric value types''.
+      | *
+      | *  [[scala.Unit]] and [[scala.Boolean]] are the ''non-numeric value types''.
+      | *
+      | *  Other groupings:
+      | *
+      | *   - The ''subrange types'' are [[scala.Byte]], [[scala.Short]], and [[scala.Char]].
+      | *   - The ''integer types'' include the subrange types as well as [[scala.Int]] and [[scala.Long]].
+      | *   - The ''floating point types'' are [[scala.Float]] and [[scala.Double]].
+      | *
+      | * Prior to Scala 2.10, `AnyVal` was a sealed trait. Beginning with Scala 2.10,
+      | * however, it is possible to define a subclass of `AnyVal` called a ''user-defined value class''
+      | * which is treated specially by the compiler. Properly-defined user value classes provide a way
+      | * to improve performance on user-defined types by avoiding object allocation at runtime, and by
+      | * replacing virtual method invocations with static method invocations.
+      | *
+      | * User-defined value classes which avoid object allocation...
+      | *
+      | *   - must have a single `val` parameter that is the underlying runtime representation.
+      | *   - can define `def`s, but no `val`s, `var`s, or nested `traits`s, `class`es or `object`s.
+      | *   - typically extend no other trait apart from `AnyVal`.
+      | *   - cannot be used in type tests or pattern matching.
+      | *   - may not override `equals` or `hashCode` methods.
+      | *
+      | * A minimal example:
+      | * {{{
+      | *     class Wrapper(val underlying: Int) extends AnyVal {
+      | *       def foo: Wrapper = new Wrapper(underlying * 19)
+      | *     }
+      | * }}}
+      | *
+      | * It's important to note that user-defined value classes are limited, and in some circumstances,
+      | * still must allocate a value class instance at runtime. These limitations and circumstances are
+      | * explained in greater detail in the [[https://docs.scala-lang.org/overviews/core/value-classes.html Value Classes and Universal Traits]].
+      | */
+    """.stripMargin)
+
+    add(NullClass,
+    """/** `Null` is - together with [[scala.Nothing]] - at the bottom of the Scala type hierarchy.
+      | *
+      | * `Null` is the type of the `null` literal. It is a subtype of every type
+      | * except those of value classes. Value classes are subclasses of [[AnyVal]], which includes
+      | * primitive types such as [[Int]], [[Boolean]], and user-defined value classes.
+      | *
+      | * Since `Null` is not a subtype of value types, `null` is not a member of any such type.
+      | * For instance, it is not possible to assign `null` to a variable of type [[scala.Int]].
+      | */
+    """.stripMargin)
+
+    add(NothingClass,
+    """/** `Nothing` is - together with [[scala.Null]] - at the bottom of Scala's type hierarchy.
+      | *
+      | *  `Nothing` is a subtype of every other type (including [[scala.Null]]); there exist
+      | *  ''no instances'' of this type.  Although type `Nothing` is uninhabited, it is
+      | *  nevertheless useful in several ways.  For instance, the Scala library defines a value
+      | *  [[scala.collection.immutable.Nil]] of type `List[Nothing]`. Because lists are covariant in Scala,
+      | *  this makes [[scala.collection.immutable.Nil]] an instance of `List[T]`, for any element of type `T`.
+      | *
+      | *  Another usage for Nothing is the return type for methods which never return normally.
+      | *  One example is method error in [[scala.sys]], which always throws an exception.
+      | */
+    """.stripMargin)
+
+    add(SingletonClass,
+    """/** `Singleton` is used by the compiler as a supertype for singleton types. This includes literal types,
+      | * as they are also singleton types.
+      | *
+      | * {{{
+      | * scala> object A { val x = 42 }
+      | * defined object A
+      | *
+      | * scala> implicitly[A.type <:< Singleton]
+      | * res12: A.type <:< Singleton = generalized constraint
+      | *
+      | * scala> implicitly[A.x.type <:< Singleton]
+      | * res13: A.x.type <:< Singleton = generalized constraint
+      | *
+      | * scala> implicitly[42 <:< Singleton]
+      | * res14: 42 <:< Singleton = generalized constraint
+      | *
+      | * scala> implicitly[Int <:< Singleton]
+      | * ^
+      | * error: Cannot prove that Int <:< Singleton.
+      | * }}}
+      | *
+      | * `Singleton` has a special meaning when it appears as an upper bound on a formal type
+      | * parameter. Normally, type inference in Scala widens singleton types to the underlying
+      | * non-singleton type. When a type parameter has an explicit upper bound of `Singleton`,
+      | * the compiler infers a singleton type.
+      | *
+      | * {{{
+      | * scala> def check42[T](x: T)(implicit ev: T =:= 42): T = x
+      | * check42: [T](x: T)(implicit ev: T =:= 42)T
+      | *
+      | * scala> val x1 = check42(42)
+      | * ^
+      | * error: Cannot prove that Int =:= 42.
+      | *
+      | * scala> def singleCheck42[T <: Singleton](x: T)(implicit ev: T =:= 42): T = x
+      | * singleCheck42: [T <: Singleton](x: T)(implicit ev: T =:= 42)T
+      | *
+      | * scala> val x2 = singleCheck42(42)
+      | * x2: Int = 42
+      | * }}}
+      | *
+      | * See also [[https://docs.scala-lang.org/sips/42.type.html SIP-23 about Literal-based Singleton Types]].
+      | */
+    """.stripMargin)
+}
diff --git a/tests/pos-with-compiler-cc/dotc/core/DenotTransformers.scala b/tests/pos-with-compiler-cc/dotc/core/DenotTransformers.scala
new file mode 100644
index 000000000000..6690cae3a142
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/core/DenotTransformers.scala
@@ -0,0 +1,82 @@
+package dotty.tools.dotc
+package core
+
+import Periods._
+import SymDenotations._
+import Contexts._
+import Types._
+import Symbols._
+import Denotations._
+import Phases._
+
+object DenotTransformers {
+
+  /** A transformer group contains a sequence of transformers,
+   *  ordered by the phase where they apply. Transformers are added
+   *  to a group via `install`.
+   */
+
+  /** A transformer transforms denotations at a given phase */
+  trait DenotTransformer extends Phase {
+
+    /** The last phase during which the transformed denotations are valid */
+    def lastPhaseId(using Context): Int = ctx.base.nextDenotTransformerId(id + 1)
+
+    /** The validity period of the transformed denotations in the given context */
+    def validFor(using Context): Period =
+      Period(ctx.runId, id + 1, lastPhaseId)
+
+    /** The transformation method */
+    def transform(ref: SingleDenotation)(using Context): SingleDenotation
+  }
+
+  /** A transformer that only transforms the info field of denotations */
+  trait InfoTransformer extends DenotTransformer {
+
+    def transformInfo(tp: Type, sym: Symbol)(using Context): Type
+
+    def transform(ref: SingleDenotation)(using Context): SingleDenotation = {
+      val sym = ref.symbol
+      if (sym.exists && !infoMayChange(sym)) ref
+      else {
+        val info1 = transformInfo(ref.info, ref.symbol)
+        if (info1 eq ref.info) ref
+        else ref match {
+          case ref: SymDenotation =>
+            ref.copySymDenotation(info = info1).copyCaches(ref, ctx.phase.next)
+          case _ =>
+            ref.derivedSingleDenotation(ref.symbol, info1)
+        }
+      }
+    }
+
+    /** Denotations with a symbol where `infoMayChange` is false are guaranteed to be
+     *  unaffected by this transform, so `transformInfo` need not be run. This
+     *  can save time, and more importantly, can help avoid forcing symbol completers.
+     */
+    protected def infoMayChange(sym: Symbol)(using Context): Boolean = true
+  }
+
+  /** A transformer that only transforms SymDenotations.
+   *  Note: Infos of non-sym denotations are left as is. So the transformer should
+   *  be used before erasure only if this is not a problem. After erasure, all
+   *  denotations are SymDenotations, so SymTransformers can be used freely.
+   */
+  trait SymTransformer extends DenotTransformer {
+
+    def transformSym(sym: SymDenotation)(using Context): SymDenotation
+
+    def transform(ref: SingleDenotation)(using Context): SingleDenotation = ref match {
+      case ref: SymDenotation => transformSym(ref)
+      case _ => ref
+    }
+  }
+
+  /** A `DenotTransformer` trait that has the identity as its `transform` method.
+   *  You might want to inherit from this trait so that new denotations can be
+   *  installed using `installAfter` and `enteredAfter` at the end of the phase.
+   */
+  trait IdentityDenotTransformer extends DenotTransformer {
+    def transform(ref: SingleDenotation)(using Context): SingleDenotation = ref
+  }
+}
diff --git a/tests/pos-with-compiler-cc/dotc/core/Denotations.scala b/tests/pos-with-compiler-cc/dotc/core/Denotations.scala
new file mode 100644
index 000000000000..5d99118e56af
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/core/Denotations.scala
@@ -0,0 +1,1375 @@
+package dotty.tools
+package dotc
+package core
+
+import SymDenotations.{ SymDenotation, ClassDenotation, NoDenotation, LazyType, stillValid, acceptStale, traceInvalid }
+import Contexts._
+import Names._
+import NameKinds._
+import StdNames._
+import Symbols.NoSymbol
+import Symbols._
+import Types._
+import Periods._
+import Flags._
+import DenotTransformers._
+import Decorators._
+import Signature.MatchDegree._
+import printing.Texts._
+import printing.Printer
+import io.AbstractFile
+import config.Config
+import config.Printers.overload
+import util.common._
+import typer.ProtoTypes.NoViewsAllowed
+import collection.mutable.ListBuffer
+import language.experimental.pureFunctions
+
+/** Denotations represent the meaning of symbols and named types.
+ *  The following diagram shows how the principal types of denotations
+ *  and their denoting entities relate to each other. Lines ending in
+ *  a down-arrow `v` are member methods. The two methods shown in the diagram are
+ *  "symbol" and "deref". Both methods are parameterized by the current context,
+ *  and are effectively indexed by current period.
+ *
+ *  Lines ending in a horizontal line mean subtyping (right is a subtype of left).
+ *
+ *  NamedType
+ *    |                                          Symbol---------ClassSymbol
+ *    |                                            |                |
+ *    | denot                                      | denot          | denot
+ *    v                                            v                v
+ *  Denotation-+-----SingleDenotation-+------SymDenotation-+----ClassDenotation
+ *             |                      |
+ *             +-----MultiDenotation  |
+ *                                    |
+ *                                    +--UniqueRefDenotation
+ *                                    +--JointRefDenotation
+ *
+ *  Here's a short summary of the classes in this diagram.
+ *
+ *  NamedType                A type consisting of a prefix type and a name, with fields
+ *                              prefix: Type
+ *                              name: Name
+ *                           It has two subtypes: TermRef and TypeRef
+ *  Symbol                   A label for a definition or declaration in one compiler run
+ *  ClassSymbol              A symbol representing a class
+ *  Denotation               The meaning of a named type or symbol during a period
+ *  MultiDenotation          A denotation representing several overloaded members
+ *  SingleDenotation         A denotation representing a non-overloaded member or definition, with main fields
+ *                              symbol: Symbol
+ *                              info: Type
+ *  UniqueRefDenotation      A denotation referring to a single definition with some member type
+ *  JointRefDenotation       A denotation referring to a member that could resolve to several definitions
+ *  SymDenotation            A denotation representing a single definition with its original type, with main fields
+ *                              name: Name
+ *                              owner: Symbol
+ *                              flags: Flags
+ *                              privateWithin: Symbol
+ *                              annotations: List[Annotation]
+ *  ClassDenotation          A denotation representing a single class definition.
+ */
+object Denotations {
+
+  implicit def eqDenotation: CanEqual[Denotation, Denotation] = CanEqual.derived
+
+  /** A PreDenotation represents a group of single denotations or a single multi-denotation
+   *  It is used as an optimization to avoid forming MultiDenotations too eagerly.
+   */
+  abstract class PreDenotation extends caps.Pure {
+
+    /** A denotation in the group exists */
+    def exists: Boolean
+
+    /** First/last denotation in the group */
+    def first: Denotation
+    def last: Denotation
+
+    /** Convert to full denotation by &-ing all elements */
+    def toDenot(pre: Type)(using Context): Denotation
+
+    /** Group contains a denotation that refers to given symbol */
+    def containsSym(sym: Symbol): Boolean
+
+    /** Group contains a denotation with the same signature as `other` */
+    def matches(other: SingleDenotation)(using Context): Boolean
+
+    /** Keep only those denotations in this group which satisfy predicate `p`. */
+    def filterWithPredicate(p: SingleDenotation => Boolean): PreDenotation
+
+    /** Keep only those denotations in this group which have a signature
+     *  that's not already defined by `denots`.
+     */
+    def filterDisjoint(denots: PreDenotation)(using Context): PreDenotation
+
+    /** Keep only those inherited members M of this predenotation for which the following is true
+     *   - M is not marked Private
+     *   - If M has a unique symbol, it does not appear in `prevDenots`.
+     *   - M's signature as seen from prefix `pre` does not appear in `ownDenots`
+     *  Return the denotation as seen from `pre`.
+     *  Called from SymDenotations.computeMember. There, `ownDenots` are the denotations found in
+     *  the base class, which shadow any inherited denotations with the same signature.
+     *  `prevDenots` are the denotations that are defined in the class or inherited from
+     *  a base type which comes earlier in the linearization.
+     */
+    def mapInherited(ownDenots: PreDenotation, prevDenots: PreDenotation, pre: Type)(using Context): PreDenotation
+
+    /** Keep only those denotations in this group that have all of the flags in `required`,
+     *  but none of the flags in `excluded`.
+     */
+    def filterWithFlags(required: FlagSet, excluded: FlagSet)(using Context): PreDenotation
+
+    /** Map `f` over all single denotations and aggregate the results with `g`. */
+    def aggregate[T](f: SingleDenotation => T, g: (T, T) => T): T
+
+    private var cachedPrefix: Type = _
+    private var cachedAsSeenFrom: AsSeenFromResult = _
+    private var validAsSeenFrom: Period = Nowhere
+
+    type AsSeenFromResult <: PreDenotation
+
+    /** The denotation with info(s) as seen from prefix type */
+    def asSeenFrom(pre: Type)(using Context): AsSeenFromResult =
+      if (Config.cacheAsSeenFrom) {
+        if ((cachedPrefix ne pre) || ctx.period != validAsSeenFrom) {
+          cachedAsSeenFrom = computeAsSeenFrom(pre)
+          cachedPrefix = pre
+          validAsSeenFrom = if (pre.isProvisional) Nowhere else ctx.period
+        }
+        cachedAsSeenFrom
+      }
+      else computeAsSeenFrom(pre)
+
+    protected def computeAsSeenFrom(pre: Type)(using Context): AsSeenFromResult
+
+    /** The union of two groups. */
+    def union(that: PreDenotation): PreDenotation =
+      if (!this.exists) that
+      else if (!that.exists) this
+      else DenotUnion(this, that)
+  }
+
+  /** A denotation is the result of resolving
+   *  a name (either simple identifier or select) during a given period.
+   *
+   *  Denotations can be combined with `&` and `|`.
+   *  & is conjunction, | is disjunction.
+   *
+   *  `&` will create an overloaded denotation from two
+   *  non-overloaded denotations if their signatures differ.
+   *  Analogously `|` of two denotations with different signatures will give
+   *  an empty denotation `NoDenotation`.
+   *
+   *  A denotation might refer to `NoSymbol`. This is the case if the denotation
+   *  was produced from a disjunction of two denotations with different symbols
+   *  and there was no common symbol in a superclass that could substitute for
+   *  both symbols. Here is an example:
+   *
+   *  Say, we have:
+   *
+   *    class A { def f: A }
+   *    class B { def f: B }
+   *    val x: A | B = if (test) new A else new B
+   *    val y = x.f
+   *
+   *  Then the denotation of `y` is `SingleDenotation(NoSymbol, A | B)`.
+   *
+   *  @param symbol  The referencing symbol, or NoSymbol is none exists
+   */
+  abstract class Denotation(val symbol: Symbol, protected var myInfo: Type) extends PreDenotation with printing.Showable {
+    type AsSeenFromResult <: Denotation
+
+    /** The type info.
+     *  The info is an instance of TypeType iff this is a type denotation
+     *  Uncompleted denotations set myInfo to a LazyType.
+     */
+    final def info(using Context): Type = {
+      def completeInfo = { // Written this way so that `info` is small enough to be inlined
+        this.asInstanceOf[SymDenotation].completeFrom(myInfo.asInstanceOf[LazyType]); info
+      }
+      if (myInfo.isInstanceOf[LazyType]) completeInfo else myInfo
+    }
+
+    /** The type info, or, if this is a SymDenotation where the symbol
+     *  is not yet completed, the completer
+     */
+    def infoOrCompleter: Type
+
+    /** The period during which this denotation is valid. */
+    def validFor: Period
+
+    /** Is this a reference to a type symbol? */
+    def isType: Boolean
+
+    /** Is this a reference to a term symbol? */
+    def isTerm: Boolean = !isType
+
+    /** Is this denotation overloaded? */
+    final def isOverloaded: Boolean = isInstanceOf[MultiDenotation]
+
+    /** Denotation points to unique symbol; false for overloaded denotations
+     * and JointRef denotations.
+     */
+    def hasUniqueSym: Boolean
+
+    /** The name of the denotation */
+    def name(using Context): Name
+
+    /** The signature of the denotation. */
+    def signature(using Context): Signature
+
+    /** Resolve overloaded denotation to pick the ones with the given signature
+     *  when seen from prefix `site`.
+     *  @param relaxed  When true, consider only parameter signatures for a match.
+     */
+    def atSignature(sig: Signature, targetName: Name, site: Type = NoPrefix, relaxed: Boolean = false)(using Context): Denotation
+
+    /** The variant of this denotation that's current in the given context.
+     *  If no such denotation exists, returns the denotation with each alternative
+     *  at its first point of definition.
+     */
+    def current(using Context): Denotation
+
+    /** Is this denotation different from NoDenotation or an ErrorDenotation? */
+    def exists: Boolean = true
+
+    /** A denotation with the info of this denotation transformed using `f` */
+    def mapInfo(f: Type => Type)(using Context): Denotation
+
+    /** If this denotation does not exist, fallback to alternative */
+    inline def orElse(inline that: Denotation): Denotation = if (this.exists) this else that
+
+    /** The set of alternative single-denotations making up this denotation */
+    final def alternatives: List[SingleDenotation] = altsWith(alwaysTrue)
+
+    /** The alternatives of this denotation that satisfy the predicate `p`. */
+    def altsWith(p: Symbol => Boolean): List[SingleDenotation]
+
+    /** The unique alternative of this denotation that satisfies the predicate `p`,
+     *  or NoDenotation if no satisfying alternative exists.
+     *  @throws TypeError if there is at more than one alternative that satisfies `p`.
+     */
+    def suchThat(p: Symbol => Boolean)(using Context): SingleDenotation
+
+    override def filterWithPredicate(p: SingleDenotation => Boolean): Denotation
+
+    /** If this is a SingleDenotation, return it, otherwise throw a TypeError */
+    def checkUnique(using Context): SingleDenotation = suchThat(alwaysTrue)
+
+    /** Does this denotation have an alternative that satisfies the predicate `p`? */
+    def hasAltWith(p: SingleDenotation => Boolean): Boolean
+
+    /** The denotation made up from the alternatives of this denotation that
+     *  are accessible from prefix `pre`, or NoDenotation if no accessible alternative exists.
+     */
+    def accessibleFrom(pre: Type, superAccess: Boolean = false)(using Context): Denotation
+
+    /** Find member of this denotation with given `name`, all `required`
+     *  flags and no `excluded` flag, and produce a denotation that contains the type of the member
+     *  as seen from given prefix `pre`.
+     */
+    def findMember(name: Name, pre: Type, required: FlagSet, excluded: FlagSet)(using Context): Denotation =
+      info.findMember(name, pre, required, excluded)
+
+    /** If this denotation is overloaded, filter with given predicate.
+     *  If result is still overloaded throw a TypeError.
+     *  Note: disambiguate is slightly different from suchThat in that
+     *  single-denotations that do not satisfy the predicate are left alone
+     *  (whereas suchThat would map them to NoDenotation).
+     */
+    inline def disambiguate(inline p: Symbol => Boolean)(using Context): SingleDenotation = this match {
+      case sdenot: SingleDenotation => sdenot
+      case mdenot => suchThat(p) orElse NoQualifyingRef(alternatives)
+    }
+
+    /** Return symbol in this denotation that satisfies the given predicate.
+     *  if generateStubs is specified, return a stubsymbol if denotation is a missing ref.
+     *  Throw a `TypeError` if predicate fails to disambiguate symbol or no alternative matches.
+     */
+    def requiredSymbol(kind: String,
+                       name: Name,
+                       site: Denotation = NoDenotation,
+                       args: List[Type] = Nil,
+                       source: AbstractFile | Null = null,
+                       generateStubs: Boolean = true)
+                      (p: Symbol => Boolean)
+                      (using Context): Symbol =
+      disambiguate(p) match {
+        case m @ MissingRef(ownerd, name) if generateStubs =>
+          if ctx.settings.YdebugMissingRefs.value then m.ex.printStackTrace()
+          newStubSymbol(ownerd.symbol, name, source)
+        case NoDenotation | _: NoQualifyingRef | _: MissingRef =>
+          def argStr = if (args.isEmpty) "" else i" matching ($args%, %)"
+          val msg =
+            if (site.exists) i"$site does not have a member $kind $name$argStr"
+            else i"missing: $kind $name$argStr"
+          throw new TypeError(msg)
+        case denot =>
+          denot.symbol
+      }
+
+    def requiredMethod(pname: PreName)(using Context): TermSymbol = {
+      val name = pname.toTermName
+      info.member(name).requiredSymbol("method", name, this)(_.is(Method)).asTerm
+    }
+    def requiredMethodRef(name: PreName)(using Context): TermRef =
+      requiredMethod(name).termRef
+
+    def requiredMethod(pname: PreName, argTypes: List[Type])(using Context): TermSymbol = {
+      val name = pname.toTermName
+      info.member(name).requiredSymbol("method", name, this, argTypes) { x =>
+        x.is(Method) && {
+          x.info.paramInfoss match {
+            case paramInfos :: Nil => paramInfos.corresponds(argTypes)(_ =:= _)
+            case _ => false
+          }
+        }
+      }.asTerm
+    }
+    def requiredMethodRef(name: PreName, argTypes: List[Type])(using Context): TermRef =
+      requiredMethod(name, argTypes).termRef
+
+    def requiredValue(pname: PreName)(using Context): TermSymbol = {
+      val name = pname.toTermName
+      info.member(name).requiredSymbol("field or getter", name, this)(_.info.isParameterless).asTerm
+    }
+    def requiredValueRef(name: PreName)(using Context): TermRef =
+      requiredValue(name).termRef
+
+    def requiredClass(pname: PreName)(using Context): ClassSymbol = {
+      val name = pname.toTypeName
+      info.member(name).requiredSymbol("class", name, this)(_.isClass).asClass
+    }
+
+    def requiredType(pname: PreName)(using Context): TypeSymbol = {
+      val name = pname.toTypeName
+      info.member(name).requiredSymbol("type", name, this)(_.isType).asType
+    }
+
+    /** The alternative of this denotation that has a type matching `targetType` when seen
+     *  as a member of type `site` and that has a target name matching `targetName`, or
+     *  `NoDenotation` if none exists.
+     */
+    def matchingDenotation(site: Type, targetType: Type, targetName: Name)(using Context): SingleDenotation = {
+      def qualifies(sym: Symbol) =
+        site.memberInfo(sym).matchesLoosely(targetType) && sym.hasTargetName(targetName)
+      if (isOverloaded)
+        atSignature(targetType.signature, targetName, site, relaxed = true) match {
+          case sd: SingleDenotation => sd.matchingDenotation(site, targetType, targetName)
+          case md => md.suchThat(qualifies(_))
+        }
+      else if (exists && !qualifies(symbol)) NoDenotation
+      else asSingleDenotation
+    }
+
+    /** Form a denotation by conjoining with denotation `that`.
+     *
+     *  NoDenotations are dropped. MultiDenotations are handled by merging
+     *  parts with same signatures. SingleDenotations with equal signatures
+     *  are joined by following this sequence of steps:
+     *
+     *  1. If exactly one the denotations has an inaccessible symbol, pick the other one.
+     *  2. Otherwise, if one of the infos overrides the other one, and the associated
+     *     symbol does not score strictly lower than the other one,
+     *     pick the associated denotation.
+     *  3. Otherwise, if the two infos can be combined with `infoMeet`, pick that as
+     *     result info, and pick the symbol that scores higher as result symbol,
+     *     or pick `sym1` as a tie breaker. The picked info and symbol are combined
+     *     in a JointDenotation.
+     *  4. Otherwise, if one of the two symbols scores strongly higher than the
+     *     other one, pick the associated denotation.
+     *  5. Otherwise return a multi-denotation consisting of both denotations.
+     *
+     *  Symbol scoring is determined according to the following ranking
+     *  where earlier criteria trump later ones. Cases marked with (*)
+     *  give a strong score advantage, the others a weak one.
+     *
+     *  1. The symbol exists, and the other one does not. (*)
+     *  2. The symbol is not a bridge, but the other one is. (*)
+     *  3. The symbol is concrete, and the other one is deferred
+     *  4. The symbol appears before the other in the linearization of `pre`
+     *  5. The symbol's visibility is strictly greater than the other one's.
+     *  6. The symbol is a method, but the other one is not.
+     */
+    def meet(that: Denotation, pre: Type, safeIntersection: Boolean = false)(using Context): Denotation = {
+      /** Try to merge denot1 and denot2 without adding a new signature. */
+      def mergeDenot(denot1: Denotation, denot2: SingleDenotation): Denotation = denot1 match {
+        case denot1 @ MultiDenotation(denot11, denot12) =>
+          val d1 = mergeDenot(denot11, denot2)
+          if (d1.exists) denot1.derivedUnionDenotation(d1, denot12)
+          else {
+            val d2 = mergeDenot(denot12, denot2)
+            if (d2.exists) denot1.derivedUnionDenotation(denot11, d2)
+            else NoDenotation
+          }
+        case denot1: SingleDenotation =>
+          if (denot1 eq denot2) denot1
+          else if denot1.matches(denot2) then mergeSingleDenot(denot1, denot2)
+          else NoDenotation
+      }
+
+      /** Try to merge single-denotations. */
+      def mergeSingleDenot(denot1: SingleDenotation, denot2: SingleDenotation): Denotation =
+        val info1 = denot1.info
+        val info2 = denot2.info
+        val sym1 = denot1.symbol
+        val sym2 = denot2.symbol
+
+        /** Does `owner1` come before `owner2` in the linearization of `pre`? */
+        def linearScore(owner1: Symbol, owner2: Symbol): Int =
+
+          def searchBaseClasses(bcs: List[ClassSymbol]): Int = bcs match
+            case bc :: bcs1 =>
+              if bc eq owner1 then 1
+              else if bc eq owner2 then -1
+              else searchBaseClasses(bcs1)
+            case Nil => 0
+
+          if owner1 eq owner2 then 0
+          else if owner1.derivesFrom(owner2) then 1
+          else if owner2.derivesFrom(owner1) then -1
+          else searchBaseClasses(pre.baseClasses)
+        end linearScore
+
+        /** Similar to SymDenotation#accessBoundary, but without the special cases. */
+        def accessBoundary(sym: Symbol) =
+          if (sym.is(Private)) sym.owner
+          else sym.privateWithin.orElse(
+            if (sym.is(Protected)) sym.owner.enclosingPackageClass
+            else defn.RootClass)
+
+        def isHidden(sym: Symbol) = sym.exists && !sym.isAccessibleFrom(pre)
+        // In typer phase filter out denotations with symbols that are not
+        // accessible. After typer, this is not possible since we cannot guarantee
+        // that the current owner is set correctly. See pos/14660.scala.
+        val hidden1 = isHidden(sym1) && ctx.isTyper
+        val hidden2 = isHidden(sym2) && ctx.isTyper
+        if hidden1 && !hidden2 then denot2
+        else if hidden2 && !hidden1 then denot1
+        else
+          // The score that determines which symbol to pick for the result denotation.
+          // A value > 0 means pick `sym1`, < 0 means pick `sym2`.
+          // A value of +/- 2 means pick one of the denotations as a tie-breaker
+          // if a common info does not exist.
+          val symScore: Int =
+            if !sym1.exists then -2
+            else if !sym2.exists then 2
+            else if sym1.is(Bridge) && !sym2.is(Bridge) then -2
+            else if sym2.is(Bridge) && !sym1.is(Bridge) then 2
+            else if !sym1.isAsConcrete(sym2) then -1
+            else if !sym2.isAsConcrete(sym1) then 1
+            else
+              val linScore = linearScore(sym1.owner, sym2.owner)
+              if linScore != 0 then linScore
+              else
+                val boundary1 = accessBoundary(sym1)
+                val boundary2 = accessBoundary(sym2)
+                if boundary1.isProperlyContainedIn(boundary2) then -1
+                else if boundary2.isProperlyContainedIn(boundary1) then 1
+                else if sym2.is(Method) && !sym1.is(Method) then -1
+                else if sym1.is(Method) && !sym2.is(Method) then 1
+                else 0
+
+          val relaxedOverriding = ctx.explicitNulls && (sym1.is(JavaDefined) || sym2.is(JavaDefined))
+          val matchLoosely = sym1.matchNullaryLoosely || sym2.matchNullaryLoosely
+
+          if symScore <= 0 && info2.overrides(info1, relaxedOverriding, matchLoosely, checkClassInfo = false) then
+            denot2
+          else if symScore >= 0 && info1.overrides(info2, relaxedOverriding, matchLoosely, checkClassInfo = false) then
+            denot1
+          else
+            val jointInfo = infoMeet(info1, info2, safeIntersection)
+            if jointInfo.exists then
+              val sym = if symScore >= 0 then sym1 else sym2
+              JointRefDenotation(sym, jointInfo, denot1.validFor & denot2.validFor, pre, denot1.isRefinedMethod || denot2.isRefinedMethod)
+            else if symScore == 2 then denot1
+            else if symScore == -2 then denot2
+            else
+              overload.println(i"overloaded with same signature: ${sym1.showLocated}: $info1 / ${sym2.showLocated}: $info2, info = ${info1.getClass}, ${info2.getClass}, $jointInfo")
+              MultiDenotation(denot1, denot2)
+      end mergeSingleDenot
+
+      if (this eq that) this
+      else if (!this.exists) that
+      else if (!that.exists) this
+      else that match {
+        case that: SingleDenotation =>
+          val r = mergeDenot(this, that)
+          if (r.exists) r else MultiDenotation(this, that)
+        case that @ MultiDenotation(denot1, denot2) =>
+          this.meet(denot1, pre).meet(denot2, pre)
+      }
+    }
+
+    final def asSingleDenotation: SingleDenotation = asInstanceOf[SingleDenotation]
+    final def asSymDenotation: SymDenotation = asInstanceOf[SymDenotation]
+
+    def toText(printer: Printer): Text = printer.toText(this)
+
+    // ------ PreDenotation ops ----------------------------------------------
+
+    final def toDenot(pre: Type)(using Context): Denotation = this
+    final def containsSym(sym: Symbol): Boolean = hasUniqueSym && (symbol eq sym)
+  }
+
+  // ------ Info meets ----------------------------------------------------
+
+  /** Merge parameter names of lambda types. If names in corresponding positions match, keep them,
+    *  otherwise generate new synthetic names.
+    */
+  private def mergeParamNames(tp1: LambdaType, tp2: LambdaType): List[tp1.ThisName] =
+    (for ((name1, name2, idx) <- tp1.paramNames.lazyZip(tp2.paramNames).lazyZip(tp1.paramNames.indices))
+      yield if (name1 == name2) name1 else tp1.companion.syntheticParamName(idx)).toList
+
+  /** Normally, `tp1 & tp2`, with extra care taken to return `tp1` or `tp2` directly if that's
+   *  a valid answer. Special cases for matching methods and classes, with
+   *  the possibility of returning NoType. Special handling of ExprTypes, where mixed
+   *  intersections widen the ExprType away.
+   */
+  def infoMeet(tp1: Type, tp2: Type, safeIntersection: Boolean)(using Context): Type =
+    if tp1 eq tp2 then tp1
+    else tp1 match
+      case tp1: TypeBounds =>
+        tp2 match
+          case tp2: TypeBounds => if safeIntersection then tp1 safe_& tp2 else tp1 & tp2
+          case tp2: ClassInfo => tp2
+          case _ => NoType
+      case tp1: ClassInfo =>
+        tp2 match
+          case tp2: ClassInfo if tp1.cls eq tp2.cls => tp1.derivedClassInfo(tp1.prefix & tp2.prefix)
+          case tp2: TypeBounds => tp1
+          case _ => NoType
+      case tp1: MethodType =>
+        tp2 match
+          case tp2: MethodType
+          if TypeComparer.matchingMethodParams(tp1, tp2)
+             && tp1.isImplicitMethod == tp2.isImplicitMethod
+             && tp1.isErasedMethod == tp2.isErasedMethod =>
+            val resType = infoMeet(tp1.resType, tp2.resType.subst(tp2, tp1), safeIntersection)
+            if resType.exists then
+              tp1.derivedLambdaType(mergeParamNames(tp1, tp2), tp1.paramInfos, resType)
+            else NoType
+          case _ => NoType
+      case tp1: PolyType =>
+        tp2 match
+          case tp2: PolyType if tp1.paramNames.hasSameLengthAs(tp2.paramNames) =>
+            val resType = infoMeet(tp1.resType, tp2.resType.subst(tp2, tp1), safeIntersection)
+            if resType.exists then
+              tp1.derivedLambdaType(
+                mergeParamNames(tp1, tp2),
+                tp1.paramInfos.zipWithConserve(tp2.paramInfos)( _ & _ ),
+                resType)
+            else NoType
+          case _ => NoType
+      case ExprType(rtp1) =>
+        tp2 match
+          case ExprType(rtp2) => ExprType(rtp1 & rtp2)
+          case _ => infoMeet(rtp1, tp2, safeIntersection)
+      case _ =>
+        tp2 match
+          case _: MethodType | _: PolyType => NoType
+          case _ => tp1 & tp2.widenExpr
+  end infoMeet
+
+  /** A non-overloaded denotation */
+  abstract class SingleDenotation(symbol: Symbol, initInfo: Type) extends Denotation(symbol, initInfo) {
+    protected def newLikeThis(symbol: Symbol, info: Type, pre: Type, isRefinedMethod: Boolean): SingleDenotation
+
+    final def name(using Context): Name = symbol.name
+
+    /** For SymDenotation, this is NoPrefix. For other denotations this is the prefix
+     *  under which the denotation was constructed.
+     *
+     *  Note that `asSeenFrom` might return a `SymDenotation` and therefore in
+     *  general one cannot rely on `prefix` being set, see
+     *  `Config.reuseSymDenotations` for details.
+     */
+    def prefix: Type = NoPrefix
+
+    /** True if the info of this denotation comes from a refinement. */
+    def isRefinedMethod: Boolean = false
+
+    /** For SymDenotations, the language-specific signature of the info, depending on
+     *  where the symbol is defined. For non-SymDenotations, the Scala 3
+     *  signature.
+     *
+     *  Invariants:
+     *  - Before erasure, the signature of a denotation is always equal to the
+     *    signature of its corresponding initial denotation.
+     *  - Two distinct overloads will have SymDenotations with distinct
+     *    signatures (the SELECTin tag in Tasty relies on this to refer to an
+     *    overload unambiguously). Note that this only applies to
+     *    SymDenotations, in general we cannot assume that distinct
+     *    SingleDenotations will have distinct signatures (cf #9050).
+     */
+    final def signature(using Context): Signature =
+      signature(sourceLanguage = if isType || !this.isInstanceOf[SymDenotation] then SourceLanguage.Scala3 else SourceLanguage(symbol))
+
+    /** Overload of `signature` which lets the caller pick the language used
+     *  to compute the signature of the info. Useful to match denotations defined in
+     *  different classes (see `matchesLoosely`).
+     */
+    def signature(sourceLanguage: SourceLanguage)(using Context): Signature =
+      if (isType) Signature.NotAMethod // don't force info if this is a type denotation
+      else info match {
+        case info: MethodOrPoly =>
+          try info.signature(sourceLanguage)
+          catch { // !!! DEBUG
+            case scala.util.control.NonFatal(ex) =>
+              report.echo(s"cannot take signature of $info")
+              throw ex
+          }
+        case _ => Signature.NotAMethod
+      }
+
+    def derivedSingleDenotation(symbol: Symbol, info: Type, pre: Type = this.prefix, isRefinedMethod: Boolean = this.isRefinedMethod)(using Context): SingleDenotation =
+      if ((symbol eq this.symbol) && (info eq this.info) && (pre eq this.prefix) && (isRefinedMethod == this.isRefinedMethod)) this
+      else newLikeThis(symbol, info, pre, isRefinedMethod)
+
+    def mapInfo(f: Type => Type)(using Context): SingleDenotation =
+      derivedSingleDenotation(symbol, f(info))
+
+    inline def orElse(inline that: SingleDenotation): SingleDenotation = if (this.exists) this else that
+
+    def altsWith(p: Symbol => Boolean): List[SingleDenotation] =
+      if (exists && p(symbol)) this :: Nil else Nil
+
+    def suchThat(p: Symbol => Boolean)(using Context): SingleDenotation =
+      if (exists && p(symbol)) this else NoDenotation
+
+    def hasAltWith(p: SingleDenotation => Boolean): Boolean =
+      exists && p(this)
+
+    def accessibleFrom(pre: Type, superAccess: Boolean)(using Context): Denotation =
+      if (!symbol.exists || symbol.isAccessibleFrom(pre, superAccess)) this else NoDenotation
+
+    def atSignature(sig: Signature, targetName: Name, site: Type, relaxed: Boolean)(using Context): SingleDenotation =
+      val situated = if site == NoPrefix then this else asSeenFrom(site)
+      val sigMatches = sig.matchDegree(situated.signature) match
+        case FullMatch =>
+          true
+        case MethodNotAMethodMatch =>
+          // See comment in `matches`
+          relaxed && !symbol.is(JavaDefined)
+        case ParamMatch =>
+          relaxed
+        case noMatch =>
+          false
+      if sigMatches && symbol.hasTargetName(targetName) then this else NoDenotation
+
+    def matchesImportBound(bound: Type)(using Context): Boolean =
+      if bound.isRef(defn.NothingClass) then false
+      else if bound.isAny then true
+      else NoViewsAllowed.normalizedCompatible(info, bound, keepConstraint = false)
+
+    // ------ Transformations -----------------------------------------
+
+    private var myValidFor: Period = Nowhere
+
+    def validFor: Period = myValidFor
+    def validFor_=(p: Period): Unit = {
+      myValidFor = p
+      symbol.invalidateDenotCache()
+    }
+
+    /** The next SingleDenotation in this run, with wrap-around from last to first.
+     *
+     *  There may be several `SingleDenotation`s with different validity
+     *  representing the same underlying definition at different phases.
+     *  These are called a "flock". Flock members are generated by
+     *  @See current. Flock members are connected in a ring
+     *  with their `nextInRun` fields.
+     *
+     *  There are the following invariants concerning flock members
+     *
+     *  1) validity periods are non-overlapping
+     *  2) the union of all validity periods is a contiguous
+     *     interval.
+     */
+    protected var nextInRun: SingleDenotation = this
+
+    /** The version of this SingleDenotation that was valid in the first phase
+     *  of this run.
+     */
+    def initial: SingleDenotation =
+      if (validFor.firstPhaseId <= 1) this
+      else {
+        var current = nextInRun
+        while (current.validFor.code > this.myValidFor.code) current = current.nextInRun
+        current
+      }
+
+    def history: List[SingleDenotation] = {
+      val b = new ListBuffer[SingleDenotation]
+      var current = initial
+      while ({
+        b += (current)
+        current = current.nextInRun
+        current ne initial
+      })
+      ()
+      b.toList
+    }
+
+    /** Invalidate all caches and fields that depend on base classes and their contents */
+    def invalidateInheritedInfo(): Unit = ()
+
+    private def updateValidity()(using Context): this.type = {
+      assert(
+        ctx.runId >= validFor.runId
+        || ctx.settings.YtestPickler.value // mixing test pickler with debug printing can travel back in time
+        || ctx.mode.is(Mode.Printing)  // no use to be picky when printing error messages
+        || symbol.isOneOf(ValidForeverFlags),
+        s"denotation $this invalid in run ${ctx.runId}. ValidFor: $validFor")
+      var d: SingleDenotation = this
+      while ({
+        d.validFor = Period(ctx.runId, d.validFor.firstPhaseId, d.validFor.lastPhaseId)
+        d.invalidateInheritedInfo()
+        d = d.nextInRun
+        d ne this
+      })
+      ()
+      this
+    }
+
+    /** Move validity period of this denotation to a new run. Throw a StaleSymbol error
+     *  if denotation is no longer valid.
+     *  However, StaleSymbol error is not thrown in the following situations:
+     *
+     *   - If acceptStale returns true (e.g. because we are in the IDE),
+     *     update the symbol to the new version if it exists, or return
+     *     the old version otherwise.
+     *   - If the symbol did not have a denotation that was defined at the current phase
+     *     return a NoDenotation instead.
+     */
+    private def bringForward()(using Context): SingleDenotation = {
+      this match {
+        case symd: SymDenotation =>
+          if (stillValid(symd)) return updateValidity()
+          if acceptStale(symd) && symd.initial.validFor.firstPhaseId <= ctx.lastPhaseId then
+            // New run might have fewer phases than old, so symbol might no longer be
+            // visible at all. TabCompleteTests have examples where this happens.
+            return symd.currentSymbol.denot.orElse(symd).updateValidity()
+        case _ =>
+      }
+      if (!symbol.exists) return updateValidity()
+      if (!coveredInterval.containsPhaseId(ctx.phaseId)) return NoDenotation
+      if (ctx.debug) traceInvalid(this)
+      staleSymbolError
+    }
+
+    /** The next defined denotation (following `nextInRun`) or an arbitrary
+     *  undefined denotation, if all denotations in a `nextinRun` cycle are
+     *  undefined.
+     */
+    private def nextDefined: SingleDenotation = {
+      var p1 = this
+      var p2 = nextInRun
+      while (p1.validFor == Nowhere && (p1 ne p2)) {
+        p1 = p1.nextInRun
+        p2 = p2.nextInRun.nextInRun
+      }
+      p1
+    }
+
+    /** Skip any denotations that have been removed by an installAfter or that
+     *  are otherwise undefined.
+     */
+    def skipRemoved(using Context): SingleDenotation =
+      if (myValidFor.code <= 0) nextDefined else this
+
+    /** Produce a denotation that is valid for the given context.
+     *  Usually called when !(validFor contains ctx.period)
+     *  (even though this is not a precondition).
+     *  If the runId of the context is the same as runId of this denotation,
+     *  the right flock member is located, or, if it does not exist yet,
+     *  created by invoking a transformer (@See Transformers).
+     *  If the runId's differ, but this denotation is a SymDenotation
+     *  and its toplevel owner class or module
+     *  is still a member of its enclosing package, then the whole flock
+     *  is brought forward to be valid in the new runId. Otherwise
+     *  the symbol is stale, which constitutes an internal error.
+     */
+    def current(using Context): SingleDenotation =
+      util.Stats.record("current")
+      val currentPeriod = ctx.period
+      val valid = myValidFor
+
+      def assertNotPackage(d: SingleDenotation, transformer: DenotTransformer) = d match
+        case d: ClassDenotation =>
+          assert(!d.is(Package), s"illegal transformation of package denotation by transformer $transformer")
+        case _ =>
+
+      def escapeToNext = nextDefined.ensuring(_.validFor != Nowhere)
+
+      def toNewRun =
+        util.Stats.record("current.bringForward")
+        if exists then initial.bringForward().current else this
+
+      def goForward =
+        var cur = this
+        // search for containing period as long as nextInRun increases.
+        var next = nextInRun
+        while next.validFor.code > valid.code && !(next.validFor contains currentPeriod) do
+          cur = next
+          next = next.nextInRun
+        if next.validFor.code > valid.code then
+          // in this case, next.validFor contains currentPeriod
+          cur = next
+          cur
+        else
+          //println(s"might need new denot for $cur, valid for ${cur.validFor} at $currentPeriod")
+          // not found, cur points to highest existing variant
+          val nextTransformerId = ctx.base.nextDenotTransformerId(cur.validFor.lastPhaseId)
+          if currentPeriod.lastPhaseId <= nextTransformerId then
+            cur.validFor = Period(currentPeriod.runId, cur.validFor.firstPhaseId, nextTransformerId)
+          else
+            var startPid = nextTransformerId + 1
+            val transformer = ctx.base.denotTransformers(nextTransformerId)
+            //println(s"transforming $this with $transformer")
+            val savedPeriod = ctx.period
+            val mutCtx = ctx.asInstanceOf[FreshContext]
+            try
+              mutCtx.setPhase(transformer)
+              next = transformer.transform(cur)
+                // We temporarily update the context with the new phase instead of creating a
+                // new one. This is done for performance. We cut down on about 30% of context
+                // creations that way, and also avoid phase caches in contexts to get large.
+                // To work correctly, we need to demand that the context with the new phase
+                // is not retained in the result.
+            catch case ex: CyclicReference =>
+              // println(s"error while transforming $this")
+              throw ex
+            finally
+              mutCtx.setPeriod(savedPeriod)
+            if next eq cur then
+              startPid = cur.validFor.firstPhaseId
+            else
+              assertNotPackage(next, transformer)
+              next.insertAfter(cur)
+              cur = next
+            cur.validFor = Period(currentPeriod.runId, startPid, transformer.lastPhaseId)
+            //printPeriods(cur)
+            //println(s"new denot: $cur, valid for ${cur.validFor}")
+          cur.current // multiple transformations could be required
+      end goForward
+
+      def goBack: SingleDenotation =
+        // currentPeriod < end of valid; in this case a version must exist
+        // but to be defensive we check for infinite loop anyway
+        var cur = this
+        var cnt = 0
+        while !(cur.validFor contains currentPeriod) do
+          //println(s"searching: $cur at $currentPeriod, valid for ${cur.validFor}")
+          cur = cur.nextInRun
+          // Note: One might be tempted to add a `prev` field to get to the new denotation
+          // more directly here. I tried that, but it degrades rather than improves
+          // performance: Test setup: Compile everything in dotc and immediate subdirectories
+          // 10 times. Best out of 10: 18154ms with `prev` field, 17777ms without.
+          cnt += 1
+          if cnt > MaxPossiblePhaseId then
+            return atPhase(coveredInterval.firstPhaseId)(current)
+        cur
+      end goBack
+
+      if valid.code <= 0 then
+        // can happen if we sit on a stale denotation which has been replaced
+        // wholesale by an installAfter; in this case, proceed to the next
+        // denotation and try again.
+        escapeToNext
+      else if valid.runId != currentPeriod.runId then
+        toNewRun
+      else if currentPeriod.code > valid.code then
+        goForward
+      else
+        goBack
+    end current
+
+    private def demandOutsideDefinedMsg(using Context): String =
+      s"demanding denotation of $this at phase ${ctx.phase}(${ctx.phaseId}) outside defined interval: defined periods are${definedPeriodsString}"
+
+    /** Install this denotation to be the result of the given denotation transformer.
+     *  This is the implementation of the same-named method in SymDenotations.
+     *  It's placed here because it needs access to private fields of SingleDenotation.
+     *  @pre  Can only be called in `phase.next`.
+     */
+    protected def installAfter(phase: DenotTransformer)(using Context): Unit = {
+      val targetId = phase.next.id
+      if (ctx.phaseId != targetId) atPhase(phase.next)(installAfter(phase))
+      else {
+        val current = symbol.current
+        // println(s"installing $this after $phase/${phase.id}, valid = ${current.validFor}")
+        // printPeriods(current)
+        this.validFor = Period(ctx.runId, targetId, current.validFor.lastPhaseId)
+        if (current.validFor.firstPhaseId >= targetId)
+          current.replaceWith(this)
+        else {
+          current.validFor = Period(ctx.runId, current.validFor.firstPhaseId, targetId - 1)
+          insertAfter(current)
+        }
+      }
+      // printPeriods(this)
+    }
+
+    /** Apply a transformation `f` to all denotations in this group that start at or after
+     *  given phase. Denotations are replaced while keeping the same validity periods.
+     */
+    protected def transformAfter(phase: DenotTransformer, f: SymDenotation => SymDenotation)(using Context): Unit = {
+      var current = symbol.current
+      while (current.validFor.firstPhaseId < phase.id && (current.nextInRun.validFor.code > current.validFor.code))
+        current = current.nextInRun
+      var hasNext = true
+      while ((current.validFor.firstPhaseId >= phase.id) && hasNext) {
+        val current1: SingleDenotation = f(current.asSymDenotation)
+        if (current1 ne current) {
+          current1.validFor = current.validFor
+          current.replaceWith(current1)
+        }
+        hasNext = current1.nextInRun.validFor.code > current1.validFor.code
+        current = current1.nextInRun
+      }
+    }
+
+    /** Insert this denotation so that it follows `prev`. */
+    private def insertAfter(prev: SingleDenotation) = {
+      this.nextInRun = prev.nextInRun
+      prev.nextInRun = this
+    }
+
+    /** Insert this denotation instead of `old`.
+     *  Also ensure that `old` refers with `nextInRun` to this denotation
+     *  and set its `validFor` field to `Nowhere`. This is necessary so that
+     *  references to the old denotation can be brought forward via `current`
+     *  to a valid denotation.
+     *
+     *  The code to achieve this is subtle in that it works correctly
+     *  whether the replaced denotation is the only one in its cycle or not.
+     */
+    private[dotc] def replaceWith(newd: SingleDenotation): Unit = {
+      var prev = this
+      while (prev.nextInRun ne this) prev = prev.nextInRun
+      // order of next two assignments is important!
+      prev.nextInRun = newd
+      newd.nextInRun = nextInRun
+      validFor = Nowhere
+      nextInRun = newd
+    }
+
+    def staleSymbolError(using Context): Nothing =
+      throw new StaleSymbol(staleSymbolMsg)
+
+    def staleSymbolMsg(using Context): String = {
+      def ownerMsg = this match {
+        case denot: SymDenotation => s"in ${denot.owner}"
+        case _ => ""
+      }
+      s"stale symbol; $this#${symbol.id} $ownerMsg, defined in ${myValidFor}, is referred to in run ${ctx.period}"
+    }
+
+    /** The period (interval of phases) for which there exists
+     *  a valid denotation in this flock.
+     */
+    def coveredInterval(using Context): Period = {
+      var cur = this
+      var cnt = 0
+      var interval = validFor
+      while ({
+        cur = cur.nextInRun
+        cnt += 1
+        assert(cnt <= MaxPossiblePhaseId, demandOutsideDefinedMsg)
+        interval |= cur.validFor
+        cur ne this
+      })
+      ()
+      interval
+    }
+
+    /** Show declaration string; useful for showing declarations
+     *  as seen from subclasses.
+     */
+    def showDcl(using Context): String = ctx.printer.dclText(this).show
+
+    override def toString: String =
+      if (symbol == NoSymbol) symbol.toString
+      else s"<SingleDenotation of type $infoOrCompleter>"
+
+    def definedPeriodsString: String = {
+      var sb = new StringBuilder()
+      var cur = this
+      var cnt = 0
+      while ({
+        sb.append(" " + cur.validFor)
+        cur = cur.nextInRun
+        cnt += 1
+        if (cnt > MaxPossiblePhaseId) { sb.append(" ..."); cur = this }
+        cur ne this
+      })
+      ()
+      sb.toString
+    }
+
+    // ------ PreDenotation ops ----------------------------------------------
+
+    final def first: SingleDenotation = this
+    final def last: SingleDenotation = this
+
+    def matches(other: SingleDenotation)(using Context): Boolean =
+      symbol.hasTargetName(other.symbol.targetName)
+      && matchesLoosely(other)
+
+    /** `matches` without a target name check.
+     *
+     *  For definitions coming from different languages, we pick a common
+     *  language to compute their signatures. This allows us for example to
+     *  override some Java definitions from Scala even if they have a different
+     *  erasure (see i8615b, i9109b), Erasure takes care of adding any necessary
+     *  bridge to make this work at runtime.
+     */
+    def matchesLoosely(other: SingleDenotation, alwaysCompareTypes: Boolean = false)(using Context): Boolean =
+      if isType then true
+      else
+        val thisLanguage = SourceLanguage(symbol)
+        val otherLanguage = SourceLanguage(other.symbol)
+        val commonLanguage = SourceLanguage.commonLanguage(thisLanguage, otherLanguage)
+        val sig = signature(commonLanguage)
+        val otherSig = other.signature(commonLanguage)
+        sig.matchDegree(otherSig) match
+          case FullMatch =>
+            !alwaysCompareTypes || info.matches(other.info)
+          case MethodNotAMethodMatch =>
+            !ctx.erasedTypes && {
+              // A Scala zero-parameter method and a Scala non-method always match.
+              if !thisLanguage.isJava && !otherLanguage.isJava then
+                true
+              // Java allows defining both a field and a zero-parameter method with the same name,
+              // so they must not match.
+              else if thisLanguage.isJava && otherLanguage.isJava then
+                false
+              // A Java field never matches a Scala method.
+              else if thisLanguage.isJava then
+                symbol.is(Method)
+              else // otherLanguage.isJava
+                other.symbol.is(Method)
+            }
+          case ParamMatch =>
+            // The signatures do not tell us enough to be sure about matching
+            !ctx.erasedTypes && info.matches(other.info)
+          case noMatch =>
+            false
+
+    def mapInherited(ownDenots: PreDenotation, prevDenots: PreDenotation, pre: Type)(using Context): SingleDenotation =
+      if hasUniqueSym && prevDenots.containsSym(symbol) then NoDenotation
+      else if isType then filterDisjoint(ownDenots).asSeenFrom(pre)
+      else asSeenFrom(pre).filterDisjoint(ownDenots)
+
+    def filterWithPredicate(p: SingleDenotation => Boolean): SingleDenotation =
+      if (p(this)) this else NoDenotation
+    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 | Invisible
+      def symd: SymDenotation = this match
+        case symd: SymDenotation => symd
+        case _ => symbol.denot
+      if !required.isEmpty && !symd.isAllOf(required)
+         || symd.isOneOf(realExcluded) then NoDenotation
+      else this
+    def aggregate[T](f: SingleDenotation => T, g: (T, T) => T): T = f(this)
+
+    type AsSeenFromResult = SingleDenotation
+
+    protected def computeAsSeenFrom(pre: Type)(using Context): SingleDenotation = {
+      val symbol = this.symbol
+      val owner = this match {
+        case thisd: SymDenotation => thisd.owner
+        case _ => if (symbol.exists) symbol.owner else NoSymbol
+      }
+
+      /** The derived denotation with the given `info` transformed with `asSeenFrom`.
+       *
+       *  As a performance hack, we might reuse an existing SymDenotation,
+       *  instead of creating a new denotation with a given `prefix`,
+       *  see `Config.reuseSymDenotations`.
+       */
+      def derived(info: Type) =
+        /** Do we need to return a denotation with a prefix set? */
+        def needsPrefix =
+          // For opaque types, the prefix is used in `ElimOpaques#transform`,
+          // without this i7159.scala would fail when compiled from tasty.
+          symbol.is(Opaque)
+
+        val derivedInfo = info.asSeenFrom(pre, owner)
+        if Config.reuseSymDenotations && this.isInstanceOf[SymDenotation]
+           && (derivedInfo eq info) && !needsPrefix then
+          this
+        else
+          derivedSingleDenotation(symbol, derivedInfo, pre)
+      end derived
+
+      // Tt could happen that we see the symbol with prefix `this` as a member a different class
+      // through a self type and that it then has a different info. In this case we have to go
+      // through the asSeenFrom to switch the type back. Test case is pos/i9352.scala.
+      def hasOriginalInfo: Boolean = this match
+        case sd: SymDenotation => true
+        case _ => info eq symbol.info
+
+      def ownerIsPrefix = pre match
+        case pre: ThisType => pre.sameThis(owner.thisType)
+        case _ => false
+
+      if !owner.membersNeedAsSeenFrom(pre) && (!ownerIsPrefix || hasOriginalInfo)
+         || symbol.is(NonMember)
+      then this
+      else if symbol.isAllOf(ClassTypeParam) then
+        val arg = symbol.typeRef.argForParam(pre, widenAbstract = true)
+        if arg.exists
+        then derivedSingleDenotation(symbol, normalizedArgBounds(arg.bounds), pre)
+        else derived(symbol.info)
+      else derived(symbol.info)
+    }
+
+    /** The argument bounds, possibly intersected with the parameter's info TypeBounds,
+     *  if the latter is not F-bounded and does not refer to other type parameters
+     *  of the same class, and the intersection is provably nonempty.
+     */
+    private def normalizedArgBounds(argBounds: TypeBounds)(using Context): TypeBounds =
+      if symbol.isCompleted && !hasBoundsDependingOnParamsOf(symbol.owner) then
+        val combined @ TypeBounds(lo, hi) = symbol.info.bounds & argBounds
+        if (lo frozen_<:< hi) then combined
+        else argBounds
+      else argBounds
+
+    private def hasBoundsDependingOnParamsOf(cls: Symbol)(using Context): Boolean =
+      val acc = new TypeAccumulator[Boolean]:
+        def apply(x: Boolean, tp: Type): Boolean = tp match
+          case _: LazyRef => true
+          case tp: TypeRef
+          if tp.symbol.isAllOf(ClassTypeParam) && tp.symbol.owner == cls => true
+          case _ => foldOver(x, tp)
+      acc(false, symbol.info)
+  }
+
+  abstract class NonSymSingleDenotation(symbol: Symbol, initInfo: Type, override val prefix: Type) extends SingleDenotation(symbol, initInfo) {
+    def infoOrCompleter: Type = initInfo
+    def isType: Boolean = infoOrCompleter.isInstanceOf[TypeType]
+  }
+
+  class UniqueRefDenotation(
+    symbol: Symbol,
+    initInfo: Type,
+    initValidFor: Period,
+    prefix: Type) extends NonSymSingleDenotation(symbol, initInfo, prefix) {
+    validFor = initValidFor
+    override def hasUniqueSym: Boolean = true
+    protected def newLikeThis(s: Symbol, i: Type, pre: Type, isRefinedMethod: Boolean): SingleDenotation =
+      if isRefinedMethod then
+        new JointRefDenotation(s, i, validFor, pre, isRefinedMethod)
+      else
+        new UniqueRefDenotation(s, i, validFor, pre)
+  }
+
+  class JointRefDenotation(
+    symbol: Symbol,
+    initInfo: Type,
+    initValidFor: Period,
+    prefix: Type,
+    override val isRefinedMethod: Boolean) extends NonSymSingleDenotation(symbol, initInfo, prefix) {
+    validFor = initValidFor
+    override def hasUniqueSym: Boolean = false
+    protected def newLikeThis(s: Symbol, i: Type, pre: Type, isRefinedMethod: Boolean): SingleDenotation =
+      new JointRefDenotation(s, i, validFor, pre, isRefinedMethod)
+  }
+
+  class ErrorDenotation(using Context) extends NonSymSingleDenotation(NoSymbol, NoType, NoType) {
+    override def exists: Boolean = false
+    override def hasUniqueSym: Boolean = false
+    validFor = Period.allInRun(ctx.runId)
+    protected def newLikeThis(s: Symbol, i: Type, pre: Type, isRefinedMethod: Boolean): SingleDenotation =
+      this
+  }
+
+  /** An error denotation that provides more info about the missing reference.
+   *  Produced by staticRef, consumed by requiredSymbol.
+   */
+  case class MissingRef(val owner: SingleDenotation, name: Name)(using Context) extends ErrorDenotation {
+    val ex: Exception = new Exception // DEBUG
+  }
+
+  /** An error denotation that provides more info about alternatives
+   *  that were found but that do not qualify.
+   *  Produced by staticRef, consumed by requiredSymbol.
+   */
+  case class NoQualifyingRef(alts: List[SingleDenotation])(using Context) extends ErrorDenotation
+
+  /** A double definition
+   */
+  def isDoubleDef(sym1: Symbol, sym2: Symbol)(using Context): Boolean =
+    (sym1.exists && sym2.exists &&
+    (sym1 `ne` sym2) && (sym1.effectiveOwner `eq` sym2.effectiveOwner) &&
+    !sym1.is(Bridge) && !sym2.is(Bridge))
+
+  // --- Overloaded denotations and predenotations -------------------------------------------------
+
+  trait MultiPreDenotation extends PreDenotation {
+    def denot1: PreDenotation
+    def denot2: PreDenotation
+
+    assert(denot1.exists && denot2.exists, s"Union of non-existing denotations ($denot1) and ($denot2)")
+    def first: Denotation = denot1.first
+    def last: Denotation = denot2.last
+    def matches(other: SingleDenotation)(using Context): Boolean =
+      denot1.matches(other) || denot2.matches(other)
+    def mapInherited(owndenot: PreDenotation, prevdenot: PreDenotation, pre: Type)(using Context): PreDenotation =
+      derivedUnion(denot1.mapInherited(owndenot, prevdenot, pre), denot2.mapInherited(owndenot, prevdenot, pre))
+    def filterWithPredicate(p: SingleDenotation => Boolean): PreDenotation =
+      derivedUnion(denot1 filterWithPredicate p, denot2 filterWithPredicate p)
+    def filterDisjoint(denot: PreDenotation)(using Context): PreDenotation =
+      derivedUnion(denot1 filterDisjoint denot, denot2 filterDisjoint denot)
+    def filterWithFlags(required: FlagSet, excluded: FlagSet)(using Context): PreDenotation =
+      derivedUnion(denot1.filterWithFlags(required, excluded), denot2.filterWithFlags(required, excluded))
+    def aggregate[T](f: SingleDenotation => T, g: (T, T) => T): T =
+      g(denot1.aggregate(f, g), denot2.aggregate(f, g))
+    protected def derivedUnion(denot1: PreDenotation, denot2: PreDenotation) =
+      if ((denot1 eq this.denot1) && (denot2 eq this.denot2)) this
+      else denot1 union denot2
+  }
+
+  final case class DenotUnion(denot1: PreDenotation, denot2: PreDenotation) extends MultiPreDenotation {
+    def exists: Boolean = true
+    def toDenot(pre: Type)(using Context): Denotation =
+      denot1.toDenot(pre).meet(denot2.toDenot(pre), pre)
+    def containsSym(sym: Symbol): Boolean =
+      (denot1 containsSym sym) || (denot2 containsSym sym)
+    type AsSeenFromResult = PreDenotation
+    def computeAsSeenFrom(pre: Type)(using Context): PreDenotation =
+      derivedUnion(denot1.asSeenFrom(pre), denot2.asSeenFrom(pre))
+  }
+
+  /** An overloaded denotation consisting of the alternatives of both given denotations.
+   */
+  case class MultiDenotation(denot1: Denotation, denot2: Denotation) extends Denotation(NoSymbol, NoType) with MultiPreDenotation {
+    final def infoOrCompleter: Type = multiHasNot("info")
+    final def validFor: Period = denot1.validFor & denot2.validFor
+    final def isType: Boolean = false
+    final def hasUniqueSym: Boolean = false
+    final def name(using Context): Name = denot1.name
+    final def signature(using Context): Signature = Signature.OverloadedSignature
+    def atSignature(sig: Signature, targetName: Name, site: Type, relaxed: Boolean)(using Context): Denotation =
+      if (sig eq Signature.OverloadedSignature) this
+      else derivedUnionDenotation(
+            denot1.atSignature(sig, targetName, site, relaxed),
+            denot2.atSignature(sig, targetName, site, relaxed))
+    def current(using Context): Denotation =
+      derivedUnionDenotation(denot1.current, denot2.current)
+    def altsWith(p: Symbol => Boolean): List[SingleDenotation] =
+      denot1.altsWith(p) ++ denot2.altsWith(p)
+    def suchThat(p: Symbol => Boolean)(using Context): SingleDenotation = {
+      val sd1 = denot1.suchThat(p)
+      val sd2 = denot2.suchThat(p)
+      if sd1.exists then
+        if sd2.exists then
+          throw TypeError(
+            em"""Failure to disambiguate overloaded reference with
+                |  ${denot1.symbol.showLocated}: ${denot1.info}  and
+                |  ${denot2.symbol.showLocated}: ${denot2.info}""")
+        else sd1
+      else sd2
+    }
+    override def filterWithPredicate(p: SingleDenotation => Boolean): Denotation =
+      derivedUnionDenotation(denot1.filterWithPredicate(p), denot2.filterWithPredicate(p))
+    def hasAltWith(p: SingleDenotation => Boolean): Boolean =
+      denot1.hasAltWith(p) || denot2.hasAltWith(p)
+    def accessibleFrom(pre: Type, superAccess: Boolean)(using Context): Denotation = {
+      val d1 = denot1 accessibleFrom (pre, superAccess)
+      val d2 = denot2 accessibleFrom (pre, superAccess)
+      if (!d1.exists) d2
+      else if (!d2.exists) d1
+      else derivedUnionDenotation(d1, d2)
+    }
+    def mapInfo(f: Type => Type)(using Context): Denotation =
+      derivedUnionDenotation(denot1.mapInfo(f), denot2.mapInfo(f))
+    def derivedUnionDenotation(d1: Denotation, d2: Denotation): Denotation =
+      if ((d1 eq denot1) && (d2 eq denot2)) this
+      else if (!d1.exists) d2
+      else if (!d2.exists) d1
+      else MultiDenotation(d1, d2)
+    type AsSeenFromResult = Denotation
+    def computeAsSeenFrom(pre: Type)(using Context): Denotation =
+      derivedUnionDenotation(denot1.asSeenFrom(pre), denot2.asSeenFrom(pre))
+    override def toString: String = alternatives.mkString(" <and> ")
+
+    private def multiHasNot(op: String): Nothing =
+      throw new UnsupportedOperationException(
+        s"multi-denotation with alternatives $alternatives does not implement operation $op")
+  }
+
+  /** The current denotation of the static reference given by path,
+    *  or a MissingRef or NoQualifyingRef instance, if it does not exist.
+    *  if generateStubs is set, generates stubs for missing top-level symbols
+    */
+  def staticRef(path: Name, generateStubs: Boolean = true, isPackage: Boolean = false)(using Context): Denotation = {
+    def select(prefix: Denotation, selector: Name): Denotation = {
+      val owner = prefix.disambiguate(_.info.isParameterless)
+      def isPackageFromCoreLibMissing: Boolean =
+        // if the scala package is missing, the stdlib must be missing
+        owner.symbol == defn.RootClass && selector == nme.scala
+      if (owner.exists) {
+        val result = if (isPackage) owner.info.decl(selector) else owner.info.member(selector)
+        if (result.exists) result
+        else if (isPackageFromCoreLibMissing) throw new MissingCoreLibraryException(selector.toString)
+        else {
+          val alt =
+            if (generateStubs) missingHook(owner.symbol.moduleClass, selector)
+            else NoSymbol
+          if (alt.exists) alt.denot
+          else MissingRef(owner, selector)
+        }
+      }
+      else owner
+    }
+    def recur(
+        path: Name,
+        wrap: TermName -> Name = identity[Name] // !cc! default argument needs to be instantiated, error if [Name] is dropped
+      ): Denotation = path match {
+      case path: TypeName =>
+        recur(path.toTermName, n => n.toTypeName)
+      case ModuleClassName(underlying) =>
+        recur(underlying, n => wrap(ModuleClassName(n)))
+      case QualifiedName(prefix, selector) =>
+        select(recur(prefix), wrap(selector))
+      case qn @ AnyQualifiedName(prefix, _) =>
+        recur(prefix, n => wrap(qn.info.mkString(n).toTermName))
+      case path: SimpleName =>
+        def recurSimple(len: Int, wrap: TermName -> Name): Denotation = {
+          val point = path.lastIndexOf('.', len - 1)
+          val selector = wrap(path.slice(point + 1, len).asTermName)
+          val prefix =
+            if (point > 0) recurSimple(point, identity)
+            else if (selector.isTermName) defn.RootClass.denot
+            else defn.EmptyPackageClass.denot
+          select(prefix, selector)
+        }
+        recurSimple(path.length, wrap)
+    }
+
+    val run = ctx.run
+    if run == null then recur(path)
+    else run.staticRefs.getOrElseUpdate(path, recur(path))
+  }
+
+  /** If we are looking for a non-existing term name in a package,
+    *  assume it is a package for which we do not have a directory and
+    *  enter it.
+    */
+  def missingHook(owner: Symbol, name: Name)(using Context): Symbol =
+    if (owner.is(Package) && name.isTermName)
+      newCompletePackageSymbol(owner, name.asTermName).entered
+    else
+      NoSymbol
+
+  /** An exception for accessing symbols that are no longer valid in current run */
+  class StaleSymbol(msg: -> String) extends Exception {
+    util.Stats.record("stale symbol")
+    override def getMessage(): String = msg
+  }
+}
diff --git a/tests/pos-with-compiler-cc/dotc/core/Flags.scala b/tests/pos-with-compiler-cc/dotc/core/Flags.scala
new file mode 100644
index 000000000000..8bf65ed8288f
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/core/Flags.scala
@@ -0,0 +1,613 @@
+package dotty.tools.dotc
+package core
+
+object Flags {
+
+  object opaques {
+
+    /** A FlagSet represents a set of flags. Flags are encoded as follows:
+    *  The first two bits indicate whether a flag set applies to terms,
+    *  to types, or to both.  Bits 2..63 are available for properties
+    *  and can be doubly used for terms and types.
+    */
+    opaque type FlagSet = Long
+    def FlagSet(bits: Long): FlagSet = bits
+    def toBits(fs: FlagSet): Long = fs
+
+    /** A flag set consisting of a single flag */
+    opaque type Flag <: FlagSet = Long
+    private[Flags] def Flag(bits: Long): Flag = bits
+  }
+  export opaques.FlagSet
+
+  type Flag = opaques.Flag
+
+  extension (x: FlagSet) {
+
+    inline def bits: Long = opaques.toBits(x)
+
+    /** The union of the given flag sets.
+     *  Combining two FlagSets with `|` will give a FlagSet
+     *  that has the intersection of the applicability to terms/types
+     *  of the two flag sets. It is checked that the intersection is not empty.
+     */
+    def | (y: FlagSet): FlagSet =
+      if (x.bits == 0) y
+      else if (y.bits == 0) x
+      else {
+        val tbits = x.bits & y.bits & KINDFLAGS
+        if (tbits == 0)
+          assert(false, s"illegal flagset combination: ${x.flagsString} and ${y.flagsString}")
+        FlagSet(tbits | ((x.bits | y.bits) & ~KINDFLAGS))
+      }
+
+    /** The intersection of the given flag sets */
+    def & (y: FlagSet): FlagSet = FlagSet(x.bits & y.bits)
+
+    /** The intersection of a flag set with the complement of another flag set */
+    def &~ (y: FlagSet): FlagSet = {
+      val tbits = x.bits & KINDFLAGS
+      if ((tbits & y.bits) == 0) x
+      else FlagSet(tbits | ((x.bits & ~y.bits) & ~KINDFLAGS))
+    }
+
+    def ^ (y: FlagSet) =
+      FlagSet((x.bits | y.bits) & KINDFLAGS | (x.bits ^ y.bits) & ~KINDFLAGS)
+
+    /** Does the given flag set contain the given flag?
+     *  This means that both the kind flags and the carrier bits have non-empty intersection.
+     */
+    def is (flag: Flag): Boolean = {
+      val fs = x.bits & flag.bits
+      (fs & KINDFLAGS) != 0 && (fs & ~KINDFLAGS) != 0
+    }
+
+    /** Does the given flag set contain the given flag
+     *  and at the same time contain none of the flags in the `butNot` set?
+     */
+    def is (flag: Flag, butNot: FlagSet): Boolean = x.is(flag) && !x.isOneOf(butNot)
+
+    /** Does the given flag set have a non-empty intersection with another flag set?
+     *  This means that both the kind flags and the carrier bits have non-empty intersection.
+     */
+    def isOneOf (flags: FlagSet): Boolean = {
+      val fs = x.bits & flags.bits
+      (fs & KINDFLAGS) != 0 && (fs & ~KINDFLAGS) != 0
+    }
+
+    /** Does the given flag set have a non-empty intersection with another flag set,
+     *  and at the same time contain none of the flags in the `butNot` set?
+     */
+    def isOneOf (flags: FlagSet, butNot: FlagSet): Boolean = x.isOneOf(flags) && !x.isOneOf(butNot)
+
+    /** Does a given flag set have all of the flags of another flag set?
+     *  Pre: The intersection of the term/type flags of both sets must be non-empty.
+     */
+    def isAllOf (flags: FlagSet): Boolean = {
+      val fs = x.bits & flags.bits
+      ((fs & KINDFLAGS) != 0 || flags.bits == 0) &&
+      (fs >>> TYPESHIFT) == (flags.bits >>> TYPESHIFT)
+    }
+
+    /** Does a given flag set have all of the flags in another flag set
+     *  and at the same time contain none of the flags in the `butNot` set?
+     *  Pre: The intersection of the term/type flags of both sets must be non-empty.
+     */
+    def isAllOf (flags: FlagSet, butNot: FlagSet): Boolean = x.isAllOf(flags) && !x.isOneOf(butNot)
+
+    def isEmpty: Boolean = (x.bits & ~KINDFLAGS) == 0
+
+    /** Is a given flag set a subset of another flag set? */
+    def <= (y: FlagSet): Boolean = (x.bits & y.bits) == x.bits
+
+    /** Does the given flag set apply to terms? */
+    def isTermFlags: Boolean = (x.bits & TERMS) != 0
+
+    /** Does the given flag set apply to terms? */
+    def isTypeFlags: Boolean = (x.bits & TYPES) != 0
+
+    /** The given flag set with all flags transposed to be type flags */
+    def toTypeFlags: FlagSet = if (x.bits == 0) x else FlagSet(x.bits & ~KINDFLAGS | TYPES)
+
+    /** The given flag set with all flags transposed to be term flags */
+    def toTermFlags: FlagSet = if (x.bits == 0) x else FlagSet(x.bits & ~KINDFLAGS | TERMS)
+
+    /** The given flag set with all flags transposed to be common flags */
+    def toCommonFlags: FlagSet = if (x.bits == 0) x else FlagSet(x.bits | KINDFLAGS)
+
+    /** The number of non-kind flags in the given flag set */
+    def numFlags: Int = java.lang.Long.bitCount(x.bits & ~KINDFLAGS)
+
+    /** The lowest non-kind bit set in the given flag set */
+    def firstBit: Int = java.lang.Long.numberOfTrailingZeros(x.bits & ~KINDFLAGS)
+
+    /** The  list of non-empty names of flags with given index idx that are set in the given flag set */
+    private def flagString(idx: Int): List[String] =
+      if ((x.bits & (1L << idx)) == 0) Nil
+      else {
+        def halfString(kind: Int) =
+          if ((x.bits & (1L << kind)) != 0) flagName(idx)(kind) else ""
+        val termFS = halfString(TERMindex)
+        val typeFS = halfString(TYPEindex)
+        val strs = termFS :: (if (termFS == typeFS) Nil else typeFS :: Nil)
+        strs filter (_.nonEmpty)
+      }
+
+    /** The list of non-empty names of flags that are set in the given flag set */
+    def flagStrings(privateWithin: String = ""): Seq[String] = {
+      var rawStrings = (2 to MaxFlag).flatMap(x.flagString(_)) // DOTTY problem: cannot drop with (_)
+      if (!privateWithin.isEmpty && !x.is(Protected))
+      	rawStrings = rawStrings :+ "private"
+      val scopeStr = if (x.is(Local)) "this" else privateWithin
+      if (scopeStr != "")
+        rawStrings.filter(_ != "<local>").map {
+          case "private" => s"private[$scopeStr]"
+          case "protected" => s"protected[$scopeStr]"
+          case str => str
+        }
+      else rawStrings
+    }
+
+    /** The string representation of the given flag set */
+    def flagsString: String = x.flagStrings("").mkString(" ")
+  }
+
+  // Temporary while extension names are in flux
+  def or(x1: FlagSet, x2: FlagSet) = x1 | x2
+  def and(x1: FlagSet, x2: FlagSet) = x1 & x2
+
+  def termFlagSet(x: Long) = FlagSet(TERMS | x)
+
+  private inline val TYPESHIFT = 2
+  private inline val TERMindex = 0
+  private inline val TYPEindex = 1
+  private inline val TERMS = 1 << TERMindex
+  private inline val TYPES = 1 << TYPEindex
+  private inline val KINDFLAGS = TERMS | TYPES
+
+  private inline val FirstFlag = 2
+  private inline val FirstNotPickledFlag = 48
+  private inline val MaxFlag = 63
+
+  private val flagName = Array.fill(64, 2)("")
+
+  private def isDefinedAsFlag(idx: Int) = flagName(idx).exists(_.nonEmpty)
+
+  /** The flag set containing all defined flags of either kind whose bits
+   *  lie in the given range
+   */
+  private def flagRange(start: Int, end: Int) =
+    FlagSet((start until end).foldLeft(KINDFLAGS.toLong) ((bits, idx) =>
+      if (isDefinedAsFlag(idx)) bits | (1L << idx) else bits))
+
+  /** The union of all flags in given flag set */
+  def union(flagss: FlagSet*): FlagSet = {
+    var flag = EmptyFlags
+    for (f <- flagss)
+      flag |= f
+    flag
+  }
+
+  def commonFlags(flagss: FlagSet*): FlagSet = union(flagss.map(_.toCommonFlags): _*)
+
+  /** The empty flag set */
+  val EmptyFlags: FlagSet = FlagSet(0)
+
+  /** The undefined flag set */
+  val UndefinedFlags: FlagSet = FlagSet(~KINDFLAGS)
+
+  /** Three flags with given index between 2 and 63.
+   *  The first applies to both terms and types. the second is a term flag, and
+   *  the third is a type flag. Installs given name(s) as the name(s) of the flags.
+   *  @param name     The name to be used for the term flag
+   *  @param typeName The name to be used for the type flag, if it is different from `name`.
+   */
+  private def newFlags(index: Int, name: String, typeName: String = ""): (Flag, Flag, Flag) = {
+    flagName(index)(TERMindex) = name
+    flagName(index)(TYPEindex) = if (typeName.isEmpty) name else typeName
+    val bits = 1L << index
+    (opaques.Flag(KINDFLAGS | bits), opaques.Flag(TERMS | bits), opaques.Flag(TYPES | bits))
+  }
+
+  // ----------------- Available flags -----------------------------------------------------
+
+  /** Labeled with `private` modifier */
+  val (Private @ _, PrivateTerm @ _, PrivateType @ _) = newFlags(2, "private")
+
+  /** Labeled with `protected` modifier */
+  val (Protected @ _, _, _) = newFlags(3, "protected")
+
+  /** Labeled with `override` modifier */
+  val (Override @ _, _, _) = newFlags(4, "override")
+
+  /** A declared, but not defined member */
+  val (Deferred @ _, DeferredTerm @ _, DeferredType @ _) = newFlags(5, "<deferred>")
+
+  /** Labeled with `final` modifier */
+  val (Final @ _, _, _) = newFlags(6, "final")
+
+  /** A method symbol / a super trait */
+  val (_, Method @ _, _) = newFlags(7, "<method>")
+
+  /** A (term or type) parameter to a class or method */
+  val (Param @ _, TermParam @ _, TypeParam @ _) = newFlags(8, "<param>")
+
+  /** Labeled with `implicit` modifier (implicit value) */
+  val (Implicit @ _, ImplicitVal @ _, _) = newFlags(9, "implicit")
+
+  /** Labeled with `lazy` (a lazy val) / a trait */
+  val (LazyOrTrait @ _, Lazy @ _, Trait @ _) = newFlags(10, "lazy", "<trait>")
+
+  /** A value or variable accessor (getter or setter) */
+  val (AccessorOrSealed @ _, Accessor @ _, Sealed @ _) = newFlags(11, "<accessor>", "sealed")
+
+  /** A mutable var, an open class */
+  val (MutableOrOpen @ __, Mutable @ _, Open @ _) = newFlags(12, "mutable", "open")
+
+  /** Symbol is local to current class (i.e. private[this] or protected[this]
+   *  pre: Private or Protected are also set
+   */
+  val (Local @ _, _, _) = newFlags(13, "<local>")
+
+  /** A field generated for a primary constructor parameter (no matter if it's a 'val' or not),
+   *  or an accessor of such a field.
+   */
+  val (_, ParamAccessor @ _, _) = newFlags(14, "<paramaccessor>")
+
+  /** A value or class implementing a module */
+  val (Module @ _, ModuleVal @ _, ModuleClass @ _) = newFlags(15, "module")
+
+   /** A value or class representing a package */
+  val (Package @ _, PackageVal @ _, PackageClass @ _) = newFlags(16, "<package>")
+
+  /** A case class or its companion object
+   *  Note: Case is also used to indicate that a symbol is bound by a pattern.
+   */
+  val (Case @ _, CaseVal @ _, CaseClass @ _) = newFlags(17, "case")
+
+  /** A compiler-generated symbol, which is visible for type-checking
+   *  (compare with artifact)
+   */
+  val (Synthetic @ _, _, _) = newFlags(18, "<synthetic>")
+
+  /** Labelled with `inline` modifier */
+  val (Inline @ _, _, _) = newFlags(19, "inline")
+
+  /** An outer accessor / a covariant type variable */
+  val (OuterOrCovariant @ _, OuterAccessor @ _, Covariant @ _) = newFlags(20, "<outer accessor>", "<covariant>")
+
+  /** The label of a labeled block / a contravariant type variable */
+  val (LabelOrContravariant @ _, Label @ _, Contravariant @ _) = newFlags(21, "<label>", "<contravariant>")
+
+  /** Labeled with of abstract & override
+   *    /
+   *  A trait that has only abstract methods as members
+   *  and therefore can be represented by a Java interface.
+   *  Warning: PureInterface is set during regular typer pass, should be tested only after typer.
+   */
+  val (_, AbsOverride @ _, PureInterface @ _) = newFlags(22, "abstract override", "interface")
+
+  /** Labeled with `abstract` modifier (an abstract class)
+   *  Note: You should never see Abstract on any symbol except a class.
+   *  Note: the flag counts as common, because it can be combined with OVERRIDE in a term.
+   */
+  val (Abstract @ _, _, _) = newFlags(23, "abstract")
+
+  /** Lazy val or method is known or assumed to be stable and realizable.
+   *
+   *  For a trait constructor, this is set if and only if owner.is(NoInits),
+   *  including for Java interfaces and for Scala 2 traits. It will be used by
+   *
+   *  - the purity analysis used by the inliner to decide whether it is safe to elide, and
+   *  - the TASTy reader of Scala 2.13, to determine whether there is a $init$ method.
+   *
+   *  StableRealizable is
+   *  - asserted for methods
+   *  - automatic in conjunction with Module or Enum vals
+   *  - cached for other vals
+   */
+  val (_, StableRealizable @ _, _) = newFlags(24, "<stable>")
+
+  /** A case parameter accessor */
+  val (_, CaseAccessor @ _, _) = newFlags(25, "<caseaccessor>")
+
+  /** A Scala 2x super accessor / an unpickled Scala 2.x class */
+  val (SuperParamAliasOrScala2x @ _, SuperParamAlias @ _, Scala2x @ _) = newFlags(26, "<super-param-alias>", "<scala-2.x>")
+
+  /** A parameter with a default value / an impure untpd.FunctionWithMods type */
+  val (_, HasDefault @ _, Impure @ _) = newFlags(27, "<hasdefault>", "<{*}>")
+
+  /** An extension method, or a collective extension instance */
+  val (Extension @ _, ExtensionMethod @ _, _) = newFlags(28, "<extension>")
+
+  /** An inferable (`given`) parameter */
+  val (Given @ _, GivenVal @ _,  _) = newFlags(29, "given")
+
+  /** Symbol is defined by a Java class */
+  val (JavaDefined @ _, JavaDefinedVal @ _, _) = newFlags(30, "<java>")
+
+  /** Symbol is implemented as a Java static */
+  val (JavaStatic @ _, JavaStaticTerm @ _, JavaStaticType @ _) = newFlags(31, "<static>")
+
+  /** Variable is accessed from nested function
+   *    /
+   *  Trait does not have own fields or initialization code or class does not
+   *  have own or inherited initialization code.
+   *
+   *  Warning: NoInits is set during regular typer pass, should be tested only after typer.
+   */
+  val (_, Captured @ _, NoInits @ _) = newFlags(32, "<captured>", "<noinits>")
+
+  /** Symbol should be ignored when typechecking; will be marked ACC_SYNTHETIC in bytecode */
+  val (Artifact @ _, _, _) = newFlags(33, "<artifact>")
+
+  /** A bridge method. Set by Erasure */
+  val (_, Bridge @ _, _) = newFlags(34, "<bridge>")
+
+  /** A proxy for an argument to an inline method */
+  val (_, InlineProxy @ _, _) = newFlags(35, "<inline proxy>")
+
+  /** Symbol is a method which should be marked ACC_SYNCHRONIZED */
+  val (_, Synchronized @ _, _) = newFlags(36, "<synchronized>")
+
+  /** Symbol is a Java-style varargs method */
+  val (_, JavaVarargs @ _, _) = newFlags(37, "<varargs>")
+
+  /** Symbol is a Java default method */
+  val (_, DefaultMethod @ _, _) = newFlags(38, "<defaultmethod>")
+
+  /** Symbol is a transparent inline method or trait */
+  val (Transparent @ _, _, _) = newFlags(39, "transparent")
+
+  /** Symbol is an enum class or enum case (if used with case) */
+  val (Enum @ _, EnumVal @ _, _) = newFlags(40, "enum")
+
+  /** An export forwarder */
+  val (Exported @ _, _, _) = newFlags(41, "exported")
+
+  /** Labeled with `erased` modifier (erased value or class)  */
+  val (Erased @ _, _, _) = newFlags(42, "erased")
+
+  /** An opaque type alias or a class containing one */
+  val (Opaque @ _, _, _) = newFlags(43, "opaque")
+
+  /** An infix method or type */
+  val (Infix @ _, _, _) = newFlags(44, "infix")
+
+  /** Symbol cannot be found as a member during typer */
+  val (Invisible @ _, _, _) = newFlags(45, "<invisible>")
+
+  // ------------ Flags following this one are not pickled ----------------------------------
+
+  /** Symbol is not a member of its owner */
+  val (NonMember @ _, _, _) = newFlags(49, "<non-member>")
+
+  /** Denotation is in train of being loaded and completed, used to catch cyclic dependencies */
+  val (Touched @ _, _, _) = newFlags(50, "<touched>")
+
+  /** Class has been lifted out to package level, local value has been lifted out to class level */
+  val (Lifted @ _, _, _) = newFlags(51, "<lifted>") // only used from lambda-lift (could be merged with ConstructorProxy)
+
+  /** Term member has been mixed in */
+  val (MixedIn @ _, _, _) = newFlags(52, "<mixedin>")
+
+  /** Symbol is a generated specialized member */
+  val (Specialized @ _, _, _) = newFlags(53, "<specialized>")
+
+  /** Symbol is a self name */
+  val (_, SelfName @ _, _) = newFlags(54, "<selfname>")
+
+  /** A Scala 2 superaccessor (only needed during Scala2Unpickling) /
+   *  an existentially bound symbol (Scala 2.x only) */
+  val (Scala2SpecialFlags @ _, Scala2SuperAccessor @ _, Scala2Existential @ _) = newFlags(55, "<existential>")
+
+  /** Children were queried on this class */
+  val (_, _, ChildrenQueried @ _) = newFlags(56, "<children-queried>")
+
+  /** A module variable (Scala 2.x only)
+   *  (re-used as a flag for private parameter accessors in Recheck)
+   */
+  val (_, Scala2ModuleVar @ _, _) = newFlags(57, "<modulevar>")
+
+  /** A macro */
+  val (Macro @ _, _, _) = newFlags(58, "<macro>")
+
+  /** Translation of Scala2's EXPANDEDNAME flag. This flag is never stored in
+   *  symbols, is only used locally when reading the flags of a Scala2 symbol.
+   *  It's therefore safe to share the code with `HasDefaultParams` because
+   *  the latter is never present in Scala2 unpickle info.
+   *    /
+   *  A method that is known to have (defined or inherited) default parameters
+   */
+  val (Scala2ExpandedName @ _, HasDefaultParams @ _, _) = newFlags(59, "<has-default-params>")
+
+  /** A method that is known to have no default parameters
+   *    /
+   *  A type symbol with provisional empty bounds
+   */
+  val (_, NoDefaultParams @ _, Provisional @ _) = newFlags(60, "<no-default-params>", "<provisional>")
+
+  /** A denotation that is valid in all run-ids */
+  val (Permanent @ _, _, _) = newFlags(61, "<permanent>")
+
+  /** Symbol is a constructor proxy (either companion, or apply method) */
+  val (ConstructorProxy @ _, _, _) = newFlags(62, "<constructor proxy>") // (could be merged with Lifted)
+
+// --------- Combined Flag Sets and Conjunctions ----------------------
+
+  /** All possible flags */
+  val AnyFlags: FlagSet = flagRange(FirstFlag, MaxFlag)
+
+  /** These flags are pickled */
+  val PickledFlags: FlagSet = flagRange(FirstFlag, FirstNotPickledFlag)
+
+  /** Flags representing access rights */
+  val AccessFlags: FlagSet = Local | Private | Protected
+
+  /** Flags representing source modifiers */
+  private val CommonSourceModifierFlags: FlagSet =
+    commonFlags(Private, Protected, Final, Case, Implicit, Given, Override, JavaStatic, Transparent, Erased)
+
+  val TypeSourceModifierFlags: FlagSet =
+    CommonSourceModifierFlags.toTypeFlags | Abstract | Sealed | Opaque | Open
+
+  val TermSourceModifierFlags: FlagSet =
+    CommonSourceModifierFlags.toTermFlags | Inline | AbsOverride | Lazy
+
+  /** Flags representing modifiers that can appear in trees */
+  val ModifierFlags: FlagSet =
+    TypeSourceModifierFlags.toCommonFlags |
+    TermSourceModifierFlags.toCommonFlags |
+    commonFlags(Module, Param, Synthetic, Package, Local, Mutable, Trait)
+
+  /** Flags that are not (re)set when completing the denotation
+   *  TODO: Should check that FromStartFlags do not change in completion
+   */
+  val FromStartFlags: FlagSet = commonFlags(
+    Module, Package, Deferred, Method, Case, Enum, Param, ParamAccessor,
+    Scala2SpecialFlags, MutableOrOpen, Opaque, Touched, JavaStatic,
+    OuterOrCovariant, LabelOrContravariant, CaseAccessor,
+    Extension, NonMember, Implicit, Given, Permanent, Synthetic, Exported,
+    SuperParamAliasOrScala2x, Inline, Macro, ConstructorProxy, Invisible)
+
+  /** Flags that are not (re)set when completing the denotation, or, if symbol is
+   *  a top-level class or object, when completing the denotation once the class
+   *  file defining the symbol is loaded (which is generally before the denotation
+   *  is completed)
+   */
+  val AfterLoadFlags: FlagSet = commonFlags(
+    FromStartFlags, AccessFlags, Final, AccessorOrSealed,
+    Abstract, LazyOrTrait, SelfName, JavaDefined, Transparent)
+
+  /** A value that's unstable unless complemented with a Stable flag */
+  val UnstableValueFlags: FlagSet = Mutable | Method
+
+  /** Flags that express the variance of a type parameter. */
+  val VarianceFlags: FlagSet = Covariant | Contravariant
+
+// ----- Creation flag sets ----------------------------------
+
+  /** Modules always have these flags set */
+  val ModuleValCreationFlags: FlagSet = ModuleVal | Lazy | Final | StableRealizable
+
+  /** Module classes always have these flags set */
+  val ModuleClassCreationFlags: FlagSet = ModuleClass | Final
+
+  /** Accessors always have these flags set */
+  val AccessorCreationFlags: FlagSet = Method | Accessor
+
+  /** Pure interfaces always have these flags */
+  val PureInterfaceCreationFlags: FlagSet = Trait | NoInits | PureInterface
+
+  /** The flags of the self symbol */
+  val SelfSymFlags: FlagSet = Private | Local | Deferred
+
+  /** The flags of a class type parameter */
+  val ClassTypeParamCreationFlags: FlagSet =
+    TypeParam | Deferred | Private | Local
+
+  /** Packages and package classes always have these flags set */
+  val PackageCreationFlags: FlagSet =
+    Module | Package | Final | JavaDefined
+
+// ----- Retained flag sets ----------------------------------
+
+  /** Flags that are passed from a type parameter of a class to a refinement symbol
+    * that sets the type parameter */
+  val RetainedTypeArgFlags: FlagSet = VarianceFlags | Protected | Local
+
+  /** Flags that can apply to both a module val and a module class, except those that
+    *  are added at creation anyway
+    */
+  val RetainedModuleValAndClassFlags: FlagSet =
+    AccessFlags | Package | Case |
+    Synthetic | JavaDefined | JavaStatic | Artifact |
+    Lifted | MixedIn | Specialized | ConstructorProxy | Invisible | Erased
+
+  /** Flags that can apply to a module val */
+  val RetainedModuleValFlags: FlagSet = RetainedModuleValAndClassFlags |
+    Override | Final | Method | Implicit | Given | Lazy |
+    Accessor | AbsOverride | StableRealizable | Captured | Synchronized | Transparent
+
+  /** Flags that can apply to a module class */
+  val RetainedModuleClassFlags: FlagSet = RetainedModuleValAndClassFlags | Enum
+
+  /** Flags retained in export forwarders */
+  val RetainedExportFlags = Given | Implicit | Inline | Transparent
+
+  /** Flags that apply only to classes */
+  val ClassOnlyFlags = Sealed | Open | Abstract.toTypeFlags
+
+// ------- Other flag sets -------------------------------------
+
+  val NotConcrete: FlagSet                   = AbsOverride | Deferred
+  val AbstractFinal: FlagSet                 = Abstract | Final
+  val AbstractOverride: FlagSet              = Abstract | Override
+  val AbstractSealed: FlagSet                = Abstract | Sealed
+  val AbstractOrTrait: FlagSet               = Abstract | Trait
+  val EffectivelyOpenFlags                   = Abstract | JavaDefined | Open | Scala2x | Trait
+  val AccessorOrDeferred: FlagSet            = Accessor | Deferred
+  val PrivateAccessor: FlagSet               = Accessor | Private
+  val AccessorOrSynthetic: FlagSet           = Accessor | Synthetic
+  val JavaOrPrivateOrSynthetic: FlagSet      = Artifact | JavaDefined | Private | Synthetic
+  val PrivateOrSynthetic: FlagSet            = Artifact | Private | Synthetic
+  val EnumCase: FlagSet                      = Case | Enum
+  val CovariantLocal: FlagSet                = Covariant | Local                              // A covariant type parameter
+  val ContravariantLocal: FlagSet            = Contravariant | Local                          // A contravariant type parameter
+  val EffectivelyErased                      = ConstructorProxy | Erased
+  val ConstructorProxyModule: FlagSet        = ConstructorProxy | Module
+  val DefaultParameter: FlagSet              = HasDefault | Param                             // A Scala 2x default parameter
+  val DeferredInline: FlagSet                = Deferred | Inline
+  val DeferredOrLazy: FlagSet                = Deferred | Lazy
+  val DeferredOrLazyOrMethod: FlagSet        = Deferred | Lazy | Method
+  val DeferredOrTermParamOrAccessor: FlagSet = Deferred | ParamAccessor | TermParam           // term symbols without right-hand sides
+  val DeferredOrTypeParam: FlagSet           = Deferred | TypeParam                           // type symbols without right-hand sides
+  val EnumValue: FlagSet                     = Enum | StableRealizable                        // A Scala enum value
+  val FinalOrInline: FlagSet                 = Final | Inline
+  val FinalOrModuleClass: FlagSet            = Final | ModuleClass                            // A module class or a final class
+  val EffectivelyFinalFlags: FlagSet         = Final | Private
+  val ExcludedForwarder: Flags.FlagSet       = Specialized | Lifted | Protected | JavaStatic | Private | Macro | ConstructorProxy
+  val FinalOrSealed: FlagSet                 = Final | Sealed
+  val GivenOrImplicit: FlagSet               = Given | Implicit
+  val GivenOrImplicitVal: FlagSet            = GivenOrImplicit.toTermFlags
+  val GivenMethod: FlagSet                   = Given | Method
+  val LazyGiven: FlagSet                     = Given | Lazy
+  val InlineOrProxy: FlagSet                 = Inline | InlineProxy                           // An inline method or inline argument proxy */
+  val InlineMethod: FlagSet                  = Inline | Method
+  val InlineParam: FlagSet                   = Inline | Param
+  val InlineByNameProxy: FlagSet             = InlineProxy | Method
+  val JavaEnumTrait: FlagSet                 = JavaDefined | Enum                             // A Java enum trait
+  val JavaEnumValue: FlagSet                 = JavaDefined | EnumValue                        // A Java enum value
+  val StaticProtected: FlagSet               = JavaDefined | JavaStatic | Protected           // Java symbol which is `protected` and `static`
+  val JavaModule: FlagSet                    = JavaDefined | Module                           // A Java companion object
+  val JavaInterface: FlagSet                 = JavaDefined | NoInits | Trait
+  val JavaProtected: FlagSet                 = JavaDefined | Protected
+  val MethodOrLazy: FlagSet                  = Lazy | Method
+  val MutableOrLazy: FlagSet                 = Lazy | Mutable
+  val MethodOrLazyOrMutable: FlagSet         = Lazy | Method | Mutable
+  val LiftedMethod: FlagSet                  = Lifted | Method
+  val LocalParam: FlagSet                    = Local | Param
+  val LocalParamAccessor: FlagSet            = Local | ParamAccessor | Private
+  val PrivateLocal: FlagSet                  = Local | Private                                // private[this]
+  val ProtectedLocal: FlagSet                = Local | Protected
+  val MethodOrModule: FlagSet                = Method | Module
+  val ParamForwarder: FlagSet                = Method | ParamAccessor | StableRealizable      // A parameter forwarder
+  val PrivateMethod: FlagSet                 = Method | Private
+  val StableMethod: FlagSet                  = Method | StableRealizable
+  val NoInitsInterface: FlagSet              = NoInits | PureInterface
+  val NoInitsTrait: FlagSet                  = NoInits | Trait                                // A trait that does not need to be initialized
+  val ValidForeverFlags: FlagSet             = Package | Permanent | Scala2SpecialFlags
+  val TermParamOrAccessor: FlagSet           = Param | ParamAccessor
+  val PrivateParamAccessor: FlagSet          = ParamAccessor | Private
+  val PrivateOrArtifact: FlagSet             = Private | Artifact
+  val ClassTypeParam: FlagSet                = Private | TypeParam
+  val Scala2Trait: FlagSet                   = Scala2x | Trait
+  val SyntheticArtifact: FlagSet             = Synthetic | Artifact
+  val SyntheticCase: FlagSet                 = Synthetic | Case
+  val SyntheticModule: FlagSet               = Synthetic | Module
+  val SyntheticOpaque: FlagSet               = Synthetic | Opaque
+  val SyntheticParam: FlagSet                = Synthetic | Param
+  val SyntheticTermParam: FlagSet            = Synthetic | TermParam
+  val SyntheticTypeParam: FlagSet            = Synthetic | TypeParam
+  val TransparentTrait: FlagSet              = Trait | Transparent
+}
diff --git a/tests/pos-with-compiler-cc/dotc/core/GadtConstraint.scala b/tests/pos-with-compiler-cc/dotc/core/GadtConstraint.scala
new file mode 100644
index 000000000000..53fc58595472
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/core/GadtConstraint.scala
@@ -0,0 +1,266 @@
+package dotty.tools
+package dotc
+package core
+
+import Decorators._
+import Contexts._
+import Types._
+import Symbols._
+import util.{SimpleIdentitySet, SimpleIdentityMap}
+import collection.mutable
+import printing._
+
+object GadtConstraint:
+  def apply(): GadtConstraint = empty
+  def empty: GadtConstraint =
+    new ProperGadtConstraint(OrderingConstraint.empty, SimpleIdentityMap.empty, SimpleIdentityMap.empty, false)
+
+/** Represents GADT constraints currently in scope */
+sealed trait GadtConstraint (
+  private var myConstraint: Constraint,
+  private var mapping: SimpleIdentityMap[Symbol, TypeVar],
+  private var reverseMapping: SimpleIdentityMap[TypeParamRef, Symbol],
+  private var wasConstrained: Boolean
+) extends Showable {
+  this: ConstraintHandling =>
+
+  import dotty.tools.dotc.config.Printers.{gadts, gadtsConstr}
+
+  /** Exposes ConstraintHandling.subsumes */
+  def subsumes(left: GadtConstraint, right: GadtConstraint, pre: GadtConstraint)(using Context): Boolean = {
+    def extractConstraint(g: GadtConstraint) = g.constraint
+    subsumes(extractConstraint(left), extractConstraint(right), extractConstraint(pre))
+  }
+
+  override protected def legalBound(param: TypeParamRef, rawBound: Type, isUpper: Boolean)(using Context): Type =
+    // GADT constraints never involve wildcards and are not propagated outside
+    // the case where they're valid, so no approximating is needed.
+    rawBound
+
+  /** Add symbols to constraint, correctly handling inter-dependencies.
+   *
+   * @see [[ConstraintHandling.addToConstraint]]
+   */
+  def addToConstraint(sym: Symbol)(using Context): Boolean = addToConstraint(sym :: Nil)
+  def addToConstraint(params: List[Symbol])(using Context): Boolean = {
+    import NameKinds.DepParamName
+
+    val poly1 = PolyType(params.map { sym => DepParamName.fresh(sym.name.toTypeName) })(
+      pt => params.map { param =>
+        // In bound type `tp`, replace the symbols in dependent positions with their internal TypeParamRefs.
+        // The replaced symbols will be later picked up in `ConstraintHandling#addToConstraint`
+        // and used as orderings.
+        def substDependentSyms(tp: Type, isUpper: Boolean)(using Context): Type = {
+          def loop(tp: Type) = substDependentSyms(tp, isUpper)
+          tp match {
+            case tp @ AndType(tp1, tp2) if !isUpper =>
+              tp.derivedAndType(loop(tp1), loop(tp2))
+            case tp @ OrType(tp1, tp2) if isUpper =>
+              tp.derivedOrType(loop(tp1), loop(tp2))
+            case tp: NamedType =>
+              params.indexOf(tp.symbol) match {
+                case -1 =>
+                  mapping(tp.symbol) match {
+                    case tv: TypeVar => tv.origin
+                    case null => tp
+                  }
+                case i => pt.paramRefs(i)
+              }
+            case tp => tp
+          }
+        }
+
+        val tb = param.info.bounds
+        tb.derivedTypeBounds(
+          lo = substDependentSyms(tb.lo, isUpper = false),
+          hi = substDependentSyms(tb.hi, isUpper = true)
+        )
+      },
+      pt => defn.AnyType
+    )
+
+    val tvars = params.lazyZip(poly1.paramRefs).map { (sym, paramRef) =>
+      val tv = TypeVar(paramRef, creatorState = null)
+      mapping = mapping.updated(sym, tv)
+      reverseMapping = reverseMapping.updated(tv.origin, sym)
+      tv
+    }
+
+    // The replaced symbols are picked up here.
+    addToConstraint(poly1, tvars)
+      .showing(i"added to constraint: [$poly1] $params%, % gadt = $this", gadts)
+  }
+
+  /** Further constrain a symbol already present in the constraint. */
+  def addBound(sym: Symbol, bound: Type, isUpper: Boolean)(using Context): Boolean = {
+    @annotation.tailrec def stripInternalTypeVar(tp: Type): Type = tp match {
+      case tv: TypeVar =>
+        val inst = constraint.instType(tv)
+        if (inst.exists) stripInternalTypeVar(inst) else tv
+      case _ => tp
+    }
+
+    val symTvar: TypeVar = stripInternalTypeVar(tvarOrError(sym)) match {
+      case tv: TypeVar => tv
+      case inst =>
+        gadts.println(i"instantiated: $sym -> $inst")
+        return if (isUpper) isSub(inst, bound) else isSub(bound, inst)
+    }
+
+    val internalizedBound = bound match {
+      case nt: NamedType =>
+        val ntTvar = mapping(nt.symbol)
+        if (ntTvar != null) stripInternalTypeVar(ntTvar) else bound
+      case _ => bound
+    }
+
+    val saved = constraint
+    val result = internalizedBound match
+      case boundTvar: TypeVar =>
+        if (boundTvar eq symTvar) true
+        else if (isUpper) addLess(symTvar.origin, boundTvar.origin)
+        else addLess(boundTvar.origin, symTvar.origin)
+      case bound =>
+        addBoundTransitively(symTvar.origin, bound, isUpper)
+
+    gadts.println {
+      val descr = if (isUpper) "upper" else "lower"
+      val op = if (isUpper) "<:" else ">:"
+      i"adding $descr bound $sym $op $bound = $result"
+    }
+
+    if constraint ne saved then wasConstrained = true
+    result
+  }
+
+  /** Is `sym1` ordered to be less than `sym2`? */
+  def isLess(sym1: Symbol, sym2: Symbol)(using Context): Boolean =
+    constraint.isLess(tvarOrError(sym1).origin, tvarOrError(sym2).origin)
+
+  /** Full bounds of `sym`, including TypeRefs to other lower/upper symbols.
+   *
+   * @note this performs subtype checks between ordered symbols.
+   *       Using this in isSubType can lead to infinite recursion. Consider `bounds` instead.
+   */
+  def fullBounds(sym: Symbol)(using Context): TypeBounds | Null =
+    mapping(sym) match {
+      case null => null
+      // TODO: Improve flow typing so that ascription becomes redundant
+      case tv: TypeVar =>
+        fullBounds(tv.origin)
+          // .ensuring(containsNoInternalTypes(_))
+    }
+
+  /** Immediate bounds of `sym`. Does not contain lower/upper symbols (see [[fullBounds]]). */
+  def bounds(sym: Symbol)(using Context): TypeBounds | Null =
+    mapping(sym) match {
+      case null => null
+      // TODO: Improve flow typing so that ascription becomes redundant
+      case tv: TypeVar =>
+        def retrieveBounds: TypeBounds = externalize(bounds(tv.origin)).bounds
+        retrieveBounds
+          //.showing(i"gadt bounds $sym: $result", gadts)
+          //.ensuring(containsNoInternalTypes(_))
+    }
+
+  /** Is the symbol registered in the constraint?
+   *
+   * @note this is true even if the symbol is constrained to be equal to another type, unlike [[Constraint.contains]].
+   */
+  def contains(sym: Symbol)(using Context): Boolean = mapping(sym) != null
+
+  /** GADT constraint narrows bounds of at least one variable */
+  def isNarrowing: Boolean = wasConstrained
+
+  /** See [[ConstraintHandling.approximation]] */
+  def approximation(sym: Symbol, fromBelow: Boolean, maxLevel: Int = Int.MaxValue)(using Context): Type = {
+    val res =
+      approximation(tvarOrError(sym).origin, fromBelow, maxLevel) match
+        case tpr: TypeParamRef =>
+          // Here we do externalization when the returned type is a TypeParamRef,
+          //  b/c ConstraintHandling.approximation may return internal types when
+          //  the type variable is instantiated. See #15531.
+          externalize(tpr)
+        case tp => tp
+
+    gadts.println(i"approximating $sym ~> $res")
+    res
+  }
+
+  def symbols: List[Symbol] = mapping.keys
+
+  def fresh: GadtConstraint = new ProperGadtConstraint(myConstraint, mapping, reverseMapping, wasConstrained)
+
+  /** Restore the state from other [[GadtConstraint]], probably copied using [[fresh]] */
+  def restore(other: GadtConstraint): Unit =
+    this.myConstraint = other.myConstraint
+    this.mapping = other.mapping
+    this.reverseMapping = other.reverseMapping
+    this.wasConstrained = other.wasConstrained
+
+  // ---- Protected/internal -----------------------------------------------
+
+  override protected def constraint = myConstraint
+  override protected def constraint_=(c: Constraint) = myConstraint = c
+
+  override protected def isSub(tp1: Type, tp2: Type)(using Context): Boolean = TypeComparer.isSubType(tp1, tp2)
+  override protected def isSame(tp1: Type, tp2: Type)(using Context): Boolean = TypeComparer.isSameType(tp1, tp2)
+
+  override def nonParamBounds(param: TypeParamRef)(using Context): TypeBounds =
+    externalize(constraint.nonParamBounds(param)).bounds
+
+  override def fullLowerBound(param: TypeParamRef)(using Context): Type =
+    constraint.minLower(param).foldLeft(nonParamBounds(param).lo) {
+      (t, u) => t | externalize(u)
+    }
+
+  override def fullUpperBound(param: TypeParamRef)(using Context): Type =
+    constraint.minUpper(param).foldLeft(nonParamBounds(param).hi) { (t, u) =>
+      val eu = externalize(u)
+      // Any as the upper bound means "no bound", but if F is higher-kinded,
+      // Any & F = F[_]; this is wrong for us so we need to short-circuit
+      if t.isAny then eu else t & eu
+    }
+
+  // ---- Private ----------------------------------------------------------
+
+  private def externalize(tp: Type, theMap: TypeMap | Null = null)(using Context): Type = tp match
+    case param: TypeParamRef => reverseMapping(param) match
+      case sym: Symbol => sym.typeRef
+      case null        => param
+    case tp: TypeAlias       => tp.derivedAlias(externalize(tp.alias, theMap))
+    case tp                  => (if theMap == null then ExternalizeMap() else theMap).mapOver(tp)
+
+  private class ExternalizeMap(using Context) extends TypeMap:
+    def apply(tp: Type): Type = externalize(tp, this)(using mapCtx)
+
+  private def tvarOrError(sym: Symbol)(using Context): TypeVar =
+    mapping(sym).ensuring(_ != null, i"not a constrainable symbol: $sym").uncheckedNN
+
+  private def containsNoInternalTypes(tp: Type, theAcc: TypeAccumulator[Boolean] | Null = null)(using Context): Boolean = tp match {
+    case tpr: TypeParamRef => !reverseMapping.contains(tpr)
+    case tv: TypeVar => !reverseMapping.contains(tv.origin)
+    case tp =>
+      (if (theAcc != null) theAcc else new ContainsNoInternalTypesAccumulator()).foldOver(true, tp)
+  }
+
+  private class ContainsNoInternalTypesAccumulator(using Context) extends TypeAccumulator[Boolean] {
+    override def apply(x: Boolean, tp: Type): Boolean = x && containsNoInternalTypes(tp, this)
+  }
+
+  // ---- Debug ------------------------------------------------------------
+
+  override def constr = gadtsConstr
+
+  override def toText(printer: Printer): Texts.Text = printer.toText(this)
+
+  /** Provides more information than toText, by showing the underlying Constraint details. */
+  def debugBoundsDescription(using Context): String = i"$this\n$constraint"
+}
+
+private class ProperGadtConstraint (
+    myConstraint: Constraint,
+    mapping: SimpleIdentityMap[Symbol, TypeVar],
+    reverseMapping: SimpleIdentityMap[TypeParamRef, Symbol],
+    wasConstrained: Boolean,
+) extends ConstraintHandling with GadtConstraint(myConstraint, mapping, reverseMapping, wasConstrained)
diff --git a/tests/pos-with-compiler-cc/dotc/core/Hashable.scala b/tests/pos-with-compiler-cc/dotc/core/Hashable.scala
new file mode 100644
index 000000000000..79da5f1dcd6f
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/core/Hashable.scala
@@ -0,0 +1,126 @@
+package dotty.tools.dotc
+package core
+
+import Types._
+import scala.util.hashing.{ MurmurHash3 => hashing }
+import annotation.tailrec
+
+object Hashable {
+
+  /** A null terminated list of BindingTypes. We use `null` here for efficiency */
+  class SomeBinders(val tp: BindingType, val next: Binders)
+
+  type Binders = SomeBinders | Null
+
+  /** A null terminated list of pairs of BindingTypes. Used for isomorphism tests. */
+  class SomeBinderPairs(tp1: BindingType, tp2: BindingType, next: BinderPairs) {
+    @tailrec final def matches(t1: Type, t2: Type): Boolean =
+      (t1 `eq` tp1) && (t2 `eq` tp2) || next != null && next.matches(t1, t2)
+  }
+
+  type BinderPairs = SomeBinderPairs | Null
+
+  /** A hash value indicating that the underlying type is not
+   *  cached in uniques.
+   */
+  inline val NotCached = 0
+
+  /** An alternative value returned from `hash` if the
+   *  computed hashCode would be `NotCached`.
+   */
+  private[core] inline val NotCachedAlt = Int.MinValue
+
+  /** A value that indicates that the hash code is unknown
+   */
+  private[core] inline val HashUnknown = 1234
+
+  /** An alternative value if computeHash would otherwise yield HashUnknown
+   */
+  private[core] inline val HashUnknownAlt = 4321
+}
+
+trait Hashable {
+  import Hashable._
+
+  protected def hashSeed: Int = getClass.hashCode
+
+  protected final def finishHash(hashCode: Int, arity: Int): Int =
+    avoidSpecialHashes(hashing.finalizeHash(hashCode, arity))
+
+  final def typeHash(bs: Binders, tp: Type): Int =
+    if (bs == null || tp.hashIsStable) tp.hash else tp.computeHash(bs)
+
+  def identityHash(bs: Binders): Int = avoidSpecialHashes(System.identityHashCode(this))
+
+  protected def finishHash(bs: Binders, seed: Int, arity: Int, tp: Type): Int = {
+    val elemHash = typeHash(bs, tp)
+    if (elemHash == NotCached) return NotCached
+    finishHash(hashing.mix(seed, elemHash), arity + 1)
+  }
+
+  protected def finishHash(bs: Binders, seed: Int, arity: Int, tp1: Type, tp2: Type): Int = {
+    val elemHash = typeHash(bs, tp1)
+    if (elemHash == NotCached) return NotCached
+    finishHash(bs, hashing.mix(seed, elemHash), arity + 1, tp2)
+  }
+
+  protected def finishHash(bs: Binders, seed: Int, arity: Int, tps: List[Type]): Int = {
+    var h = seed
+    var xs = tps
+    var len = arity
+    while (!xs.isEmpty) {
+      val elemHash = typeHash(bs, xs.head)
+      if (elemHash == NotCached) return NotCached
+      h = hashing.mix(h, elemHash)
+      xs = xs.tail
+      len += 1
+    }
+    finishHash(h, len)
+  }
+
+  protected def finishHash(bs: Binders, seed: Int, arity: Int, tp: Type, tps: List[Type]): Int = {
+    val elemHash = typeHash(bs, tp)
+    if (elemHash == NotCached) return NotCached
+    finishHash(bs, hashing.mix(seed, elemHash), arity + 1, tps)
+  }
+
+
+  protected final def doHash(x: Any): Int =
+    finishHash(hashing.mix(hashSeed, x.hashCode), 1)
+
+  protected final def doHash(bs: Binders, tp: Type): Int =
+    finishHash(bs, hashSeed, 0, tp)
+
+  protected final def doHash(bs: Binders, x1: Any, tp2: Type): Int =
+    finishHash(bs, hashing.mix(hashSeed, x1.hashCode), 1, tp2)
+
+  protected final def doHash(bs: Binders, x1: Int, tp2: Type): Int =
+    finishHash(bs, hashing.mix(hashSeed, x1), 1, tp2)
+
+  protected final def doHash(bs: Binders, x1: Int, tp2: Type, tp3: Type): Int =
+    finishHash(bs, hashing.mix(hashSeed, x1), 1, tp2, tp3)
+
+  protected final def doHash(bs: Binders, tp1: Type, tp2: Type): Int =
+    finishHash(bs, hashSeed, 0, tp1, tp2)
+
+  protected final def doHash(bs: Binders, x1: Any, tp2: Type, tp3: Type): Int =
+    finishHash(bs, hashing.mix(hashSeed, x1.hashCode), 1, tp2, tp3)
+
+  protected final def doHash(bs: Binders, tp1: Type, tps2: List[Type]): Int =
+    finishHash(bs, hashSeed, 0, tp1, tps2)
+
+  protected final def doHash(bs: Binders, x1: Any, tp2: Type, tps3: List[Type]): Int =
+    finishHash(bs, hashing.mix(hashSeed, x1.hashCode), 1, tp2, tps3)
+
+  protected final def doHash(x1: Int, x2: Int): Int =
+    finishHash(hashing.mix(hashing.mix(hashSeed, x1), x2), 1)
+
+  protected final def addDelta(elemHash: Int, delta: Int): Int =
+    if (elemHash == NotCached) NotCached
+    else avoidSpecialHashes(elemHash + delta)
+
+  protected def avoidSpecialHashes(h: Int): Int =
+    if (h == NotCached) NotCachedAlt
+    else if (h == HashUnknown) HashUnknownAlt
+    else h
+}
diff --git a/tests/pos-with-compiler-cc/dotc/core/JavaNullInterop.scala b/tests/pos-with-compiler-cc/dotc/core/JavaNullInterop.scala
new file mode 100644
index 000000000000..60fc4a4274e0
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/core/JavaNullInterop.scala
@@ -0,0 +1,149 @@
+package dotty.tools.dotc
+package core
+
+import Contexts._
+import Flags.JavaDefined
+import StdNames.nme
+import Symbols._
+import Types._
+
+/** This module defines methods to interpret types of Java symbols, which are implicitly nullable in Java,
+ *  as Scala types, which are explicitly nullable.
+ *
+ *  The transformation is (conceptually) a function `n` that adheres to the following rules:
+ *    (1) n(T)              = T | Null              if T is a reference type
+ *    (2) n(T)              = T                       if T is a value type
+ *    (3) n(C[T])           = C[T] | Null           if C is Java-defined
+ *    (4) n(C[T])           = C[n(T)] | Null        if C is Scala-defined
+ *    (5) n(A|B)            = n(A) | n(B) | Null
+ *    (6) n(A&B)            = n(A) & n(B)
+ *    (7) n((A1, ..., Am)R) = (n(A1), ..., n(Am))n(R) for a method with arguments (A1, ..., Am) and return type R
+ *    (8) n(T)              = T                       otherwise
+ *
+ *   Treatment of generics (rules 3 and 4):
+ *     - if `C` is Java-defined, then `n(C[T]) = C[T] | Null`. That is, we don't recurse
+ *       on the type argument, and only add Null on the outside. This is because
+ *       `C` itself will be nullified, and in particular so will be usages of `C`'s type argument within C's body.
+ *       e.g. calling `get` on a `java.util.List[String]` already returns `String|Null` and not `String`, so
+ *       we don't need to write `java.util.List[String | Null]`.
+ *     - if `C` is Scala-defined, however, then we want `n(C[T]) = C[n(T)] | Null`. This is because
+ *       `C` won't be nullified, so we need to indicate that its type argument is nullable.
+ *
+ *   Notice that since the transformation is only applied to types attached to Java symbols, it doesn't need
+ *   to handle the full spectrum of Scala types. Additionally, some kinds of symbols like constructors and
+ *   enum instances get special treatment.
+ */
+object JavaNullInterop {
+
+  /** Transforms the type `tp` of Java member `sym` to be explicitly nullable.
+   *  `tp` is needed because the type inside `sym` might not be set when this method is called.
+   *
+   *  e.g. given a Java method
+   *  String foo(String arg) { return arg; }
+   *
+   *  After calling `nullifyMember`, Scala will see the method as
+   *
+   *  def foo(arg: String | Null): String | Null
+   *
+   *  If unsafeNulls is enabled, we can select on the return of `foo`:
+   *
+   *  val len = foo("hello").length
+   *
+   *  But the selection can throw an NPE if the returned value is `null`.
+   */
+  def nullifyMember(sym: Symbol, tp: Type, isEnumValueDef: Boolean)(using Context): Type = {
+    assert(ctx.explicitNulls)
+    assert(sym.is(JavaDefined), "can only nullify java-defined members")
+
+    // Some special cases when nullifying the type
+    if isEnumValueDef || sym.name == nme.TYPE_ then
+      // Don't nullify the `TYPE` field in every class and Java enum instances
+      tp
+    else if sym.name == nme.toString_ || sym.isConstructor || hasNotNullAnnot(sym) then
+      // Don't nullify the return type of the `toString` method.
+      // Don't nullify the return type of constructors.
+      // Don't nullify the return type of methods with a not-null annotation.
+      nullifyExceptReturnType(tp)
+    else
+      // Otherwise, nullify everything
+      nullifyType(tp)
+  }
+
+  private def hasNotNullAnnot(sym: Symbol)(using Context): Boolean =
+    ctx.definitions.NotNullAnnots.exists(nna => sym.unforcedAnnotation(nna).isDefined)
+
+  /** If tp is a MethodType, the parameters and the inside of return type are nullified,
+   *  but the result return type is not nullable.
+   *  If tp is a type of a field, the inside of the type is nullified,
+   *  but the result type is not nullable.
+   */
+  private def nullifyExceptReturnType(tp: Type)(using Context): Type =
+    new JavaNullMap(true)(tp)
+
+  /** Nullifies a Java type by adding `| Null` in the relevant places. */
+  private def nullifyType(tp: Type)(using Context): Type =
+    new JavaNullMap(false)(tp)
+
+  /** A type map that implements the nullification function on types. Given a Java-sourced type, this adds `| Null`
+   *  in the right places to make the nulls explicit in Scala.
+   *
+   *  @param outermostLevelAlreadyNullable whether this type is already nullable at the outermost level.
+   *                                       For example, `Array[String] | Null` is already nullable at the
+   *                                       outermost level, but `Array[String | Null]` isn't.
+   *                                       If this parameter is set to true, then the types of fields, and the return
+   *                                       types of methods will not be nullified.
+   *                                       This is useful for e.g. constructors, and also so that `A & B` is nullified
+   *                                       to `(A & B) | Null`, instead of `(A | Null & B | Null) | Null`.
+   */
+  private class JavaNullMap(var outermostLevelAlreadyNullable: Boolean)(using Context) extends TypeMap {
+    /** Should we nullify `tp` at the outermost level? */
+    def needsNull(tp: Type): Boolean =
+      !outermostLevelAlreadyNullable && (tp match {
+        case tp: TypeRef =>
+          // We don't modify value types because they're non-nullable even in Java.
+          !tp.symbol.isValueClass &&
+          // We don't modify `Any` because it's already nullable.
+          !tp.isRef(defn.AnyClass) &&
+          // We don't nullify Java varargs at the top level.
+          // Example: if `setNames` is a Java method with signature `void setNames(String... names)`,
+          // then its Scala signature will be `def setNames(names: (String|Null)*): Unit`.
+          // This is because `setNames(null)` passes as argument a single-element array containing the value `null`,
+          // and not a `null` array.
+          !tp.isRef(defn.RepeatedParamClass)
+        case _ => true
+      })
+
+    override def apply(tp: Type): Type = tp match {
+      case tp: TypeRef if needsNull(tp) => OrNull(tp)
+      case appTp @ AppliedType(tycon, targs) =>
+        val oldOutermostNullable = outermostLevelAlreadyNullable
+        // We don't make the outmost levels of type arguments nullable if tycon is Java-defined.
+        // This is because Java classes are _all_ nullified, so both `java.util.List[String]` and
+        // `java.util.List[String|Null]` contain nullable elements.
+        outermostLevelAlreadyNullable = tp.classSymbol.is(JavaDefined)
+        val targs2 = targs map this
+        outermostLevelAlreadyNullable = oldOutermostNullable
+        val appTp2 = derivedAppliedType(appTp, tycon, targs2)
+        if needsNull(tycon) then OrNull(appTp2) else appTp2
+      case ptp: PolyType =>
+        derivedLambdaType(ptp)(ptp.paramInfos, this(ptp.resType))
+      case mtp: MethodType =>
+        val oldOutermostNullable = outermostLevelAlreadyNullable
+        outermostLevelAlreadyNullable = false
+        val paramInfos2 = mtp.paramInfos map this
+        outermostLevelAlreadyNullable = oldOutermostNullable
+        derivedLambdaType(mtp)(paramInfos2, this(mtp.resType))
+      case tp: TypeAlias => mapOver(tp)
+      case tp: AndType =>
+        // nullify(A & B) = (nullify(A) & nullify(B)) | Null, but take care not to add
+        // duplicate `Null`s at the outermost level inside `A` and `B`.
+        outermostLevelAlreadyNullable = true
+        OrNull(derivedAndType(tp, this(tp.tp1), this(tp.tp2)))
+      case tp: TypeParamRef if needsNull(tp) => OrNull(tp)
+      // In all other cases, return the type unchanged.
+      // In particular, if the type is a ConstantType, then we don't nullify it because it is the
+      // type of a final non-nullable field.
+      case _ => tp
+    }
+  }
+}
diff --git a/tests/pos-with-compiler-cc/dotc/core/MacroClassLoader.scala b/tests/pos-with-compiler-cc/dotc/core/MacroClassLoader.scala
new file mode 100644
index 000000000000..d8f41ef99b11
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/core/MacroClassLoader.scala
@@ -0,0 +1,29 @@
+package dotty.tools.dotc.core
+
+import dotty.tools.dotc.core.Contexts._
+import dotty.tools.dotc.util.Property
+import dotty.tools.dotc.reporting.trace
+import dotty.tools.io.ClassPath
+
+object MacroClassLoader {
+
+  /** A key to be used in a context property that caches the class loader used for macro expansion */
+  private val MacroClassLoaderKey = new Property.Key[ClassLoader]
+
+  /** Get the macro class loader */
+  def fromContext(using Context): ClassLoader =
+    ctx.property(MacroClassLoaderKey).getOrElse(makeMacroClassLoader)
+
+  /** Context with a cached macro class loader that can be accessed with `macroClassLoader` */
+  def init(ctx: FreshContext): ctx.type =
+    ctx.setProperty(MacroClassLoaderKey, makeMacroClassLoader(using ctx))
+
+  private def makeMacroClassLoader(using Context): ClassLoader = trace("new macro class loader") {
+    import scala.language.unsafeNulls
+
+    val entries = ClassPath.expandPath(ctx.settings.classpath.value, expandStar=true)
+    val urls = entries.map(cp => java.nio.file.Paths.get(cp).toUri.toURL).toArray
+    val out = Option(ctx.settings.outputDir.value.toURL) // to find classes in case of suspended compilation
+    new java.net.URLClassLoader(urls ++ out.toList, getClass.getClassLoader)
+  }
+}
diff --git a/tests/pos-with-compiler-cc/dotc/core/MatchTypeTrace.scala b/tests/pos-with-compiler-cc/dotc/core/MatchTypeTrace.scala
new file mode 100644
index 000000000000..062ddd5e846c
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/core/MatchTypeTrace.scala
@@ -0,0 +1,136 @@
+package dotty.tools
+package dotc
+package core
+
+import Types._, Contexts._, Symbols._, Decorators._
+import util.Property
+import Names.Name
+
+/** A utility module to produce match type reduction traces in error messages.
+ */
+object MatchTypeTrace:
+
+  private enum TraceEntry:
+    case TryReduce(scrut: Type)
+    case NoMatches(scrut: Type, cases: List[Type])
+    case Stuck(scrut: Type, stuckCase: Type, otherCases: List[Type])
+    case NoInstance(scrut: Type, stuckCase: Type, fails: List[(Name, TypeBounds)])
+    case EmptyScrutinee(scrut: Type)
+  import TraceEntry._
+
+  private class MatchTrace:
+    var entries: List[TraceEntry] = Nil
+
+  private val MatchTrace = new Property.Key[MatchTrace]
+
+  /** Execute `op` and if it involves a failed match type reduction
+   *  return the trace of that reduction. Otherwise return the empty string.
+   */
+  def record(op: Context ?=> Any)(using Context): String =
+    val trace = new MatchTrace
+    inContext(ctx.fresh.setProperty(MatchTrace, trace)) {
+      op
+      if trace.entries.isEmpty then ""
+      else
+        i"""
+           |
+           |Note: a match type could not be fully reduced:
+           |
+           |${trace.entries.reverse.map(explainEntry)}%\n%"""
+    }
+
+  /** Are we running an operation that records a match type trace? */
+  def isRecording(using Context): Boolean =
+    ctx.property(MatchTrace).isDefined
+
+  private def matchTypeFail(entry: TraceEntry)(using Context) =
+    ctx.property(MatchTrace) match
+      case Some(trace) =>
+        trace.entries match
+          case (e: TryReduce) :: es => trace.entries = entry :: trace.entries
+          case _ =>
+      case _ =>
+
+  /** Record a failure that scrutinee `scrut` does not match any case in `cases`.
+   *  Only the first failure is recorded.
+   */
+  def noMatches(scrut: Type, cases: List[Type])(using Context) =
+    matchTypeFail(NoMatches(scrut, cases))
+
+  /** Record a failure that scrutinee `scrut` does not match `stuckCase` but is
+   *  not disjoint from it either, which means that the remaining cases `otherCases`
+   *  cannot be visited. Only the first failure is recorded.
+   */
+  def stuck(scrut: Type, stuckCase: Type, otherCases: List[Type])(using Context) =
+    matchTypeFail(Stuck(scrut, stuckCase, otherCases))
+
+  def noInstance(scrut: Type, stuckCase: Type, fails: List[(Name, TypeBounds)])(using Context) =
+    matchTypeFail(NoInstance(scrut, stuckCase, fails))
+
+  /** Record a failure that scrutinee `scrut` is provably empty.
+   *  Only the first failure is recorded.
+   */
+  def emptyScrutinee(scrut: Type)(using Context) =
+    matchTypeFail(EmptyScrutinee(scrut))
+
+  /** Record in the trace that we are trying to reduce `scrut` when performing `op`
+   *  If `op` succeeds the entry is removed after exit. If `op` fails, it stays.
+   */
+  def recurseWith(scrut: Type)(op: => Type)(using Context): Type =
+    ctx.property(MatchTrace) match
+      case Some(trace) =>
+        val prev = trace.entries
+        trace.entries = TryReduce(scrut) :: prev
+        val res = op
+        if res.exists then trace.entries = prev
+        res
+      case _ =>
+        op
+
+  def caseText(tp: Type)(using Context): String = tp match
+    case tp: HKTypeLambda => caseText(tp.resultType)
+    case defn.MatchCase(any, body) if any eq defn.AnyType => i"case _ => $body"
+    case defn.MatchCase(pat, body) => i"case $pat => $body"
+    case _ => i"case $tp"
+
+  private def casesText(cases: List[Type])(using Context) =
+    i"${cases.map(caseText)}%\n    %"
+
+  private def explainEntry(entry: TraceEntry)(using Context): String = entry match
+    case TryReduce(scrut: Type) =>
+      i"  trying to reduce  $scrut"
+    case NoMatches(scrut, cases) =>
+      i"""  failed since selector  $scrut
+         |  matches none of the cases
+         |
+         |    ${casesText(cases)}"""
+    case EmptyScrutinee(scrut) =>
+      i"""  failed since selector  $scrut
+         |  is uninhabited (there are no values of that type)."""
+    case Stuck(scrut, stuckCase, otherCases) =>
+      val msg =
+        i"""  failed since selector  $scrut
+           |  does not match  ${caseText(stuckCase)}
+           |  and cannot be shown to be disjoint from it either."""
+      if otherCases.length == 0 then msg
+      else
+        val s = if otherCases.length == 1 then "" else "s"
+        i"""$msg
+           |  Therefore, reduction cannot advance to the remaining case$s
+           |
+           |    ${casesText(otherCases)}"""
+    case NoInstance(scrut, stuckCase, fails) =>
+      def params = if fails.length == 1 then "parameter" else "parameters"
+      i"""  failed since selector  $scrut
+         |  does not uniquely determine $params ${fails.map(_._1)}%, % in
+         |    ${caseText(stuckCase)}
+         |  The computed bounds for the $params are:
+         |    ${fails.map((name, bounds) => i"$name$bounds")}%\n    %"""
+
+  def noMatchesText(scrut: Type, cases: List[Type])(using Context): String =
+    i"""failed since selector  $scrut
+       |matches none of the cases
+       |
+       |    ${casesText(cases)}"""
+
+end MatchTypeTrace
diff --git a/tests/pos-with-compiler-cc/dotc/core/Mode.scala b/tests/pos-with-compiler-cc/dotc/core/Mode.scala
new file mode 100644
index 000000000000..40a45b9f4678
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/core/Mode.scala
@@ -0,0 +1,144 @@
+package dotty.tools.dotc.core
+
+/** A collection of mode bits that are part of a context */
+case class Mode(val bits: Int) extends AnyVal {
+  import Mode._
+  def | (that: Mode): Mode = Mode(bits | that.bits)
+  def & (that: Mode): Mode = Mode(bits & that.bits)
+  def &~ (that: Mode): Mode = Mode(bits & ~that.bits)
+  def is (that: Mode): Boolean = (bits & that.bits) == that.bits
+
+  def isExpr: Boolean = (this & PatternOrTypeBits) == None
+
+  override def toString: String =
+    (0 until 31).filter(i => (bits & (1 << i)) != 0).map(modeName).mkString("Mode(", ",", ")")
+
+  def ==(that: Mode): Boolean = this.bits == that.bits
+  def !=(that: Mode): Boolean = this.bits != that.bits
+}
+
+object Mode {
+  val None: Mode = Mode(0)
+
+  private val modeName = new Array[String](32)
+
+  def newMode(bit: Int, name: String): Mode = {
+    modeName(bit) = name
+    Mode(1 << bit)
+  }
+
+  val Pattern: Mode = newMode(0, "Pattern")
+  val Type: Mode = newMode(1, "Type")
+
+  val ImplicitsEnabled: Mode = newMode(2, "ImplicitsEnabled")
+  val InferringReturnType: Mode = newMode(3, "InferringReturnType")
+
+  /** This mode bit is set if we collect information without reference to a valid
+   *  context with typerstate and constraint. This is typically done when we
+   *  cache the eligibility of implicits. Caching needs to be done across different constraints.
+   *  Therefore, if TypevarsMissContext is set, subtyping becomes looser, and assumes
+   *  that TypeParamRefs can be sub- and supertypes of anything. See TypeComparer.
+   */
+  val TypevarsMissContext: Mode = newMode(4, "TypevarsMissContext")
+
+  /** Are we looking for cyclic references? */
+  val CheckCyclic: Mode = newMode(5, "CheckCyclic")
+
+  /** We are in a pattern alternative */
+  val InPatternAlternative: Mode = newMode(7, "InPatternAlternative")
+
+  /** Make subtyping checks instead infer constraints necessarily following from given subtyping relation.
+   *
+   *  This enables changing [[GadtConstraint]] and alters how [[TypeComparer]] approximates constraints.
+   */
+  val GadtConstraintInference: Mode = newMode(8, "GadtConstraintInference")
+
+  /** Assume -language:strictEquality */
+  val StrictEquality: Mode = newMode(9, "StrictEquality")
+
+  /** We are currently printing something: avoid producing more logs about
+   *  the printing.
+   */
+  val Printing: Mode = newMode(10, "Printing")
+
+  /** We are currently in a `viewExists` check. In that case, ambiguous
+   *  implicits checks are disabled and we succeed with the first implicit
+   *  found.
+   */
+  val ImplicitExploration: Mode = newMode(12, "ImplicitExploration")
+
+  /** We are currently unpickling Scala2 info */
+  val Scala2Unpickling: Mode = newMode(13, "Scala2Unpickling")
+
+  /** Signifies one of two possible situations:
+   *   1. We are currently checking bounds to be non-empty, so we should not
+   *      do any widening when computing members of refined types.
+   *   2. We are currently checking self type conformance, so we should not
+   *      ignore capture sets added to otherwise pure classes (only needed
+   *      for capture checking).
+   */
+  val CheckBoundsOrSelfType: Mode = newMode(14, "CheckBoundsOrSelfType")
+
+  /** Use Scala2 scheme for overloading and implicit resolution */
+  val OldOverloadingResolution: Mode = newMode(15, "OldOverloadingResolution")
+
+  /** Treat CapturingTypes as plain AnnotatedTypes even in phase CheckCaptures.
+   *  Reuses the value of OldOverloadingResolution to save Mode bits.
+   *  This is OK since OldOverloadingResolution only affects implicit search, which
+   *  is done during phases Typer and Inlinig, and IgnoreCaptures only has an
+   *  effect during phase CheckCaptures.
+   */
+  val IgnoreCaptures = OldOverloadingResolution
+
+  /** Allow hk applications of type lambdas to wildcard arguments;
+   *  used for checking that such applications do not normally arise
+   */
+  val AllowLambdaWildcardApply: Mode = newMode(16, "AllowHKApplyToWildcards")
+
+  /** Read original positions when unpickling from TASTY */
+  val ReadPositions: Mode = newMode(17, "ReadPositions")
+
+  /** Don't suppress exceptions thrown during show */
+  val PrintShowExceptions: Mode = newMode(18, "PrintShowExceptions")
+
+  val PatternOrTypeBits: Mode = Pattern | Type
+
+  /** We are elaborating the fully qualified name of a package clause.
+   *  In this case, identifiers should never be imported.
+   */
+  val InPackageClauseName: Mode = newMode(19, "InPackageClauseName")
+
+  /** We are in the IDE */
+  val Interactive: Mode = newMode(20, "Interactive")
+
+  /** We are typing the body of an inline method */
+  val InlineableBody: Mode = newMode(21, "InlineableBody")
+
+  /** We are synthesizing the receiver of an extension method */
+  val SynthesizeExtMethodReceiver: Mode = newMode(23, "SynthesizeExtMethodReceiver")
+
+  /** Are we trying to find a hidden implicit? */
+  val FindHiddenImplicits: Mode = newMode(24, "FindHiddenImplicits")
+
+  /** Are we in a quote in a pattern? */
+  val QuotedPattern: Mode = newMode(25, "QuotedPattern")
+
+  /** Are we typechecking the rhs of an extension method? */
+  val InExtensionMethod: Mode = newMode(26, "InExtensionMethod")
+
+  /** Are we resolving a TypeTest node? */
+  val InTypeTest: Mode = newMode(27, "InTypeTest")
+
+  /** Are we enforcing null safety? */
+  val SafeNulls = newMode(28, "SafeNulls")
+
+  /** We are typing the body of the condition of an `inline if` or the scrutinee of an `inline match`
+   *  This mode forces expansion of inline calls in those positions even during typing.
+   */
+  val ForceInline: Mode = newMode(29, "ForceInline")
+
+  /** This mode is enabled when we check Java overriding in explicit nulls.
+   *  Type `Null` becomes a subtype of non-primitive value types in TypeComparer.
+   */
+  val RelaxedOverriding: Mode = newMode(30, "RelaxedOverriding")
+}
diff --git a/tests/pos-with-compiler-cc/dotc/core/NameKinds.scala b/tests/pos-with-compiler-cc/dotc/core/NameKinds.scala
new file mode 100644
index 000000000000..2ed9a17b9f7e
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/core/NameKinds.scala
@@ -0,0 +1,414 @@
+package dotty.tools
+package dotc
+package core
+
+import Names._
+import NameOps._
+import StdNames._
+import NameTags._
+import Contexts._
+import Decorators._
+
+import scala.annotation.internal.sharable
+
+/** Defines possible kinds of NameInfo of a derived name */
+object NameKinds {
+
+  // These are sharable since all NameKinds are created eagerly at the start of the program
+  // before any concurrent threads are forked. for this to work, NameKinds should never
+  // be created lazily or in modules that start running after compilers are forked.
+  @sharable private val simpleNameKinds = util.HashMap[Int, ClassifiedNameKind]()
+  @sharable private val qualifiedNameKinds = util.HashMap[Int, QualifiedNameKind]()
+  @sharable private val numberedNameKinds = util.HashMap[Int, NumberedNameKind]()
+  @sharable private val uniqueNameKinds = util.HashMap[String, UniqueNameKind]()
+
+  /** A class for the info stored in a derived name */
+  abstract class NameInfo extends caps.Pure {
+    def kind: NameKind
+    def mkString(underlying: TermName): String
+    def map(f: SimpleName => SimpleName): NameInfo = this
+  }
+
+  /** An abstract base class of classes that define the kind of a derived name info */
+  abstract class NameKind(val tag: Int) extends caps.Pure { self =>
+
+    /** The info class defined by this kind */
+    type ThisInfo <: Info
+
+    /** A simple info type; some subclasses of Kind define more refined versions */
+    class Info extends NameInfo { this: ThisInfo =>
+      def kind: NameKind = self
+      def mkString(underlying: TermName): String = self.mkString(underlying, this)
+      override def toString: String = infoString
+    }
+
+    /** Does this kind define logically a new name (respectively qualified name)?
+     *  Tested by the `replace` and `collect` combinators of class `Name`.
+     */
+    def definesNewName: Boolean = false
+    def definesQualifiedName: Boolean = false
+
+    /** Unmangle simple name `name` into a name of this kind, or return
+     *  original name if this is not possible.
+     */
+    def unmangle(name: SimpleName): TermName = name
+
+    /** Turn a name of this kind consisting of an `underlying` prefix
+     *  and the given `info` into a string. Used to turn structured into
+     *  simple name.
+     */
+    def mkString(underlying: TermName, info: ThisInfo): String
+
+    /** A string used for displaying the structure of a name */
+    def infoString: String
+  }
+
+  object SimpleNameKind extends NameKind(UTF8) { self =>
+    type ThisInfo = Info
+    val info: Info = new Info
+    def mkString(underlying: TermName, info: ThisInfo): Nothing = unsupported("mkString")
+    def infoString: Nothing = unsupported("infoString")
+  }
+
+  /** The kind of names that add a simple classification to an underlying name.
+   */
+  abstract class ClassifiedNameKind(tag: Int, val infoString: String) extends NameKind(tag) {
+    type ThisInfo = Info
+    val info: Info = new Info
+
+    /** Build a new name of this kind from an underlying name */
+    def apply(underlying: TermName): TermName = underlying.derived(info)
+
+    /** Extractor operation for names of this kind */
+    def unapply(name: DerivedName): Option[TermName] =  name match {
+      case DerivedName(underlying, `info`) => Some(underlying)
+      case _ => None
+    }
+
+    simpleNameKinds(tag) = this: @unchecked
+  }
+
+  /** The kind of names that get formed by adding a prefix to an underlying name */
+  class PrefixNameKind(tag: Int, prefix: String, optInfoString: String = "")
+  extends ClassifiedNameKind(tag, if (optInfoString.isEmpty) s"Prefix $prefix" else optInfoString) {
+    def mkString(underlying: TermName, info: ThisInfo): String =
+      underlying.qualToString(_.toString, n => prefix + n.toString)
+    override def unmangle(name: SimpleName): TermName =
+      if (name.startsWith(prefix)) apply(name.drop(prefix.length).asSimpleName)
+      else name
+  }
+
+  /** The kind of names that get formed by appending a suffix to an underlying name */
+  class SuffixNameKind(tag: Int, suffix: String, optInfoString: String = "")
+  extends ClassifiedNameKind(tag, if (optInfoString.isEmpty) s"Suffix $suffix" else optInfoString) {
+    def mkString(underlying: TermName, info: ThisInfo): String =
+      underlying.qualToString(_.toString, n => n.toString + suffix)
+    override def unmangle(name: SimpleName): TermName =
+      if (name.endsWith(suffix)) apply(name.take(name.length - suffix.length).asSimpleName)
+      else name
+  }
+
+  /** A base trait for infos that define an additional selector name */
+  trait QualifiedInfo extends NameInfo {
+    val name: SimpleName
+  }
+
+  /** The kind of qualified names, consisting of an underlying name as a prefix,
+   *  followed by a separator, followed by a simple selector name.
+   *
+   *  A qualified names always constitutes a new name, different from its underlying name.
+   */
+  class QualifiedNameKind(tag: Int, val separator: String)
+  extends NameKind(tag) {
+    type ThisInfo = QualInfo
+    case class QualInfo(name: SimpleName) extends Info with QualifiedInfo {
+      override def map(f: SimpleName => SimpleName): NameInfo = new QualInfo(f(name))
+      override def toString: String = s"$infoString $name"
+      override def hashCode = scala.runtime.ScalaRunTime._hashCode(this) * 31 + kind.hashCode
+    }
+
+    def apply(qual: TermName, name: SimpleName): TermName =
+      qual.derived(new QualInfo(name))
+
+    /** Overloaded version used only for ExpandedName and TraitSetterName.
+     *  Needed because the suffix of an expanded name may itself be expanded.
+     *  For example, look at javap of scala.App.initCode
+     */
+    def apply(qual: TermName, name: TermName): TermName = name replace {
+      case name: SimpleName => apply(qual, name)
+      case AnyQualifiedName(_, _) => apply(qual, name.toSimpleName)
+    }
+
+    def unapply(name: DerivedName): Option[(TermName, SimpleName)] = name match {
+      case DerivedName(qual, info: this.QualInfo) => Some((qual, info.name))
+      case _ => None
+    }
+
+    override def definesNewName: Boolean = true
+    override def definesQualifiedName: Boolean = true
+
+    def mkString(underlying: TermName, info: ThisInfo): String =
+      s"$underlying$separator${info.name}"
+
+    def infoString: String = s"Qualified $separator"
+
+    qualifiedNameKinds(tag) = this: @unchecked
+  }
+
+  /** An extractor for qualified names of an arbitrary kind */
+  object AnyQualifiedName {
+    def unapply(name: DerivedName): Option[(TermName, SimpleName)] = name match {
+      case DerivedName(qual, info: QualifiedInfo) =>
+        Some((name.underlying, info.name))
+      case _ => None
+    }
+  }
+
+  /** A base trait for infos that contain a number */
+  trait NumberedInfo extends NameInfo {
+    def num: Int
+  }
+
+  /** The kind of numbered names consisting of an underlying name and a number */
+  abstract class NumberedNameKind(tag: Int, val infoString: String) extends NameKind(tag) { self =>
+    type ThisInfo = NumberedInfo
+    case class NumberedInfo(val num: Int) extends Info with NameKinds.NumberedInfo {
+      override def toString: String = s"$infoString $num"
+      override def hashCode = scala.runtime.ScalaRunTime._hashCode(this) * 31 + kind.hashCode
+    }
+    def apply(qual: TermName, num: Int): TermName =
+      qual.derived(new NumberedInfo(num))
+    def unapply(name: DerivedName): Option[(TermName, Int)] = name match {
+      case DerivedName(underlying, info: this.NumberedInfo) => Some((underlying, info.num))
+      case _ => None
+    }
+    protected def skipSeparatorAndNum(name: SimpleName, separator: String): Int = {
+      var i = name.length
+      while (i > 0 && name(i - 1).isDigit) i -= 1
+      if (i > separator.length && i < name.length &&
+          name.slice(i - separator.length, i).toString == separator) i
+      else -1
+    }
+
+    numberedNameKinds(tag) = this: @unchecked
+  }
+
+  /** An extractor for numbered names of arbitrary kind */
+  object AnyNumberedName {
+    def unapply(name: DerivedName): Option[(TermName, Int)] = name match {
+      case DerivedName(qual, info: NumberedInfo) => Some((qual, info.num))
+      case _ => None
+    }
+  }
+
+  /** The kind of unique names that consist of an underlying name (can be empty),
+   *  a separator indicating the class of unique name, and a unique number.
+   *
+   *  A unique names always constitutes a new name, different from its underlying name.
+   */
+  case class UniqueNameKind(val separator: String)
+  extends NumberedNameKind(UNIQUE, s"Unique $separator") {
+    override def definesNewName: Boolean = true
+
+    val separatorName = separator.toTermName
+
+    def mkString(underlying: TermName, info: ThisInfo): String = {
+      val safePrefix = str.sanitize(underlying.toString) + separator
+      safePrefix + info.num
+    }
+
+    /** Generate fresh unique term name of this kind with given prefix name */
+    def fresh(prefix: TermName = EmptyTermName)(using Context): TermName =
+      ctx.compilationUnit.freshNames.newName(prefix, this)
+
+    /** Generate fresh unique type name of this kind with given prefix name */
+    def fresh(prefix: TypeName)(using Context): TypeName =
+      fresh(prefix.toTermName).toTypeName
+
+    uniqueNameKinds(separator) = this: @unchecked
+  }
+
+  /** An extractor for unique names of arbitrary kind */
+  object AnyUniqueName {
+    def unapply(name: DerivedName): Option[(TermName, TermName, Int)] = name match {
+      case DerivedName(qual, info: NumberedInfo) =>
+        info.kind match {
+          case unique: UniqueNameKind => Some((qual, unique.separatorName, info.num))
+          case _ => None
+        }
+      case _ => None
+    }
+  }
+
+  /** Names of the form `prefix . name` */
+  val QualifiedName: QualifiedNameKind = new QualifiedNameKind(QUALIFIED, ".")
+
+  /** Names of the form `prefix $ name` that are constructed as a result of flattening */
+  val FlatName: QualifiedNameKind = new QualifiedNameKind(FLATTENED, "$")
+
+  /** Names of the form `prefix $ name` that are prefixes of expanded names */
+  val ExpandPrefixName: QualifiedNameKind = new QualifiedNameKind(EXPANDPREFIX, "$")
+
+  /** Expanded names of the form `prefix $$ name`. */
+  val ExpandedName: QualifiedNameKind = new QualifiedNameKind(EXPANDED, str.EXPAND_SEPARATOR) {
+    private val FalseSuper = termName("$$super")
+    private val FalseSuperLength = FalseSuper.length
+
+    override def unmangle(name: SimpleName): TermName = {
+      var i = name.lastIndexOfSlice(str.EXPAND_SEPARATOR)
+      if (i < 0) name
+      else {
+        // Hack to make super accessors from traits work. They would otherwise fail because of #765
+        // The problem is that in `x$$super$$plus` the expansion prefix needs to be `x`
+        // instead of `x$$super`.
+        if (i > FalseSuperLength && name.slice(i - FalseSuperLength, i) == FalseSuper)
+          i -= FalseSuper.length
+
+        apply(name.take(i).asTermName, name.drop(i + str.EXPAND_SEPARATOR.length).asSimpleName)
+      }
+    }
+  }
+
+  /** Expanded names of the form `prefix $_setter_$ name`. These only occur in Scala2. */
+  val TraitSetterName: QualifiedNameKind = new QualifiedNameKind(TRAITSETTER, str.TRAIT_SETTER_SEPARATOR)
+
+  /** Unique names of the form `prefix $ n` or `$ n $` */
+  val UniqueName: UniqueNameKind = new UniqueNameKind("$") {
+    override def mkString(underlying: TermName, info: ThisInfo) =
+      if (underlying.isEmpty) "$" + info.num + "$" else super.mkString(underlying, info)
+  }
+
+  /** Other unique names */
+  val TempResultName: UniqueNameKind         = new UniqueNameKind("ev$")
+  val EvidenceParamName: UniqueNameKind      = new UniqueNameKind("evidence$")
+  val DepParamName: UniqueNameKind           = new UniqueNameKind("(param)")
+  val LazyImplicitName: UniqueNameKind       = new UniqueNameKind("$_lazy_implicit_$")
+  val LazyLocalName: UniqueNameKind          = new UniqueNameKind("$lzy")
+  val LazyLocalInitName: UniqueNameKind      = new UniqueNameKind("$lzyINIT")
+  val LazyFieldOffsetName: UniqueNameKind    = new UniqueNameKind("$OFFSET")
+  val LazyBitMapName: UniqueNameKind         = new UniqueNameKind(nme.BITMAP_PREFIX.toString)
+  val NonLocalReturnKeyName: UniqueNameKind  = new UniqueNameKind("nonLocalReturnKey")
+  val WildcardParamName: UniqueNameKind      = new UniqueNameKind("_$")
+  val TailLabelName: UniqueNameKind          = new UniqueNameKind("tailLabel")
+  val TailLocalName: UniqueNameKind          = new UniqueNameKind("$tailLocal")
+  val TailTempName: UniqueNameKind           = new UniqueNameKind("$tmp")
+  val ExceptionBinderName: UniqueNameKind    = new UniqueNameKind("ex")
+  val SkolemName: UniqueNameKind             = new UniqueNameKind("?")
+  val LiftedTreeName: UniqueNameKind         = new UniqueNameKind("liftedTree")
+  val SuperArgName: UniqueNameKind           = new UniqueNameKind("$superArg$")
+  val DocArtifactName: UniqueNameKind        = new UniqueNameKind("$doc")
+  val UniqueInlineName: UniqueNameKind       = new UniqueNameKind("$i")
+  val InlineScrutineeName: UniqueNameKind    = new UniqueNameKind("$scrutinee")
+  val InlineBinderName: UniqueNameKind       = new UniqueNameKind("$proxy")
+
+  /** A kind of unique extension methods; Unlike other unique names, these can be
+   *  unmangled.
+   */
+  val UniqueExtMethName: UniqueNameKind = new UniqueNameKind("$extension") {
+    override def unmangle(name: SimpleName): TermName = {
+      val i = skipSeparatorAndNum(name, separator)
+      if (i > 0) {
+        val index = name.drop(i).toString.toInt
+        val original = name.take(i - separator.length).asTermName
+        apply(original, index)
+      }
+      else name
+    }
+  }
+
+  /** Kinds of unique names generated by the pattern matcher */
+  val PatMatStdBinderName: UniqueNameKind    = new UniqueNameKind("x")
+  val PatMatAltsName: UniqueNameKind         = new UniqueNameKind("matchAlts")
+  val PatMatResultName: UniqueNameKind       = new UniqueNameKind("matchResult")
+  val PatMatGivenVarName: UniqueNameKind     = new UniqueNameKind("$given")
+
+  val LocalOptInlineLocalObj: UniqueNameKind = new UniqueNameKind("ilo")
+
+  /** The kind of names of default argument getters */
+  val DefaultGetterName: NumberedNameKind = new NumberedNameKind(DEFAULTGETTER, "DefaultGetter") {
+    def mkString(underlying: TermName, info: ThisInfo) = {
+      val prefix = if (underlying.isConstructorName) nme.DEFAULT_GETTER_INIT else underlying
+      prefix.toString + str.DEFAULT_GETTER + (info.num + 1)
+    }
+    // TODO: Reduce code duplication with UniqueExtMethName
+    override def unmangle(name: SimpleName): TermName = {
+      val i = skipSeparatorAndNum(name, str.DEFAULT_GETTER)
+      if (i > 0) {
+        val index = name.drop(i).toString.toInt - 1
+        var original = name.take(i - str.DEFAULT_GETTER.length).asTermName
+        if (original == nme.DEFAULT_GETTER_INIT) original = nme.CONSTRUCTOR
+        apply(original, index)
+      }
+      else name
+    }
+  }
+
+  /** Names of the form N_<outer>. Emitted by inliner, replaced by outer path
+   *  in ExplicitOuter.
+   */
+  val OuterSelectName: NumberedNameKind = new NumberedNameKind(OUTERSELECT, "OuterSelect") {
+    def mkString(underlying: TermName, info: ThisInfo) = {
+      assert(underlying.isEmpty)
+      s"${info.num}_<outer>"
+    }
+  }
+
+  val SuperAccessorName: PrefixNameKind = new PrefixNameKind(SUPERACCESSOR, "super$")
+  val InitializerName: PrefixNameKind = new PrefixNameKind(INITIALIZER, "initial$")
+  val ProtectedAccessorName: PrefixNameKind = new PrefixNameKind(PROTECTEDACCESSOR, "protected$")
+  val InlineAccessorName: PrefixNameKind = new PrefixNameKind(INLINEACCESSOR, "inline$")
+
+  /** See `ConstraintHandling#LevelAvoidMap`. */
+  enum AvoidNameKind(tag: Int, prefix: String) extends PrefixNameKind(tag, prefix):
+    override def definesNewName = true
+    case UpperBound extends AvoidNameKind(AVOIDUPPER, "(upper)")
+    case LowerBound extends AvoidNameKind(AVOIDLOWER, "(lower)")
+    case BothBounds extends AvoidNameKind(AVOIDBOTH, "(avoid)")
+
+  val BodyRetainerName: SuffixNameKind = new SuffixNameKind(BODYRETAINER, "$retainedBody")
+  val FieldName: SuffixNameKind = new SuffixNameKind(FIELD, "$$local") {
+      override def mkString(underlying: TermName, info: ThisInfo) = underlying.toString
+  }
+  val ExplicitFieldName: SuffixNameKind = new SuffixNameKind(EXPLICITFIELD, "$field")
+  val ExtMethName: SuffixNameKind = new SuffixNameKind(EXTMETH, "$extension")
+  val ParamAccessorName: SuffixNameKind = new SuffixNameKind(PARAMACC, "$accessor")
+  val ModuleClassName: SuffixNameKind = new SuffixNameKind(OBJECTCLASS, "$", optInfoString = "ModuleClass")
+  val DirectMethName: SuffixNameKind = new SuffixNameKind(DIRECT, "$direct")
+  val AdaptedClosureName: SuffixNameKind = new SuffixNameKind(ADAPTEDCLOSURE, "$adapted") { override def definesNewName = true }
+  val SyntheticSetterName: SuffixNameKind = new SuffixNameKind(SETTER, "_$eq")
+
+  /** A name together with a signature. Used in Tasty trees. */
+  object SignedName extends NameKind(SIGNED) {
+
+    case class SignedInfo(sig: Signature, target: TermName) extends Info {
+      assert(sig ne Signature.NotAMethod)
+      override def toString: String =
+        val targetStr = if target.isEmpty then "" else s" @$target"
+        s"$infoString $sig$targetStr"
+      override def hashCode = scala.runtime.ScalaRunTime._hashCode(this) * 31 + kind.hashCode
+    }
+    type ThisInfo = SignedInfo
+
+    def apply(qual: TermName, sig: Signature, target: TermName): TermName =
+      qual.derived(new SignedInfo(sig, target))
+    def unapply(name: DerivedName): Option[(TermName, Signature, TermName)] = name match {
+      case DerivedName(underlying, info: SignedInfo) => Some((underlying, info.sig, info.target))
+      case _ => None
+    }
+
+    def mkString(underlying: TermName, info: ThisInfo): String = s"$underlying[with sig ${info.sig}]"
+    def infoString: String = "Signed"
+  }
+
+  /** Possible name kinds of a method that comes from Scala2 pickling info.
+   *  and that need to be unmangled. Note: Scala2 protected accessors and setters
+   *  can be left mangled, so they are not included in thus list.
+   */
+  val Scala2MethodNameKinds: List[NameKind] =
+    List(DefaultGetterName, ExtMethName, UniqueExtMethName)
+
+  def simpleNameKindOfTag      : util.ReadOnlyMap[Int, ClassifiedNameKind] = simpleNameKinds
+  def qualifiedNameKindOfTag   : util.ReadOnlyMap[Int, QualifiedNameKind]  = qualifiedNameKinds
+  def numberedNameKindOfTag    : util.ReadOnlyMap[Int, NumberedNameKind]   = numberedNameKinds
+  def uniqueNameKindOfSeparator: util.ReadOnlyMap[String, UniqueNameKind]  = uniqueNameKinds
+}
diff --git a/tests/pos-with-compiler-cc/dotc/core/NameOps.scala b/tests/pos-with-compiler-cc/dotc/core/NameOps.scala
new file mode 100644
index 000000000000..7c1073852681
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/core/NameOps.scala
@@ -0,0 +1,400 @@
+package dotty.tools
+package dotc
+package core
+
+import java.security.MessageDigest
+import java.nio.CharBuffer
+import scala.io.Codec
+import Int.MaxValue
+import Names._, StdNames._, Contexts._, Symbols._, Flags._, NameKinds._, Types._
+import util.Chars.{isOperatorPart, digit2int}
+import Decorators.*
+import Definitions._
+import nme._
+
+object NameOps {
+
+  object compactify {
+    lazy val md5: MessageDigest = MessageDigest.getInstance("MD5").nn
+
+    inline val CLASSFILE_NAME_CHAR_LIMIT = 240
+
+    /** COMPACTIFY
+     *
+     *  The hashed name has the form (prefix + marker + md5 + marker + suffix), where
+     *   - prefix/suffix.length = MaxNameLength / 4
+     *   - md5.length = 32
+     *
+     *  We obtain the formula:
+     *
+     *   FileNameLength = 2*(MaxNameLength / 4) + 2.marker.length + 32 + 6
+     *
+     *  (+6 for ".class"). MaxNameLength can therefore be computed as follows:
+     */
+    def apply(s: String): String = {
+      val marker = "$$$$"
+
+      val MaxNameLength = (CLASSFILE_NAME_CHAR_LIMIT - 6).min(
+        2 * (CLASSFILE_NAME_CHAR_LIMIT - 6 - 2 * marker.length - 32)
+      )
+
+      def toMD5(s: String, edge: Int): String = {
+        val prefix = s.take(edge)
+        val suffix = s.takeRight(edge)
+
+        val cs = s.toArray
+        val bytes = Codec.toUTF8(CharBuffer.wrap(cs).nn)
+        md5.update(bytes)
+        val md5chars = md5.digest().nn.map(b => (b & 0xFF).toHexString).mkString
+
+        prefix + marker + md5chars + marker + suffix
+      }
+
+      if (s.length <= MaxNameLength) s else toMD5(s, MaxNameLength / 4)
+    }
+  }
+
+  extension [N <: Name](name: N) {
+
+    def testSimple(f: SimpleName => Boolean): Boolean = name match {
+      case name: SimpleName => f(name)
+      case name: TypeName => name.toTermName.testSimple(f)
+      case _ => false
+    }
+
+    private def likeSpacedN(n: Name): N =
+      name.likeSpaced(n).asInstanceOf[N]
+
+    def isConstructorName: Boolean = name == CONSTRUCTOR || name == TRAIT_CONSTRUCTOR
+    def isStaticConstructorName: Boolean = name == STATIC_CONSTRUCTOR
+    def isLocalDummyName: Boolean = name startsWith str.LOCALDUMMY_PREFIX
+    def isReplWrapperName: Boolean = name.toString contains str.REPL_SESSION_LINE
+    def isReplAssignName: Boolean = name.toString contains str.REPL_ASSIGN_SUFFIX
+    def isSetterName: Boolean = name.endsWith(str.SETTER_SUFFIX) || name.is(SyntheticSetterName)
+    def isScala2LocalSuffix: Boolean = testSimple(_.endsWith(" "))
+    def isSelectorName: Boolean = testSimple(n => n.startsWith("_") && n.drop(1).forall(_.isDigit))
+    def isAnonymousClassName: Boolean = name.startsWith(str.ANON_CLASS)
+    def isAnonymousFunctionName: Boolean = name.startsWith(str.ANON_FUN)
+    def isUnapplyName: Boolean = name == nme.unapply || name == nme.unapplySeq
+    def isRightAssocOperatorName: Boolean = name.lastPart.last == ':'
+
+    def isOperatorName: Boolean = name match
+      case name: SimpleName => name.exists(isOperatorPart)
+      case _ => false
+
+    /** Is name of a variable pattern? */
+    def isVarPattern: Boolean =
+      testSimple { n =>
+        n.length > 0 && {
+          val first = n.head
+          (((first.isLower && first.isLetter) || first == '_')
+            && (n != false_)
+            && (n != true_)
+            && (n != null_))
+        }
+      } || name.is(PatMatGivenVarName)
+
+    def isOpAssignmentName: Boolean = name match {
+      case raw.NE | raw.LE | raw.GE | EMPTY =>
+        false
+      case name: SimpleName =>
+        name.length > 0 && name.last == '=' && name.head != '=' && isOperatorPart(name.head)
+      case _ =>
+        false
+    }
+
+    /** is this the name of an object enclosing packagel-level definitions? */
+    def isPackageObjectName: Boolean = name match {
+      case name: TermName => name == nme.PACKAGE || name.endsWith(str.TOPLEVEL_SUFFIX)
+      case name: TypeName =>
+        name.toTermName match {
+          case ModuleClassName(original) => original.isPackageObjectName
+          case _ => false
+        }
+    }
+
+    /** Convert this module name to corresponding module class name */
+    def moduleClassName: TypeName = name.derived(ModuleClassName).toTypeName
+
+    /** Convert this module class name to corresponding source module name */
+    def sourceModuleName: TermName = name.toTermName.exclude(ModuleClassName)
+
+    /** If name ends in module class suffix, drop it. This
+     *  method needs to work on mangled as well as unmangled names because
+     *  it is also called from the backend.
+     */
+    def stripModuleClassSuffix: N = likeSpacedN {
+      val semName = name.toTermName match
+        case name: SimpleName if name.endsWith(str.MODULE_SUFFIX) && name.lastPart != MODULE_SUFFIX => name.unmangleClassName
+        case _ => name
+      semName.exclude(ModuleClassName)
+    }
+
+    /** If flags is a ModuleClass but not a Package, add module class suffix */
+    def adjustIfModuleClass(flags: FlagSet): N = likeSpacedN {
+      if (flags.is(ModuleClass, butNot = Package)) name.asTypeName.moduleClassName
+      else name.toTermName
+    }
+
+    /** The expanded name.
+     *  This is the fully qualified name of `base` with `ExpandPrefixName` as separator,
+     *  followed by `kind` and the name.
+     */
+    def expandedName(base: Symbol, kind: QualifiedNameKind = ExpandedName)(using Context): N =
+      likeSpacedN { base.fullNameSeparated(ExpandPrefixName, kind, name) }
+
+    /** Revert the expanded name. */
+    def unexpandedName: N = likeSpacedN {
+      name.replaceDeep {
+        case ExpandedName(_, unexp) => unexp
+      }
+    }
+
+    def errorName: N = likeSpacedN(name ++ nme.ERROR)
+
+    def freshened(using Context): N = likeSpacedN {
+      name.toTermName match {
+        case ModuleClassName(original) => ModuleClassName(original.freshened)
+        case name => UniqueName.fresh(name)
+      }
+    }
+
+    /** Do two target names match? An empty target name matchws any other name. */
+    def matchesTargetName(other: Name) =
+      name == other || name.isEmpty || other.isEmpty
+
+    private def functionSuffixStart: Int =
+      val first = name.firstPart
+      var idx = first.length - 1
+      if idx >= 8 && first(idx).isDigit then
+        while
+          idx = idx - 1
+          idx >= 8 && first(idx).isDigit
+        do ()
+        if    first(idx - 7) == 'F'
+           && first(idx - 6) == 'u'
+           && first(idx - 5) == 'n'
+           && first(idx - 4) == 'c'
+           && first(idx - 3) == 't'
+           && first(idx - 2) == 'i'
+           && first(idx - 1) == 'o'
+           && first(idx)     == 'n'
+        then idx - 7
+        else -1
+      else -1
+
+    /** The arity of a name ending in the suffix `Function{\d}`, but -1
+     *  if the number is larger than Int.MaxValue / 10.
+     *  @param suffixStart  The index of the suffix
+     */
+    private def funArity(suffixStart: Int): Int =
+      inline val MaxSafeInt = MaxValue / 10
+      val first = name.firstPart
+      def collectDigits(acc: Int, idx: Int): Int =
+        if idx == first.length then acc
+        else
+          val d = digit2int(first(idx), 10)
+          if d < 0 || acc > MaxSafeInt then -1
+          else collectDigits(acc * 10 + d, idx + 1)
+      collectDigits(0, suffixStart + 8)
+
+    private def isFunctionPrefix(suffixStart: Int, mustHave: String = "")(using Context): Boolean =
+      suffixStart >= 0
+      && {
+        val first = name.firstPart
+        var found = mustHave.isEmpty
+        def skip(idx: Int, str: String) =
+          if first.startsWith(str, idx) then
+            if str == mustHave then found = true
+            idx + str.length
+          else idx
+        skip(skip(skip(0, "Impure"), "Erased"), "Context") == suffixStart
+        && found
+      }
+
+    /** Same as `funArity`, except that it returns -1 if the prefix
+     *  is not one of a (possibly empty) concatenation of a subset of
+     *  "Impure" (only under pureFunctions), "Erased" and "Context" (in that order).
+     */
+    private def checkedFunArity(suffixStart: Int)(using Context): Int =
+      if isFunctionPrefix(suffixStart) then funArity(suffixStart) else -1
+
+    /** Is a function name, i.e one of FunctionXXL, FunctionN, ContextFunctionN, ErasedFunctionN, ErasedContextFunctionN for N >= 0
+     */
+    def isFunction(using Context): Boolean =
+      (name eq tpnme.FunctionXXL) || checkedFunArity(functionSuffixStart) >= 0
+
+    /** Is a function name
+     *    - FunctionN for N >= 0
+     */
+    def isPlainFunction(using Context): Boolean = functionArity >= 0
+
+    /** Is a function name that contains `mustHave` as a substring */
+    private def isSpecificFunction(mustHave: String)(using Context): Boolean =
+      val suffixStart = functionSuffixStart
+      isFunctionPrefix(suffixStart, mustHave) && funArity(suffixStart) >= 0
+
+    def isContextFunction(using Context): Boolean = isSpecificFunction("Context")
+    def isErasedFunction(using Context): Boolean = isSpecificFunction("Erased")
+    def isImpureFunction(using Context): Boolean = isSpecificFunction("Impure")
+
+    /** Is a synthetic function name, i.e. one of
+     *    - FunctionN for N > 22
+     *    - ContextFunctionN for N >= 0
+     *    - ErasedFunctionN for N >= 0
+     *    - ErasedContextFunctionN for N >= 0
+     */
+    def isSyntheticFunction(using Context): Boolean =
+      val suffixStart = functionSuffixStart
+      if suffixStart == 0 then funArity(suffixStart) > MaxImplementedFunctionArity
+      else checkedFunArity(suffixStart) >= 0
+
+    def functionArity(using Context): Int =
+      val suffixStart = functionSuffixStart
+      if suffixStart >= 0 then checkedFunArity(suffixStart) else -1
+
+    /** The name of the generic runtime operation corresponding to an array operation */
+    def genericArrayOp: TermName = name match {
+      case nme.apply => nme.array_apply
+      case nme.length => nme.array_length
+      case nme.update => nme.array_update
+      case nme.clone_ => nme.array_clone
+    }
+
+    /** The name of the primitive runtime operation corresponding to an array operation */
+    def primitiveArrayOp: TermName = name match {
+      case nme.apply => nme.primitive.arrayApply
+      case nme.length => nme.primitive.arrayLength
+      case nme.update => nme.primitive.arrayUpdate
+      case nme.clone_ => nme.clone_
+    }
+
+    /** This method is to be used on **type parameters** from a class, since
+     *  this method does sorting based on their names
+     */
+    def specializedFor(classTargs: List[Type], classTargsNames: List[Name], methodTargs: List[Type], methodTarsNames: List[Name])(using Context): N = {
+      val methodTags: Seq[Name] = (methodTargs zip methodTarsNames).sortBy(_._2).map(x => defn.typeTag(x._1))
+      val classTags: Seq[Name] = (classTargs zip classTargsNames).sortBy(_._2).map(x => defn.typeTag(x._1))
+
+      likeSpacedN(name ++ nme.specializedTypeNames.prefix ++
+        methodTags.fold(nme.EMPTY)(_ ++ _) ++ nme.specializedTypeNames.separator ++
+        classTags.fold(nme.EMPTY)(_ ++ _) ++ nme.specializedTypeNames.suffix)
+    }
+
+    /** Determines if the current name is the specialized name of the given base name.
+     *  For example `typeName("Tuple2$mcII$sp").isSpecializedNameOf(tpnme.Tuple2) == true`
+     */
+    def isSpecializedNameOf(base: N)(using Context): Boolean =
+      var i = 0
+      inline def nextString(str: String) = name.startsWith(str, i) && { i += str.length; true }
+      nextString(base.toString)
+        && nextString(nme.specializedTypeNames.prefix.toString)
+        && nextString(nme.specializedTypeNames.separator.toString)
+        && name.endsWith(nme.specializedTypeNames.suffix.toString)
+
+    /** Returns the name of the class specialised to the provided types,
+     *  in the given order.  Used for the specialized tuple classes.
+     */
+    def specializedName(args: List[Type])(using Context): N =
+      val sb = new StringBuilder
+      sb.append(name.toString)
+      sb.append(nme.specializedTypeNames.prefix.toString)
+      sb.append(nme.specializedTypeNames.separator)
+      args.foreach { arg => sb.append(defn.typeTag(arg)) }
+      sb.append(nme.specializedTypeNames.suffix)
+      likeSpacedN(termName(sb.toString))
+
+    /** Use for specializing function names ONLY and use it if you are **not**
+     *  creating specialized name from type parameters. The order of names will
+     *  be:
+     *
+     *  `<return type><first type><second type><...>`
+     */
+    def specializedFunction(ret: Type, args: List[Type])(using Context): N =
+      val sb = new StringBuilder
+      sb.append(name.toString)
+      sb.append(nme.specializedTypeNames.prefix.toString)
+      sb.append(nme.specializedTypeNames.separator)
+      sb.append(defn.typeTag(ret).toString)
+      args.foreach { arg => sb.append(defn.typeTag(arg)) }
+      sb.append(nme.specializedTypeNames.suffix)
+      likeSpacedN(termName(sb.toString))
+
+    /** If name length exceeds allowable limit, replace part of it by hash */
+    def compactified(using Context): TermName = termName(compactify(name.toString))
+
+    def unmangleClassName: N = name.toTermName match {
+      case name: SimpleName
+      if name.endsWith(str.MODULE_SUFFIX) && !nme.falseModuleClassNames.contains(name) =>
+        likeSpacedN(name.dropRight(str.MODULE_SUFFIX.length).moduleClassName)
+      case _ => name
+    }
+
+    def unmangle(kind: NameKind): N = likeSpacedN {
+      name match
+        case name: SimpleName =>
+          kind.unmangle(name)
+        case name: TypeName =>
+          name.toTermName.unmangle(kind).toTypeName
+        case _ =>
+          name replace {
+            case unmangled: SimpleName =>
+              kind.unmangle(unmangled)
+            case ExpandedName(prefix, last) =>
+              kind.unmangle(last) replace {
+                case kernel: SimpleName =>
+                  ExpandedName(prefix, kernel)
+              }
+          }
+    }
+
+    def unmangle(kinds: List[NameKind]): N = {
+      val unmangled = kinds.foldLeft(name)(_.unmangle(_))
+      if (unmangled eq name) name else unmangled.unmangle(kinds)
+    }
+  }
+
+  extension (name: TermName) {
+
+    def setterName: TermName = name.exclude(FieldName) ++ str.SETTER_SUFFIX
+
+    def syntheticSetterName = SyntheticSetterName(name.exclude(FieldName))
+
+    def getterName: TermName =
+      val name1 = name.exclude(FieldName)
+      if name1.is(SyntheticSetterName) then name1.exclude(SyntheticSetterName)
+      else name1.mapLast(n =>
+        if (n.endsWith(str.SETTER_SUFFIX)) n.take(n.length - str.SETTER_SUFFIX.length).asSimpleName
+        else n)
+
+    def fieldName: TermName =
+      if (name.isSetterName)
+        if name.is(SyntheticSetterName) then
+          name.exclude(SyntheticSetterName)
+            .replace { case TraitSetterName(_, original) => original }
+            .fieldName
+        else getterName.fieldName
+      else FieldName(name.toSimpleName)
+
+    def stripScala2LocalSuffix: TermName =
+      if (name.isScala2LocalSuffix) name.asSimpleName.dropRight(1) else name
+
+    /** The name unary_x for a prefix operator x */
+    def toUnaryName: TermName = name match {
+      case raw.MINUS => UNARY_-
+      case raw.PLUS  => UNARY_+
+      case raw.TILDE => UNARY_~
+      case raw.BANG  => UNARY_!
+      case _ => name
+    }
+
+    /** If this is a super accessor name, its underlying name, which is the name
+     *  of the method that the super accessor forwards to.
+     */
+    def originalOfSuperAccessorName: TermName = name match
+      case SuperAccessorName(name1)   => name1.originalOfSuperAccessorName
+      case ExpandedName(_, name1)     => name1.originalOfSuperAccessorName
+      case ExpandPrefixName(_, name1) => name1.originalOfSuperAccessorName
+      case _ => name
+  }
+}
diff --git a/tests/pos-with-compiler-cc/dotc/core/NameTags.scala b/tests/pos-with-compiler-cc/dotc/core/NameTags.scala
new file mode 100644
index 000000000000..59dfaa3d437b
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/core/NameTags.scala
@@ -0,0 +1,68 @@
+package dotty.tools.dotc.core
+
+import dotty.tools.tasty.TastyFormat
+
+/** The possible tags of a NameKind */
+object NameTags extends TastyFormat.NameTags {
+
+  inline val FLATTENED = 5       // A flat name, generated by Flatten
+
+  inline val TRAITSETTER = 6     // A Scala-2 trait setter, generated by AugmentScala2Traits
+
+  inline val OUTERSELECT = 13    // A name `<num>_outer`, used by the inliner to indicate an
+                                // outer accessor that will be filled in by ExplicitOuter.
+                                // <num> indicates the number of hops needed to select the outer field.
+
+  inline val PROTECTEDACCESSOR = 24 // The name of a protected accesor `protected$<name>` created by ProtectedAccessors.
+
+  inline val INITIALIZER = 26    // A mixin initializer method
+
+  inline val FIELD = 29          // Used by Memoize to tag the name of a class member field.
+
+  inline val EXTMETH = 30        // Used by ExtensionMethods for the name of an extension method
+                                // implementing a value class method.
+
+  inline val ADAPTEDCLOSURE = 31 // Used in Erasure to adapt closures over primitive types.
+
+  inline val DIRECT = 32         // Used to define implementations of methods with
+                                // erased context function results that can override some
+                                // other method.
+
+  inline val PARAMACC = 33       // Used for a private parameter alias
+
+  inline val SETTER = 34         // A synthesized += suffix.
+
+  // Name of type variables created by `ConstraintHandling#LevelAvoidMap`.
+  final val AVOIDUPPER = 35
+  final val AVOIDLOWER = 36
+  final val AVOIDBOTH = 37
+
+  inline val EXPLICITFIELD = 38  // An explicitly named field, introduce to avoid a clash
+                                 // with a regular field of the underlying name
+
+  def nameTagToString(tag: Int): String = tag match {
+    case UTF8 => "UTF8"
+    case QUALIFIED => "QUALIFIED"
+    case FLATTENED => "FLATTENED"
+    case EXPANDED => "EXPANDED"
+    case EXPANDPREFIX => "EXPANDPREFIX"
+    case TRAITSETTER => "TRAITSETTER"
+    case UNIQUE => "UNIQUE"
+    case DEFAULTGETTER => "DEFAULTGETTER"
+    case OUTERSELECT => "OUTERSELECT"
+
+    case SUPERACCESSOR => "SUPERACCESSOR"
+    case INLINEACCESSOR => "INLINEACCESSOR"
+    case PROTECTEDACCESSOR => "PROTECTEDACCESSOR"
+    case INITIALIZER => "INITIALIZER"
+    case FIELD => "FIELD"
+    case EXTMETH => "EXTMETH"
+    case DIRECT => "DIRECT"
+    case PARAMACC => "PARAMACC"
+    case ADAPTEDCLOSURE => "ADAPTEDCLOSURE"
+    case OBJECTCLASS => "OBJECTCLASS"
+
+    case SIGNED => "SIGNED"
+    case TARGETSIGNED => "TARGETSIGNED"
+  }
+}
diff --git a/tests/pos-with-compiler-cc/dotc/core/NamerOps.scala b/tests/pos-with-compiler-cc/dotc/core/NamerOps.scala
new file mode 100644
index 000000000000..fa0a89349b5e
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/core/NamerOps.scala
@@ -0,0 +1,222 @@
+package dotty.tools
+package dotc
+package core
+
+import Contexts._, Symbols._, Types._, Flags._, Scopes._, Decorators._, Names._, NameOps._
+import SymDenotations.{LazyType, SymDenotation}, StdNames.nme
+import TypeApplications.EtaExpansion
+
+/** Operations that are shared between Namer and TreeUnpickler */
+object NamerOps:
+
+  /** The type of the constructed instance is returned
+   *
+   *  @param ctor the constructor
+   */
+  def effectiveResultType(ctor: Symbol, paramss: List[List[Symbol]])(using Context): Type =
+    paramss match
+      case TypeSymbols(tparams) :: _ => ctor.owner.typeRef.appliedTo(tparams.map(_.typeRef))
+      case _ => ctor.owner.typeRef
+
+  /** If isConstructor, make sure it has at least one non-implicit parameter list
+   *  This is done by adding a () in front of a leading old style implicit parameter,
+   *  or by adding a () as last -- or only -- parameter list if the constructor has
+   *  only using clauses as parameters.
+   */
+  def normalizeIfConstructor(paramss: List[List[Symbol]], isConstructor: Boolean)(using Context): List[List[Symbol]] =
+    if !isConstructor then paramss
+    else paramss match
+      case TypeSymbols(tparams) :: paramss1 => tparams :: normalizeIfConstructor(paramss1, isConstructor)
+      case TermSymbols(vparam :: _) :: _ if vparam.is(Implicit) => Nil :: paramss
+      case _ =>
+        if paramss.forall {
+          case TermSymbols(vparams) => vparams.nonEmpty && vparams.head.is(Given)
+          case _ => true
+        }
+        then paramss :+ Nil
+        else paramss
+
+  /** The method type corresponding to given parameters and result type */
+  def methodType(paramss: List[List[Symbol]], resultType: Type, isJava: Boolean = false)(using Context): Type =
+    def recur(paramss: List[List[Symbol]]): Type = (paramss: @unchecked) match
+      case Nil =>
+        resultType
+      case TermSymbols(params) :: paramss1 =>
+        val (isContextual, isImplicit, isErased) =
+          if params.isEmpty then (false, false, false)
+          else (params.head.is(Given), params.head.is(Implicit), params.head.is(Erased))
+        val make = MethodType.companion(isContextual = isContextual, isImplicit = isImplicit, isErased = isErased)
+        if isJava then
+          for param <- params do
+            if param.info.isDirectRef(defn.ObjectClass) then param.info = defn.AnyType
+        make.fromSymbols(params, recur(paramss1))
+      case TypeSymbols(tparams) :: paramss1 =>
+        PolyType.fromParams(tparams, recur(paramss1))
+
+    if paramss.isEmpty then ExprType(resultType) else recur(paramss)
+  end methodType
+
+  /** Add moduleClass or sourceModule functionality to completer
+   *  for a module or module class
+   */
+  def adjustModuleCompleter(completer: LazyType, name: Name)(using Context): LazyType =
+    val scope = ctx.effectiveScope
+    if name.isTermName then
+      completer.withModuleClass(findModuleBuddy(name.moduleClassName, scope))
+    else
+      completer.withSourceModule(findModuleBuddy(name.sourceModuleName, scope))
+
+  /** Find moduleClass/sourceModule in effective scope */
+  def findModuleBuddy(name: Name, scope: Scope)(using Context) = {
+    val it = scope.lookupAll(name).filter(_.is(Module))
+    if (it.hasNext) it.next()
+    else NoSymbol.assertingErrorsReported(s"no companion $name in $scope")
+  }
+
+  /** If a class has one of these flags, it does not get a constructor companion */
+  private val NoConstructorProxyNeededFlags = Abstract | Trait | Case | Synthetic | Module | Invisible
+
+  /** The flags of a constructor companion */
+  private val ConstructorCompanionFlags = Synthetic | ConstructorProxy
+
+  /** The flags of an `apply` method that serves as a constructor proxy */
+  val ApplyProxyFlags = Synthetic | ConstructorProxy | Inline | Method
+
+  /** If this is a reference to a class and the reference has a stable prefix, the reference
+   *  otherwise NoType
+   */
+  private def underlyingStableClassRef(tp: Type)(using Context): TypeRef | NoType.type = tp match
+    case EtaExpansion(tp1) => underlyingStableClassRef(tp1)
+    case _ => tp.underlyingClassRef(refinementOK = false) match
+      case ref: TypeRef if ref.prefix.isStable => ref
+      case _ => NoType
+
+  /** Does symbol `sym` need constructor proxies to be generated? */
+  def needsConstructorProxies(sym: Symbol)(using Context): Boolean =
+    sym.isClass
+    && !sym.flagsUNSAFE.isOneOf(NoConstructorProxyNeededFlags)
+    && !sym.isAnonymousClass
+    ||
+    sym.isType && sym.is(Exported)
+    && underlyingStableClassRef(sym.info.loBound).exists
+
+  /** The completer of a constructor proxy apply method */
+  class ApplyProxyCompleter(constr: Symbol)(using Context) extends LazyType:
+    def complete(denot: SymDenotation)(using Context): Unit =
+      denot.info = constr.info
+
+  /** Add constructor proxy apply methods to `scope`. Proxies are for constructors
+   *  in `cls` and they reside in `modcls`.
+   */
+  def addConstructorApplies(scope: MutableScope, cls: ClassSymbol, modcls: ClassSymbol)(using Context): scope.type =
+    def proxy(constr: Symbol): Symbol =
+      newSymbol(
+        modcls, nme.apply, ApplyProxyFlags | (constr.flagsUNSAFE & AccessFlags),
+        ApplyProxyCompleter(constr), coord = constr.coord)
+    for dcl <- cls.info.decls do
+      if dcl.isConstructor then scope.enter(proxy(dcl))
+    scope
+  end addConstructorApplies
+
+  /** The completer of a constructor companion for class `cls`, where
+   *  `modul` is the companion symbol and `modcls` is its class.
+   */
+  def constructorCompanionCompleter(cls: ClassSymbol)(
+      modul: TermSymbol, modcls: ClassSymbol)(using Context): LazyType =
+    new LazyType with SymbolLoaders.SecondCompleter {
+      def complete(denot: SymDenotation)(using Context): Unit =
+        val prefix = modcls.owner.thisType
+        denot.info = ClassInfo(
+          prefix, modcls, defn.AnyType :: Nil,
+          addConstructorApplies(newScope, cls, modcls), TermRef(prefix, modul))
+    }.withSourceModule(modul)
+
+  /** A new symbol that is the constructor companion for class `cls` */
+  def classConstructorCompanion(cls: ClassSymbol)(using Context): TermSymbol =
+    val companion = newModuleSymbol(
+        cls.owner, cls.name.toTermName,
+        ConstructorCompanionFlags, ConstructorCompanionFlags,
+        constructorCompanionCompleter(cls),
+        coord = cls.coord,
+        assocFile = cls.assocFile)
+    companion.moduleClass.registerCompanion(cls)
+    cls.registerCompanion(companion.moduleClass)
+    companion
+
+  def typeConstructorCompanion(tsym: Symbol, prefix: Type, proxy: Symbol)(using Context): TermSymbol =
+    newSymbol(tsym.owner, tsym.name.toTermName,
+        ConstructorCompanionFlags | StableRealizable | Method, ExprType(prefix.select(proxy)), coord = tsym.coord)
+
+  /** Add all necesssary constructor proxy symbols for members of class `cls`. This means:
+   *
+   *   - if a member is a class, or type alias, that needs a constructor companion, add one,
+   *     provided no member with the same name exists.
+   *   - if `cls` is a companion object of a class that needs a constructor companion,
+   *     and `cls` does not already define or inherit an `apply` method,
+   *     add `apply` methods for all constructors of the companion class.
+   */
+  def addConstructorProxies(cls: ClassSymbol)(using Context): Unit =
+
+    def memberExists(cls: ClassSymbol, name: TermName): Boolean =
+      cls.baseClasses.exists(_.info.decls.lookupEntry(name) != null)
+
+    for mbr <- cls.info.decls do
+      if needsConstructorProxies(mbr) then
+        mbr match
+          case mbr: ClassSymbol =>
+            if !mbr.unforcedRegisteredCompanion.exists
+              && !memberExists(cls, mbr.name.toTermName)
+            then
+              classConstructorCompanion(mbr).entered
+          case _ =>
+            underlyingStableClassRef(mbr.info.loBound): @unchecked match
+              case ref: TypeRef =>
+                val proxy = ref.symbol.registeredCompanion
+                if proxy.is(ConstructorProxy) && !memberExists(cls, mbr.name.toTermName) then
+                  typeConstructorCompanion(mbr, ref.prefix, proxy).entered
+
+    if cls.is(Module)
+       && needsConstructorProxies(cls.linkedClass)
+       && !memberExists(cls, nme.apply)
+    then
+      addConstructorApplies(cls.info.decls.openForMutations, cls.linkedClass.asClass, cls)
+  end addConstructorProxies
+
+  /** Turn `modul` into a constructor companion for class `cls` */
+  def makeConstructorCompanion(modul: TermSymbol, cls: ClassSymbol)(using Context): Unit =
+    val modcls = modul.moduleClass.asClass
+    modul.setFlag(ConstructorCompanionFlags)
+    modcls.setFlag(ConstructorCompanionFlags)
+    modcls.info = constructorCompanionCompleter(cls)(modul, modcls)
+    cls.registeredCompanion = modcls
+    modcls.registeredCompanion = cls
+
+  /** For secondary constructors, make it known in the context that their type parameters
+   *  are aliases of the class type parameters.
+   *  @return  if `sym` is a secondary constructor, a fresh context that
+   *           contains GADT constraints linking the type parameters.
+   */
+  def linkConstructorParams(sym: Symbol)(using Context): Context =
+    if sym.isConstructor && !sym.isPrimaryConstructor then
+      sym.rawParamss match
+        case (tparams @ (tparam :: _)) :: _ if tparam.isType =>
+          val rhsCtx = ctx.fresh.setFreshGADTBounds
+          linkConstructorParams(sym, tparams, rhsCtx)
+          rhsCtx
+        case _ =>
+          ctx
+    else ctx
+
+  /** For secondary constructor `sym`, make it known in the given context `rhsCtx`
+   *  that their type parameters are aliases of the class type parameters. This is done
+   *  by (ab?)-using GADT constraints. See pos/i941.scala.
+   */
+  def linkConstructorParams(sym: Symbol, tparams: List[Symbol], rhsCtx: Context)(using Context): Unit =
+    rhsCtx.gadt.addToConstraint(tparams)
+    tparams.lazyZip(sym.owner.typeParams).foreach { (psym, tparam) =>
+      val tr = tparam.typeRef
+      rhsCtx.gadt.addBound(psym, tr, isUpper = false)
+      rhsCtx.gadt.addBound(psym, tr, isUpper = true)
+    }
+
+end NamerOps
diff --git a/tests/pos-with-compiler-cc/dotc/core/Names.scala b/tests/pos-with-compiler-cc/dotc/core/Names.scala
new file mode 100644
index 000000000000..3c3c04147de6
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/core/Names.scala
@@ -0,0 +1,692 @@
+package dotty.tools
+package dotc
+package core
+
+import scala.io.Codec
+import util.NameTransformer
+import printing.{Showable, Texts, Printer}
+import Texts.Text
+import StdNames.str
+import config.Config
+import util.{LinearMap, HashSet}
+
+import scala.annotation.internal.sharable
+
+object Names {
+  import NameKinds._
+
+  /** Things that can be turned into names with `totermName` and `toTypeName`
+   *  Decorators defines implements these as extension methods for strings.
+   */
+  type PreName = Name | String
+
+  /** A common superclass of Name and Symbol. After bootstrap, this should be
+   *  just the type alias Name | Symbol
+   */
+  abstract class Designator
+
+  /** A name if either a term name or a type name. Term names can be simple
+   *  or derived. A simple term name is essentially an interned string stored
+   *  in a name table. A derived term name adds a tag, and possibly a number
+   *  or a further simple name to some other name.
+   */
+  abstract class Name extends Designator, Showable, caps.Pure derives CanEqual {
+
+    /** A type for names of the same kind as this name */
+    type ThisName <: Name
+
+    /** Is this name a type name? */
+    def isTypeName: Boolean
+
+    /** Is this name a term name? */
+    def isTermName: Boolean
+
+    /** This name converted to a type name */
+    def toTypeName: TypeName
+
+    /** This name converted to a term name */
+    def toTermName: TermName
+
+    /** This name downcasted to a type name */
+    def asTypeName: TypeName
+
+    /** This name downcasted to a term name */
+    def asTermName: TermName
+
+    /** This name downcasted to a simple term name */
+    def asSimpleName: SimpleName
+
+    /** This name converted to a simple term name */
+    def toSimpleName: SimpleName
+
+    /** This name converted to a simple term name and in addition
+     *  with all symbolic operator characters expanded.
+     */
+    def mangled: ThisName
+
+    /** Convert to string after mangling */
+    def mangledString: String
+
+    /** Apply rewrite rule given by `f` to some part of this name, skipping and rewrapping
+     *  other decorators.
+     *  Stops at DerivedNames with infos of kind QualifiedInfo.
+     *  If `f` does not apply to any part, return name unchanged.
+     */
+    def replace(f: PartialFunction[Name, Name]): ThisName
+
+    /** Same as replace, but does not stop at DerivedNames with infos of kind QualifiedInfo. */
+    def replaceDeep(f: PartialFunction[Name, Name]): ThisName =
+      replace(f.orElse {
+        case DerivedName(underlying, info: QualifiedInfo) =>
+          underlying.replaceDeep(f).derived(info)
+      })
+
+    /** If partial function `f` is defined for some part of this name, apply it
+     *  in a Some, otherwise None.
+     *  Stops at derived names whose kind has `definesNewName = true`.
+     */
+    def collect[T](f: PartialFunction[Name, T]): Option[T]
+
+    /** Apply `f` to last simple term name making up this name */
+    def mapLast(f: SimpleName => SimpleName): ThisName
+
+    /** Apply `f` to all simple term names making up this name */
+    def mapParts(f: SimpleName => SimpleName): ThisName
+
+    /** A name in the same (term or type) namespace as this name and
+     *  with same characters as given `name`.
+     */
+    def likeSpaced(name: Name): ThisName
+
+    /** A derived name consisting of this name and the added info, unless it is
+     *  already present in this name.
+     *  @pre This name does not have a different info of the same kind as `info`.
+     */
+    def derived(info: NameInfo): ThisName
+
+    /** A derived name consisting of this name and the info of `kind` */
+    def derived(kind: ClassifiedNameKind): ThisName = derived(kind.info)
+
+    /** This name without any info of the given `kind`. Excepted, as always,
+     *  is the underlying name part of a qualified name.
+     */
+    def exclude(kind: NameKind): ThisName
+
+    /** Does this name contain an info of the given kind? Excepted, as always,
+     *  is the underlying name part of a qualified name.
+     */
+    def is(kind: NameKind): Boolean
+
+    /** A string showing the internal structure of this name. By contrast, `toString`
+     *  shows the name after conversion to a simple name.
+     */
+    def debugString: String
+
+    /** Convert name to text via `printer`. */
+    def toText(printer: Printer): Text = printer.toText(this)
+
+    /** Replace operator expansions by corresponding operator symbols. */
+    def decode: ThisName
+
+    /** Replace operator symbols by corresponding operator expansions */
+    def encode: ThisName
+
+    /** The first part of this (possible qualified) name */
+    def firstPart: SimpleName
+
+    /** The last part of this (possible qualified) name */
+    def lastPart: SimpleName
+
+    /** Append `other` to the last part of this name */
+    def ++ (other: Name): ThisName = ++ (other.toString)
+    def ++ (other: String): ThisName = mapLast(n => termName(n.toString + other))
+
+    /** Replace all occurrences of `from` to `to` in this name */
+    def replace(from: Char, to: Char): ThisName = mapParts(_.replace(from, to))
+
+    /** Is this name empty? */
+    def isEmpty: Boolean
+
+    /** Does (the first part of) this name starting at index `start` starts with `str`? */
+    def startsWith(str: String, start: Int = 0): Boolean = firstPart.startsWith(str, start)
+
+    /** Does (the last part of) this name end with `str`? */
+    def endsWith(suffix: String): Boolean = lastPart.endsWith(suffix)
+
+    def endsWith(suffix: SimpleName): Boolean = lastPart.endsWith(suffix)
+
+    override def hashCode: Int = System.identityHashCode(this)
+    override def equals(that: Any): Boolean = this eq that.asInstanceOf[AnyRef]
+  }
+
+  /** Names for terms, can be simple or derived */
+  abstract class TermName extends Name {
+    type ThisName = TermName
+
+    override def isTypeName: Boolean = false
+    override def isTermName: Boolean = true
+    override def toTermName: TermName = this
+    override def asTypeName: Nothing = throw new ClassCastException(s"$this is not a type name")
+    override def asTermName: TermName = this
+
+    @sharable // because it is only modified in the synchronized block of toTypeName.
+    private var myTypeName: TypeName | Null = null
+      // Note: no @volatile needed since type names are immutable and therefore safely published
+
+    override def toTypeName: TypeName =
+      if myTypeName == null then
+        synchronized {
+          if myTypeName == null then myTypeName = new TypeName(this)
+        }
+      myTypeName.nn
+
+    override def likeSpaced(name: Name): TermName = name.toTermName
+
+    def info: NameInfo = SimpleNameKind.info
+    def underlying: TermName = unsupported("underlying")
+
+    @sharable // because of synchronized block in `and`
+    private var derivedNames: LinearMap[NameInfo, DerivedName] = LinearMap.empty
+
+    private def add(info: NameInfo): TermName = synchronized {
+      val dnOpt = derivedNames.lookup(info)
+      dnOpt match
+        case null =>
+          val derivedName = new DerivedName(this, info)
+          derivedNames = derivedNames.updated(info, derivedName)
+          derivedName
+        case _ => dnOpt
+    }
+
+    private def rewrap(underlying: TermName) =
+      if (underlying eq this.underlying) this else underlying.add(info)
+
+    override def derived(info: NameInfo): TermName = {
+      val thisKind = this.info.kind
+      val thatKind = info.kind
+      if (thisKind.tag < thatKind.tag || thatKind.definesNewName) add(info)
+      else if (thisKind.tag > thatKind.tag) rewrap(underlying.derived(info))
+      else {
+        assert(info == this.info)
+        this
+      }
+    }
+
+    /** Is it impossible that names of kind `kind` also qualify as names of kind `shadowed`? */
+    private def shadows(kind: NameKind, shadowed: NameKind): Boolean =
+      kind.tag < shadowed.tag ||
+      kind.definesQualifiedName ||
+      kind.definesNewName && !shadowed.definesQualifiedName
+
+    override def exclude(kind: NameKind): TermName = {
+      val thisKind = this.info.kind
+      if (shadows(thisKind, kind)) this
+      else if (thisKind.tag > kind.tag) rewrap(underlying.exclude(kind))
+      else underlying
+    }
+
+    override def is(kind: NameKind): Boolean = {
+      val thisKind = this.info.kind
+      thisKind == kind ||
+      !shadows(thisKind, kind) && underlying.is(kind)
+    }
+
+    @sharable // because it's just a cache for performance
+    private var myMangledString: String | Null = null
+
+    @sharable // because it's just a cache for performance
+    private var myMangled: Name | Null = null
+
+    protected[Names] def mangle: ThisName
+
+    final def mangled: ThisName = {
+      if (myMangled == null) myMangled = mangle
+      myMangled.asInstanceOf[ThisName]
+    }
+
+    final def mangledString: String = {
+      if (myMangledString == null)
+        myMangledString = qualToString(_.mangledString, _.mangled.toString)
+      myMangledString.nn
+    }
+
+    /** If this a qualified name, split it into underlying, last part, and separator
+     *  Otherwise return an empty name, the name itself, and "")
+     */
+    def split: (TermName, TermName, String)
+
+    /** Convert to string as follows. If this is a qualified name
+     *  `<first> <sep> <last>`, the sanitized version of `f1(<first>) <sep> f2(<last>)`.
+     *  Otherwise `f2` applied to this name.
+     */
+    def qualToString(f1: TermName => String, f2: TermName => String): String = {
+      val (first, last, sep) = split
+      if (first.isEmpty) f2(last) else str.sanitize(f1(first) + sep + f2(last))
+    }
+
+    protected def computeToString: String
+
+    @sharable private var myToString: String | Null = null
+
+    override def toString: String =
+      if myToString == null then myToString = computeToString
+      myToString.nn
+
+  }
+
+  /** A simple name is essentially an interned string */
+  final class SimpleName(val start: Int, val length: Int) extends TermName {
+
+  /** The n'th character */
+    def apply(n: Int): Char = chrs(start + n)
+
+    /** A character in this name satisfies predicate `p` */
+    def exists(p: Char => Boolean): Boolean = {
+      var i = 0
+      while (i < length && !p(chrs(start + i))) i += 1
+      i < length
+    }
+
+    /** All characters in this name satisfy predicate `p` */
+    def forall(p: Char => Boolean): Boolean = !exists(!p(_))
+
+    /** The name contains given character `ch` */
+    def contains(ch: Char): Boolean = {
+      var i = 0
+      while (i < length && chrs(start + i) != ch) i += 1
+      i < length
+    }
+
+    /** The index of the last occurrence of `ch` in this name which is at most
+     *  `start`.
+     */
+    def lastIndexOf(ch: Char, start: Int = length - 1): Int = {
+      var i = start
+      while (i >= 0 && apply(i) != ch) i -= 1
+      i
+    }
+
+    /** The index of the last occurrence of `str` in this name */
+    def lastIndexOfSlice(str: String): Int = toString.lastIndexOfSlice(str)
+
+    /** A slice of this name making up the characters between `from` and `until` (exclusive) */
+    def slice(from: Int, end: Int): SimpleName = {
+      assert(0 <= from && from <= end && end <= length)
+      termName(chrs, start + from, end - from)
+    }
+
+    def drop(n: Int): SimpleName = slice(n, length)
+    def take(n: Int): SimpleName = slice(0, n)
+    def dropRight(n: Int): SimpleName = slice(0, length - n)
+    def takeRight(n: Int): SimpleName = slice(length - n, length)
+
+    /** Same as slice, but as a string */
+    def sliceToString(from: Int, end: Int): String =
+      if (end <= from) "" else new String(chrs, start + from, end - from)
+
+    def head: Char = apply(0)
+    def last: Char = apply(length - 1)
+
+    /** Copy character slice (from until end) to character array starting at `dstStart`.
+     *  @pre Destination must have enough space to hold all characters of this name.
+     */
+    def getChars(from: Int, end: Int, dst: Array[Char], dstStart: Int): Unit =
+      assert(0 <= from && from <= end && end <= length)
+      Array.copy(chrs, start + from, dst, dstStart, end - from)
+
+    override def asSimpleName: SimpleName = this
+    override def toSimpleName: SimpleName = this
+    override final def mangle: SimpleName = encode
+
+    override def replace(f: PartialFunction[Name, Name]): ThisName =
+      if (f.isDefinedAt(this)) likeSpaced(f(this)) else this
+    override def collect[T](f: PartialFunction[Name, T]): Option[T] = f.lift(this)
+    override def mapLast(f: SimpleName => SimpleName): SimpleName = f(this)
+    override def mapParts(f: SimpleName => SimpleName): SimpleName = f(this)
+    override def split: (TermName, SimpleName, String) = (EmptyTermName, this, "")
+
+    override def encode: SimpleName = {
+      val dontEncode =
+        this == StdNames.nme.CONSTRUCTOR || this == StdNames.nme.STATIC_CONSTRUCTOR
+      if (dontEncode) this else NameTransformer.encode(this)
+    }
+
+    override def decode: SimpleName = NameTransformer.decode(this)
+
+    override def isEmpty: Boolean = length == 0
+
+    override def startsWith(str: String, start: Int): Boolean = {
+      var i = 0
+      while (i < str.length && start + i < length && apply(start + i) == str(i)) i += 1
+      i == str.length
+    }
+
+    override def endsWith(suffix: String): Boolean =
+      var i = 1
+      while i <= suffix.length && i <= length && apply(length - i) == suffix(suffix.length - i) do i += 1
+      i > suffix.length
+
+    override def endsWith(suffix: SimpleName): Boolean =
+      var i = 1
+      while i <= suffix.length && i <= length && apply(length - i) == suffix(suffix.length - i) do i += 1
+      i > suffix.length
+
+    override def replace(from: Char, to: Char): SimpleName = {
+      val cs = new Array[Char](length)
+      System.arraycopy(chrs, start, cs, 0, length)
+      for (i <- 0 until length)
+        if (cs(i) == from) cs(i) = to
+      termName(cs, 0, length)
+    }
+
+    override def firstPart: SimpleName = this
+    override def lastPart: SimpleName = this
+
+    override def hashCode: Int = start
+
+    protected def computeToString: String =
+      if (length == 0) ""
+      else {
+        if (Config.checkBackendNames)
+          if (!toStringOK) {
+            // We print the stacktrace instead of doing an assert directly,
+            // because asserts are caught in exception handlers which might
+            // cause other failures. In that case the first, important failure
+            // is lost.
+            System.err.nn.println("Backend should not call Name#toString, Name#mangledString should be used instead.")
+            Thread.dumpStack()
+            assert(false)
+          }
+        new String(chrs, start, length)
+      }
+
+    /** It's OK to take a toString if the stacktrace does not contain a method
+     *  from GenBCode or it also contains one of the whitelisted methods below.
+     */
+    private def toStringOK = {
+      val trace: Array[StackTraceElement] = Thread.currentThread.nn.getStackTrace.asInstanceOf[Array[StackTraceElement]]
+      !trace.exists(_.getClassName.nn.endsWith("GenBCode")) ||
+      trace.exists(elem =>
+          List(
+              "mangledString",
+              "toSimpleName",
+              "decode",
+              "unmangle",
+              "dotty$tools$dotc$core$NameOps$NameDecorator$$functionArityFor$extension",
+              "dotty$tools$dotc$typer$Checking$CheckNonCyclicMap$$apply",
+              "$plus$plus",
+              "readConstant",
+              "extractedName")
+            .contains(elem.getMethodName))
+    }
+
+    def debugString: String = toString
+  }
+
+  final class TypeName(val toTermName: TermName) extends Name {
+
+    type ThisName = TypeName
+
+    override def isTypeName: Boolean = true
+    override def isTermName: Boolean = false
+    override def toTypeName: TypeName = this
+    override def asTypeName: TypeName = this
+    override def asTermName: Nothing = throw new ClassCastException(s"$this is not a term name")
+
+    override def asSimpleName: SimpleName = toTermName.asSimpleName
+    override def toSimpleName: SimpleName = toTermName.toSimpleName
+    override def mangled: TypeName = toTermName.mangled.toTypeName
+    override def mangledString: String = toTermName.mangledString
+
+    override def replace(f: PartialFunction[Name, Name]): ThisName = toTermName.replace(f).toTypeName
+    override def collect[T](f: PartialFunction[Name, T]): Option[T] = toTermName.collect(f)
+    override def mapLast(f: SimpleName => SimpleName): TypeName = toTermName.mapLast(f).toTypeName
+    override def mapParts(f: SimpleName => SimpleName): TypeName = toTermName.mapParts(f).toTypeName
+
+    override def likeSpaced(name: Name): TypeName = name.toTypeName
+
+    override def derived(info: NameInfo): TypeName = toTermName.derived(info).toTypeName
+    override def exclude(kind: NameKind): TypeName = toTermName.exclude(kind).toTypeName
+    override def is(kind: NameKind): Boolean = toTermName.is(kind)
+
+    override def isEmpty: Boolean = toTermName.isEmpty
+
+    override def encode: TypeName   = toTermName.encode.toTypeName
+    override def decode: TypeName   = toTermName.decode.toTypeName
+    override def firstPart: SimpleName = toTermName.firstPart
+    override def lastPart: SimpleName = toTermName.lastPart
+
+    override def toString: String = toTermName.toString
+    override def debugString: String = toTermName.debugString + "/T"
+  }
+
+  /** A term name that's derived from an `underlying` name and that
+   *  adds `info` to it.
+   */
+  final case class DerivedName(override val underlying: TermName, override val info: NameInfo)
+  extends TermName {
+
+    override def asSimpleName: Nothing = throw new UnsupportedOperationException(s"$debugString is not a simple name")
+
+    override def toSimpleName: SimpleName = termName(toString)
+    override final def mangle: SimpleName = encode.toSimpleName
+
+    override def replace(f: PartialFunction[Name, Name]): ThisName =
+      if (f.isDefinedAt(this)) likeSpaced(f(this))
+      else info match {
+        case qual: QualifiedInfo => this
+        case _ => underlying.replace(f).derived(info)
+      }
+
+    override def collect[T](f: PartialFunction[Name, T]): Option[T] =
+      if (f.isDefinedAt(this)) Some(f(this))
+      else info match {
+        case qual: QualifiedInfo => None
+        case _ => underlying.collect(f)
+      }
+
+    override def mapLast(f: SimpleName => SimpleName): ThisName =
+      info match {
+        case qual: QualifiedInfo => underlying.derived(qual.map(f))
+        case _ => underlying.mapLast(f).derived(info)
+      }
+
+    override def mapParts(f: SimpleName => SimpleName): ThisName =
+      info match {
+        case qual: QualifiedInfo => underlying.mapParts(f).derived(qual.map(f))
+        case _ => underlying.mapParts(f).derived(info)
+      }
+
+    override def split: (TermName, TermName, String) = info match {
+      case info: QualifiedInfo =>
+        (underlying, info.name, info.kind.asInstanceOf[QualifiedNameKind].separator)
+      case _ =>
+        val (prefix, suffix, separator) = underlying.split
+        (prefix, suffix.derived(info), separator)
+    }
+
+    override def isEmpty: Boolean = false
+    override def encode: ThisName = underlying.encode.derived(info.map(_.encode))
+    override def decode: ThisName = underlying.decode.derived(info.map(_.decode))
+    override def firstPart: SimpleName = underlying.firstPart
+    override def lastPart: SimpleName = info match {
+      case qual: QualifiedInfo => qual.name
+      case _ => underlying.lastPart
+    }
+    protected def computeToString: String = info.mkString(underlying)
+    override def debugString: String = s"${underlying.debugString}[$info]"
+  }
+
+  /** The term name represented by the empty string */
+  val EmptyTermName: SimpleName = SimpleName(-1, 0)
+
+  // Nametable
+
+  inline val InitialNameSize = 0x20000
+
+  /** Memory to store all names sequentially. */
+  @sharable // because it's only mutated in synchronized block of enterIfNew
+  private[dotty] var chrs: Array[Char] = new Array[Char](InitialNameSize)
+
+  /** The number of characters filled. */
+  @sharable // because it's only mutated in synchronized block of enterIfNew
+  private var nc = 0
+
+  /** Make sure the capacity of the character array is at least `n` */
+  private def ensureCapacity(n: Int) =
+    if n > chrs.length then
+      val newchrs = new Array[Char](chrs.length * 2)
+      chrs.copyToArray(newchrs)
+      chrs = newchrs
+
+  private class NameTable extends HashSet[SimpleName](initialCapacity = 0x10000, capacityMultiple = 2):
+    import util.Stats
+
+    override def hash(x: SimpleName) = hashValue(chrs, x.start, x.length) // needed for resize
+    override def isEqual(x: SimpleName, y: SimpleName) = ???              // not needed
+
+    def enterIfNew(cs: Array[Char], offset: Int, len: Int): SimpleName =
+      Stats.record(statsItem("put"))
+      val myTable = currentTable // could be outdated under parallel execution
+      var idx = hashValue(cs, offset, len) & (myTable.length - 1)
+      var name: SimpleName | Null = myTable(idx).asInstanceOf[SimpleName | Null]
+      while name != null do
+        if name.nn.length == len && Names.equals(name.nn.start, cs, offset, len) then
+          return name.nn
+        Stats.record(statsItem("miss"))
+        idx = (idx + 1) & (myTable.length - 1)
+        name = myTable(idx).asInstanceOf[SimpleName | Null]
+      Stats.record(statsItem("addEntryAt"))
+      synchronized {
+        if (myTable eq currentTable) && myTable(idx) == null then
+          // Our previous unsynchronized computation of the next free index is still correct.
+          // This relies on the fact that table entries go from null to non-null, and then
+          // stay the same. Note that we do not need the table or the entry in it to be
+          // volatile since SimpleNames are immutable, and hence safely published.
+          // The same holds for the chrs array. We might miss before the synchronized
+          // on published characters but that would make name comparison false, which
+          // means we end up in the synchronized block here, where we get the correct state.
+          name = SimpleName(nc, len)
+          ensureCapacity(nc + len)
+          Array.copy(cs, offset, chrs, nc, len)
+          nc += len
+          addEntryAt(idx, name.nn)
+        else
+          enterIfNew(cs, offset, len)
+      }
+
+    addEntryAt(0, EmptyTermName: @unchecked)
+  end NameTable
+
+  /** Hashtable for finding term names quickly. */
+  @sharable // because it's only mutated in synchronized block of enterIfNew
+  private val nameTable = NameTable()
+
+  /** The hash of a name made of from characters cs[offset..offset+len-1].  */
+  private def hashValue(cs: Array[Char], offset: Int, len: Int): Int = {
+    var i = offset
+    var hash = 0
+    while (i < len + offset) {
+      hash = 31 * hash + cs(i)
+      i += 1
+    }
+    hash
+  }
+
+  /** Is (the ASCII representation of) name at given index equal to
+   *  cs[offset..offset+len-1]?
+   */
+  private def equals(index: Int, cs: Array[Char], offset: Int, len: Int): Boolean = {
+    var i = 0
+    while ((i < len) && (chrs(index + i) == cs(offset + i)))
+      i += 1
+    i == len
+  }
+
+  /** Create a term name from the characters in cs[offset..offset+len-1].
+   *  Assume they are already encoded.
+   */
+  def termName(cs: Array[Char], offset: Int, len: Int): SimpleName =
+    nameTable.enterIfNew(cs, offset, len)
+
+  /** Create a type name from the characters in cs[offset..offset+len-1].
+   *  Assume they are already encoded.
+   */
+  def typeName(cs: Array[Char], offset: Int, len: Int): TypeName =
+    termName(cs, offset, len).toTypeName
+
+  /** Create a term name from the UTF8 encoded bytes in bs[offset..offset+len-1].
+   *  Assume they are already encoded.
+   */
+  def termName(bs: Array[Byte], offset: Int, len: Int): SimpleName = {
+    val chars = Codec.fromUTF8(bs, offset, len)
+    termName(chars, 0, chars.length)
+  }
+
+  /** Create a type name from the UTF8 encoded bytes in bs[offset..offset+len-1].
+   *  Assume they are already encoded.
+   */
+  def typeName(bs: Array[Byte], offset: Int, len: Int): TypeName =
+    termName(bs, offset, len).toTypeName
+
+  /** Create a term name from a string.
+   *  See `sliceToTermName` in `Decorators` for a more efficient version
+   *  which however requires a Context for its operation.
+   */
+  def termName(s: String): SimpleName = termName(s.toCharArray.nn, 0, s.length)
+
+  /** Create a type name from a string */
+  def typeName(s: String): TypeName = typeName(s.toCharArray.nn, 0, s.length)
+
+  /** The type name represented by the empty string */
+  val EmptyTypeName: TypeName = EmptyTermName.toTypeName
+
+  implicit val NameOrdering: Ordering[Name] = new Ordering[Name] {
+    private def compareInfos(x: NameInfo, y: NameInfo): Int =
+      if (x.kind.tag != y.kind.tag) x.kind.tag - y.kind.tag
+      else x match {
+        case x: QualifiedInfo =>
+          y match {
+            case y: QualifiedInfo =>
+              compareSimpleNames(x.name, y.name)
+          }
+        case x: NumberedInfo =>
+          y match {
+            case y: NumberedInfo =>
+              x.num - y.num
+          }
+        case _ =>
+          assert(x == y)
+          0
+      }
+    private def compareSimpleNames(x: SimpleName, y: SimpleName): Int = {
+      val until = x.length min y.length
+      var i = 0
+      while (i < until && x(i) == y(i)) i = i + 1
+      if (i < until)
+        if (x(i) < y(i)) -1
+        else /*(x(i) > y(i))*/ 1
+      else
+        x.length - y.length
+    }
+    private def compareTermNames(x: TermName, y: TermName): Int = x match {
+      case x: SimpleName =>
+        y match {
+          case y: SimpleName => compareSimpleNames(x, y)
+          case _ => -1
+        }
+      case DerivedName(xPre, xInfo) =>
+        y match {
+          case DerivedName(yPre, yInfo) =>
+            val s = compareInfos(xInfo, yInfo)
+            if (s == 0) compareTermNames(xPre, yPre) else s
+          case _ => 1
+        }
+    }
+    def compare(x: Name, y: Name): Int =
+      if (x.isTermName && y.isTypeName) 1
+      else if (x.isTypeName && y.isTermName) -1
+      else if (x eq y) 0
+      else compareTermNames(x.toTermName, y.toTermName)
+  }
+}
diff --git a/tests/pos-with-compiler-cc/dotc/core/NullOpsDecorator.scala b/tests/pos-with-compiler-cc/dotc/core/NullOpsDecorator.scala
new file mode 100644
index 000000000000..e18271772ff1
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/core/NullOpsDecorator.scala
@@ -0,0 +1,60 @@
+package dotty.tools.dotc
+package core
+
+import Contexts._
+import Types._
+
+/** Defines operations on nullable types and tree. */
+object NullOpsDecorator:
+
+  extension (self: Type)
+    /** Syntactically strips the nullability from this type.
+     *  If the type is `T1 | ... | Tn`, and `Ti` references to `Null`,
+     *  then return `T1 | ... | Ti-1 | Ti+1 | ... | Tn`.
+     *  If this type isn't (syntactically) nullable, then returns the type unchanged.
+     *  The type will not be changed if explicit-nulls is not enabled.
+     */
+    def stripNull(using Context): Type = {
+      def strip(tp: Type): Type =
+        val tpWiden = tp.widenDealias
+        val tpStripped = tpWiden match {
+          case tp @ OrType(lhs, rhs) =>
+            val llhs = strip(lhs)
+            val rrhs = strip(rhs)
+            if rrhs.isNullType then llhs
+            else if llhs.isNullType then rrhs
+            else tp.derivedOrType(llhs, rrhs)
+          case tp @ AndType(tp1, tp2) =>
+            // We cannot `tp.derivedAndType(strip(tp1), strip(tp2))` directly,
+            // since `stripNull((A | Null) & B)` would produce the wrong
+            // result `(A & B) | Null`.
+            val tp1s = strip(tp1)
+            val tp2s = strip(tp2)
+            if (tp1s ne tp1) && (tp2s ne tp2) then
+              tp.derivedAndType(tp1s, tp2s)
+            else tp
+          case tp @ TypeBounds(lo, hi) =>
+            tp.derivedTypeBounds(strip(lo), strip(hi))
+          case tp => tp
+        }
+        if tpStripped ne tpWiden then tpStripped else tp
+
+      if ctx.explicitNulls then strip(self) else self
+    }
+
+    /** Is self (after widening and dealiasing) a type of the form `T | Null`? */
+    def isNullableUnion(using Context): Boolean = {
+      val stripped = self.stripNull
+      stripped ne self
+    }
+  end extension
+
+  import ast.tpd._
+
+  extension (self: Tree)
+    // cast the type of the tree to a non-nullable type
+    def castToNonNullable(using Context): Tree = self.typeOpt match {
+      case OrNull(tp) => self.cast(tp)
+      case _ => self
+    }
+end NullOpsDecorator
diff --git a/tests/pos-with-compiler-cc/dotc/core/OrderingConstraint.scala b/tests/pos-with-compiler-cc/dotc/core/OrderingConstraint.scala
new file mode 100644
index 000000000000..961d106a14c8
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/core/OrderingConstraint.scala
@@ -0,0 +1,676 @@
+package dotty.tools
+package dotc
+package core
+
+import Types._, Contexts._, Symbols._, Decorators._, TypeApplications._
+import util.{SimpleIdentitySet, SimpleIdentityMap}
+import collection.mutable
+import printing.Printer
+import printing.Texts._
+import config.Config
+import config.Printers.constr
+import reflect.ClassTag
+import annotation.tailrec
+import annotation.internal.sharable
+import cc.{CapturingType, derivedCapturingType}
+import caps.unsafe.unsafeUnbox
+
+object OrderingConstraint {
+
+  type ArrayValuedMap[T] = SimpleIdentityMap[TypeLambda, Array[T]]
+
+  /** The type of `OrderingConstraint#boundsMap` */
+  type ParamBounds = ArrayValuedMap[Type]
+
+  /** The type of `OrderingConstraint#lowerMap`, `OrderingConstraint#upperMap` */
+  type ParamOrdering = ArrayValuedMap[List[TypeParamRef]]
+
+  /** A new constraint with given maps and given set of hard typevars */
+  private def newConstraint(
+      boundsMap: ParamBounds, lowerMap: ParamOrdering, upperMap: ParamOrdering,
+      hardVars: TypeVars)(using Context) : OrderingConstraint =
+    if boundsMap.isEmpty && lowerMap.isEmpty && upperMap.isEmpty then
+      empty
+    else
+      val result = new OrderingConstraint(boundsMap, lowerMap, upperMap, hardVars)
+      if ctx.run != null then ctx.run.nn.recordConstraintSize(result, result.boundsMap.size)
+      result
+
+  /** A lens for updating a single entry array in one of the three constraint maps */
+  abstract class ConstraintLens[T <: AnyRef: ClassTag] {
+    def entries(c: OrderingConstraint, poly: TypeLambda): Array[T] | Null
+    def updateEntries(c: OrderingConstraint, poly: TypeLambda, entries: Array[T])(using Context): OrderingConstraint
+    def initial: T
+
+    def apply(c: OrderingConstraint, poly: TypeLambda, idx: Int): T = {
+      val es = entries(c, poly)
+      if (es == null) initial else es(idx)
+    }
+
+    /** The `current` constraint but with the entry for `param` updated to `entry`.
+     *  `current` is used linearly. If it is different from `prev` it is
+     *  known to be dead after the call. Hence it is OK to update destructively
+     *  parts of `current` which are not shared by `prev`.
+     */
+    def update(prev: OrderingConstraint, current: OrderingConstraint,
+        poly: TypeLambda, idx: Int, entry: T)(using Context): OrderingConstraint = {
+      var es = entries(current, poly)
+      // TODO: investigate why flow typing is not working on `es`
+      if (es != null && (es.nn(idx) eq entry)) current
+      else {
+        val result =
+          if (es == null) {
+            es = Array.fill(poly.paramNames.length)(initial)
+            updateEntries(current, poly, es.nn)
+          }
+          else {
+            val prev_es = entries(prev, poly)
+            if (prev_es == null || (es.nn ne prev_es.nn))
+              current // can re-use existing entries array.
+            else {
+              es = es.nn.clone
+              updateEntries(current, poly, es.nn)
+            }
+          }
+        es.nn(idx) = entry
+        result
+      }
+    }
+
+    def update(prev: OrderingConstraint, current: OrderingConstraint,
+        param: TypeParamRef, entry: T)(using Context): OrderingConstraint =
+      update(prev, current, param.binder, param.paramNum, entry)
+
+    def map(prev: OrderingConstraint, current: OrderingConstraint,
+        poly: TypeLambda, idx: Int, f: T => T)(using Context): OrderingConstraint =
+     update(prev, current, poly, idx, f(apply(current, poly, idx)))
+
+    def map(prev: OrderingConstraint, current: OrderingConstraint,
+        param: TypeParamRef, f: T => T)(using Context): OrderingConstraint =
+      map(prev, current, param.binder, param.paramNum, f)
+  }
+
+  val boundsLens: ConstraintLens[Type] = new ConstraintLens[Type] {
+    def entries(c: OrderingConstraint, poly: TypeLambda): Array[Type] | Null =
+      c.boundsMap(poly)
+    def updateEntries(c: OrderingConstraint, poly: TypeLambda, entries: Array[Type])(using Context): OrderingConstraint =
+      newConstraint(c.boundsMap.updated(poly, entries), c.lowerMap, c.upperMap, c.hardVars)
+    def initial = NoType
+  }
+
+  val lowerLens: ConstraintLens[List[TypeParamRef]] = new ConstraintLens[List[TypeParamRef]] {
+    def entries(c: OrderingConstraint, poly: TypeLambda): Array[List[TypeParamRef]] | Null =
+      c.lowerMap(poly)
+    def updateEntries(c: OrderingConstraint, poly: TypeLambda, entries: Array[List[TypeParamRef]])(using Context): OrderingConstraint =
+      newConstraint(c.boundsMap, c.lowerMap.updated(poly, entries), c.upperMap, c.hardVars)
+    def initial = Nil
+  }
+
+  val upperLens: ConstraintLens[List[TypeParamRef]] = new ConstraintLens[List[TypeParamRef]] {
+    def entries(c: OrderingConstraint, poly: TypeLambda): Array[List[TypeParamRef]] | Null =
+      c.upperMap(poly)
+    def updateEntries(c: OrderingConstraint, poly: TypeLambda, entries: Array[List[TypeParamRef]])(using Context): OrderingConstraint =
+      newConstraint(c.boundsMap, c.lowerMap, c.upperMap.updated(poly, entries), c.hardVars)
+    def initial = Nil
+  }
+
+  @sharable
+  val empty = new OrderingConstraint(SimpleIdentityMap.empty, SimpleIdentityMap.empty, SimpleIdentityMap.empty, SimpleIdentitySet.empty)
+}
+
+import OrderingConstraint._
+
+/** Constraint over undetermined type parameters that keeps separate maps to
+ *  reflect parameter orderings.
+ *  @param boundsMap a map from TypeLambda to arrays.
+ *               Each array contains twice the number of entries as there a type parameters
+ *               in the TypeLambda. The first half of the array contains the type bounds that constrain the
+ *               lambda's type parameters. The second half might contain type variables that
+ *               track the corresponding parameters, or is left empty (filled with nulls).
+ *               An instantiated type parameter is represented by having its instance type in
+ *               the corresponding array entry. The dual use of arrays for poly params
+ *               and typevars is to save space and hopefully gain some speed.
+ *
+ *  @param lowerMap a map from TypeLambdas to arrays. Each array entry corresponds
+ *               to a parameter P of the type lambda; it contains all constrained parameters
+ *               Q that are known to be smaller than P, i.e. Q <: P.
+ *  @param upperMap a map from TypeLambdas to arrays. Each array entry corresponds
+ *               to a parameter P of the type lambda; it contains all constrained parameters
+ *               Q that are known to be greater than P, i.e. P <: Q.
+ *  @param hardVars a set of type variables that are marked as hard and therefore will not
+ *               undergo a `widenUnion` when instantiated to their lower bound.
+ */
+class OrderingConstraint(private val boundsMap: ParamBounds,
+                         private val lowerMap : ParamOrdering,
+                         private val upperMap : ParamOrdering,
+                         private val hardVars : TypeVars) extends Constraint {
+
+  import UnificationDirection.*
+
+  type This = OrderingConstraint
+
+// ----------- Basic indices --------------------------------------------------
+
+  /** The number of type parameters in the given entry array */
+  private def paramCount(entries: Array[Type]) = entries.length >> 1
+
+  /** The type variable corresponding to parameter numbered `n`, null if none was created */
+  private def typeVar(entries: Array[Type], n: Int): Type | Null =
+    entries(paramCount(entries) + n)
+
+  /** The `boundsMap` entry corresponding to `param` */
+  def entry(param: TypeParamRef): Type = {
+    val entries = boundsMap(param.binder)
+    if (entries == null) NoType
+    else entries(param.paramNum)
+  }
+
+// ----------- Contains tests --------------------------------------------------
+
+  def contains(pt: TypeLambda): Boolean = boundsMap(pt) != null
+
+  def contains(param: TypeParamRef): Boolean = {
+    val entries = boundsMap(param.binder)
+    entries != null && isBounds(entries(param.paramNum))
+  }
+
+  def contains(tvar: TypeVar): Boolean = {
+    val origin = tvar.origin
+    val entries = boundsMap(origin.binder)
+    val pnum = origin.paramNum
+    entries != null && isBounds(entries(pnum)) && (typeVar(entries, pnum) eq tvar)
+  }
+
+// ---------- Dependency handling ----------------------------------------------
+
+  def lower(param: TypeParamRef): List[TypeParamRef] = lowerLens(this, param.binder, param.paramNum)
+  def upper(param: TypeParamRef): List[TypeParamRef] = upperLens(this, param.binder, param.paramNum)
+
+  def minLower(param: TypeParamRef): List[TypeParamRef] = {
+    val all = lower(param)
+    all.filterNot(p => all.exists(isLess(p, _)))
+  }
+
+  def minUpper(param: TypeParamRef): List[TypeParamRef] = {
+    val all = upper(param)
+    all.filterNot(p => all.exists(isLess(_, p)))
+  }
+
+  def exclusiveLower(param: TypeParamRef, butNot: TypeParamRef): List[TypeParamRef] =
+    lower(param).filterNot(isLess(_, butNot))
+
+  def exclusiveUpper(param: TypeParamRef, butNot: TypeParamRef): List[TypeParamRef] =
+    upper(param).filterNot(isLess(butNot, _))
+
+// ---------- Info related to TypeParamRefs -------------------------------------------
+
+  def isLess(param1: TypeParamRef, param2: TypeParamRef): Boolean =
+    upper(param1).contains(param2)
+
+  def nonParamBounds(param: TypeParamRef)(using Context): TypeBounds =
+    entry(param).bounds
+
+  def typeVarOfParam(param: TypeParamRef): Type =
+    val entries = boundsMap(param.binder)
+    if entries == null then NoType
+    else
+      val tvar = typeVar(entries, param.paramNum)
+      if tvar == null then NoType
+      else tvar
+
+// ---------- Adding TypeLambdas --------------------------------------------------
+
+  /** The bound type `tp` without constrained parameters which are clearly
+   *  dependent. A parameter in an upper bound is clearly dependent if it appears
+   *  in a hole of a context H given by:
+   *
+   *      H = []
+   *          H & T
+   *          T & H
+   *
+   *  (the idea is that a parameter P in a H context is guaranteed to be a supertype of the
+   *   bounded parameter.)
+   *  Analogously, a parameter in a lower bound is clearly dependent if it appears
+   *  in a hole of a context H given by:
+   *
+   *      L = []
+   *          L | T
+   *          T | L
+   *
+   *  "Clearly dependent" is not synonymous with "dependent" in the sense
+   *  it is defined in `dependentParams`. Dependent parameters are handled
+   *  in `updateEntry`. The idea of stripping off clearly dependent parameters
+   *  and to handle them separately is for efficiency, so that type expressions
+   *  used as bounds become smaller.
+   *
+   *  TODO: try to do without stripping? It would mean it is more efficient
+   *  to pull out full bounds from a constraint.
+   *
+   *  @param isUpper   If true, `bound` is an upper bound, else a lower bound.
+   */
+  private def stripParams(
+      tp: Type,
+      todos: mutable.ListBuffer[(OrderingConstraint, TypeParamRef) => OrderingConstraint],
+      isUpper: Boolean)(using Context): Type = tp match {
+    case param: TypeParamRef if contains(param) =>
+      todos += (if isUpper then order(_, _, param) else order(_, param, _))
+      NoType
+    case tp: TypeBounds =>
+      val lo1 = stripParams(tp.lo, todos, !isUpper).orElse(defn.NothingType)
+      val hi1 = stripParams(tp.hi, todos, isUpper).orElse(tp.topType)
+      tp.derivedTypeBounds(lo1, hi1)
+    case tp: AndType if isUpper =>
+      val tp1 = stripParams(tp.tp1, todos, isUpper)
+      val tp2 = stripParams(tp.tp2, todos, isUpper)
+      if (tp1.exists)
+        if (tp2.exists) tp.derivedAndType(tp1, tp2)
+        else tp1
+      else tp2
+    case tp: OrType if !isUpper =>
+      val tp1 = stripParams(tp.tp1, todos, isUpper)
+      val tp2 = stripParams(tp.tp2, todos, isUpper)
+      if (tp1.exists)
+        if (tp2.exists) tp.derivedOrType(tp1, tp2)
+        else tp1
+      else tp2
+    case _ =>
+      tp
+  }
+
+  def add(poly: TypeLambda, tvars: List[TypeVar])(using Context): This = {
+    assert(!contains(poly))
+    val nparams = poly.paramNames.length
+    val entries1 = new Array[Type](nparams * 2)
+    poly.paramInfos.copyToArray(entries1, 0)
+    tvars.copyToArray(entries1, nparams)
+    newConstraint(boundsMap.updated(poly, entries1), lowerMap, upperMap, hardVars).init(poly)
+  }
+
+  /** Split dependent parameters off the bounds for parameters in `poly`.
+   *  Update all bounds to be normalized and update ordering to account for
+   *  dependent parameters.
+   */
+  private def init(poly: TypeLambda)(using Context): This = {
+    var current = this
+    val todos = new mutable.ListBuffer[(OrderingConstraint, TypeParamRef) => OrderingConstraint]
+    var i = 0
+    val dropWildcards = AvoidWildcardsMap()
+    while (i < poly.paramNames.length) {
+      val param = poly.paramRefs(i)
+      val bounds = dropWildcards(nonParamBounds(param))
+      val stripped = stripParams(bounds, todos, isUpper = true)
+      current = updateEntry(current, param, stripped)
+      while todos.nonEmpty do
+        current = todos.head.unsafeUnbox(current, param)
+        todos.dropInPlace(1)
+      i += 1
+    }
+    current.checkNonCyclic()
+  }
+
+// ---------- Updates ------------------------------------------------------------
+
+  /** If `inst` is a TypeBounds, make sure it does not contain toplevel
+   *  references to `param` (see `Constraint#occursAtToplevel` for a definition
+   *  of "toplevel").
+   *  Any such references are replaced by `Nothing` in the lower bound and `Any`
+   *  in the upper bound.
+   *  References can be direct or indirect through instantiations of other
+   *  parameters in the constraint.
+   */
+  private def ensureNonCyclic(param: TypeParamRef, inst: Type)(using Context): Type =
+
+    def recur(tp: Type, fromBelow: Boolean): Type = tp match
+      case tp: AndOrType =>
+        val r1 = recur(tp.tp1, fromBelow)
+        val r2 = recur(tp.tp2, fromBelow)
+        if (r1 eq tp.tp1) && (r2 eq tp.tp2) then tp
+        else tp.match
+          case tp: OrType =>
+            TypeComparer.lub(r1, r2, isSoft = tp.isSoft)
+          case _ =>
+            r1 & r2
+      case tp: TypeParamRef =>
+        if tp eq param then
+          if fromBelow then defn.NothingType else defn.AnyType
+        else entry(tp) match
+          case NoType => tp
+          case TypeBounds(lo, hi) => if lo eq hi then recur(lo, fromBelow) else tp
+          case inst => recur(inst, fromBelow)
+      case tp: TypeVar =>
+        val underlying1 = recur(tp.underlying, fromBelow)
+        if underlying1 ne tp.underlying then underlying1 else tp
+      case CapturingType(parent, refs) =>
+        val parent1 = recur(parent, fromBelow)
+        if parent1 ne parent then tp.derivedCapturingType(parent1, refs) else tp
+      case tp: AnnotatedType =>
+        val parent1 = recur(tp.parent, fromBelow)
+        if parent1 ne tp.parent then tp.derivedAnnotatedType(parent1, tp.annot) else tp
+      case _ =>
+        val tp1 = tp.dealiasKeepAnnots
+        if tp1 ne tp then
+          val tp2 = recur(tp1, fromBelow)
+          if tp2 ne tp1 then tp2 else tp
+        else tp
+
+    inst match
+      case bounds: TypeBounds =>
+        bounds.derivedTypeBounds(
+          recur(bounds.lo, fromBelow = true),
+          recur(bounds.hi, fromBelow = false))
+      case _ =>
+        inst
+  end ensureNonCyclic
+
+  /** Add the fact `param1 <: param2` to the constraint `current` and propagate
+   *  `<:<` relationships between parameters ("edges") but not bounds.
+   */
+  def order(current: This, param1: TypeParamRef, param2: TypeParamRef, direction: UnificationDirection = NoUnification)(using Context): This =
+    // /!\ Careful here: we're adding constraints on `current`, not `this`, so
+    // think twice when using an instance method! We only need to pass `this` as
+    // the `prev` argument in methods on `ConstraintLens`.
+    // TODO: Refactor this code to take `prev` as a parameter and add
+    // constraints on `this` instead?
+    if param1 == param2 || current.isLess(param1, param2) then current
+    else
+      assert(current.contains(param1), i"$param1")
+      assert(current.contains(param2), i"$param2")
+      val unifying = direction != NoUnification
+      val newUpper = {
+        val up = current.exclusiveUpper(param2, param1)
+        if unifying then
+          // Since param2 <:< param1 already holds now, filter out param1 to avoid adding
+          //   duplicated orderings.
+          val filtered = up.filterNot(_ eq param1)
+          // Only add bounds for param2 if it will be kept in the constraint after unification.
+          if direction == KeepParam2 then
+            param2 :: filtered
+          else
+            filtered
+        else
+          param2 :: up
+      }
+      val newLower = {
+        val lower = current.exclusiveLower(param1, param2)
+        if unifying then
+          // Similarly, filter out param2 from lowerly-ordered parameters
+          //   to avoid duplicated orderings.
+          val filtered = lower.filterNot(_ eq param2)
+          // Only add bounds for param1 if it will be kept in the constraint after unification.
+          if direction == KeepParam1 then
+            param1 :: filtered
+          else
+            filtered
+        else
+          param1 :: lower
+      }
+      val current1 = newLower.foldLeft(current)(upperLens.map(this, _, _, newUpper ::: _))
+      val current2 = newUpper.foldLeft(current1)(lowerLens.map(this, _, _, newLower ::: _))
+      current2
+    end if
+  end order
+
+  /** The list of parameters P such that, for a fresh type parameter Q:
+   *
+   *    Q <: tp  implies  Q <: P      and isUpper = true, or
+   *    tp <: Q  implies  P <: Q      and isUpper = false
+   */
+  private def dependentParams(tp: Type, isUpper: Boolean)(using Context): List[TypeParamRef] = tp match
+    case param: TypeParamRef if contains(param) =>
+      param :: (if (isUpper) upper(param) else lower(param))
+    case tp: AndType if isUpper  =>
+      dependentParams(tp.tp1, isUpper) | (dependentParams(tp.tp2, isUpper))
+    case tp: OrType if !isUpper =>
+      dependentParams(tp.tp1, isUpper).intersect(dependentParams(tp.tp2, isUpper))
+    case EtaExpansion(tycon) =>
+      dependentParams(tycon, isUpper)
+    case _ =>
+      Nil
+
+  private def updateEntry(current: This, param: TypeParamRef, tp: Type)(using Context): This = {
+    if Config.checkNoWildcardsInConstraint then assert(!tp.containsWildcardTypes)
+    var current1 = boundsLens.update(this, current, param, tp)
+    tp match {
+      case TypeBounds(lo, hi) =>
+        for p <- dependentParams(lo, isUpper = false) do
+          current1 = order(current1, p, param)
+        for p <- dependentParams(hi, isUpper = true) do
+          current1 = order(current1, param, p)
+      case _ =>
+    }
+    current1
+  }
+
+  /** The public version of `updateEntry`. Guarantees that there are no cycles */
+  def updateEntry(param: TypeParamRef, tp: Type)(using Context): This =
+    updateEntry(this, param, ensureNonCyclic(param, tp)).checkNonCyclic()
+
+  def addLess(param1: TypeParamRef, param2: TypeParamRef, direction: UnificationDirection)(using Context): This =
+    order(this, param1, param2, direction).checkNonCyclic()
+
+// ---------- Replacements and Removals -------------------------------------
+
+  /** A new constraint which is derived from this constraint by removing
+   *  the type parameter `param` from the domain and replacing all top-level occurrences
+   *  of the parameter elsewhere in the constraint by type `tp`.
+   */
+  def replace(param: TypeParamRef, tp: Type)(using Context): OrderingConstraint =
+    val replacement = tp.dealiasKeepAnnots.stripTypeVar
+    if param == replacement then this.checkNonCyclic()
+    else
+      assert(replacement.isValueTypeOrLambda)
+      var current =
+        if isRemovable(param.binder) then remove(param.binder)
+        else updateEntry(this, param, replacement)
+
+      def removeParam(ps: List[TypeParamRef]) = ps.filterConserve(param ne _)
+
+      def replaceParam(tp: Type, atPoly: TypeLambda, atIdx: Int): Type =
+        current.ensureNonCyclic(atPoly.paramRefs(atIdx), tp.substParam(param, replacement))
+
+      current.foreachParam { (p, i) =>
+        current = boundsLens.map(this, current, p, i, replaceParam(_, p, i))
+        current = lowerLens.map(this, current, p, i, removeParam)
+        current = upperLens.map(this, current, p, i, removeParam)
+      }
+      current.checkNonCyclic()
+  end replace
+
+  def remove(pt: TypeLambda)(using Context): This = {
+    def removeFromOrdering(po: ParamOrdering) = {
+      def removeFromBoundss(key: TypeLambda, bndss: Array[List[TypeParamRef]]): Array[List[TypeParamRef]] = {
+        val bndss1 = bndss.map(_.filterConserve(_.binder ne pt))
+        if (bndss.corresponds(bndss1)(_ eq _)) bndss else bndss1
+      }
+      po.remove(pt).mapValuesNow(removeFromBoundss)
+    }
+    val hardVars1 = pt.paramRefs.foldLeft(hardVars)((hvs, param) => hvs - typeVarOfParam(param))
+    newConstraint(boundsMap.remove(pt), removeFromOrdering(lowerMap), removeFromOrdering(upperMap), hardVars1)
+      .checkNonCyclic()
+  }
+
+  def isRemovable(pt: TypeLambda): Boolean = {
+    val entries = boundsMap(pt).nn
+    @tailrec def allRemovable(last: Int): Boolean =
+      if (last < 0) true
+      else typeVar(entries, last) match {
+        case tv: TypeVar => tv.inst.exists && allRemovable(last - 1)
+        case _ => false
+      }
+    allRemovable(paramCount(entries) - 1)
+  }
+
+// ----------- Joins -----------------------------------------------------
+
+  def hasConflictingTypeVarsFor(tl: TypeLambda, that: Constraint): Boolean =
+    contains(tl) && that.contains(tl) &&
+    // Since TypeVars are allocated in bulk for each type lambda, we only have
+    // to check the first one to find out if some of them are different.
+    (this.typeVarOfParam(tl.paramRefs(0)) ne that.typeVarOfParam(tl.paramRefs(0)))
+
+  def subst(from: TypeLambda, to: TypeLambda)(using Context): OrderingConstraint =
+    def swapKey[T](m: ArrayValuedMap[T]) =
+      val info = m(from)
+      if info == null then m else m.remove(from).updated(to, info)
+    var current = newConstraint(swapKey(boundsMap), swapKey(lowerMap), swapKey(upperMap), hardVars)
+    def subst[T <: Type](x: T): T = x.subst(from, to).asInstanceOf[T]
+    current.foreachParam {(p, i) =>
+      current = boundsLens.map(this, current, p, i, subst)
+      current = lowerLens.map(this, current, p, i, _.map(subst))
+      current = upperLens.map(this, current, p, i, _.map(subst))
+    }
+    constr.println(i"renamed $this to $current")
+    current.checkNonCyclic()
+
+  def isHard(tv: TypeVar) = hardVars.contains(tv)
+
+  def withHard(tv: TypeVar)(using Context) =
+    newConstraint(boundsMap, lowerMap, upperMap, hardVars + tv)
+
+  def instType(tvar: TypeVar): Type = entry(tvar.origin) match
+    case _: TypeBounds => NoType
+    case tp: TypeParamRef => typeVarOfParam(tp).orElse(tp)
+    case tp => tp
+
+  def ensureFresh(tl: TypeLambda)(using Context): TypeLambda =
+    if (contains(tl)) {
+      var paramInfos = tl.paramInfos
+      if (tl.isInstanceOf[HKLambda]) {
+        // HKLambdas are hash-consed, need to create an artificial difference by adding
+        // a LazyRef to a bound.
+        val TypeBounds(lo, hi) :: pinfos1 = tl.paramInfos: @unchecked
+        paramInfos = TypeBounds(lo, LazyRef.of(hi)) :: pinfos1
+      }
+      ensureFresh(tl.newLikeThis(tl.paramNames, paramInfos, tl.resultType))
+    }
+    else tl
+
+  def checkConsistentVars()(using Context): Unit =
+    for param <- domainParams do
+      typeVarOfParam(param) match
+        case tvar: TypeVar =>
+          assert(tvar.origin == param, i"mismatch $tvar, $param")
+        case _ =>
+
+// ---------- Exploration --------------------------------------------------------
+
+  def domainLambdas: List[TypeLambda] = boundsMap.keys
+
+  def domainParams: List[TypeParamRef] =
+    for {
+      (poly, entries) <- boundsMap.toList
+      n <- 0 until paramCount(entries)
+      if entries(n).exists
+    }
+    yield poly.paramRefs(n)
+
+  def forallParams(p: TypeParamRef => Boolean): Boolean =
+    boundsMap.forallBinding { (poly, entries) =>
+      !0.until(paramCount(entries)).exists(i => isBounds(entries(i)) && !p(poly.paramRefs(i)))
+    }
+
+  def foreachParam(p: (TypeLambda, Int) => Unit): Unit =
+    boundsMap.foreachBinding { (poly, entries) =>
+      0.until(poly.paramNames.length).foreach(p(poly, _))
+    }
+
+  def foreachTypeVar(op: TypeVar => Unit): Unit =
+    boundsMap.foreachBinding { (poly, entries) =>
+      var i = 0
+      val limit = paramCount(entries)
+      while i < limit do
+        typeVar(entries, i) match
+          case tv: TypeVar if !tv.inst.exists => op(tv)
+          case _ =>
+        i += 1
+    }
+
+  private var myUninstVars: mutable.ArrayBuffer[TypeVar] | Null = _
+
+  /** The uninstantiated typevars of this constraint */
+  def uninstVars: collection.Seq[TypeVar] = {
+    if (myUninstVars == null || myUninstVars.uncheckedNN.exists(_.inst.exists)) {
+      myUninstVars = new mutable.ArrayBuffer[TypeVar]
+      boundsMap.foreachBinding { (poly, entries) =>
+        for (i <- 0 until paramCount(entries))
+          typeVar(entries, i) match {
+            case tv: TypeVar if !tv.inst.exists && isBounds(entries(i)) => myUninstVars.uncheckedNN += tv
+            case _ =>
+          }
+      }
+    }
+    myUninstVars.uncheckedNN
+  }
+
+// ---------- Checking -----------------------------------------------
+
+  def checkNonCyclic()(using Context): this.type =
+    if Config.checkConstraintsNonCyclic then
+      domainParams.foreach { param =>
+        val inst = entry(param)
+        assert(!isLess(param, param),
+          s"cyclic ordering involving $param in ${this.show}, upper = $inst")
+        assert(!occursAtToplevel(param, inst),
+          s"cyclic bound for $param: ${inst.show} in ${this.show}")
+      }
+    this
+
+  def occursAtToplevel(param: TypeParamRef, inst: Type)(using Context): Boolean =
+
+    def occurs(tp: Type)(using Context): Boolean = tp match
+      case tp: AndOrType =>
+        occurs(tp.tp1) || occurs(tp.tp2)
+      case tp: TypeParamRef =>
+        (tp eq param) || entry(tp).match
+          case NoType => false
+          case TypeBounds(lo, hi) => (lo eq hi) && occurs(lo)
+          case inst => occurs(inst)
+      case tp: TypeVar =>
+        occurs(tp.underlying)
+      case TypeBounds(lo, hi) =>
+        occurs(lo) || occurs(hi)
+      case _ =>
+        val tp1 = tp.dealias
+        (tp1 ne tp) && occurs(tp1)
+
+    occurs(inst)
+  end occursAtToplevel
+
+  override def checkClosed()(using Context): Unit =
+
+    def isFreeTypeParamRef(tp: Type) = tp match
+      case TypeParamRef(binder: TypeLambda, _) => !contains(binder)
+      case _ => false
+
+    def checkClosedType(tp: Type | Null, where: String) =
+      if tp != null then
+        assert(!tp.existsPart(isFreeTypeParamRef), i"unclosed constraint: $this refers to $tp in $where")
+
+    boundsMap.foreachBinding((_, tps) => tps.foreach(checkClosedType(_, "bounds")))
+    lowerMap.foreachBinding((_, paramss) => paramss.foreach(_.foreach(checkClosedType(_, "lower"))))
+    upperMap.foreachBinding((_, paramss) => paramss.foreach(_.foreach(checkClosedType(_, "upper"))))
+  end checkClosed
+
+// ---------- Printing -----------------------------------------------------
+
+  override def toText(printer: Printer): Text =
+    printer.toText(this)
+
+  override def toString: String = {
+    def entryText(tp: Type): String = tp match {
+      case tp: TypeBounds => tp.toString
+      case _ => " := " + tp
+    }
+    val constrainedText =
+      " constrained types = " + domainLambdas.mkString("\n")
+    val boundsText =
+      " bounds = " + {
+        val assocs =
+          for (param <- domainParams)
+          yield
+            s"${param.binder.paramNames(param.paramNum)}: ${entryText(entry(param))}"
+        assocs.mkString("\n")
+    }
+    constrainedText + "\n" + boundsText
+  }
+}
diff --git a/tests/pos-with-compiler-cc/dotc/core/ParamInfo.scala b/tests/pos-with-compiler-cc/dotc/core/ParamInfo.scala
new file mode 100644
index 000000000000..e88d6540e64b
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/core/ParamInfo.scala
@@ -0,0 +1,53 @@
+package dotty.tools.dotc.core
+
+import Names.Name
+import Contexts._
+import Types.Type
+import Variances.{Variance, varianceToInt}
+
+/** A common super trait of Symbol and LambdaParam.
+ *  Used to capture the attributes of type parameters which can be implemented as either.
+ */
+trait ParamInfo {
+
+  type ThisName <: Name
+
+  /** Is this the info of a type parameter? Will return `false` for symbols
+   *  that are not type parameters.
+   */
+  def isTypeParam(using Context): Boolean
+
+  /** The name of the type parameter */
+  def paramName(using Context): ThisName
+
+  /** The info of the type parameter */
+  def paramInfo(using Context): Type
+
+  /** The info of the type parameter as seen from a prefix type.
+   *  For type parameter symbols, this is the `memberInfo` as seen from `prefix`.
+   *  For type lambda parameters, it's the same as `paramInfos` as
+   *  `asSeenFrom` has already been applied to the whole type lambda.
+   */
+  def paramInfoAsSeenFrom(prefix: Type)(using Context): Type
+
+  /** The parameter bounds, or the completer if the type parameter
+   *  is an as-yet uncompleted symbol.
+   */
+  def paramInfoOrCompleter(using Context): Type
+
+  /** The variance of the type parameter */
+  def paramVariance(using Context): Variance
+
+  /** The variance of the type parameter, as a number -1, 0, +1.
+   *  Bivariant is mapped to 1, i.e. it is treated like Covariant.
+   */
+  final def paramVarianceSign(using Context): Int =
+    varianceToInt(paramVariance)
+
+  /** A type that refers to the parameter */
+  def paramRef(using Context): Type
+}
+
+object ParamInfo {
+  type Of[N] = ParamInfo { type ThisName = N }
+}
\ No newline at end of file
diff --git a/tests/pos-with-compiler-cc/dotc/core/PatternTypeConstrainer.scala b/tests/pos-with-compiler-cc/dotc/core/PatternTypeConstrainer.scala
new file mode 100644
index 000000000000..ff9a5cd0aed7
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/core/PatternTypeConstrainer.scala
@@ -0,0 +1,298 @@
+package dotty.tools
+package dotc
+package core
+
+import Decorators._
+import Symbols._
+import Types._
+import Flags._
+import Contexts.ctx
+import dotty.tools.dotc.reporting.trace
+import config.Feature.migrateTo3
+import config.Printers._
+
+trait PatternTypeConstrainer { self: TypeComparer =>
+
+  /** Derive type and GADT constraints that necessarily follow from a pattern with the given type matching
+   *  a scrutinee of the given type.
+   *
+   *  This function breaks down scrutinee and pattern types into subcomponents between which there must be
+   *  a subtyping relationship, and derives constraints from those relationships. We have the following situation
+   *  in case of a (dynamic) pattern match:
+   *
+   *       StaticScrutineeType           PatternType
+   *                         \            /
+   *                      DynamicScrutineeType
+   *
+   *  In simple cases, it must hold that `PatternType <: StaticScrutineeType`:
+   *
+   *            StaticScrutineeType
+   *                  |         \
+   *                  |          PatternType
+   *                  |         /
+   *               DynamicScrutineeType
+   *
+   *  A good example of a situation where the above must hold is when static scrutinee type is the root of an enum,
+   *  and the pattern is an unapply of a case class, or a case object literal (of that enum).
+   *
+   *  In slightly more complex cases, we may need to upcast `StaticScrutineeType`:
+   *
+   *           SharedPatternScrutineeSuperType
+   *                  /         \
+   *   StaticScrutineeType       PatternType
+   *                  \         /
+   *               DynamicScrutineeType
+   *
+   *  This may be the case if the scrutinee is a singleton type or a path-dependent type. It is also the case
+   *  for the following definitions:
+   *
+   *     trait Expr[T]
+   *     trait IntExpr extends Expr[T]
+   *     trait Const[T] extends Expr[T]
+   *
+   *     StaticScrutineeType = Const[T]
+   *     PatternType = IntExpr
+   *
+   *  Union and intersection types are an additional complication - if either scrutinee or pattern are a union type,
+   *  then the above relationships only need to hold for the "leaves" of the types.
+   *
+   *  Finally, if pattern type contains hk-types applied to concrete types (as opposed to type variables),
+   *  or either scrutinee or pattern type contain type member refinements, the above relationships do not need
+   *  to hold at all. Consider (where `T1`, `T2` are unrelated traits):
+   *
+   *     StaticScrutineeType = { type T <: T1 }
+   *     PatternType = { type T <: T2 }
+   *
+   *  In the above situation, DynamicScrutineeType can equal { type T = T1 & T2 }, but there is no useful relationship
+   *  between StaticScrutineeType and PatternType (nor any of their subcomponents). Similarly:
+   *
+   *     StaticScrutineeType = Option[T1]
+   *     PatternType = Some[T2]
+   *
+   *  Again, DynamicScrutineeType may equal Some[T1 & T2], and there's no useful relationship between the static
+   *  scrutinee and pattern types. This does not apply if the pattern type is only applied to type variables,
+   *  in which case the subtyping relationship "heals" the type.
+   */
+  def constrainPatternType(pat: Type, scrut: Type, forceInvariantRefinement: Boolean = false): Boolean = trace(i"constrainPatternType($scrut, $pat)", gadts) {
+
+    def classesMayBeCompatible: Boolean = {
+      import Flags._
+      val patCls = pat.classSymbol
+      val scrCls = scrut.classSymbol
+      !patCls.exists || !scrCls.exists || {
+        if (patCls.is(Final)) patCls.derivesFrom(scrCls)
+        else if (scrCls.is(Final)) scrCls.derivesFrom(patCls)
+        else if (!patCls.is(Flags.Trait) && !scrCls.is(Flags.Trait))
+          patCls.derivesFrom(scrCls) || scrCls.derivesFrom(patCls)
+        else true
+      }
+    }
+
+    def stripRefinement(tp: Type): Type = tp match {
+      case tp: RefinedOrRecType => stripRefinement(tp.parent)
+      case tp => tp
+    }
+
+    def tryConstrainSimplePatternType(pat: Type, scrut: Type) = {
+      val patCls = pat.classSymbol
+      val scrCls = scrut.classSymbol
+      patCls.exists && scrCls.exists
+      && (patCls.derivesFrom(scrCls) || scrCls.derivesFrom(patCls))
+      && constrainSimplePatternType(pat, scrut, forceInvariantRefinement)
+    }
+
+    def constrainUpcasted(scrut: Type): Boolean = trace(i"constrainUpcasted($scrut)", gadts) {
+      // Fold a list of types into an AndType
+      def buildAndType(xs: List[Type]): Type = {
+        @annotation.tailrec def recur(acc: Type, rem: List[Type]): Type = rem match {
+          case Nil => acc
+          case x :: rem => recur(AndType(acc, x), rem)
+        }
+        xs match {
+          case Nil => NoType
+          case x :: xs => recur(x, xs)
+        }
+      }
+
+      scrut match {
+        case scrut: TypeRef if scrut.symbol.isClass =>
+          // consider all parents
+          val parents = scrut.parents
+          val andType = buildAndType(parents)
+          !andType.exists || constrainPatternType(pat, andType)
+        case scrut @ AppliedType(tycon: TypeRef, _) if tycon.symbol.isClass =>
+          val patCls = pat.classSymbol
+          // find all shared parents in the inheritance hierarchy between pat and scrut
+          def allParentsSharedWithPat(tp: Type, tpClassSym: ClassSymbol): List[Symbol] = {
+            var parents = tpClassSym.info.parents
+            if parents.nonEmpty && parents.head.classSymbol == defn.ObjectClass then
+              parents = parents.tail
+            parents flatMap { tp =>
+              val sym = tp.classSymbol.asClass
+              if patCls.derivesFrom(sym) then List(sym)
+              else allParentsSharedWithPat(tp, sym)
+            }
+          }
+          val allSyms = allParentsSharedWithPat(tycon, tycon.symbol.asClass)
+          val baseClasses = allSyms map scrut.baseType
+          val andType = buildAndType(baseClasses)
+          !andType.exists || constrainPatternType(pat, andType)
+        case _ =>
+          def tryGadtBounds = scrut match {
+            case scrut: TypeRef =>
+              ctx.gadt.bounds(scrut.symbol) match {
+                case tb: TypeBounds =>
+                  val hi = tb.hi
+                  constrainPatternType(pat, hi)
+                case null => true
+              }
+            case _ => true
+          }
+
+          def trySuperType =
+            val upcasted: Type = scrut match {
+              case scrut: TypeProxy =>
+                scrut.superType
+              case _ => NoType
+            }
+            if (upcasted.exists)
+              tryConstrainSimplePatternType(pat, upcasted) || constrainUpcasted(upcasted)
+            else true
+
+          tryGadtBounds && trySuperType
+      }
+    }
+
+    def dealiasDropNonmoduleRefs(tp: Type) = tp.dealias match {
+      case tp: TermRef =>
+        // we drop TermRefs that don't have a class symbol, as they can't
+        // meaningfully participate in GADT reasoning and just get in the way.
+        // Their info could, for an example, be an AndType. One example where
+        // this is important is an enum case that extends its parent and an
+        // additional trait - argument-less enum cases desugar to vals.
+        // See run/enum-Tree.scala.
+        if tp.classSymbol.exists then tp else tp.info
+      case tp => tp
+    }
+
+    dealiasDropNonmoduleRefs(scrut) match {
+      case OrType(scrut1, scrut2) =>
+        either(constrainPatternType(pat, scrut1), constrainPatternType(pat, scrut2))
+      case AndType(scrut1, scrut2) =>
+        constrainPatternType(pat, scrut1) && constrainPatternType(pat, scrut2)
+      case scrut: RefinedOrRecType =>
+        constrainPatternType(pat, stripRefinement(scrut))
+      case scrut => dealiasDropNonmoduleRefs(pat) match {
+        case OrType(pat1, pat2) =>
+          either(constrainPatternType(pat1, scrut), constrainPatternType(pat2, scrut))
+        case AndType(pat1, pat2) =>
+          constrainPatternType(pat1, scrut) && constrainPatternType(pat2, scrut)
+        case pat: RefinedOrRecType =>
+          constrainPatternType(stripRefinement(pat), scrut)
+        case pat =>
+          tryConstrainSimplePatternType(pat, scrut)
+          || classesMayBeCompatible && constrainUpcasted(scrut)
+      }
+    }
+  }
+
+  /** Constrain "simple" patterns (see `constrainPatternType`).
+   *
+   *  This function expects to receive two types (scrutinee and pattern), both
+   *  of which have class symbols, one of which is derived from another. If the
+   *  type "being derived from" is an applied type, it will 1) "upcast" the
+   *  deriving type to an applied type with the same constructor and 2) infer
+   *  constraints for the applied types' arguments that follow from both
+   *  types being inhabited by one value (the scrutinee).
+   *
+   *  Importantly, note that the pattern type may contain type variables, which
+   *  are used to infer type arguments to Unapply trees.
+   *
+   *  ## Invariant refinement
+   *  Essentially, we say that `D[B] extends C[B]` s.t. refines parameter `A` of `trait C[A]` invariantly if
+   *  when `c: C[T]` and `c` is instance of `D`, then necessarily `c: D[T]`. This is violated if `A` is variant:
+   *
+   *     trait C[+A]
+   *     trait D[+B](val b: B) extends C[B]
+   *     trait E extends D[Any](0) with C[String]
+   *
+   *  `E` is a counter-example to the above - if `e: E`, then `e: C[String]` and `e` is instance of `D`, but
+   *  it is false that `e: D[String]`! This is a problem if we're constraining a pattern like the below:
+   *
+   *     def foo[T](c: C[T]): T = c match {
+   *       case d: D[t] => d.b
+   *     }
+   *
+   *  It'd be unsound for us to say that `t <: T`, even though that follows from `D[t] <: C[T]`.
+   *  Note, however, that if `D` was a final class, we *could* rely on that relationship.
+   *  To support typical case classes, we also assume that this relationship holds for them and their parent traits.
+   *  This is enforced by checking that classes inheriting from case classes do not extend the parent traits of those
+   *  case classes without also appropriately extending the relevant case class
+   *  (see `RefChecks#checkCaseClassInheritanceInvariant`).
+   */
+  def constrainSimplePatternType(patternTp: Type, scrutineeTp: Type, forceInvariantRefinement: Boolean): Boolean = {
+    def refinementIsInvariant(tp: Type): Boolean = tp match {
+      case tp: SingletonType => true
+      case tp: ClassInfo => tp.cls.is(Final) || tp.cls.is(Case)
+      case tp: TypeProxy => refinementIsInvariant(tp.superType)
+      case _ => false
+    }
+
+    def widenVariantParams(tp: Type) = tp match {
+      case tp @ AppliedType(tycon, args) =>
+        val args1 = args.zipWithConserve(tycon.typeParams)((arg, tparam) =>
+          if (tparam.paramVarianceSign != 0) TypeBounds.empty else arg
+        )
+        tp.derivedAppliedType(tycon, args1)
+      case tp =>
+        tp
+    }
+
+    val patternCls = patternTp.classSymbol
+    val scrutineeCls = scrutineeTp.classSymbol
+
+    // NOTE: we already know that there is a derives-from relationship in either direction
+    val upcastPattern =
+      patternCls.derivesFrom(scrutineeCls)
+
+    val pt = if upcastPattern then patternTp.baseType(scrutineeCls) else patternTp
+    val tp = if !upcastPattern then scrutineeTp.baseType(patternCls) else scrutineeTp
+
+    val assumeInvariantRefinement =
+      migrateTo3 || forceInvariantRefinement || refinementIsInvariant(patternTp)
+
+    trace(i"constraining simple pattern type $tp >:< $pt", gadts, (res: Boolean) => i"$res gadt = ${ctx.gadt}") {
+      (tp, pt) match {
+        case (AppliedType(tyconS, argsS), AppliedType(tyconP, argsP)) =>
+          val saved = state.nn.constraint
+          val savedGadt = ctx.gadt.fresh
+          val result =
+            tyconS.typeParams.lazyZip(argsS).lazyZip(argsP).forall { (param, argS, argP) =>
+              val variance = param.paramVarianceSign
+              if variance == 0 || assumeInvariantRefinement ||
+                // As a special case, when pattern and scrutinee types have the same type constructor,
+                // we infer better bounds for pattern-bound abstract types.
+                argP.typeSymbol.isPatternBound && patternTp.classSymbol == scrutineeTp.classSymbol
+              then
+                val TypeBounds(loS, hiS) = argS.bounds
+                val TypeBounds(loP, hiP) = argP.bounds
+                var res = true
+                if variance <  1 then res &&= isSubType(loS, hiP)
+                if variance > -1 then res &&= isSubType(loP, hiS)
+                res
+              else true
+            }
+          if !result then
+            constraint = saved
+            ctx.gadt.restore(savedGadt)
+          result
+        case _ =>
+          // Give up if we don't get AppliedType, e.g. if we upcasted to Any.
+          // Note that this doesn't mean that patternTp, scrutineeTp cannot possibly
+          // be co-inhabited, just that we cannot extract information out of them directly
+          // and should upcast.
+          false
+      }
+    }
+  }
+}
diff --git a/tests/pos-with-compiler-cc/dotc/core/Periods.scala b/tests/pos-with-compiler-cc/dotc/core/Periods.scala
new file mode 100644
index 000000000000..44d83dcb5278
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/core/Periods.scala
@@ -0,0 +1,143 @@
+package dotty.tools.dotc.core
+
+import Contexts._
+import Phases.unfusedPhases
+
+object Periods {
+
+  /** The period containing the current period where denotations do not change.
+   *  We compute this by taking as first phase the first phase less or equal to
+   *  the current phase that has the same "nextTransformerId". As last phase
+   *  we take the next transformer id following the current phase.
+   */
+  def currentStablePeriod(using Context): Period =
+    var first = ctx.phaseId
+    val nxTrans = ctx.base.nextDenotTransformerId(first)
+    while (first - 1 > NoPhaseId && (ctx.base.nextDenotTransformerId(first - 1) == nxTrans))
+      first -= 1
+    Period(ctx.runId, first, nxTrans)
+
+  /** Are all base types in the current period guaranteed to be the same as in period `p`? */
+  def currentHasSameBaseTypesAs(p: Period)(using Context): Boolean =
+    val period = ctx.period
+    period == p ||
+    period.runId == p.runId &&
+      unfusedPhases(period.phaseId).sameBaseTypesStartId ==
+      unfusedPhases(p.phaseId).sameBaseTypesStartId
+
+  /** A period is a contiguous sequence of phase ids in some run.
+   *  It is coded as follows:
+   *
+   *     sign, always 0        1 bit
+   *     runid                17 bits
+   *     last phase id:        7 bits
+   *     #phases before last:  7 bits
+   *
+   *     // Dmitry: sign == 0 isn't actually always true, in some cases phaseId == -1 is used for shifts, that easily creates code < 0
+   */
+  class Period(val code: Int) extends AnyVal {
+
+    /** The run identifier of this period. */
+    def runId: RunId = code >>> (PhaseWidth * 2)
+
+    /** The phase identifier of this single-phase period. */
+    def phaseId: PhaseId = (code >>> PhaseWidth) & PhaseMask
+
+    /** The last phase of this period */
+    def lastPhaseId: PhaseId =
+      (code >>> PhaseWidth) & PhaseMask
+
+    /** The first phase of this period */
+    def firstPhaseId: Int = lastPhaseId - (code & PhaseMask)
+
+    def containsPhaseId(id: PhaseId): Boolean = firstPhaseId <= id && id <= lastPhaseId
+
+    /** Does this period contain given period? */
+    def contains(that: Period): Boolean = {
+      // Let    this = (r1, l1, d1), that = (r2, l2, d2)
+      // where  r = runid, l = last phase, d = duration - 1
+      // Then seen as intervals:
+      //
+      //  this = r1 / (l1 - d1) .. l1
+      //  that = r2 / (l2 - d2) .. l2
+      //
+      // Let's compute:
+      //
+      //  lastDiff = X * 2^5 + (l1 - l2) mod 2^5
+      //             where X >= 0, X == 0 iff r1 == r2 & l1 - l2 >= 0
+      //  result = lastDiff + d2 <= d1
+      //  We have:
+      //      lastDiff + d2 <= d1
+      //  iff X == 0 && l1 - l2 >= 0 && l1 - l2 + d2 <= d1
+      //  iff r1 == r2 & l1 >= l2 && l1 - d1 <= l2 - d2
+      //  q.e.d
+      val lastDiff = (code - that.code) >>> PhaseWidth
+      lastDiff + (that.code & PhaseMask ) <= (this.code & PhaseMask)
+    }
+
+    /** Does this period overlap with given period? */
+    def overlaps(that: Period): Boolean =
+      this.runId == that.runId &&
+      this.firstPhaseId <= that.lastPhaseId &&
+      that.firstPhaseId <= this.lastPhaseId
+
+    /** The intersection of two periods */
+    def & (that: Period): Period =
+      if (this overlaps that)
+        Period(
+          this.runId,
+          this.firstPhaseId max that.firstPhaseId,
+          this.lastPhaseId min that.lastPhaseId)
+      else
+        Nowhere
+
+    /** The smallest period containing two periods */
+    def | (that: Period): Period =
+      Period(this.runId,
+          this.firstPhaseId min that.firstPhaseId,
+          this.lastPhaseId max that.lastPhaseId)
+
+    override def toString: String = s"Period($firstPhaseId..$lastPhaseId, run = $runId)"
+
+    def ==(that: Period): Boolean = this.code == that.code
+    def !=(that: Period): Boolean = this.code != that.code
+  }
+
+  object Period {
+
+    /** The single-phase period consisting of given run id and phase id */
+    def apply(rid: RunId, pid: PhaseId): Period =
+      new Period(((rid << PhaseWidth) | pid) << PhaseWidth)
+
+    /** The period consisting of given run id, and lo/hi phase ids */
+    def apply(rid: RunId, loPid: PhaseId, hiPid: PhaseId): Period =
+      new Period(((rid << PhaseWidth) | hiPid) << PhaseWidth | (hiPid - loPid))
+
+    /** The interval consisting of all periods of given run id */
+    def allInRun(rid: RunId): Period =
+      apply(rid, 0, PhaseMask)
+  }
+
+  final val Nowhere: Period = new Period(0)
+
+  final val InitialPeriod: Period = Period(InitialRunId, FirstPhaseId)
+
+  final val InvalidPeriod: Period = Period(NoRunId, NoPhaseId)
+
+  /** An ordinal number for compiler runs. First run has number 1. */
+  type RunId = Int
+  inline val NoRunId = 0
+  inline val InitialRunId = 1
+  inline val RunWidth = java.lang.Integer.SIZE - PhaseWidth * 2 - 1/* sign */
+  inline val MaxPossibleRunId = (1 << RunWidth) - 1
+
+  /** An ordinal number for phases. First phase has number 1. */
+  type PhaseId = Int
+  inline val NoPhaseId = 0
+  inline val FirstPhaseId = 1
+
+  /** The number of bits needed to encode a phase identifier. */
+  inline val PhaseWidth = 7
+  inline val PhaseMask = (1 << PhaseWidth) - 1
+  inline val MaxPossiblePhaseId = PhaseMask
+}
diff --git a/tests/pos-with-compiler-cc/dotc/core/Phases.scala b/tests/pos-with-compiler-cc/dotc/core/Phases.scala
new file mode 100644
index 000000000000..3744b1f21122
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/core/Phases.scala
@@ -0,0 +1,475 @@
+package dotty.tools
+package dotc
+package core
+
+import Periods._
+import Contexts._
+import dotty.tools.backend.jvm.GenBCode
+import DenotTransformers._
+import Denotations._
+import Decorators._
+import config.Printers.config
+import scala.collection.mutable.ListBuffer
+import dotty.tools.dotc.transform.MegaPhase._
+import dotty.tools.dotc.transform._
+import Periods._
+import parsing.Parser
+import printing.XprintMode
+import typer.{TyperPhase, RefChecks}
+import cc.CheckCaptures
+import typer.ImportInfo.withRootImports
+import ast.{tpd, untpd}
+import scala.annotation.internal.sharable
+import scala.util.control.NonFatal
+
+object Phases {
+
+  inline def phaseOf(id: PhaseId)(using Context): Phase =
+    ctx.base.phases(id)
+
+  @sharable object NoPhase extends Phase {
+    override def exists: Boolean = false
+    def phaseName: String = "<no phase>"
+    def run(using Context): Unit = unsupported("run")
+    def transform(ref: SingleDenotation)(using Context): SingleDenotation = unsupported("transform")
+  }
+
+  trait PhasesBase {
+    this: ContextBase =>
+
+    // drop NoPhase at beginning
+    def allPhases: Array[Phase] = (if (fusedPhases.nonEmpty) fusedPhases else phases).tail
+
+    object SomePhase extends Phase {
+      def phaseName: String = "<some phase>"
+      def run(using Context): Unit = unsupported("run")
+    }
+
+    /** A sentinel transformer object */
+    class TerminalPhase extends DenotTransformer {
+      def phaseName: String = "terminal"
+      def run(using Context): Unit = unsupported("run")
+      def transform(ref: SingleDenotation)(using Context): SingleDenotation =
+        unsupported("transform")
+      override def lastPhaseId(using Context): Int = id
+    }
+
+    final def phasePlan: List[List[Phase]] = this.phasesPlan
+    final def setPhasePlan(phasess: List[List[Phase]]): Unit = this.phasesPlan = phasess
+
+    /** Squash TreeTransform's beloning to same sublist to a single TreeTransformer
+      * Each TreeTransform gets own period,
+      * whereas a combined TreeTransformer gets period equal to union of periods of it's TreeTransforms
+      */
+    final def fusePhases(phasess: List[List[Phase]],
+                           phasesToSkip: List[String],
+                           stopBeforePhases: List[String],
+                           stopAfterPhases: List[String],
+                           YCheckAfter: List[String])(using Context): List[Phase] = {
+      val fusedPhases = ListBuffer[Phase]()
+      var prevPhases: Set[String] = Set.empty
+
+      var stop = false
+
+      def isEnabled(p: Phase): Boolean =
+        !stop &&
+        !stopBeforePhases.contains(p.phaseName) &&
+        !phasesToSkip.contains(p.phaseName) &&
+        p.isEnabled
+
+      val filteredPhases = phasess.map(_.filter { p =>
+        try isEnabled(p)
+        finally stop |= stopBeforePhases.contains(p.phaseName) | stopAfterPhases.contains(p.phaseName)
+      })
+
+      var i = 0
+
+      while (i < filteredPhases.length) {
+        if (filteredPhases(i).nonEmpty) { //could be empty due to filtering
+          val filteredPhaseBlock = filteredPhases(i)
+          val phaseToAdd =
+            if (filteredPhaseBlock.length > 1) {
+              for (phase <- filteredPhaseBlock)
+                phase match {
+                  case p: MiniPhase =>
+                    val unmetRequirements = p.runsAfterGroupsOf &~ prevPhases
+                    assert(unmetRequirements.isEmpty,
+                      s"${phase.phaseName} requires ${unmetRequirements.mkString(", ")} to be in different TreeTransformer")
+
+                  case _ =>
+                    assert(false, s"Only tree transforms can be fused, ${phase.phaseName} can not be fused")
+                }
+              val superPhase = new MegaPhase(filteredPhaseBlock.asInstanceOf[List[MiniPhase]].toArray)
+              prevPhases ++= filteredPhaseBlock.map(_.phaseName)
+              superPhase
+            }
+            else { // block of a single phase, no fusion
+              val phase = filteredPhaseBlock.head
+              prevPhases += phase.phaseName
+              phase
+            }
+          fusedPhases += phaseToAdd
+          val shouldAddYCheck = filteredPhases(i).exists(_.isCheckable) && YCheckAfter.containsPhase(phaseToAdd)
+          if (shouldAddYCheck) {
+            val checker = new TreeChecker
+            fusedPhases += checker
+          }
+        }
+
+        i += 1
+      }
+      fusedPhases.toList
+    }
+
+    /** Use the following phases in the order they are given.
+     *  The list should never contain NoPhase.
+     *  if fusion is enabled, phases in same subgroup will be fused to single phase.
+     */
+    final def usePhases(phasess: List[Phase], fuse: Boolean = true): Unit = {
+
+      val flatPhases = collection.mutable.ListBuffer[Phase]()
+
+      phasess.foreach(p => p match {
+        case p: MegaPhase => flatPhases ++= p.miniPhases
+        case _ => flatPhases += p
+      })
+
+      phases = (NoPhase :: flatPhases.toList ::: new TerminalPhase :: Nil).toArray
+      setSpecificPhases()
+      var phasesAfter: Set[String] = Set.empty
+      nextDenotTransformerId = new Array[Int](phases.length)
+      denotTransformers = new Array[DenotTransformer](phases.length)
+
+      var phaseId = 0
+      def nextPhaseId = {
+        phaseId += 1
+        phaseId // starting from 1 as NoPhase is 0
+      }
+
+      def checkRequirements(p: Phase) = {
+        val unmetPrecedeRequirements = p.runsAfter -- phasesAfter
+        assert(unmetPrecedeRequirements.isEmpty,
+          s"phase ${p} has unmet requirement: ${unmetPrecedeRequirements.mkString(", ")} should precede this phase")
+        phasesAfter += p.phaseName
+      }
+
+      var i = 0
+
+      while (i < phasess.length) {
+        val phase = phasess(i)
+        phase match {
+          case p: MegaPhase =>
+            val miniPhases = p.miniPhases
+            miniPhases.foreach{ phase =>
+              checkRequirements(phase)
+              phase.init(this, nextPhaseId)}
+            p.init(this, miniPhases.head.id, miniPhases.last.id)
+          case _ =>
+            phase.init(this, nextPhaseId)
+            checkRequirements(phase)
+        }
+
+        i += 1
+      }
+
+      phases.last.init(this, nextPhaseId) // init terminal phase
+
+      i = phases.length
+      var lastTransformerId = i
+      while (i > 0) {
+        i -= 1
+        val phase = phases(i)
+        phase match {
+          case transformer: DenotTransformer =>
+            lastTransformerId = i
+            denotTransformers(i) = transformer
+          case _ =>
+        }
+        nextDenotTransformerId(i) = lastTransformerId
+      }
+
+      if (fuse)
+        this.fusedPhases = (NoPhase :: phasess).toArray
+      else
+        this.fusedPhases = this.phases
+
+      config.println(s"Phases = ${phases.toList}")
+      config.println(s"nextDenotTransformerId = ${nextDenotTransformerId.toList}")
+    }
+
+    /** Unlink `phase` from Denot transformer chain. This means that
+     *  any denotation transformer defined by the phase will not be executed.
+     */
+    def unlinkPhaseAsDenotTransformer(phase: Phase)(using Context) =
+      for i <- 0 until nextDenotTransformerId.length do
+        if nextDenotTransformerId(i) == phase.id then
+          nextDenotTransformerId(i) = nextDenotTransformerId(phase.id + 1)
+
+    private var myParserPhase: Phase = _
+    private var myTyperPhase: Phase = _
+    private var myPostTyperPhase: Phase = _
+    private var mySbtExtractDependenciesPhase: Phase = _
+    private var myPicklerPhase: Phase = _
+    private var myInliningPhase: Phase = _
+    private var mySplicingPhase: Phase = _
+    private var myFirstTransformPhase: Phase = _
+    private var myCollectNullableFieldsPhase: Phase = _
+    private var myRefChecksPhase: Phase = _
+    private var myPatmatPhase: Phase = _
+    private var myElimRepeatedPhase: Phase = _
+    private var myElimByNamePhase: Phase = _
+    private var myExtensionMethodsPhase: Phase = _
+    private var myExplicitOuterPhase: Phase = _
+    private var myGettersPhase: Phase = _
+    private var myErasurePhase: Phase = _
+    private var myElimErasedValueTypePhase: Phase = _
+    private var myLambdaLiftPhase: Phase = _
+    private var myCountOuterAccessesPhase: Phase = _
+    private var myFlattenPhase: Phase = _
+    private var myGenBCodePhase: Phase = _
+    private var myCheckCapturesPhase: Phase = _
+
+    final def parserPhase: Phase = myParserPhase
+    final def typerPhase: Phase = myTyperPhase
+    final def postTyperPhase: Phase = myPostTyperPhase
+    final def sbtExtractDependenciesPhase: Phase = mySbtExtractDependenciesPhase
+    final def picklerPhase: Phase = myPicklerPhase
+    final def inliningPhase: Phase = myInliningPhase
+    final def splicingPhase: Phase = mySplicingPhase
+    final def firstTransformPhase: Phase = myFirstTransformPhase
+    final def collectNullableFieldsPhase: Phase = myCollectNullableFieldsPhase
+    final def refchecksPhase: Phase = myRefChecksPhase
+    final def patmatPhase: Phase = myPatmatPhase
+    final def elimRepeatedPhase: Phase = myElimRepeatedPhase
+    final def elimByNamePhase: Phase = myElimByNamePhase
+    final def extensionMethodsPhase: Phase = myExtensionMethodsPhase
+    final def explicitOuterPhase: Phase = myExplicitOuterPhase
+    final def gettersPhase: Phase = myGettersPhase
+    final def erasurePhase: Phase = myErasurePhase
+    final def elimErasedValueTypePhase: Phase = myElimErasedValueTypePhase
+    final def lambdaLiftPhase: Phase = myLambdaLiftPhase
+    final def countOuterAccessesPhase = myCountOuterAccessesPhase
+    final def flattenPhase: Phase = myFlattenPhase
+    final def genBCodePhase: Phase = myGenBCodePhase
+    final def checkCapturesPhase: Phase = myCheckCapturesPhase
+
+    private def setSpecificPhases() = {
+      def phaseOfClass(pclass: Class[?]) = phases.find(pclass.isInstance).getOrElse(NoPhase)
+
+      myParserPhase = phaseOfClass(classOf[Parser])
+      myTyperPhase = phaseOfClass(classOf[TyperPhase])
+      myPostTyperPhase = phaseOfClass(classOf[PostTyper])
+      mySbtExtractDependenciesPhase = phaseOfClass(classOf[sbt.ExtractDependencies])
+      myPicklerPhase = phaseOfClass(classOf[Pickler])
+      myInliningPhase = phaseOfClass(classOf[Inlining])
+      mySplicingPhase = phaseOfClass(classOf[Splicing])
+      myFirstTransformPhase = phaseOfClass(classOf[FirstTransform])
+      myCollectNullableFieldsPhase = phaseOfClass(classOf[CollectNullableFields])
+      myRefChecksPhase = phaseOfClass(classOf[RefChecks])
+      myElimRepeatedPhase = phaseOfClass(classOf[ElimRepeated])
+      myElimByNamePhase = phaseOfClass(classOf[ElimByName])
+      myExtensionMethodsPhase = phaseOfClass(classOf[ExtensionMethods])
+      myErasurePhase = phaseOfClass(classOf[Erasure])
+      myElimErasedValueTypePhase = phaseOfClass(classOf[ElimErasedValueType])
+      myPatmatPhase = phaseOfClass(classOf[PatternMatcher])
+      myLambdaLiftPhase = phaseOfClass(classOf[LambdaLift])
+      myCountOuterAccessesPhase = phaseOfClass(classOf[CountOuterAccesses])
+      myFlattenPhase = phaseOfClass(classOf[Flatten])
+      myExplicitOuterPhase = phaseOfClass(classOf[ExplicitOuter])
+      myGettersPhase = phaseOfClass(classOf[Getters])
+      myGenBCodePhase = phaseOfClass(classOf[GenBCode])
+      myCheckCapturesPhase = phaseOfClass(classOf[CheckCaptures])
+    }
+
+    final def isAfterTyper(phase: Phase): Boolean = phase.id > typerPhase.id
+    final def isTyper(phase: Phase): Boolean = phase.id == typerPhase.id
+  }
+
+  abstract class Phase extends caps.Pure {
+
+    /** A name given to the `Phase` that can be used to debug the compiler. For
+     *  instance, it is possible to print trees after a given phase using:
+     *
+     *  ```bash
+     *  $ ./bin/scalac -Xprint:<phaseNameHere> sourceFile.scala
+     *  ```
+     */
+    def phaseName: String
+
+    def isRunnable(using Context): Boolean =
+      !ctx.reporter.hasErrors
+        // TODO: This might test an unintended condition.
+        // To find out whether any errors have been reported during this
+        // run one calls `errorsReported`, not `hasErrors`.
+        // But maybe changing this would prevent useful phases from running?
+
+    /** If set, allow missing or superfluous arguments in applications
+     *  and type applications.
+     */
+    def relaxedTyping: Boolean = false
+
+    /** If set, implicit search is enabled */
+    def allowsImplicitSearch: Boolean = false
+
+    /** List of names of phases that should precede this phase */
+    def runsAfter: Set[String] = Set.empty
+
+    /** @pre `isRunnable` returns true */
+    def run(using Context): Unit
+
+    /** @pre `isRunnable` returns true */
+    def runOn(units: List[CompilationUnit])(using Context): List[CompilationUnit] =
+      units.map { unit =>
+        val unitCtx = ctx.fresh.setPhase(this.start).setCompilationUnit(unit).withRootImports
+        try run(using unitCtx)
+        catch case ex: Throwable =>
+          println(s"$ex while running $phaseName on $unit")
+          throw ex
+        unitCtx.compilationUnit
+      }
+
+    /** Convert a compilation unit's tree to a string; can be overridden */
+    def show(tree: untpd.Tree)(using Context): String =
+      tree.show(using ctx.withProperty(XprintMode, Some(())))
+
+    def description: String = phaseName
+
+    /** Output should be checkable by TreeChecker */
+    def isCheckable: Boolean = true
+
+    /** Check what the phase achieves, to be called at any point after it is finished.
+     */
+    def checkPostCondition(tree: tpd.Tree)(using Context): Unit = ()
+
+    /** Is this phase the standard typerphase? True for TyperPhase, but
+     *  not for other first phases (such as FromTasty or Parser). The predicate
+     *  is tested in some places that perform checks and corrections. It's
+     *  different from ctx.isAfterTyper (and cheaper to test).
+     */
+    def isTyper: Boolean = false
+
+    /** Can this transform create or delete non-private members? */
+    def changesMembers: Boolean = false
+
+    /** Can this transform change the parents of a class? */
+    def changesParents: Boolean = false
+
+    /** Can this transform change the base types of a type? */
+    def changesBaseTypes: Boolean = changesParents
+
+    def isEnabled(using Context): Boolean = true
+
+    def exists: Boolean = true
+
+    def initContext(ctx: FreshContext): Unit = ()
+
+    private var myPeriod: Period = Periods.InvalidPeriod
+    private var myBase: ContextBase = _
+    private var myErasedTypes = false
+    private var myFlatClasses = false
+    private var myRefChecked = false
+    private var myLambdaLifted = false
+    private var myPatternTranslated = false
+
+    private var mySameMembersStartId = NoPhaseId
+    private var mySameParentsStartId = NoPhaseId
+    private var mySameBaseTypesStartId = NoPhaseId
+
+    /** The sequence position of this phase in the given context where 0
+     * is reserved for NoPhase and the first real phase is at position 1.
+     * -1 if the phase is not installed in the context.
+     */
+    def id: Int = myPeriod.firstPhaseId
+
+    def period: Period = myPeriod
+    def start: Int = myPeriod.firstPhaseId
+    def end: Periods.PhaseId = myPeriod.lastPhaseId
+
+    final def erasedTypes: Boolean = myErasedTypes   // Phase is after erasure
+    final def flatClasses: Boolean = myFlatClasses   // Phase is after flatten
+    final def refChecked: Boolean = myRefChecked     // Phase is after RefChecks
+    final def lambdaLifted: Boolean = myLambdaLifted // Phase is after LambdaLift
+    final def patternTranslated: Boolean = myPatternTranslated // Phase is after PatternMatcher
+
+    final def sameMembersStartId: Int = mySameMembersStartId
+      // id of first phase where all symbols are guaranteed to have the same members as in this phase
+    final def sameParentsStartId: Int = mySameParentsStartId
+      // id of first phase where all symbols are guaranteed to have the same parents as in this phase
+    final def sameBaseTypesStartId: Int = mySameBaseTypesStartId
+      // id of first phase where all symbols are guaranteed to have the same base tpyes as in this phase
+
+    protected[Phases] def init(base: ContextBase, start: Int, end: Int): Unit = {
+      if (start >= FirstPhaseId)
+        assert(myPeriod == Periods.InvalidPeriod, s"phase $this has already been used once; cannot be reused")
+      assert(start <= Periods.MaxPossiblePhaseId, s"Too many phases, Period bits overflow")
+      myBase = base
+      myPeriod = Period(NoRunId, start, end)
+      myErasedTypes  = prev.getClass == classOf[Erasure]    || prev.erasedTypes
+      myFlatClasses  = prev.getClass == classOf[Flatten]    || prev.flatClasses
+      myRefChecked   = prev.getClass == classOf[RefChecks]  || prev.refChecked
+      myLambdaLifted = prev.getClass == classOf[LambdaLift] || prev.lambdaLifted
+      myPatternTranslated = prev.getClass == classOf[PatternMatcher] || prev.patternTranslated
+      mySameMembersStartId = if (changesMembers) id else prev.sameMembersStartId
+      mySameParentsStartId = if (changesParents) id else prev.sameParentsStartId
+      mySameBaseTypesStartId = if (changesBaseTypes) id else prev.sameBaseTypesStartId
+    }
+
+    protected[Phases] def init(base: ContextBase, id: Int): Unit = init(base, id, id)
+
+    final def <=(that: Phase): Boolean =
+      exists && id <= that.id
+
+    final def prev: Phase =
+      if (id > FirstPhaseId) myBase.phases(start - 1) else NoPhase
+
+    final def prevMega(using Context): Phase =
+      ctx.base.fusedContaining(ctx.phase.prev)
+
+    final def next: Phase =
+      if (hasNext) myBase.phases(end + 1) else NoPhase
+
+    final def hasNext: Boolean = start >= FirstPhaseId && end + 1 < myBase.phases.length
+
+    final def iterator: Iterator[Phase] =
+      Iterator.iterate(this)(_.next) takeWhile (_.hasNext)
+
+    final def monitor(doing: String)(body: => Unit)(using Context): Unit =
+      try body
+      catch
+        case NonFatal(ex) =>
+          report.echo(s"exception occurred while $doing ${ctx.compilationUnit}")
+          throw ex
+
+    override def toString: String = phaseName
+  }
+
+  def parserPhase(using Context): Phase                 = ctx.base.parserPhase
+  def typerPhase(using Context): Phase                  = ctx.base.typerPhase
+  def postTyperPhase(using Context): Phase              = ctx.base.postTyperPhase
+  def sbtExtractDependenciesPhase(using Context): Phase = ctx.base.sbtExtractDependenciesPhase
+  def picklerPhase(using Context): Phase                = ctx.base.picklerPhase
+  def inliningPhase(using Context): Phase               = ctx.base.inliningPhase
+  def splicingPhase(using Context): Phase               = ctx.base.splicingPhase
+  def firstTransformPhase(using Context): Phase         = ctx.base.firstTransformPhase
+  def refchecksPhase(using Context): Phase              = ctx.base.refchecksPhase
+  def elimRepeatedPhase(using Context): Phase           = ctx.base.elimRepeatedPhase
+  def elimByNamePhase(using Context): Phase             = ctx.base.elimByNamePhase
+  def extensionMethodsPhase(using Context): Phase       = ctx.base.extensionMethodsPhase
+  def explicitOuterPhase(using Context): Phase          = ctx.base.explicitOuterPhase
+  def gettersPhase(using Context): Phase                = ctx.base.gettersPhase
+  def erasurePhase(using Context): Phase                = ctx.base.erasurePhase
+  def elimErasedValueTypePhase(using Context): Phase    = ctx.base.elimErasedValueTypePhase
+  def lambdaLiftPhase(using Context): Phase             = ctx.base.lambdaLiftPhase
+  def flattenPhase(using Context): Phase                = ctx.base.flattenPhase
+  def genBCodePhase(using Context): Phase               = ctx.base.genBCodePhase
+  def checkCapturesPhase(using Context): Phase          = ctx.base.checkCapturesPhase
+
+  def unfusedPhases(using Context): Array[Phase] = ctx.base.phases
+
+  /** Replace all instances of `oldPhaseClass` in `current` phases
+   *  by the result of `newPhases` applied to the old phase.
+   */
+  private def replace(oldPhaseClass: Class[? <: Phase], newPhases: Phase => List[Phase], current: List[List[Phase]]): List[List[Phase]] =
+    current.map(_.flatMap(phase =>
+      if (oldPhaseClass.isInstance(phase)) newPhases(phase) else phase :: Nil))
+}
diff --git a/tests/pos-with-compiler-cc/dotc/core/Scopes.scala b/tests/pos-with-compiler-cc/dotc/core/Scopes.scala
new file mode 100644
index 000000000000..5a2ad41c88df
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/core/Scopes.scala
@@ -0,0 +1,474 @@
+/* NSC -- new Scala compiler
+ * Copyright 2005-2012 LAMP/EPFL
+ * @author  Martin Odersky
+ */
+
+package dotty.tools
+package dotc
+package core
+
+import Symbols._
+import Types.{TermRef, NoPrefix}
+import Flags._
+import Names._
+import Contexts._
+import Phases._
+import Denotations._
+import printing.Texts._
+import printing.Printer
+import SymDenotations.NoDenotation
+
+import collection.mutable
+
+object Scopes {
+
+  /** Maximal fill factor of hash table */
+  private inline val FillFactor = 2.0/3.0
+
+  /** A hashtable is created once current size exceeds MinHash * FillFactor
+   *  The initial hash table has twice that size (i.e 16).
+   *  This value must be a power of two, so that the index of an element can
+   *  be computed as element.hashCode & (hashTable.length - 1)
+   */
+  inline val MinHashedScopeSize = 8
+
+  /** The maximal permissible number of recursions when creating
+   *  a hashtable
+   */
+  private inline val MaxRecursions = 1000
+
+  /** A function that optionally produces synthesized symbols with
+   *  the given name in the given context. Returns `NoSymbol` if the
+   *  no symbol should be synthesized for the given name.
+   */
+  type SymbolSynthesizer = Name => Context ?=> Symbol
+
+  class ScopeEntry private[Scopes] (val name: Name, _sym: Symbol, val owner: Scope) {
+
+    var sym: Symbol = _sym
+
+    /** the next entry in the hash bucket
+     */
+    var tail: ScopeEntry | Null = null
+
+    /** the preceding entry in this scope
+     */
+    var prev: ScopeEntry | Null = null
+
+    override def toString: String = sym.toString
+  }
+
+  /** A scope contains a set of symbols. It can be an extension
+   *  of some outer scope, from which it inherits all symbols.
+   *  This class does not have any methods to add symbols to a scope
+   *  or to delete them. These methods are provided by subclass
+   *  MutableScope.
+   */
+  abstract class Scope extends printing.Showable, caps.Pure {
+
+    /** The last scope-entry from which all others are reachable via `prev` */
+    private[dotc] def lastEntry: ScopeEntry | Null
+
+    /** The number of symbols in this scope (including inherited ones
+     *  from outer scopes).
+     */
+    def size: Int
+
+    /** The number of scopes enclosing this scope. */
+    def nestingLevel: Int
+
+    /** The symbols in this scope in the order they were entered;
+     *  inherited from outer ones first.
+     */
+    def toList(using Context): List[Symbol]
+
+    /** Return all symbols as an iterator in the order they were entered in this scope.
+     */
+    def iterator(using Context): Iterator[Symbol] = toList.iterator
+
+    /** Is the scope empty? */
+    def isEmpty: Boolean = lastEntry == null
+
+    /** Applies a function f to all Symbols of this Scope. */
+    def foreach[U](f: Symbol => U)(using Context): Unit = toList.foreach(f)
+
+    /** Selects all Symbols of this Scope which satisfy a predicate. */
+    def filter(p: Symbol => Boolean)(using Context): List[Symbol] = {
+      ensureComplete()
+      var syms: List[Symbol] = Nil
+      var e = lastEntry
+      while ((e != null) && e.owner == this) {
+        val sym = e.sym
+        if (p(sym)) syms = sym :: syms
+        e = e.prev
+      }
+      syms
+    }
+
+    /** Tests whether a predicate holds for at least one Symbol of this Scope. */
+    def exists(p: Symbol => Boolean)(using Context): Boolean = filter(p).nonEmpty
+
+    /** Finds the first Symbol of this Scope satisfying a predicate, if any. */
+    def find(p: Symbol => Boolean)(using Context): Symbol = filter(p) match {
+      case sym :: _ => sym
+      case _ => NoSymbol
+    }
+
+    /** Returns a new mutable scope with the same content as this one. */
+    def cloneScope(using Context): MutableScope
+
+    /** Lookup a symbol entry matching given name. */
+    def lookupEntry(name: Name)(using Context): ScopeEntry | Null
+
+    /** Lookup next entry with same name as this one */
+    def lookupNextEntry(entry: ScopeEntry)(using Context): ScopeEntry | Null
+
+    /** Lookup a symbol */
+    final def lookup(name: Name)(using Context): Symbol = {
+      val e = lookupEntry(name)
+      if (e == null) NoSymbol else e.sym
+    }
+
+    /** Returns an iterator yielding every symbol with given name in this scope.
+     */
+    final def lookupAll(name: Name)(using Context): Iterator[Symbol] = new Iterator[Symbol] {
+      var e = lookupEntry(name)
+      def hasNext: Boolean = e != null
+      def next(): Symbol = { val r = e.nn.sym; e = lookupNextEntry(e.uncheckedNN); r }
+    }
+
+    /** Does this scope contain a reference to `sym` when looking up `name`? */
+    final def contains(name: Name, sym: Symbol)(using Context): Boolean =
+      var e = lookupEntry(name)
+      while e != null && e.sym != sym do e = lookupNextEntry(e)
+      e != null
+
+    /** The denotation set of all the symbols with given name in this scope
+     *  Symbols occur in the result in reverse order relative to their occurrence
+     *  in `this.toList`.
+     */
+    final def denotsNamed(name: Name)(using Context): PreDenotation = {
+      var syms: PreDenotation = NoDenotation
+      var e = lookupEntry(name)
+      while (e != null) {
+        syms = syms union e.sym.denot
+        e = lookupNextEntry(e)
+      }
+      syms
+    }
+
+    /** The scope that keeps only those symbols from this scope that match the
+     *  given predicates. If all symbols match, returns the scope itself, otherwise
+     *  a copy with the matching symbols.
+     */
+    final def filteredScope(p: Symbol => Boolean)(using Context): Scope = {
+      var result: MutableScope | Null = null
+      for (sym <- iterator)
+        if (!p(sym)) {
+          if (result == null) result = cloneScope
+          result.nn.unlink(sym)
+        }
+      // TODO: improve flow typing to handle this case
+      if (result == null) this else result.uncheckedNN
+    }
+
+    def implicitDecls(using Context): List[TermRef] = Nil
+
+    def openForMutations: MutableScope = unsupported("openForMutations")
+
+    final def toText(printer: Printer): Text = printer.toText(this)
+
+    def checkConsistent()(using Context): Unit = ()
+
+    /** Ensure that all elements of this scope have been entered.
+     *  Overridden by SymbolLoaders.PackageLoader#PackageScope, where it
+     *  makes sure that all names with `$`'s have been added.
+     */
+    protected def ensureComplete()(using Context): Unit = ()
+  }
+
+  /** A subclass of Scope that defines methods for entering and
+   *  unlinking entries.
+   *  Note: constructor is protected to force everyone to use the factory methods newScope or newNestedScope instead.
+   *  This is necessary because when run from reflection every scope needs to have a
+   *  SynchronizedScope as mixin.
+   */
+  class MutableScope protected[Scopes](initElems: ScopeEntry | Null, initSize: Int, val nestingLevel: Int)
+      extends Scope {
+
+    /** Scope shares elements with `base` */
+    protected[Scopes] def this(base: Scope)(using Context) =
+      this(base.lastEntry, base.size, base.nestingLevel + 1)
+      ensureCapacity(MinHashedScopeSize)
+
+    def this(nestingLevel: Int) = this(null, 0, nestingLevel)
+
+    private[dotc] var lastEntry: ScopeEntry | Null = initElems
+
+    /** The size of the scope */
+    private var _size = initSize
+
+    override final def size: Int = _size
+    private def size_= (x: Int) = _size = x
+
+    /** the hash table
+     */
+    private var hashTable: Array[ScopeEntry | Null] | Null = null
+
+    /** a cache for all elements, to be used by symbol iterator.
+     */
+    private var elemsCache: List[Symbol] | Null = null
+
+    /** The synthesizer to be used, or `null` if no synthesis is done on this scope */
+    private var synthesize: SymbolSynthesizer | Null = null
+
+    /** Use specified synthesize for this scope */
+    def useSynthesizer(s: SymbolSynthesizer): Unit = synthesize = s
+
+    protected def newScopeLikeThis(): MutableScope = new MutableScope(nestingLevel)
+
+    /** Clone scope, taking care not to force the denotations of any symbols in the scope.
+     */
+    def cloneScope(using Context): MutableScope = {
+      val entries = new mutable.ArrayBuffer[ScopeEntry]
+      var e = lastEntry
+      while ((e != null) && e.owner == this) {
+        entries += e
+        e = e.prev
+      }
+      val scope = newScopeLikeThis()
+      for (i <- entries.length - 1 to 0 by -1) {
+        val e = entries(i)
+        scope.newScopeEntry(e.name, e.sym)
+      }
+      scope.synthesize = synthesize
+      scope
+    }
+
+    /** create and enter a scope entry with given name and symbol */
+    protected def newScopeEntry(name: Name, sym: Symbol)(using Context): ScopeEntry = {
+      ensureCapacity(if (hashTable != null) hashTable.uncheckedNN.length else MinHashedScopeSize)
+      val e = new ScopeEntry(name, sym, this)
+      e.prev = lastEntry
+      lastEntry = e
+      if (hashTable != null) enterInHash(e)
+      size += 1
+      elemsCache = null
+      e
+    }
+
+    private def enterInHash(e: ScopeEntry)(using Context): Unit = {
+      val idx = e.name.hashCode & (hashTable.nn.length - 1)
+      e.tail = hashTable.nn(idx)
+      assert(e.tail != e)
+      hashTable.nn(idx) = e
+    }
+
+    /** enter a symbol in this scope. */
+    final def enter[T <: Symbol](sym: T)(using Context): T = {
+      if (sym.isType && ctx.phaseId <= typerPhase.id)
+        assert(lookup(sym.name) == NoSymbol,
+          s"duplicate ${sym.debugString}; previous was ${lookup(sym.name).debugString}") // !!! DEBUG
+      enter(sym.name, sym)
+    }
+
+    final def enter[T <: Symbol](name: Name, sym: T)(using Context): T = {
+      newScopeEntry(name, sym)
+      sym
+    }
+
+    /** enter a symbol, asserting that no symbol with same name exists in scope */
+    final def enterUnique(sym: Symbol)(using Context): Unit = {
+      assert(lookup(sym.name) == NoSymbol, (sym.showLocated, lookup(sym.name).showLocated))
+      enter(sym)
+    }
+
+    private def ensureCapacity(tableSize: Int)(using Context): Unit =
+      if (size >= tableSize * FillFactor) createHash(tableSize * 2)
+
+    private def createHash(tableSize: Int)(using Context): Unit =
+      if (size > tableSize * FillFactor) createHash(tableSize * 2)
+      else {
+        hashTable = new Array[ScopeEntry | Null](tableSize)
+        enterAllInHash(lastEntry)
+        // checkConsistent() // DEBUG
+      }
+
+    private def enterAllInHash(e: ScopeEntry | Null, n: Int = 0)(using Context): Unit =
+      if (e != null)
+        if (n < MaxRecursions) {
+          enterAllInHash(e.prev, n + 1)
+          enterInHash(e)
+        }
+        else {
+          var entries: List[ScopeEntry] = List()
+          var ee: ScopeEntry | Null = e
+          while (ee != null) {
+            entries = ee :: entries
+            ee = ee.prev
+          }
+          entries foreach enterInHash
+        }
+
+    /** Remove entry from this scope (which is required to be present) */
+    final def unlink(e: ScopeEntry)(using Context): Unit = {
+      if (lastEntry == e)
+        lastEntry = e.prev
+      else {
+        var e1 = lastEntry.nn
+        while (e1.prev != e) e1 = e1.prev.nn
+        e1.prev = e.prev
+      }
+      if (hashTable != null) {
+        val index = e.name.hashCode & (hashTable.nn.length - 1)
+        var e1 = hashTable.nn(index)
+        if (e1 == e)
+          hashTable.nn(index) = e.tail
+        else {
+          while (e1.nn.tail != e) e1 = e1.nn.tail
+          e1.nn.tail = e.tail
+        }
+      }
+      elemsCache = null
+      size -= 1
+    }
+
+    /** remove symbol from this scope if it is present */
+    final def unlink(sym: Symbol)(using Context): Unit =
+      unlink(sym, sym.name)
+
+    /** remove symbol from this scope if it is present under the given name */
+    final def unlink(sym: Symbol, name: Name)(using Context): Unit = {
+      var e = lookupEntry(name)
+      while (e != null) {
+        if (e.sym == sym) unlink(e)
+        e = lookupNextEntry(e)
+      }
+    }
+
+    /** Replace symbol `prev` (if it exists in current scope) by symbol `replacement`.
+     *  @pre `prev` and `replacement` have the same name.
+     */
+    final def replace(prev: Symbol, replacement: Symbol)(using Context): Unit = {
+      require(prev.name == replacement.name)
+      var e = lookupEntry(prev.name)
+      while (e != null) {
+        if (e.sym == prev) e.sym = replacement
+        e = lookupNextEntry(e)
+      }
+      elemsCache = null
+    }
+
+    /** Lookup a symbol entry matching given name.
+     */
+    override def lookupEntry(name: Name)(using Context): ScopeEntry | Null = {
+      var e: ScopeEntry | Null = null
+      if (hashTable != null) {
+        e = hashTable.nn(name.hashCode & (hashTable.nn.length - 1))
+        while ((e != null) && e.name != name)
+          e = e.tail
+      }
+      else {
+        e = lastEntry
+        while ((e != null) && e.name != name)
+          e = e.prev
+      }
+      if ((e == null) && (synthesize != null)) {
+        val sym = synthesize.uncheckedNN(name)
+        if (sym.exists) newScopeEntry(sym.name, sym) else e
+      }
+      else e
+    }
+
+    /** lookup next entry with same name as this one */
+    override final def lookupNextEntry(entry: ScopeEntry)(using Context): ScopeEntry | Null = {
+      var e: ScopeEntry | Null = entry
+      if (hashTable != null)
+        while ({ e = e.nn.tail ; (e != null) && e.uncheckedNN.name != entry.name }) ()
+      else
+        while ({ e = e.nn.prev ; (e != null) && e.uncheckedNN.name != entry.name }) ()
+      e
+    }
+
+    /** Returns all symbols as a list in the order they were entered in this scope.
+     *  Does _not_ include the elements of inherited scopes.
+     */
+    override final def toList(using Context): List[Symbol] = {
+      if (elemsCache == null) {
+        ensureComplete()
+        elemsCache = Nil
+        var e = lastEntry
+        while ((e != null) && e.owner == this) {
+          elemsCache = e.sym :: elemsCache.nn
+          e = e.prev
+        }
+      }
+      elemsCache.nn
+    }
+
+    override def implicitDecls(using Context): List[TermRef] = {
+      ensureComplete()
+      var irefs = new mutable.ListBuffer[TermRef]
+      var e = lastEntry
+      while (e != null) {
+        if (e.sym.isOneOf(GivenOrImplicitVal)) {
+          val d = e.sym.denot
+          irefs += TermRef(NoPrefix, d.symbol.asTerm).withDenot(d)
+        }
+        e = e.prev
+      }
+      irefs.toList
+    }
+
+    /** Vanilla scope - symbols are stored in declaration order.
+     */
+    final def sorted(using Context): List[Symbol] = toList
+
+    override def openForMutations: MutableScope = this
+
+    /** Check that all symbols in this scope are in their correct hashtable buckets. */
+    override def checkConsistent()(using Context): Unit = {
+      ensureComplete()
+      var e = lastEntry
+      while (e != null) {
+        var e1 = lookupEntry(e.name)
+        while (e1 != e && e1 != null) e1 = lookupNextEntry(e1)
+        assert(e1 == e, s"PANIC: Entry ${e.nn.name} is badly linked")
+        e = e.prev
+      }
+    }
+  }
+
+  /** Create a new scope */
+  def newScope(using Context): MutableScope =
+    new MutableScope(ctx.nestingLevel + 1)
+
+  def newScope(nestingLevel: Int): MutableScope = new MutableScope(nestingLevel)
+
+  /** Create a new scope nested in another one with which it shares its elements */
+  def newNestedScope(outer: Scope)(using Context): MutableScope = new MutableScope(outer)
+
+  /** Create a new scope with given initial elements */
+  def newScopeWith(elems: Symbol*)(using Context): MutableScope = {
+    val scope = newScope
+    elems foreach scope.enter
+    scope
+  }
+
+  /** Transform scope of members of `owner` using operation `op`
+   *  This is overridden by the reflective compiler to avoid creating new scopes for packages
+   */
+  def scopeTransform(owner: Symbol)(op: => MutableScope): MutableScope = op
+
+  /** The empty scope (immutable).
+   */
+  object EmptyScope extends Scope {
+    override private[dotc] def lastEntry: ScopeEntry | Null = null
+    override def size: Int = 0
+    override def nestingLevel: Int = 0
+    override def toList(using Context): List[Symbol] = Nil
+    override def cloneScope(using Context): MutableScope = unsupported("cloneScope")
+    override def lookupEntry(name: Name)(using Context): ScopeEntry | Null = null
+    override def lookupNextEntry(entry: ScopeEntry)(using Context): ScopeEntry | Null = null
+  }
+}
diff --git a/tests/pos-with-compiler-cc/dotc/core/Signature.scala b/tests/pos-with-compiler-cc/dotc/core/Signature.scala
new file mode 100644
index 000000000000..bd744ec01846
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/core/Signature.scala
@@ -0,0 +1,197 @@
+package dotty.tools.dotc
+package core
+
+import scala.annotation.tailrec
+
+import Names._, Types._, Contexts._, StdNames._, Decorators._
+import TypeErasure.sigName
+import Signature._
+
+/** The signature of a denotation.
+ *
+ *  Same-named denotations with different signatures are considered to be
+ *  overloads, see `SingleDenotation#matches` for more details.
+ *
+ *  A _method signature_ (a value of type `Signature`, excluding `NotAMethod`
+ *  and `OverloadedSignature`) is composed of a list of _parameter signatures_,
+ *  plus a _type signature_ for the final result type.
+ *
+ *  A _parameter signature_ (a value of type `ParamSig`) is either an integer,
+ *  representing the number of type parameters in a type parameter section, or
+ *  the _type signature_ of a term parameter.
+ *
+ *  A _type signature_ is the fully qualified name of the type symbol of the
+ *  type's erasure.
+ *
+ *  For instance a definition
+ *
+ *      def f[T, S](x: Int)(y: List[T]): S
+ *
+ *  would have signature
+ *
+ *      Signature(
+ *        List(2, "scala.Int".toTypeName, "scala.collection.immutable.List".toTypeName),
+ *        "java.lang.Object".toTypeName)
+ *
+ *  Note that `paramsSig` has one entry for *a whole type parameter section* but
+ *  one entry *for each term parameter* (currently, methods in Dotty can only
+ *  have one type parameter section but this encoding leaves the door open for
+ *  supporting multiple sections).
+ *
+ *  The signatures of non-method types are always `NotAMethod`.
+ *
+ *  There are three kinds of "missing" parts of signatures:
+ *
+ *   - tpnme.EMPTY          Result type marker for NotAMethod and OverloadedSignature
+ *   - tpnme.WILDCARD       Arises from a Wildcard or error type
+ *   - tpnme.Uninstantiated Arises from an uninstantiated type variable
+ */
+case class Signature(paramsSig: List[ParamSig], resSig: TypeName) {
+
+  /** Two names are consistent if they are the same or one of them is tpnme.Uninstantiated */
+  private def consistent(name1: ParamSig, name2: ParamSig) =
+    name1 == name2 || name1 == tpnme.Uninstantiated || name2 == tpnme.Uninstantiated
+
+  /** Does this signature coincide with that signature on their parameter parts?
+   *  This is the case if all parameter signatures are _consistent_, i.e. they are either
+   *  equal or on of them is tpnme.Uninstantiated.
+   */
+  final def consistentParams(that: Signature)(using Context): Boolean = {
+    @tailrec def loop(names1: List[ParamSig], names2: List[ParamSig]): Boolean =
+      if (names1.isEmpty) names2.isEmpty
+      else !names2.isEmpty && consistent(names1.head, names2.head) && loop(names1.tail, names2.tail)
+    loop(this.paramsSig, that.paramsSig)
+  }
+
+  /** `that` signature, but keeping all corresponding parts of `this` signature. */
+  final def updateWith(that: Signature): Signature = {
+    def update[T <: ParamSig](name1: T, name2: T): T =
+      if (consistent(name1, name2)) name1 else name2
+    if (this == that) this
+    else if (!this.paramsSig.hasSameLengthAs(that.paramsSig)) that
+    else {
+      val mapped = Signature(
+          this.paramsSig.zipWithConserve(that.paramsSig)(update),
+          update(this.resSig, that.resSig))
+      if (mapped == this) this else mapped
+    }
+  }
+
+  /** The degree to which this signature matches `that`.
+   *  If parameter signatures are consistent and result types names match (i.e. they are the same
+   *  or one is a wildcard), the result is `FullMatch`.
+   *  If only the parameter signatures are consistent, the result is either
+   *  `MethodNotAMethodMatch` (if one side is a method signature and the other isn't),
+   *  or `ParamMatch`.
+   *  If the parameters are inconsistent, the result is always `NoMatch`.
+   */
+  final def matchDegree(that: Signature)(using Context): MatchDegree =
+    if consistentParams(that) then
+      if resSig == that.resSig || isWildcard(resSig) || isWildcard(that.resSig) then
+        FullMatch
+      else if (this == NotAMethod) != (that == NotAMethod) then
+        MethodNotAMethodMatch
+      else
+        ParamMatch
+    else
+      NoMatch
+
+  /** Does this signature potentially clash with `that` ? */
+  def clashes(that: Signature)(using Context): Boolean =
+    matchDegree(that) == FullMatch
+
+  private def isWildcard(name: TypeName) = name == tpnme.WILDCARD
+
+  /** Construct a signature by prepending the signature names of the given `params`
+   *  to the parameter part of this signature.
+   *
+   *  Like Signature#apply, the result is only cacheable if `isUnderDefined == false`.
+   */
+  def prependTermParams(params: List[Type], sourceLanguage: SourceLanguage)(using Context): Signature =
+    Signature(params.map(p => sigName(p, sourceLanguage)) ::: paramsSig, resSig)
+
+  /** Construct a signature by prepending the length of a type parameter section
+   *  to the parameter part of this signature.
+   *
+   *  Like Signature#apply, the result is only cacheable if `isUnderDefined == false`.
+   */
+  def prependTypeParams(typeParamSigsSectionLength: Int)(using Context): Signature =
+    Signature(typeParamSigsSectionLength :: paramsSig, resSig)
+
+  /** A signature is under-defined if its paramsSig part contains at least one
+   *  `tpnme.Uninstantiated`. Under-defined signatures arise when taking a signature
+   *  of a type that still contains uninstantiated type variables.
+   */
+  def isUnderDefined(using Context): Boolean =
+    paramsSig.contains(tpnme.Uninstantiated) || resSig == tpnme.Uninstantiated
+}
+
+object Signature {
+  /** A parameter signature, see the documentation of `Signature` for more information. */
+  type ParamSig = TypeName | Int
+    // Erasure means that our Ints will be boxed, but Integer#valueOf caches
+    // small values, so the performance hit should be minimal.
+
+  enum MatchDegree {
+    /** The signatures are unrelated. */
+    case NoMatch
+    /** The parameter signatures are equivalent. */
+    case ParamMatch
+    /** Both signatures have no parameters, one is a method and the other isn't.
+     *
+     *  @see NotAMethod
+     */
+    case MethodNotAMethodMatch
+    /** The parameter and result type signatures are equivalent. */
+    case FullMatch
+  }
+  export MatchDegree._
+
+  /** The signature of everything that's not a method, i.e. that has
+   *  a type different from PolyType or MethodType.
+   */
+  val NotAMethod: Signature = Signature(List(), EmptyTypeName)
+
+  /** The signature of an overloaded denotation.
+   */
+  val OverloadedSignature: Signature = Signature(List(tpnme.OVERLOADED), EmptyTypeName)
+
+  /** The signature of a method with no parameters and result type `resultType`.
+   *
+   *  The resulting value is only cacheable if `isUnderDefined == false`,
+   *  otherwise the signature will change once the contained type variables have
+   *  been instantiated.
+   */
+  def apply(resultType: Type, sourceLanguage: SourceLanguage)(using Context): Signature = {
+    assert(!resultType.isInstanceOf[ExprType])
+    apply(Nil, sigName(resultType, sourceLanguage))
+  }
+
+  val lexicographicOrdering: Ordering[Signature] = new Ordering[Signature] {
+    val paramSigOrdering: Ordering[Signature.ParamSig] = new Ordering[Signature.ParamSig] {
+      def compare(x: ParamSig, y: ParamSig): Int = x match { // `(x, y) match` leads to extra allocations
+        case x: TypeName =>
+          y match {
+            case y: TypeName =>
+              // `Ordering[TypeName]` doesn't work due to `Ordering` still being invariant
+              summon[Ordering[Name]].compare(x, y)
+            case y: Int =>
+              1
+          }
+        case x: Int =>
+          y match {
+            case y: Name =>
+              -1
+            case y: Int =>
+              x - y
+          }
+      }
+    }
+    def compare(x: Signature, y: Signature): Int = {
+      import scala.math.Ordering.Implicits.seqOrdering
+      val paramsOrdering = seqOrdering(paramSigOrdering).compare(x.paramsSig, y.paramsSig)
+      if (paramsOrdering != 0) paramsOrdering
+      else summon[Ordering[Name]].compare(x.resSig, y.resSig)
+    }
+  }
+}
diff --git a/tests/pos-with-compiler-cc/dotc/core/StagingContext.scala b/tests/pos-with-compiler-cc/dotc/core/StagingContext.scala
new file mode 100644
index 000000000000..41e77655d5d6
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/core/StagingContext.scala
@@ -0,0 +1,58 @@
+package dotty.tools.dotc.core
+
+import dotty.tools.dotc.ast.tpd
+import dotty.tools.dotc.core.Contexts._
+import dotty.tools.dotc.ast.tpd
+import dotty.tools.dotc.util.Property
+import dotty.tools.dotc.transform.PCPCheckAndHeal
+
+object StagingContext {
+
+  /** A key to be used in a context property that tracks the quotation level */
+  private val QuotationLevel = new Property.Key[Int]
+
+  /** A key to be used in a context property that tracks the quotation stack.
+   *  Stack containing the Quotes references received by the surrounding quotes.
+   */
+  private val QuotesStack = new Property.Key[List[tpd.Tree]]
+
+  private val TaggedTypes = new Property.Key[PCPCheckAndHeal.QuoteTypeTags]
+
+  /** All enclosing calls that are currently inlined, from innermost to outermost. */
+  def level(using Context): Int =
+    ctx.property(QuotationLevel).getOrElse(0)
+
+  /** Context with an incremented quotation level. */
+  def quoteContext(using Context): Context =
+    ctx.fresh.setProperty(QuotationLevel, level + 1)
+
+  /** Context with an incremented quotation level and pushes a reference to a Quotes on the quote context stack */
+  def pushQuotes(qctxRef: tpd.Tree)(using Context): Context =
+    val old = ctx.property(QuotesStack).getOrElse(List.empty)
+    ctx.fresh.setProperty(QuotationLevel, level + 1)
+             .setProperty(QuotesStack, qctxRef :: old)
+
+  /** Context with a decremented quotation level. */
+  def spliceContext(using Context): Context =
+    ctx.fresh.setProperty(QuotationLevel, level - 1)
+
+  def contextWithQuoteTypeTags(taggedTypes: PCPCheckAndHeal.QuoteTypeTags)(using Context) =
+    ctx.fresh.setProperty(TaggedTypes, taggedTypes)
+
+  def getQuoteTypeTags(using Context): PCPCheckAndHeal.QuoteTypeTags =
+    ctx.property(TaggedTypes).get
+
+  /** Context with a decremented quotation level and pops the Some of top of the quote context stack or None if the stack is empty.
+   *  The quotation stack could be empty if we are in a top level splice or an erroneous splice directly within a top level splice.
+   */
+  def popQuotes()(using Context): (Option[tpd.Tree], Context) =
+    val ctx1 = ctx.fresh.setProperty(QuotationLevel, level - 1)
+    val head =
+      ctx.property(QuotesStack) match
+        case Some(x :: xs) =>
+          ctx1.setProperty(QuotesStack, xs)
+          Some(x)
+        case _ =>
+          None // Splice at level 0 or lower
+    (head, ctx1)
+}
diff --git a/tests/pos-with-compiler-cc/dotc/core/StdNames.scala b/tests/pos-with-compiler-cc/dotc/core/StdNames.scala
new file mode 100644
index 000000000000..c0aca9d8abf4
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/core/StdNames.scala
@@ -0,0 +1,950 @@
+package dotty.tools.dotc
+package core
+
+import scala.collection.mutable
+import scala.annotation.switch
+import Names._
+import Symbols._
+import Contexts._
+
+object StdNames {
+
+/** Base strings from which synthetic names are derived. */
+
+  object str {
+    inline val SETTER_SUFFIX            = "_="
+    inline val EXPAND_SEPARATOR         = "$$"
+    inline val TRAIT_SETTER_SEPARATOR   = "$_setter_$"
+    inline val SUPER_PREFIX             = "super$"
+    inline val INITIALIZER_PREFIX       = "initial$"
+    inline val AVOID_CLASH_SUFFIX       = "$_avoid_name_clash_$"
+    inline val MODULE_SUFFIX            = "$"
+    inline val TOPLEVEL_SUFFIX          = "$package"
+    inline val NAME_JOIN                = "$"
+    inline val DEFAULT_GETTER           = "$default$"
+    inline val LOCALDUMMY_PREFIX        = "<local "       // owner of local blocks
+    inline val ANON_CLASS               = "$anon"
+    inline val ANON_FUN                 = "$anonfun"
+
+    inline val REPL_SESSION_LINE  = "rs$line$"
+    inline val REPL_ASSIGN_SUFFIX = "$assign"
+    inline val REPL_RES_PREFIX    = "res"
+
+    inline val MODULE_INSTANCE_FIELD      = "MODULE$"
+
+    inline val Function                   = "Function"
+    inline val ErasedFunction             = "ErasedFunction"
+    inline val ContextFunction            = "ContextFunction"
+    inline val ErasedContextFunction      = "ErasedContextFunction"
+    inline val AbstractFunction           = "AbstractFunction"
+    inline val Tuple                      = "Tuple"
+    inline val Product                    = "Product"
+
+    def sanitize(str: String): String = str.replaceAll("""[<>]""", """\$""").nn
+  }
+
+  abstract class DefinedNames[N <: Name] {
+    protected implicit def fromString(s: String): N
+    protected def fromName(name: Name): N = fromString(name.toString)
+
+    private val kws = mutable.Set[N]()
+    protected def kw(name: N): N = { kws += name; name }
+
+    final val keywords: collection.Set[N] = kws
+  }
+
+  abstract class ScalaNames[N <: Name] extends DefinedNames[N] {
+    protected def encode(s: String): N = fromName(fromString(s).encode)
+
+// Keywords, need to come first -----------------------
+
+    final val ABSTRACTkw: N  = kw("abstract")
+    final val CASEkw: N      = kw("case")
+    final val CLASSkw: N     = kw("class")
+    final val CATCHkw: N     = kw("catch")
+    final val DEFkw: N       = kw("def")
+    final val DOkw: N        = kw("do")
+    final val ELSEkw: N      = kw("else")
+    final val EXTENDSkw: N   = kw("extends")
+    final val FALSEkw: N     = kw("false")
+    final val FINALkw: N     = kw("final")
+    final val FINALLYkw: N   = kw("finally")
+    final val FORkw: N       = kw("for")
+    final val FORSOMEkw: N   = kw("forSome")
+    final val IFkw: N        = kw("if")
+    final val IMPLICITkw: N  = kw("implicit")
+    final val IMPORTkw: N    = kw("import")
+    final val LAZYkw: N      = kw("lazy")
+    final val MACROkw: N     = kw("macro")
+    final val MATCHkw: N     = kw("match")
+    final val NEWkw: N       = kw("new")
+    final val NULLkw: N      = kw("null")
+    final val OBJECTkw: N    = kw("object")
+    final val OVERRIDEkw: N  = kw("override")
+    final val PACKAGEkw: N   = kw("package")
+    final val PRIVATEkw: N   = kw("private")
+    final val PROTECTEDkw: N = kw("protected")
+    final val RETURNkw: N    = kw("return")
+    final val SEALEDkw: N    = kw("sealed")
+    final val SUPERkw: N     = kw("super")
+    final val THENkw: N      = kw("then")
+    final val THISkw: N      = kw("this")
+    final val THROWkw: N     = kw("throw")
+    final val TRAITkw: N     = kw("trait")
+    final val TRUEkw: N      = kw("true")
+    final val TRYkw: N       = kw("try")
+    final val TYPEkw: N      = kw("type")
+    final val VALkw: N       = kw("val")
+    final val VARkw: N       = kw("var")
+    final val WITHkw: N      = kw("with")
+    final val WHILEkw: N     = kw("while")
+    final val YIELDkw: N     = kw("yield")
+    final val DOTkw: N       = kw(".")
+    final val USCOREkw: N    = kw("_")
+    final val COLONkw: N     = kw(":")
+    final val EQUALSkw: N    = kw("=")
+    final val ARROWkw: N     = kw("=>")
+    final val LARROWkw: N    = kw("<-")
+    final val SUBTYPEkw: N   = kw("<:")
+    final val VIEWBOUNDkw: N = kw("<%")
+    final val SUPERTYPEkw: N = kw(">:")
+    final val HASHkw: N      = kw("#")
+    final val ATkw: N        = kw("@")
+
+    val ANON_CLASS: N                 = str.ANON_CLASS
+    val ANON_FUN: N                   = str.ANON_FUN
+    val BITMAP_PREFIX: N              = "bitmap$"  // @darkdimius: $bitmap? Also, the next 4 names are unused.
+    val BITMAP_NORMAL: N              = BITMAP_PREFIX         // initialization bitmap for public/protected lazy vals
+    val BITMAP_TRANSIENT: N           = s"${BITMAP_PREFIX}trans$$"    // initialization bitmap for transient lazy vals
+    val BITMAP_CHECKINIT: N           = s"${BITMAP_PREFIX}init$$"      // initialization bitmap for checkinit values
+    val BITMAP_CHECKINIT_TRANSIENT: N = s"${BITMAP_PREFIX}inittrans$$" // initialization bitmap for transient checkinit values
+    val DEFAULT_GETTER: N             = str.DEFAULT_GETTER
+    val DEFAULT_GETTER_INIT: N        = "$lessinit$greater"
+    val DO_WHILE_PREFIX: N            = "doWhile$"
+    val DOLLAR_VALUES: N              = "$values"
+    val DOLLAR_NEW: N                 = "$new"
+    val EMPTY: N                      = ""
+    val EMPTY_PACKAGE: N              = "<empty>"
+    val EXCEPTION_RESULT_PREFIX: N    = "exceptionResult"
+    val EXPAND_SEPARATOR: N           = str.EXPAND_SEPARATOR
+    val IMPORT: N                     = "<import>"
+    val MODULE_SUFFIX: N              = str.MODULE_SUFFIX
+    val OPS_PACKAGE: N                = "<special-ops>"
+    val OVERLOADED: N                 = "<overloaded>"
+    val PACKAGE: N                    = "package"
+    val ROOT: N                       = "<root>"
+    val SPECIALIZED_SUFFIX: N         = "$sp"
+    val SUPER_PREFIX: N               = "super$"
+    val WHILE_PREFIX: N               = "while$"
+    val DEFAULT_EXCEPTION_NAME: N     = "ex$"
+    val INITIALIZER_PREFIX: N         = "initial$"
+    val BOUNDTYPE_ANNOT: N            = "$boundType$"
+    val QUOTE: N                      = "'"
+    val TYPE_QUOTE: N                 = "type_'"
+    val TRAIT_SETTER_SEPARATOR: N     = str.TRAIT_SETTER_SEPARATOR
+    val AMBIGUOUS: N                  = "/* ambiguous */"
+    val MISSING: N                    = "/* missing */"
+
+    // value types (and AnyRef) are all used as terms as well
+    // as (at least) arguments to the @specialize annotation.
+    final val Boolean: N = "Boolean"
+    final val Byte: N    = "Byte"
+    final val Char: N    = "Char"
+    final val Double: N  = "Double"
+    final val Float: N   = "Float"
+    final val Int: N     = "Int"
+    final val Long: N    = "Long"
+    final val Short: N   = "Short"
+    final val Unit: N    = "Unit"
+
+    final val ScalaValueNames: _root_.scala.List[N] =
+      _root_.scala.List(Byte, Char, Short, Int, Long, Float, Double, Boolean, Unit)
+
+    // some types whose companions we utilize
+    final val AnyRef: N     = "AnyRef"
+    final val Array: N      = "Array"
+    final val List: N       = "List"
+    final val Seq: N        = "Seq"
+    final val Symbol: N     = "Symbol"
+    final val ClassTag: N   = "ClassTag"
+    final val classTag: N   = "classTag"
+    final val WeakTypeTag: N = "WeakTypeTag"
+    final val TypeTag : N   = "TypeTag"
+    final val typeTag: N    = "typeTag"
+    final val Expr: N       = "Expr"
+    final val String: N     = "String"
+    final val Annotation: N = "Annotation"
+
+    // fictions we use as both types and terms
+    final val ERROR: N    = "<error>"
+    final val NO_NAME: N  = "<none>"  // formerly NOSYMBOL
+    final val WILDCARD: N = "_"
+
+// ----- Type names -----------------------------------------
+
+    final val BYNAME_PARAM_CLASS: N             = "<byname>"
+    final val EQUALS_PATTERN: N                 = "<equals>"
+    final val LOCAL_CHILD: N                    = "<local child>"
+    final val REPEATED_PARAM_CLASS: N           = "<repeated>"
+    final val WILDCARD_STAR: N                  = "_*"
+    final val REIFY_TREECREATOR_PREFIX: N       = "$treecreator"
+    final val REIFY_TYPECREATOR_PREFIX: N       = "$typecreator"
+
+    final val Any: N                 = "Any"
+    final val AnyKind: N             = "AnyKind"
+    final val AnyVal: N              = "AnyVal"
+    final val ExprApi: N             = "ExprApi"
+    final val Mirror: N              = "Mirror"
+    final val Nothing: N             = "Nothing"
+    final val NotNull: N             = "NotNull"
+    final val Null: N                = "Null"
+    final val Object: N              = "Object"
+    final val FromJavaObject: N      = "<FromJavaObject>"
+    final val Product: N             = "Product"
+    final val PartialFunction: N     = "PartialFunction"
+    final val PrefixType: N          = "PrefixType"
+    final val Serializable: N        = "Serializable"
+    final val Singleton: N           = "Singleton"
+    final val Throwable: N           = "Throwable"
+    final val IOOBException: N       = "IndexOutOfBoundsException"
+    final val FunctionXXL: N         = "FunctionXXL"
+
+    final val Abs: N                  = "Abs"
+    final val And: N                  = "&&"
+    final val BitwiseAnd: N           = "BitwiseAnd"
+    final val BitwiseOr: N            = "BitwiseOr"
+    final val Div: N                  = "/"
+    final val Equals: N               = "=="
+    final val Ge: N                   = ">="
+    final val Gt: N                   = ">"
+    final val IsConst: N              = "IsConst"
+    final val Le: N                   = "<="
+    final val Length: N               = "Length"
+    final val Lt: N                   = "<"
+    final val Matches: N              = "Matches"
+    final val Max: N                  = "Max"
+    final val Min: N                  = "Min"
+    final val Minus: N                = "-"
+    final val Mod: N                  = "%"
+    final val Negate: N               = "Negate"
+    final val Not: N                  = "!"
+    final val NotEquals: N            = "!="
+    final val NumberOfLeadingZeros: N = "NumberOfLeadingZeros"
+    final val Or: N                   = "||"
+    final val Plus: N                 = "+"
+    final val S: N                    = "S"
+    final val Substring: N            = "Substring"
+    final val CharAt: N               = "CharAt"
+    final val Times: N                = "*"
+    final val ToInt: N                = "ToInt"
+    final val ToLong: N               = "ToLong"
+    final val ToFloat: N              = "ToFloat"
+    final val ToDouble: N             = "ToDouble"
+    final val ToString: N             = "ToString"
+    final val Xor: N                  = "^"
+
+    final val ClassfileAnnotation: N = "ClassfileAnnotation"
+    final val ClassManifest: N       = "ClassManifest"
+    final val Enum: N                = "Enum"
+    final val Group: N               = "Group"
+    final val Tree: N                = "Tree"
+    final val Type : N               = "Type"
+    final val TypeTree: N            = "TypeTree"
+    final val Underlying: N          = "Underlying"
+
+    // Annotation simple names, used in Namer
+    final val BeanPropertyAnnot: N = "BeanProperty"
+    final val BooleanBeanPropertyAnnot: N = "BooleanBeanProperty"
+    final val bridgeAnnot: N = "bridge"
+
+    // Classfile Attributes
+    final val AnnotationDefaultATTR: N            = "AnnotationDefault"
+    final val BridgeATTR: N                       = "Bridge"
+    final val CodeATTR: N                         = "Code"
+    final val ConstantValueATTR: N                = "ConstantValue"
+    final val DeprecatedATTR: N                   = "Deprecated"
+    final val ExceptionsATTR: N                   = "Exceptions"
+    final val InnerClassesATTR: N                 = "InnerClasses"
+    final val MethodParametersATTR: N             = "MethodParameters"
+    final val LineNumberTableATTR: N              = "LineNumberTable"
+    final val LocalVariableTableATTR: N           = "LocalVariableTable"
+    final val RuntimeVisibleAnnotationATTR: N     = "RuntimeVisibleAnnotations"   // RetentionPolicy.RUNTIME
+    final val RuntimeInvisibleAnnotationATTR: N   = "RuntimeInvisibleAnnotations" // RetentionPolicy.CLASS
+    final val RuntimeParamAnnotationATTR: N       = "RuntimeVisibleParameterAnnotations" // RetentionPolicy.RUNTIME (annotations on parameters)
+    final val ScalaATTR: N                        = "Scala"
+    final val ScalaSignatureATTR: N               = "ScalaSig"
+    final val TASTYATTR: N                        = "TASTY"
+    final val SignatureATTR: N                    = "Signature"
+    final val SourceFileATTR: N                   = "SourceFile"
+    final val SyntheticATTR: N                    = "Synthetic"
+
+
+// ----- Term names -----------------------------------------
+
+    // Compiler-internal
+    val CAPTURE_ROOT: N             = "*"
+    val CONSTRUCTOR: N              = "<init>"
+    val STATIC_CONSTRUCTOR: N       = "<clinit>"
+    val EVT2U: N                    = "evt2u$"
+    val EQEQ_LOCAL_VAR: N           = "eqEqTemp$"
+    val LAZY_FIELD_OFFSET: N        = "OFFSET$"
+    val OUTER: N                    = "$outer"
+    val REFINE_CLASS: N             = "<refinement>"
+    val ROOTPKG: N                  = "_root_"
+    val SELF: N                     = "$this"
+    val SKOLEM: N                   = "<skolem>"
+    val TRAIT_CONSTRUCTOR: N        = "$init$"
+    val THROWS: N                   = "$throws"
+    val U2EVT: N                    = "u2evt$"
+    val ALLARGS: N                  = "$allArgs"
+
+    final val Nil: N                = "Nil"
+    final val Predef: N             = "Predef"
+    final val BoxedUnit: N          = "BoxedUnit"
+
+    val x_0 : N  = "x$0"
+    val x_1 : N  = "x$1"
+    val x_2 : N  = "x$2"
+    val x_3 : N  = "x$3"
+    val x_4 : N  = "x$4"
+    val x_5 : N  = "x$5"
+    val x_6 : N  = "x$6"
+    val x_7 : N  = "x$7"
+    val x_8 : N  = "x$8"
+    val x_9 : N  = "x$9"
+    val _1 : N  = "_1"
+    val _2 : N  = "_2"
+    val _3 : N  = "_3"
+    val _4 : N  = "_4"
+    val _5 : N  = "_5"
+    val _6 : N  = "_6"
+    val _7 : N  = "_7"
+    val _8 : N  = "_8"
+    val _9 : N  = "_9"
+    val _10 : N = "_10"
+    val _11 : N = "_11"
+    val _12 : N = "_12"
+    val _13 : N = "_13"
+    val _14 : N = "_14"
+    val _15 : N = "_15"
+    val _16 : N = "_16"
+    val _17 : N = "_17"
+    val _18 : N = "_18"
+    val _19 : N = "_19"
+    val _20 : N = "_20"
+    val _21 : N = "_21"
+    val _22 : N = "_22"
+
+    val * : N   = "*"
+    val ? : N   = "?"
+    val ??? : N = "???"
+
+    val genericWrapArray: N     = "genericWrapArray"
+    def wrapRefArray: N         = "wrapRefArray"
+    def wrapXArray(clsName: Name): N = "wrap" + clsName + "Array"
+
+    // Compiler utilized names
+
+    val AnnotatedType: N        = "AnnotatedType"
+    val AppliedTypeTree: N      = "AppliedTypeTree"
+    val ArrayAnnotArg: N        = "ArrayAnnotArg"
+    val CAP: N                  = "CAP"
+    val Constant: N             = "Constant"
+    val ConstantType: N         = "ConstantType"
+    val Eql: N                  = "Eql"
+    val EnumValue: N            = "EnumValue"
+    val ExistentialTypeTree: N  = "ExistentialTypeTree"
+    val Flag : N                = "Flag"
+    val Ident: N                = "Ident"
+    val Import: N               = "Import"
+    val Literal: N              = "Literal"
+    val LiteralAnnotArg: N      = "LiteralAnnotArg"
+    val Matchable: N            = "Matchable"
+    val MatchCase: N            = "MatchCase"
+    val MirroredElemTypes: N    = "MirroredElemTypes"
+    val MirroredElemLabels: N   = "MirroredElemLabels"
+    val MirroredLabel: N        = "MirroredLabel"
+    val MirroredMonoType: N     = "MirroredMonoType"
+    val MirroredType: N         = "MirroredType"
+    val Modifiers: N            = "Modifiers"
+    val NestedAnnotArg: N       = "NestedAnnotArg"
+    val NoFlags: N              = "NoFlags"
+    val NoPrefix: N             = "NoPrefix"
+    val NoSymbol: N             = "NoSymbol"
+    val NoType: N               = "NoType"
+    val Pair: N                 = "Pair"
+    val Ref: N                  = "Ref"
+    val RootPackage: N          = "RootPackage"
+    val RootClass: N            = "RootClass"
+    val Select: N               = "Select"
+    val Shape: N                = "Shape"
+    val StringContext: N        = "StringContext"
+    val This: N                 = "This"
+    val ThisType: N             = "ThisType"
+    val Tuple2: N               = "Tuple2"
+    val TYPE_ : N               = "TYPE"
+    val TypeApply: N            = "TypeApply"
+    val TypeRef: N              = "TypeRef"
+    val UNIT : N                = "UNIT"
+    val acc: N                  = "acc"
+    val adhocExtensions: N      = "adhocExtensions"
+    val annotation: N           = "annotation"
+    val any2stringadd: N        = "any2stringadd"
+    val anyHash: N              = "anyHash"
+    val anyValClass: N          = "anyValClass"
+    val append: N               = "append"
+    val apply: N                = "apply"
+    val applyDynamic: N         = "applyDynamic"
+    val applyDynamicNamed: N    = "applyDynamicNamed"
+    val applyOrElse: N          = "applyOrElse"
+    val args : N                = "args"
+    val argv : N                = "argv"
+    val argGetter : N           = "argGetter"
+    val arrayClass: N           = "arrayClass"
+    val arrayElementClass: N    = "arrayElementClass"
+    val arrayType: N            = "arrayType"
+    val arrayValue: N           = "arrayValue"
+    val array_apply : N         = "array_apply"
+    val array_clone : N         = "array_clone"
+    val array_length : N        = "array_length"
+    val array_update : N        = "array_update"
+    val arraycopy: N            = "arraycopy"
+    val as: N                   = "as"
+    val asTerm: N               = "asTerm"
+    val asModule: N             = "asModule"
+    val asMethod: N             = "asMethod"
+    val asType: N               = "asType"
+    val asClass: N              = "asClass"
+    val asInstanceOf_ : N       = "asInstanceOf"
+    val asInstanceOfPM: N       = "$asInstanceOf$"
+    val assert_ : N             = "assert"
+    val assume_ : N             = "assume"
+    val box: N                  = "box"
+    val build : N               = "build"
+    val bundle: N               = "bundle"
+    val bytes: N                = "bytes"
+    val canEqual_ : N           = "canEqual"
+    val canEqualAny : N         = "canEqualAny"
+    val caps: N                 = "caps"
+    val captureChecking: N      = "captureChecking"
+    val checkInitialized: N     = "checkInitialized"
+    val classOf: N              = "classOf"
+    val classType: N            = "classType"
+    val clone_ : N              = "clone"
+    val cmd: N                  = "cmd"
+    val command: N              = "command"
+    val common: N               = "common"
+    val compiletime : N         = "compiletime"
+    val conforms_ : N           = "$conforms"
+    val contents: N             = "contents"
+    val copy: N                 = "copy"
+    val currentMirror: N        = "currentMirror"
+    val create: N               = "create"
+    val definitions: N          = "definitions"
+    val delayedInit: N          = "delayedInit"
+    val delayedInitArg: N       = "delayedInit$body"
+    val deprecated: N           = "deprecated"
+    val derived: N              = "derived"
+    val derives: N              = "derives"
+    val doubleHash: N           = "doubleHash"
+    val dotty: N                = "dotty"
+    val drop: N                 = "drop"
+    val dynamics: N             = "dynamics"
+    val elem: N                 = "elem"
+    val elems: N                = "elems"
+    val emptyValDef: N          = "emptyValDef"
+    val end: N                  = "end"
+    val ensureAccessible : N    = "ensureAccessible"
+    val eq: N                   = "eq"
+    val eqInstance: N           = "eqInstance"
+    val equalsNumChar : N       = "equalsNumChar"
+    val equalsNumNum : N        = "equalsNumNum"
+    val equalsNumObject : N     = "equalsNumObject"
+    val equals_ : N             = "equals"
+    val erased: N               = "erased"
+    val error: N                = "error"
+    val eval: N                 = "eval"
+    val eqlAny: N               = "eqlAny"
+    val ex: N                   = "ex"
+    val extension: N            = "extension"
+    val experimental: N         = "experimental"
+    val f: N                    = "f"
+    val false_ : N              = "false"
+    val filter: N               = "filter"
+    val finalize_ : N           = "finalize"
+    val find_ : N               = "find"
+    val flagsFromBits : N       = "flagsFromBits"
+    val flatMap: N              = "flatMap"
+    val floatHash: N            = "floatHash"
+    val foreach: N              = "foreach"
+    val format: N               = "format"
+    val fromDigits: N           = "fromDigits"
+    val fromProduct: N          = "fromProduct"
+    val genericArrayOps: N      = "genericArrayOps"
+    val genericClass: N         = "genericClass"
+    val get: N                  = "get"
+    val getClass_ : N           = "getClass"
+    val getOrElse: N            = "getOrElse"
+    val hasNext: N              = "hasNext"
+    val hashCode_ : N           = "hashCode"
+    val _hashCode_ : N          = "_hashCode"
+    val hash_ : N               = "hash"
+    val head: N                 = "head"
+    val higherKinds: N          = "higherKinds"
+    val idx: N                  = "idx"
+    val identity: N             = "identity"
+    val implicitConversions: N  = "implicitConversions"
+    val implicitly: N           = "implicitly"
+    val in: N                   = "in"
+    val inline: N               = "inline"
+    val infix: N                = "infix"
+    val info: N                 = "info"
+    val inlinedEquals: N        = "inlinedEquals"
+    val internal: N             = "internal"
+    val isArray: N              = "isArray"
+    val isDefinedAt: N          = "isDefinedAt"
+    val isDefinedAtImpl: N      = "$isDefinedAt"
+    val isDefined: N            = "isDefined"
+    val isEmpty: N              = "isEmpty"
+    val isInstanceOf_ : N       = "isInstanceOf"
+    val isInstanceOfPM: N       = "$isInstanceOf$"
+    val java: N                 = "java"
+    val key: N                  = "key"
+    val lang: N                 = "lang"
+    val language: N             = "language"
+    val length: N               = "length"
+    val lengthCompare: N        = "lengthCompare"
+    val longHash: N             = "longHash"
+    val macroThis : N           = "_this"
+    val macroContext : N        = "c"
+    val main: N                 = "main"
+    val manifest: N             = "manifest"
+    val ManifestFactory: N      = "ManifestFactory"
+    val manifestToTypeTag: N    = "manifestToTypeTag"
+    val map: N                  = "map"
+    val materializeClassTag: N  = "materializeClassTag"
+    val materializeWeakTypeTag: N = "materializeWeakTypeTag"
+    val materializeTypeTag: N   = "materializeTypeTag"
+    val mirror : N              = "mirror"
+    val moduleClass : N         = "moduleClass"
+    val name: N                 = "name"
+    val nameDollar: N           = "$name"
+    val ne: N                   = "ne"
+    val newFreeTerm: N          = "newFreeTerm"
+    val newFreeType: N          = "newFreeType"
+    val newScopeWith: N         = "newScopeWith"
+    val next: N                 = "next"
+    val nmeNewTermName: N       = "newTermName"
+    val nmeNewTypeName: N       = "newTypeName"
+    val noAutoTupling: N        = "noAutoTupling"
+    val normalize: N            = "normalize"
+    val notifyAll_ : N          = "notifyAll"
+    val notify_ : N             = "notify"
+    val null_ : N               = "null"
+    val ofDim: N                = "ofDim"
+    val on: N                   = "on"
+    val opaque: N               = "opaque"
+    val open: N                 = "open"
+    val ordinal: N              = "ordinal"
+    val ordinalDollar: N        = "$ordinal"
+    val ordinalDollar_ : N      = "_$ordinal"
+    val origin: N               = "origin"
+    val parameters: N           = "parameters"
+    val parts: N                = "parts"
+    val postfixOps: N           = "postfixOps"
+    val prefix : N              = "prefix"
+    val processEscapes: N       = "processEscapes"
+    val productArity: N         = "productArity"
+    val productElement: N       = "productElement"
+    val productElementName: N   = "productElementName"
+    val productIterator: N      = "productIterator"
+    val productPrefix: N        = "productPrefix"
+    val quotes : N              = "quotes"
+    val raw_ : N                = "raw"
+    val refl: N                 = "refl"
+    val reflect: N              = "reflect"
+    val reflectiveSelectable: N = "reflectiveSelectable"
+    val reify : N               = "reify"
+    val releaseFence : N        = "releaseFence"
+    val retains: N              = "retains"
+    val retainsByName: N        = "retainsByName"
+    val rootMirror : N          = "rootMirror"
+    val run: N                  = "run"
+    val runOrElse: N            = "runOrElse"
+    val runtime: N              = "runtime"
+    val runtimeClass: N         = "runtimeClass"
+    val runtimeMirror: N        = "runtimeMirror"
+    val s: N                    = "s"
+    val sameElements: N         = "sameElements"
+    val scala : N               = "scala"
+    val selectDynamic: N        = "selectDynamic"
+    val selectOverloadedMethod: N = "selectOverloadedMethod"
+    val selectTerm: N           = "selectTerm"
+    val selectType: N           = "selectType"
+    val self: N                 = "self"
+    val seqToArray: N           = "seqToArray"
+    val setAccessible: N        = "setAccessible"
+    val setAnnotations: N       = "setAnnotations"
+    val setSymbol: N            = "setSymbol"
+    val setType: N              = "setType"
+    val setTypeSignature: N     = "setTypeSignature"
+    val standardInterpolator: N = "standardInterpolator"
+    val staticClass : N         = "staticClass"
+    val staticModule : N        = "staticModule"
+    val staticPackage : N       = "staticPackage"
+    val strictEquality: N       = "strictEquality"
+    val synchronized_ : N       = "synchronized"
+    val tag: N                  = "tag"
+    val tail: N                 = "tail"
+    val `then` : N              = "then"
+    val this_ : N               = "this"
+    val thisPrefix : N          = "thisPrefix"
+    val throw_ : N              = "throw"
+    val throws: N               = "throws"
+    val toArray: N              = "toArray"
+    val toList: N               = "toList"
+    val toObjectArray : N       = "toObjectArray"
+    val toSeq: N                = "toSeq"
+    val toString_ : N           = "toString"
+    val toTypeConstructor: N    = "toTypeConstructor"
+    val tpe : N                 = "tpe"
+    val transparent : N         = "transparent"
+    val tree : N                = "tree"
+    val true_ : N               = "true"
+    val typedProductIterator: N = "typedProductIterator"
+    val typeTagToManifest: N    = "typeTagToManifest"
+    val unapply: N              = "unapply"
+    val unapplySeq: N           = "unapplySeq"
+    val unbox: N                = "unbox"
+    val universe: N             = "universe"
+    val unsafeNulls: N          = "unsafeNulls"
+    val update: N               = "update"
+    val updateDynamic: N        = "updateDynamic"
+    val using: N                = "using"
+    val value: N                = "value"
+    val valueOf : N             = "valueOf"
+    val fromOrdinal: N          = "fromOrdinal"
+    val values: N               = "values"
+    val view_ : N               = "view"
+    val varargGetter : N        = "varargGetter"
+    val wait_ : N               = "wait"
+    val wildcardType: N         = "wildcardType"
+    val withFilter: N           = "withFilter"
+    val withFilterIfRefutable: N = "withFilterIfRefutable$"
+    val WorksheetWrapper: N     = "WorksheetWrapper"
+    val wrap: N                 = "wrap"
+    val writeReplace: N         = "writeReplace"
+    val readResolve: N          = "readResolve"
+    val zero: N                 = "zero"
+    val zip: N                  = "zip"
+    val nothingRuntimeClass: N  = "scala.runtime.Nothing$"
+    val nullRuntimeClass: N     = "scala.runtime.Null$"
+
+    val synthSwitch: N          = "$synthSwitch"
+    val _scope: N               = "$scope"
+
+    val nothingClass: N         = "Nothing$"
+    val nullClass: N            = "Null$"
+
+    val falseModuleClassNames: Set[N] = Set(nothingClass, nullClass, nothingRuntimeClass, nullRuntimeClass)
+
+    // unencoded operators
+    object raw {
+      final val AMP  : N  = "&"
+      final val BANG : N  = "!"
+      final val BAR  : N  = "|"
+      final val DOLLAR: N = "$"
+      final val GE: N     = ">="
+      final val LAMBDA: N = "λ"
+      final val LE: N     = "<="
+      final val MINUS: N  = "-"
+      final val NE: N     = "!="
+      final val PLUS : N  = "+"
+      final val SLASH: N  = "/"
+      final val STAR : N  = "*"
+      final val TILDE: N  = "~"
+
+      // kind-projector compat symbols
+      final val MINUS_STAR  : N = "-*"
+      final val PLUS_STAR   : N = "+*"
+      final val MINUS_USCORE: N = "-_"
+      final val PLUS_USCORE : N = "+_"
+
+      final val isUnary: Set[Name] = Set(MINUS, PLUS, TILDE, BANG)
+    }
+
+    object specializedTypeNames {
+      final val Boolean: N = "Z"
+      final val Byte: N    = "B"
+      final val Char: N    = "C"
+      final val Short: N   = "S"
+      final val Int: N     = "I"
+      final val Long: N    = "J"
+      final val Float: N   = "F"
+      final val Double: N  = "D"
+      final val Void: N    = "V"
+      final val Object: N  = "L"
+
+      final val prefix: N = "$m"
+      final val separator: N = "c"
+      final val suffix: N = "$sp"
+    }
+
+    // value-conversion methods
+    val toByte: N   = "toByte"
+    val toShort: N  = "toShort"
+    val toChar: N   = "toChar"
+    val toInt: N    = "toInt"
+    val toLong: N   = "toLong"
+    val toFloat: N  = "toFloat"
+    val toDouble: N = "toDouble"
+
+    // primitive operation methods for structural types mostly
+    // overlap with the above, but not for these two.
+    val toCharacter: N = "toCharacter"
+    val toInteger: N   = "toInteger"
+
+    // ASCII names for operators
+    val ADD      : N = "+"
+    val AND      : N = "&"
+    val ASR      : N = ">>"
+    val DIV      : N = "/"
+    val EQ       : N = "=="
+    val EQL      : N = "="
+    val GE       : N = ">="
+    val GT       : N = ">"
+    val HASHHASH : N = "##"
+    val LE       : N = "<="
+    val LSL      : N = "<<"
+    val LSR      : N = ">>>"
+    val LT       : N = "<"
+    val MINUS    : N = "-"
+    val MOD      : N = "%"
+    val MUL      : N = "*"
+    val NE       : N = "!="
+    val OR       : N = "|"
+    val PLUS     : N = ADD    // technically redundant, but ADD looks funny with MINUS
+    val SUB      : N = MINUS  // ... as does SUB with PLUS
+    val XOR      : N = "^"
+    val ZAND     : N = "&&"
+    val ZOR      : N = "||"
+    val PUREARROW: N = "->"
+    val PURECTXARROW: N = "?->"
+
+    // unary operators
+    val UNARY_PREFIX: N = "unary_"
+    val UNARY_~ : N = "unary_~"
+    val UNARY_+ : N = "unary_+"
+    val UNARY_- : N = "unary_-"
+    val UNARY_! : N = "unary_!"
+
+    // Grouped here so Cleanup knows what tests to perform.
+    val CommonOpNames: Set[Name]   = Set(OR, XOR, AND, EQ, NE)
+    val ConversionNames: Set[Name] = Set(toByte, toChar, toDouble, toFloat, toInt, toLong, toShort)
+    val BooleanOpNames: Set[Name]  = Set(ZOR, ZAND, UNARY_!) ++ CommonOpNames
+    val NumberOpNames: Set[Name]   = (
+         Set(ADD, SUB, MUL, DIV, MOD, LSL, LSR, ASR, LT, LE, GE, GT)
+      ++ Set(UNARY_+, UNARY_-, UNARY_!)
+      ++ ConversionNames
+      ++ CommonOpNames
+    )
+
+    val add: N                    = "add"
+    val complement: N             = "complement"
+    val divide: N                 = "divide"
+    val multiply: N               = "multiply"
+    val negate: N                 = "negate"
+    val positive: N               = "positive"
+    val shiftLogicalRight: N      = "shiftLogicalRight"
+    val shiftSignedLeft: N        = "shiftSignedLeft"
+    val shiftSignedRight: N       = "shiftSignedRight"
+    val subtract: N               = "subtract"
+    val takeAnd: N                = "takeAnd"
+    val takeConditionalAnd: N     = "takeConditionalAnd"
+    val takeConditionalOr: N      = "takeConditionalOr"
+    val takeModulo: N             = "takeModulo"
+    val takeNot: N                = "takeNot"
+    val takeOr: N                 = "takeOr"
+    val takeXor: N                = "takeXor"
+    val testEqual: N              = "testEqual"
+    val testGreaterOrEqualThan: N = "testGreaterOrEqualThan"
+    val testGreaterThan: N        = "testGreaterThan"
+    val testLessOrEqualThan: N    = "testLessOrEqualThan"
+    val testLessThan: N           = "testLessThan"
+    val testNotEqual: N           = "testNotEqual"
+
+    val isBoxedNumberOrBoolean: N = "isBoxedNumberOrBoolean"
+    val isBoxedNumber: N = "isBoxedNumber"
+  }
+
+  class ScalaTermNames extends ScalaNames[TermName] {
+    protected implicit def fromString(s: String): TermName = termName(s)
+
+    def syntheticParamName(i: Int): TermName = (i: @switch) match {
+      case 0  => x_0
+      case 1  => x_1
+      case 2  => x_2
+      case 3  => x_3
+      case 4  => x_4
+      case 5  => x_5
+      case 6  => x_6
+      case 7  => x_7
+      case 8  => x_8
+      case 9  => x_9
+      case _  => termName("x$" + i)
+    }
+
+    def productAccessorName(j: Int): TermName = (j: @switch) match {
+      case 1  => nme._1
+      case 2  => nme._2
+      case 3  => nme._3
+      case 4  => nme._4
+      case 5  => nme._5
+      case 6  => nme._6
+      case 7  => nme._7
+      case 8  => nme._8
+      case 9  => nme._9
+      case 10 => nme._10
+      case 11 => nme._11
+      case 12 => nme._12
+      case 13 => nme._13
+      case 14 => nme._14
+      case 15 => nme._15
+      case 16 => nme._16
+      case 17 => nme._17
+      case 18 => nme._18
+      case 19 => nme._19
+      case 20 => nme._20
+      case 21 => nme._21
+      case 22 => nme._22
+      case _  => termName("_" + j)
+    }
+
+    def localDummyName(clazz: Symbol)(using Context): TermName =
+      termName(str.LOCALDUMMY_PREFIX + clazz.name + ">")
+
+    def newBitmapName(bitmapPrefix: TermName, n: Int): TermName = bitmapPrefix ++ n.toString
+
+    def selectorName(n: Int): TermName = "_" + (n + 1)
+
+    object primitive {
+      val arrayApply: TermName  = "[]apply"
+      val arrayUpdate: TermName = "[]update"
+      val arrayLength: TermName = "[]length"
+      val names: Set[Name] = Set(arrayApply, arrayUpdate, arrayLength)
+    }
+
+    def isPrimitiveName(name: Name): Boolean = primitive.names.contains(name)
+  }
+
+  class ScalaTypeNames extends ScalaNames[TypeName] {
+    protected implicit def fromString(s: String): TypeName = typeName(s)
+
+    def syntheticTypeParamName(i: Int): TypeName = "X" + i
+
+    final val Conforms: TypeName = encode("<:<")
+
+    final val Uninstantiated: TypeName = "?$"
+
+    val JFunctionPrefix: Seq[TypeName] = (0 to 2).map(i => s"scala.runtime.java8.JFunction${i}")
+    val JProcedure: Seq[TypeName] = (0 to 22).map(i => s"scala.runtime.function.JProcedure${i}")
+  }
+
+  abstract class JavaNames[N <: Name] extends DefinedNames[N] {
+    final val ABSTRACTkw: N     = kw("abstract")
+    final val ASSERTkw: N       = kw("assert")
+    final val BOOLEANkw: N      = kw("boolean")
+    final val BREAKkw: N        = kw("break")
+    final val BYTEkw: N         = kw("byte")
+    final val CASEkw: N         = kw("case")
+    final val CATCHkw: N        = kw("catch")
+    final val CHARkw: N         = kw("char")
+    final val CLASSkw: N        = kw("class")
+    final val CONSTkw: N        = kw("const")
+    final val CONTINUEkw: N     = kw("continue")
+    final val DEFAULTkw: N      = kw("default")
+    final val DOkw: N           = kw("do")
+    final val DOUBLEkw: N       = kw("double")
+    final val ELSEkw: N         = kw("else")
+    final val ENUMkw: N         = kw("enum")
+    final val EXTENDSkw: N      = kw("extends")
+    final val FALSEkw: N        = kw("false")
+    final val FINALkw: N        = kw("final")
+    final val FINALLYkw: N      = kw("finally")
+    final val FLOATkw: N        = kw("float")
+    final val FORkw: N          = kw("for")
+    final val IFkw: N           = kw("if")
+    final val GOTOkw: N         = kw("goto")
+    final val IMPLEMENTSkw: N   = kw("implements")
+    final val IMPORTkw: N       = kw("import")
+    final val INSTANCEOFkw: N   = kw("instanceof")
+    final val INTkw: N          = kw("int")
+    final val INTERFACEkw: N    = kw("interface")
+    final val LONGkw: N         = kw("long")
+    final val NATIVEkw: N       = kw("native")
+    final val NEWkw: N          = kw("new")
+    final val PACKAGEkw: N      = kw("package")
+    final val PRIVATEkw: N      = kw("private")
+    final val PROTECTEDkw: N    = kw("protected")
+    final val PUBLICkw: N       = kw("public")
+    final val RETURNkw: N       = kw("return")
+    final val SHORTkw: N        = kw("short")
+    final val STATICkw: N       = kw("static")
+    final val STRICTFPkw: N     = kw("strictfp")
+    final val SUPERkw: N        = kw("super")
+    final val SWITCHkw: N       = kw("switch")
+    final val SYNCHRONIZEDkw: N = kw("synchronized")
+    final val THISkw: N         = kw("this")
+    final val THROWkw: N        = kw("throw")
+    final val THROWSkw: N       = kw("throws")
+    final val TRANSIENTkw: N    = kw("transient")
+    final val TRUEkw: N         = kw("true")
+    final val TRYkw: N          = kw("try")
+    final val VOIDkw: N         = kw("void")
+    final val VOLATILEkw: N     = kw("volatile")
+    final val WHILEkw: N        = kw("while")
+
+    final val BoxedBoolean: N       = "java.lang.Boolean"
+    final val BoxedByte: N          = "java.lang.Byte"
+    final val BoxedCharacter: N     = "java.lang.Character"
+    final val BoxedDouble: N        = "java.lang.Double"
+    final val BoxedFloat: N         = "java.lang.Float"
+    final val BoxedInteger: N       = "java.lang.Integer"
+    final val BoxedLong: N          = "java.lang.Long"
+    final val BoxedNumber: N        = "java.lang.Number"
+    final val BoxedShort: N         = "java.lang.Short"
+    final val Class: N              = "java.lang.Class"
+    final val IOOBException: N      = "java.lang.IndexOutOfBoundsException"
+    final val InvTargetException: N = "java.lang.reflect.InvocationTargetException"
+    final val MethodAsObject: N     = "java.lang.reflect.Method"
+    final val NPException: N        = "java.lang.NullPointerException"
+    final val Object: N             = "java.lang.Object"
+    final val String: N             = "java.lang.String"
+    final val Throwable: N          = "java.lang.Throwable"
+
+    final val ForName: N          = "forName"
+    final val GetCause: N         = "getCause"
+    final val GetClass: N         = "getClass"
+    final val GetClassLoader: N   = "getClassLoader"
+    final val GetComponentType: N = "getComponentType"
+    final val GetMethod: N        = "getMethod"
+    final val Invoke: N           = "invoke"
+    final val JavaLang: N         = "java.lang"
+
+    final val BeanProperty: N        = "scala.beans.BeanProperty"
+    final val BooleanBeanProperty: N = "scala.beans.BooleanBeanProperty"
+    final val JavaSerializable: N    = "java.io.Serializable"
+  }
+
+  class JavaTermNames extends JavaNames[TermName] {
+    protected def fromString(s: String): TermName = termName(s)
+  }
+  class JavaTypeNames extends JavaNames[TypeName] {
+    protected def fromString(s: String): TypeName = typeName(s)
+  }
+
+  val nme:    ScalaTermNames = new ScalaTermNames
+  val tpnme:  ScalaTypeNames = new ScalaTypeNames
+  val jnme:   JavaTermNames  = new JavaTermNames
+  val jtpnme: JavaTypeNames  = new JavaTypeNames
+}
diff --git a/tests/pos-with-compiler-cc/dotc/core/Substituters.scala b/tests/pos-with-compiler-cc/dotc/core/Substituters.scala
new file mode 100644
index 000000000000..3e32340b21bd
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/core/Substituters.scala
@@ -0,0 +1,227 @@
+package dotty.tools.dotc
+package core
+
+import Types._, Symbols._, Contexts._
+import cc.CaptureSet.IdempotentCaptRefMap
+
+/** Substitution operations on types. See the corresponding `subst` and
+ *  `substThis` methods on class Type for an explanation.
+ */
+object Substituters:
+
+  final def subst(tp: Type, from: BindingType, to: BindingType, theMap: SubstBindingMap | Null)(using Context): Type =
+    tp match {
+      case tp: BoundType =>
+        if (tp.binder eq from) tp.copyBoundType(to.asInstanceOf[tp.BT]) else tp
+      case tp: NamedType =>
+        if (tp.prefix `eq` NoPrefix) tp
+        else tp.derivedSelect(subst(tp.prefix, from, to, theMap))
+      case _: ThisType =>
+        tp
+      case tp: AppliedType =>
+        tp.map(subst(_, from, to, theMap))
+      case _ =>
+        (if (theMap != null) theMap else new SubstBindingMap(from, to))
+          .mapOver(tp)
+    }
+
+  final def subst1(tp: Type, from: Symbol, to: Type, theMap: Subst1Map | Null)(using Context): Type =
+    tp match {
+      case tp: NamedType =>
+        val sym = tp.symbol
+        if (sym eq from) return to
+        if (tp.prefix `eq` NoPrefix) tp
+        else tp.derivedSelect(subst1(tp.prefix, from, to, theMap))
+      case _: ThisType | _: BoundType =>
+        tp
+      case _ =>
+        (if (theMap != null) theMap else new Subst1Map(from, to))
+          .mapOver(tp)
+    }
+
+  final def subst2(tp: Type, from1: Symbol, to1: Type, from2: Symbol, to2: Type, theMap: Subst2Map  | Null)(using Context): Type =
+    tp match {
+      case tp: NamedType =>
+        val sym = tp.symbol
+        if (sym eq from1) return to1
+        if (sym eq from2) return to2
+        if (tp.prefix `eq` NoPrefix) tp
+        else tp.derivedSelect(subst2(tp.prefix, from1, to1, from2, to2, theMap))
+      case _: ThisType | _: BoundType =>
+        tp
+      case _ =>
+        (if (theMap != null) theMap else new Subst2Map(from1, to1, from2, to2))
+          .mapOver(tp)
+    }
+
+  final def subst(tp: Type, from: List[Symbol], to: List[Type], theMap: SubstMap | Null)(using Context): Type =
+    tp match {
+      case tp: NamedType =>
+        val sym = tp.symbol
+        var fs = from
+        var ts = to
+        while (fs.nonEmpty && ts.nonEmpty) {
+          if (fs.head eq sym) return ts.head
+          fs = fs.tail
+          ts = ts.tail
+        }
+        if (tp.prefix `eq` NoPrefix) tp
+        else tp.derivedSelect(subst(tp.prefix, from, to, theMap))
+      case _: ThisType | _: BoundType =>
+        tp
+      case _ =>
+        (if (theMap != null) theMap else new SubstMap(from, to))
+          .mapOver(tp)
+    }
+
+  final def substSym(tp: Type, from: List[Symbol], to: List[Symbol], theMap: SubstSymMap | Null)(using Context): Type =
+    tp match {
+      case tp: NamedType =>
+        val sym = tp.symbol
+        var fs = from
+        var ts = to
+        while (fs.nonEmpty) {
+          if (fs.head eq sym)
+            return substSym(tp.prefix, from, to, theMap) select ts.head
+          fs = fs.tail
+          ts = ts.tail
+        }
+        if (tp.prefix `eq` NoPrefix) tp
+        else tp.derivedSelect(substSym(tp.prefix, from, to, theMap))
+      case tp: ThisType =>
+        val sym = tp.cls
+        var fs = from
+        var ts = to
+        while (fs.nonEmpty) {
+          if (fs.head eq sym) return ts.head.asClass.thisType
+          fs = fs.tail
+          ts = ts.tail
+        }
+        tp
+      case _: BoundType =>
+        tp
+      case _ =>
+        (if (theMap != null) theMap else new SubstSymMap(from, to))
+          .mapOver(tp)
+    }
+
+  final def substThis(tp: Type, from: ClassSymbol, to: Type, theMap: SubstThisMap | Null)(using Context): Type =
+    tp match {
+      case tp: ThisType =>
+        if (tp.cls eq from) to else tp
+      case tp: NamedType =>
+        if (tp.currentSymbol.isStaticOwner || (tp.prefix `eq` NoPrefix)) tp
+        else tp.derivedSelect(substThis(tp.prefix, from, to, theMap))
+      case _: BoundType =>
+        tp
+      case _ =>
+        (if (theMap != null) theMap else new SubstThisMap(from, to))
+          .mapOver(tp)
+    }
+
+  final def substRecThis(tp: Type, from: Type, to: Type, theMap: SubstRecThisMap | Null)(using Context): Type =
+    tp match {
+      case tp @ RecThis(binder) =>
+        if (binder eq from) to else tp
+      case tp: NamedType =>
+        if (tp.prefix `eq` NoPrefix) tp
+        else tp.derivedSelect(substRecThis(tp.prefix, from, to, theMap))
+      case _: ThisType | _: BoundType =>
+        tp
+      case _ =>
+        (if (theMap != null) theMap else new SubstRecThisMap(from, to))
+          .mapOver(tp)
+    }
+
+  final def substParam(tp: Type, from: ParamRef, to: Type, theMap: SubstParamMap | Null)(using Context): Type =
+    tp match {
+      case tp: BoundType =>
+        if (tp == from) to else tp
+      case tp: NamedType =>
+        if (tp.prefix `eq` NoPrefix) tp
+        else tp.derivedSelect(substParam(tp.prefix, from, to, theMap))
+      case _: ThisType =>
+        tp
+      case _ =>
+        (if (theMap != null) theMap else new SubstParamMap(from, to))
+          .mapOver(tp)
+    }
+
+  final def substParams(tp: Type, from: BindingType, to: List[Type], theMap: SubstParamsMap | Null)(using Context): Type =
+    tp match {
+      case tp: ParamRef =>
+        if (tp.binder == from) to(tp.paramNum) else tp
+      case tp: NamedType =>
+        if (tp.prefix `eq` NoPrefix) tp
+        else tp.derivedSelect(substParams(tp.prefix, from, to, theMap))
+      case _: ThisType =>
+        tp
+      case tp: AppliedType =>
+        tp.map(substParams(_, from, to, theMap))
+      case _ =>
+        (if (theMap != null) theMap else new SubstParamsMap(from, to))
+          .mapOver(tp)
+    }
+
+  final class SubstBindingMap(from: BindingType, to: BindingType)(using Context) extends DeepTypeMap, BiTypeMap {
+    def apply(tp: Type): Type = subst(tp, from, to, this)(using mapCtx)
+    def inverse(tp: Type): Type = tp.subst(to, from)
+  }
+
+  final class Subst1Map(from: Symbol, to: Type)(using Context) extends DeepTypeMap {
+    def apply(tp: Type): Type = subst1(tp, from, to, this)(using mapCtx)
+  }
+
+  final class Subst2Map(from1: Symbol, to1: Type, from2: Symbol, to2: Type)(using Context) extends DeepTypeMap {
+    def apply(tp: Type): Type = subst2(tp, from1, to1, from2, to2, this)(using mapCtx)
+  }
+
+  final class SubstMap(from: List[Symbol], to: List[Type])(using Context) extends DeepTypeMap {
+    def apply(tp: Type): Type = subst(tp, from, to, this)(using mapCtx)
+  }
+
+  final class SubstSymMap(from: List[Symbol], to: List[Symbol])(using Context) extends DeepTypeMap, BiTypeMap {
+    def apply(tp: Type): Type = substSym(tp, from, to, this)(using mapCtx)
+    def inverse(tp: Type) = tp.substSym(to, from) // implicitly requires that `to` contains no duplicates.
+  }
+
+  final class SubstThisMap(from: ClassSymbol, to: Type)(using Context) extends DeepTypeMap {
+    def apply(tp: Type): Type = substThis(tp, from, to, this)(using mapCtx)
+  }
+
+  final class SubstRecThisMap(from: Type, to: Type)(using Context) extends DeepTypeMap {
+    def apply(tp: Type): Type = substRecThis(tp, from, to, this)(using mapCtx)
+  }
+
+  final class SubstParamMap(from: ParamRef, to: Type)(using Context) extends DeepTypeMap, IdempotentCaptRefMap {
+    def apply(tp: Type): Type = substParam(tp, from, to, this)(using mapCtx)
+  }
+
+  final class SubstParamsMap(from: BindingType, to: List[Type])(using Context) extends DeepTypeMap, IdempotentCaptRefMap {
+    def apply(tp: Type): Type = substParams(tp, from, to, this)(using mapCtx)
+  }
+
+  /** An approximating substitution that can handle wildcards in the `to` list */
+  final class SubstApproxMap(from: List[Symbol], to: List[Type])(using Context) extends ApproximatingTypeMap {
+    def apply(tp: Type): Type = tp match {
+      case tp: NamedType =>
+        val sym = tp.symbol
+        var fs = from
+        var ts = to
+        while (fs.nonEmpty && ts.nonEmpty) {
+          if (fs.head eq sym)
+            return ts.head match {
+              case TypeBounds(lo, hi) => range(lo, hi)
+              case tp1 => tp1
+            }
+          fs = fs.tail
+          ts = ts.tail
+        }
+        if (tp.prefix `eq` NoPrefix) tp else derivedSelect(tp, apply(tp.prefix))
+      case _: ThisType | _: BoundType =>
+        tp
+      case _ =>
+        mapOver(tp)
+    }
+  }
+end Substituters
diff --git a/tests/pos-with-compiler-cc/dotc/core/SymDenotations.scala b/tests/pos-with-compiler-cc/dotc/core/SymDenotations.scala
new file mode 100644
index 000000000000..31c540955371
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/core/SymDenotations.scala
@@ -0,0 +1,2969 @@
+package dotty.tools
+package dotc
+package core
+
+import Periods._, Contexts._, Symbols._, Denotations._, Names._, NameOps._, Annotations._
+import Types._, Flags._, Decorators._, DenotTransformers._, StdNames._, Scopes._
+import NameOps._, NameKinds._
+import Phases.{Phase, typerPhase, unfusedPhases}
+import Constants.Constant
+import TypeApplications.TypeParamInfo
+import Scopes.Scope
+import dotty.tools.io.AbstractFile
+import Decorators._
+import ast._
+import ast.Trees.{LambdaTypeTree, TypeBoundsTree}
+import Trees.Literal
+import Variances.Variance
+import annotation.tailrec
+import util.SimpleIdentityMap
+import util.Stats
+import java.util.WeakHashMap
+import scala.util.control.NonFatal
+import config.Config
+import reporting._
+import collection.mutable
+import transform.TypeUtils._
+import cc.{CapturingType, derivedCapturingType}
+import language.experimental.pureFunctions
+
+import scala.annotation.internal.sharable
+
+object SymDenotations {
+
+  /** A sym-denotation represents the contents of a definition
+   *  during a period.
+   */
+  class SymDenotation private[SymDenotations] (
+    symbol: Symbol,
+    final val maybeOwner: Symbol,
+    final val name: Name,
+    initFlags: FlagSet,
+    initInfo: Type,
+    initPrivateWithin: Symbol = NoSymbol) extends SingleDenotation(symbol, initInfo) {
+
+    //assert(symbol.id != 4940, name)
+
+    override def hasUniqueSym: Boolean = exists
+
+    /** Debug only
+    override def validFor_=(p: Period) = {
+      super.validFor_=(p)
+    }
+    */
+    if (Config.checkNoSkolemsInInfo) assertNoSkolems(initInfo)
+
+    // ------ Getting and setting fields -----------------------------
+
+    private var myFlags: FlagSet = adaptFlags(initFlags)
+    private var myPrivateWithin: Symbol = initPrivateWithin
+    private var myAnnotations: List[Annotation] = Nil
+    private var myParamss: List[List[Symbol]] = Nil
+
+    /** The owner of the symbol; overridden in NoDenotation */
+    def owner: Symbol = maybeOwner
+
+    /** The flag set */
+    final def flags(using Context): FlagSet = { ensureCompleted(); myFlags }
+
+    /** The flag set without forcing symbol completion.
+     *  Should be used only for printing.
+     */
+    private[dotc] final def flagsUNSAFE: FlagSet = myFlags
+
+    final def flagsString(using Context): String = flags.flagsString
+
+    /** Adapt flag set to this denotation's term or type nature */
+    private def adaptFlags(flags: FlagSet) = if (isType) flags.toTypeFlags else flags.toTermFlags
+
+    /** Update the flag set */
+    final def flags_=(flags: FlagSet): Unit =
+      myFlags = adaptFlags(flags)
+
+    /** Set given flags(s) of this denotation */
+    final def setFlag(flags: FlagSet): Unit = { myFlags |= flags }
+
+    /** Unset given flags(s) of this denotation */
+    final def resetFlag(flags: FlagSet): Unit = { myFlags &~= flags }
+
+    /** Set applicable flags in {NoInits, PureInterface}
+     *  @param  parentFlags  The flags that match the class or trait's parents
+     *  @param  bodyFlags    The flags that match the class or trait's body
+     */
+    final def setNoInitsFlags(parentFlags: FlagSet, bodyFlags: FlagSet): Unit =
+      setFlag(
+        if (myFlags.is(Trait)) NoInitsInterface & bodyFlags // no parents are initialized from a trait
+        else NoInits & bodyFlags & parentFlags)
+
+    final def setStableConstructor()(using Context): Unit =
+      val ctorStable = if myFlags.is(Trait) then myFlags.is(NoInits) else isNoInitsRealClass
+      if ctorStable then primaryConstructor.setFlag(StableRealizable)
+
+    def isCurrent(fs: FlagSet)(using Context): Boolean =
+      def knownFlags(info: Type): FlagSet = info match
+        case _: SymbolLoader | _: ModuleCompleter => FromStartFlags
+        case _ => AfterLoadFlags
+      !myInfo.isInstanceOf[LazyType] || fs <= knownFlags(myInfo)
+
+    final def relevantFlagsFor(fs: FlagSet)(using Context) =
+      if (isCurrent(fs)) myFlags else flags
+
+    /** Has this denotation one of given flag set? */
+    final def is(flag: Flag)(using Context): Boolean =
+      (if (isCurrent(flag)) myFlags else flags).is(flag)
+
+    /** Has this denotation one of the flags in `fs` set? */
+    final def isOneOf(fs: FlagSet)(using Context): Boolean =
+      (if (isCurrent(fs)) myFlags else flags).isOneOf(fs)
+
+    /** Has this denotation the given flag set, whereas none of the flags
+     *  in `butNot` are set?
+     */
+    final def is(flag: Flag, butNot: FlagSet)(using Context): Boolean =
+      (if (isCurrent(flag) && isCurrent(butNot)) myFlags else flags).is(flag, butNot)
+
+    /** Has this denotation one of the flags in `fs` set, whereas none of the flags
+     *  in `butNot` are set?
+     */
+    final def isOneOf(fs: FlagSet, butNot: FlagSet)(using Context): Boolean =
+      (if (isCurrent(fs) && isCurrent(butNot)) myFlags else flags).isOneOf(fs, butNot)
+
+    /** Has this denotation all of the flags in `fs` set? */
+    final def isAllOf(fs: FlagSet)(using Context): Boolean =
+      (if (isCurrent(fs)) myFlags else flags).isAllOf(fs)
+
+    /** Has this denotation all of the flags in `fs` set, whereas none of the flags
+     *  in `butNot` are set?
+     */
+    final def isAllOf(fs: FlagSet, butNot: FlagSet)(using Context): Boolean =
+      (if (isCurrent(fs) && isCurrent(butNot)) myFlags else flags).isAllOf(fs, butNot)
+
+    /** The type info, or, if symbol is not yet completed, the completer */
+    final def infoOrCompleter: Type = myInfo
+
+    /** Optionally, the info if it is completed */
+    final def unforcedInfo: Option[Type] = myInfo match {
+      case myInfo: LazyType => None
+      case _ => Some(myInfo)
+    }
+
+    final def completeFrom(completer: LazyType)(using Context): Unit =
+      if completer.needsCompletion(this) then
+        if (Config.showCompletions) {
+          println(i"${"  " * indent}completing ${if (isType) "type" else "val"} $name")
+          indent += 1
+
+          if (myFlags.is(Touched)) throw CyclicReference(this)
+          myFlags |= Touched
+
+          // completions.println(s"completing ${this.debugString}")
+          try atPhase(validFor.firstPhaseId)(completer.complete(this))
+          catch {
+            case ex: CyclicReference =>
+              println(s"error while completing ${this.debugString}")
+              throw ex
+          }
+          finally {
+            indent -= 1
+            println(i"${"  " * indent}completed $name in $owner")
+          }
+        }
+        else {
+          if (myFlags.is(Touched)) throw CyclicReference(this)
+          myFlags |= Touched
+          atPhase(validFor.firstPhaseId)(completer.complete(this))
+        }
+
+    protected[dotc] def info_=(tp: Type): Unit = {
+      /* // DEBUG
+       def illegal: String = s"illegal type for $this: $tp"
+      if (this is Module) // make sure module invariants that allow moduleClass and sourceModule to work are kept.
+        tp match {
+          case tp: ClassInfo => assert(tp.selfInfo.isInstanceOf[TermRefBySym], illegal)
+          case tp: NamedType => assert(tp.isInstanceOf[TypeRefBySym], illegal)
+          case tp: ExprType => assert(tp.resultType.isInstanceOf[TypeRefBySym], illegal)
+          case _ =>
+        }
+        */
+      if (Config.checkNoSkolemsInInfo) assertNoSkolems(tp)
+      myInfo = tp
+    }
+
+    /** The name, except
+     *   - if this is a module class, strip the module class suffix
+     *   - if this is a companion object with a clash-avoiding name, strip the
+     *     "avoid clash" suffix
+     */
+    def effectiveName(using Context): Name =
+      if (this.is(ModuleClass)) name.stripModuleClassSuffix
+      else name
+
+    /** The privateWithin boundary, NoSymbol if no boundary is given.
+     */
+    @tailrec
+    final def privateWithin(using Context): Symbol = myInfo match {
+      case myInfo: ModuleCompleter =>
+        // Instead of completing the ModuleCompleter, we can get `privateWithin`
+        // directly from the module class, which might require less completions.
+        myInfo.moduleClass.privateWithin
+      case _: SymbolLoader =>
+         // Completing a SymbolLoader might call `setPrivateWithin()`
+        completeOnce()
+        privateWithin
+      case _ =>
+        // Otherwise, no completion is necessary, see the preconditions of `markAbsent()`.
+        myPrivateWithin
+    }
+
+    /** Set privateWithin, prefer setting it at symbol-creation time instead if
+     *  possible.
+     *  @pre `isCompleting` is false, or this is a ModuleCompleter or SymbolLoader
+     */
+    protected[dotc] final def setPrivateWithin(pw: Symbol)(using Context): Unit = {
+      if (isCompleting)
+        assert(myInfo.isInstanceOf[ModuleCompleter | SymbolLoader],
+          s"Illegal call to `setPrivateWithin($pw)` while completing $this using completer $myInfo")
+      myPrivateWithin = pw
+    }
+
+    /** The annotations of this denotation */
+    final def annotations(using Context): List[Annotation] = {
+      ensureCompleted(); myAnnotations
+    }
+
+    /** The annotations without ensuring that the symbol is completed.
+     *  Used for diagnostics where we don't want to force symbols.
+     */
+    final def annotationsUNSAFE(using Context): List[Annotation] = myAnnotations
+
+    /** Update the annotations of this denotation */
+    final def annotations_=(annots: List[Annotation]): Unit =
+      myAnnotations = annots
+
+    /** Does this denotation have an annotation matching the given class symbol? */
+    final def hasAnnotation(cls: Symbol)(using Context): Boolean =
+      dropOtherAnnotations(annotations, cls).nonEmpty
+
+    /** Apply transform `f` to all annotations of this denotation */
+    final def transformAnnotations(f: Annotation => Annotation)(using Context): Unit =
+      annotations = annotations.mapConserve(f)
+
+    /** Keep only those annotations that satisfy `p` */
+    final def filterAnnotations(p: Annotation => Boolean)(using Context): Unit =
+      annotations = annotations.filterConserve(p)
+
+    /** Optionally, the annotation matching the given class symbol */
+    final def getAnnotation(cls: Symbol)(using Context): Option[Annotation] =
+      dropOtherAnnotations(annotations, cls) match {
+        case annot :: _ => Some(annot)
+        case nil => None
+      }
+
+    /** The same as getAnnotation, but without ensuring
+     *  that the symbol carrying the annotation is completed
+     */
+    final def unforcedAnnotation(cls: Symbol)(using Context): Option[Annotation] =
+      dropOtherAnnotations(myAnnotations, cls) match {
+        case annot :: _ => Some(annot)
+        case nil => None
+      }
+
+    /** Add given annotation to the annotations of this denotation */
+    final def addAnnotation(annot: Annotation): Unit =
+      annotations = annot :: myAnnotations
+
+    /** Add the given annotation without parameters to the annotations of this denotation */
+    final def addAnnotation(cls: ClassSymbol)(using Context): Unit =
+      addAnnotation(Annotation(cls))
+
+    /** Remove annotation with given class from this denotation */
+    final def removeAnnotation(cls: Symbol)(using Context): Unit =
+      annotations = myAnnotations.filterNot(_ matches cls)
+
+    /** Remove any annotations with same class as `annot`, and add `annot` */
+    final def updateAnnotation(annot: Annotation)(using Context): Unit = {
+      removeAnnotation(annot.symbol)
+      addAnnotation(annot)
+    }
+
+    /** Add all given annotations to this symbol */
+    final def addAnnotations(annots: TraversableOnce[Annotation])(using Context): Unit =
+      annots.iterator.foreach(addAnnotation)
+
+    @tailrec
+    private def dropOtherAnnotations(anns: List[Annotation], cls: Symbol)(using Context): List[Annotation] = anns match {
+      case ann :: rest => if (ann matches cls) anns else dropOtherAnnotations(rest, cls)
+      case Nil => Nil
+    }
+
+    /** If this is a method, the parameter symbols, by section.
+     *  Both type and value parameters are included. Empty sections are skipped.
+     */
+    final def rawParamss: List[List[Symbol]] = myParamss
+    final def rawParamss_=(pss: List[List[Symbol]]): Unit =
+      myParamss = pss
+
+    final def setParamss(paramss: List[List[Symbol]])(using Context): Unit =
+      rawParamss = paramss.filterConserve(!_.isEmpty)
+
+    final def setParamssFromDefs(paramss: List[tpd.ParamClause])(using Context): Unit =
+      setParamss(paramss.map(_.map(_.symbol)))
+
+    /** The symbols of each type parameter list and value parameter list of this
+     *  method, or Nil if this isn't a method.
+     *
+     *  Makes use of `rawParamss` when present, or constructs fresh parameter symbols otherwise.
+     *  This method can be allocation-heavy.
+     */
+    final def paramSymss(using Context): List[List[Symbol]] =
+
+      def recurWithParamss(info: Type, paramss: List[List[Symbol]]): List[List[Symbol]] =
+        info match
+          case info: LambdaType =>
+            if info.paramNames.isEmpty then Nil :: recurWithParamss(info.resType, paramss)
+            else paramss.head :: recurWithParamss(info.resType, paramss.tail)
+          case _ =>
+            Nil
+
+      def recurWithoutParamss(info: Type): List[List[Symbol]] = info match
+        case info: LambdaType =>
+          val params = info.paramNames.lazyZip(info.paramInfos).map((pname, ptype) =>
+            newSymbol(symbol, pname, SyntheticParam, ptype))
+          val prefs = params.map(_.namedType)
+          for param <- params do
+            param.info = param.info.substParams(info, prefs)
+          params :: recurWithoutParamss(info.instantiate(prefs))
+        case _ =>
+          Nil
+
+      ensureCompleted()
+      if rawParamss.isEmpty then recurWithoutParamss(info)
+      else recurWithParamss(info, rawParamss)
+    end paramSymss
+
+    /** The extension parameter of this extension method
+     *  @pre this symbol is an extension method
+     */
+    final def extensionParam(using Context): Symbol =
+      def leadParam(paramss: List[List[Symbol]]): Symbol = paramss match
+        case (param :: _) :: paramss1 if param.isType => leadParam(paramss1)
+        case _ :: (snd :: Nil) :: _ if name.isRightAssocOperatorName => snd
+        case (fst :: Nil) :: _ => fst
+        case _ => NoSymbol
+      assert(isAllOf(ExtensionMethod))
+      ensureCompleted()
+      leadParam(rawParamss)
+
+    /** The denotation is completed: info is not a lazy type and attributes have defined values */
+    final def isCompleted: Boolean = !myInfo.isInstanceOf[LazyType]
+
+    /** The denotation is in train of being completed */
+    final def isCompleting: Boolean = myFlags.is(Touched) && !isCompleted
+
+    /** The completer of this denotation. @pre: Denotation is not yet completed */
+    final def completer: LazyType = myInfo.asInstanceOf[LazyType]
+
+    /** If this denotation is not completed, run the completer.
+     *  The resulting info might be another completer.
+     *
+     *  @see ensureCompleted
+     */
+    final def completeOnce()(using Context): Unit = myInfo match {
+      case myInfo: LazyType =>
+        completeFrom(myInfo)
+      case _ =>
+    }
+
+    /** Make sure this denotation is fully completed.
+     *
+     *  @see completeOnce
+     */
+    final def ensureCompleted()(using Context): Unit = info
+
+    /** The symbols defined in this class or object.
+     *  Careful! This does not force the type, so is compilation order dependent.
+     *  This method should be used only in the following circumstances:
+     *
+     *  1. When accessing type parameters or type parameter accessors (both are entered before
+     *     completion).
+     *  2. When obtaining the current scope in order to enter, rename or delete something there.
+     *  3. When playing it safe in order not to raise CylicReferences, e.g. for printing things
+     *     or taking more efficient shortcuts (e.g. the stillValid test).
+     */
+    final def unforcedDecls(using Context): Scope = myInfo match {
+      case cinfo: LazyType =>
+        val knownDecls = cinfo.decls
+        if (knownDecls ne EmptyScope) knownDecls
+        else { completeOnce(); unforcedDecls }
+      case _ => info.decls
+    }
+
+    /** If this is a package class, the symbols entered in it
+     *  before it is completed. (this is needed to eagerly enter synthetic
+     *  aliases such as AnyRef into a package class without forcing it.
+     *  Right now, the only usage is for the AnyRef alias in Definitions.
+     */
+    final private[core] def currentPackageDecls(using Context): MutableScope = myInfo match {
+      case pinfo: SymbolLoaders.PackageLoader => pinfo.currentDecls
+      case _ => unforcedDecls.openForMutations
+    }
+
+    /** If this is an opaque alias, replace the right hand side `info`
+     *  by appropriate bounds and store `info` in the refinement of the
+     *  self type of the enclosing class.
+     *  Otherwise return `info`
+     *
+     *  @param info    Is assumed to be a (lambda-abstracted) right hand side TypeAlias
+     *                 of the opaque type definition.
+     *  @param rhs     The right hand side tree of the type definition
+     *  @param tparams The type parameters with which the right-hand side bounds should be abstracted
+     *
+     */
+    def opaqueToBounds(info: Type, rhs: tpd.Tree, tparams: List[TypeSymbol])(using Context): Type =
+
+      def setAlias(tp: Type) =
+        def recur(self: Type): Unit = self match
+          case RefinedType(parent, name, rinfo) => rinfo match
+            case TypeAlias(lzy: LazyRef) if name == this.name =>
+              if !lzy.completed then
+                lzy.update(tp)
+              else
+                throw CyclicReference(this)
+            case _ =>
+              recur(parent)
+        recur(owner.asClass.givenSelfType)
+      end setAlias
+
+      def bounds(t: tpd.Tree): TypeBounds = t match
+        case LambdaTypeTree(tparams, body) =>
+          bounds(body)
+        case TypeBoundsTree(lo, hi, alias) =>
+          assert(!alias.isEmpty)
+          TypeBounds(lo.tpe, hi.tpe)
+        case _ =>
+          TypeBounds.empty
+
+      info match
+        case info: AliasingBounds if isOpaqueAlias && owner.isClass =>
+          setAlias(info.alias)
+          HKTypeLambda.boundsFromParams(tparams, bounds(rhs))
+        case _ =>
+          info
+    end opaqueToBounds
+
+    // ------ Names ----------------------------------------------
+
+    /** The expanded name of this denotation. */
+    final def expandedName(using Context): Name =
+      if (name.is(ExpandedName) || isConstructor) name
+      else name.expandedName(initial.owner)
+        // need to use initial owner to disambiguate, as multiple private symbols with the same name
+        // might have been moved from different origins into the same class
+
+    /** The effective name with which the denoting symbol was created */
+    final def originalName(using Context): Name = initial.effectiveName
+
+    /** The owner with which the denoting symbol was created. */
+    final def originalOwner(using Context): Symbol = initial.maybeOwner
+
+    /** The encoded full path name of this denotation, where outer names and inner names
+     *  are separated by `separator` strings as indicated by the given name kind.
+     *  Drops package objects. Represents each term in the owner chain by a simple `_$`.
+     */
+    def fullNameSeparated(kind: QualifiedNameKind)(using Context): Name =
+      maybeOwner.fullNameSeparated(kind, kind, name)
+
+    /** The encoded full path name of this denotation (separated by `prefixKind`),
+     *  followed by the separator implied by `kind` and the given `name`.
+     *  Drops package objects. Represents each term in the owner chain by a simple `_$`.
+     */
+    def fullNameSeparated(prefixKind: QualifiedNameKind, kind: QualifiedNameKind, name: Name)(using Context): Name =
+      if (symbol == NoSymbol || isEffectiveRoot || kind == FlatName && is(PackageClass))
+        name
+      else {
+        var filler = ""
+        var encl = symbol
+        while (!encl.isClass && !encl.isPackageObject) {
+          encl = encl.owner
+          filler += "_$"
+        }
+        var prefix = encl.fullNameSeparated(prefixKind)
+        if (kind.separator == "$")
+          // duplicate scalac's behavior: don't write a double '$$' for module class members.
+          prefix = prefix.exclude(ModuleClassName)
+        def qualify(n: SimpleName) =
+          val qn = kind(prefix.toTermName, if (filler.isEmpty) n else termName(filler + n))
+          if kind == FlatName && !encl.is(JavaDefined) then qn.compactified else qn
+        val fn = name.replaceDeep {
+          case n: SimpleName => qualify(n)
+        }
+        if name.isTypeName then fn.toTypeName else fn.toTermName
+      }
+
+    /** The encoded flat name of this denotation, where joined names are separated by `separator` characters. */
+    def flatName(using Context): Name = fullNameSeparated(FlatName)
+
+    /** `fullName` where `.' is the separator character */
+    def fullName(using Context): Name = fullNameSeparated(QualifiedName)
+
+    private var myTargetName: Name | Null = null
+
+    private def computeTargetName(targetNameAnnot: Option[Annotation])(using Context): Name =
+      targetNameAnnot match
+        case Some(ann) =>
+          ann.arguments match
+            case Literal(Constant(str: String)) :: Nil =>
+              if isType then
+                if is(ModuleClass) then str.toTypeName.moduleClassName
+                else str.toTypeName
+              else str.toTermName
+            case _ => name
+        case _ => name
+
+    def setTargetName(name: Name): Unit =
+      myTargetName = name
+
+    def hasTargetName(name: Name)(using Context): Boolean =
+      targetName.matchesTargetName(name)
+
+    /** The name given in a `@targetName` annotation if one is present, `name` otherwise */
+    def targetName(using Context): Name =
+      if myTargetName == null then
+        val carrier: SymDenotation =
+          if isAllOf(ModuleClass | Synthetic) then companionClass else this
+        val targetNameAnnot =
+          if carrier.isCompleting // annotations have been set already in this case
+          then carrier.unforcedAnnotation(defn.TargetNameAnnot)
+          else carrier.getAnnotation(defn.TargetNameAnnot)
+        myTargetName = computeTargetName(targetNameAnnot)
+        if name.is(SuperAccessorName) then
+          myTargetName = myTargetName.nn.unmangle(List(ExpandedName, SuperAccessorName, ExpandPrefixName))
+
+      myTargetName.nn
+
+    // ----- Tests -------------------------------------------------
+
+    /** Is this denotation a type? */
+    override def isType: Boolean = name.isTypeName
+
+    /** Is this denotation a class? */
+    final def isClass: Boolean = isInstanceOf[ClassDenotation]
+
+    /** Is this denotation a non-trait class? */
+    final def isRealClass(using Context): Boolean = isClass && !is(Trait)
+
+    /** Cast to class denotation */
+    final def asClass: ClassDenotation = asInstanceOf[ClassDenotation]
+
+    /** is this symbol the result of an erroneous definition? */
+    def isError: Boolean = false
+
+    /** Make denotation not exist.
+     *  @pre `isCompleting` is false, or this is a ModuleCompleter or SymbolLoader
+     */
+    final def markAbsent()(using Context): Unit = {
+      if (isCompleting)
+        assert(myInfo.isInstanceOf[ModuleCompleter | SymbolLoader],
+          s"Illegal call to `markAbsent()` while completing $this using completer $myInfo")
+      myInfo = NoType
+    }
+
+    /** Is symbol known to not exist?
+     *  @param canForce  If this is true, the info may be forced to avoid a false-negative result
+     */
+    @tailrec
+    final def isAbsent(canForce: Boolean = true)(using Context): Boolean = myInfo match {
+      case myInfo: ModuleCompleter =>
+        // Instead of completing the ModuleCompleter, we can check whether
+        // the module class is absent, which might require less completions.
+        myInfo.moduleClass.isAbsent(canForce)
+      case _: SymbolLoader if canForce =>
+         // Completing a SymbolLoader might call `markAbsent()`
+        completeOnce()
+        isAbsent(canForce)
+      case _ =>
+        // Otherwise, no completion is necessary, see the preconditions of `markAbsent()`.
+        (myInfo `eq` NoType)
+        || is(Invisible) && ctx.isTyper
+        || is(ModuleVal, butNot = Package) && moduleClass.isAbsent(canForce)
+    }
+
+    /** Is this symbol the root class or its companion object? */
+    final def isRoot: Boolean =
+      (maybeOwner eq NoSymbol) && (name.toTermName == nme.ROOT || name == nme.ROOTPKG)
+
+    /** Is this symbol the empty package class or its companion object? */
+    final def isEmptyPackage(using Context): Boolean =
+      name.toTermName == nme.EMPTY_PACKAGE && owner.isRoot
+
+    /** Is this symbol the empty package class or its companion object? */
+    final def isEffectiveRoot(using Context): Boolean = isRoot || isEmptyPackage
+
+    /** Is this symbol an anonymous class? */
+    final def isAnonymousClass(using Context): Boolean =
+      isClass && initial.name.isAnonymousClassName
+
+    final def isAnonymousFunction(using Context): Boolean =
+      this.symbol.is(Method) && initial.name.isAnonymousFunctionName
+
+    final def isAnonymousModuleVal(using Context): Boolean =
+      this.symbol.is(ModuleVal) && initial.name.isAnonymousClassName
+
+    /** Is this a synthetic method that represents conversions between representations of a value class
+      *  These methods are generated in ExtensionMethods
+      *  and used in ElimErasedValueType.
+      */
+    final def isValueClassConvertMethod(using Context): Boolean =
+      name.toTermName == nme.U2EVT ||
+      name.toTermName == nme.EVT2U
+
+    /** Is symbol a primitive value class? */
+    def isPrimitiveValueClass(using Context): Boolean =
+      maybeOwner == defn.ScalaPackageClass && defn.ScalaValueClasses().contains(symbol)
+
+    /** Is symbol a primitive numeric value class? */
+    def isNumericValueClass(using Context): Boolean =
+      maybeOwner == defn.ScalaPackageClass && defn.ScalaNumericValueClasses().contains(symbol)
+
+    /** Is symbol a class for which no runtime representation exists? */
+    def isNotRuntimeClass(using Context): Boolean = defn.NotRuntimeClasses contains symbol
+
+    /** Is this symbol a class representing a refinement? These classes
+     *  are used only temporarily in Typer and Unpickler as an intermediate
+     *  step for creating Refinement types.
+     */
+    final def isRefinementClass(using Context): Boolean =
+      name == tpnme.REFINE_CLASS
+
+    /** Is this symbol a package object or its module class? */
+    def isPackageObject(using Context): Boolean =
+      name.isPackageObjectName && owner.is(Package) && this.is(Module)
+
+    /** Is this symbol a toplevel definition in a package object? */
+    def isWrappedToplevelDef(using Context): Boolean =
+      !isConstructor && owner.isPackageObject
+
+    /** Is this symbol an abstract type? */
+    final def isAbstractType(using Context): Boolean = this.is(DeferredType)
+
+    /** Is this symbol an alias type? */
+    final def isAliasType(using Context): Boolean = isAbstractOrAliasType && !this.is(Deferred)
+
+    /** Is this symbol an abstract or alias type? */
+    final def isAbstractOrAliasType: Boolean = isType & !isClass
+
+    /** Is this symbol an abstract type or type parameter? */
+    final def isAbstractOrParamType(using Context): Boolean = this.isOneOf(DeferredOrTypeParam)
+
+    /** Is this symbol a user-defined opaque alias type? */
+    def isOpaqueAlias(using Context): Boolean = is(Opaque) && !isClass
+
+    /** Is this symbol a module that contains opaque aliases? */
+    def containsOpaques(using Context): Boolean = is(Opaque) && isClass
+
+    def seesOpaques(using Context): Boolean =
+      containsOpaques ||
+      is(Module, butNot = Package) && owner.seesOpaques
+
+    def isProvisional(using Context): Boolean =
+      flagsUNSAFE.is(Provisional) // do not force the info to check the flag
+
+    /** Is this the denotation of a self symbol of some class?
+     *  This is the case if one of two conditions holds:
+     *  1. It is the symbol referred to in the selfInfo part of the ClassInfo
+     *     which is the type of this symbol's owner.
+     *  2. This symbol is owned by a class, it's selfInfo field refers to a type
+     *     (indicating the self definition does not introduce a name), and the
+     *     symbol's name is "_".
+     *  TODO: Find a more robust way to characterize self symbols, maybe by
+     *       spending a Flag on them?
+     */
+    final def isSelfSym(using Context): Boolean = owner.infoOrCompleter match {
+      case ClassInfo(_, _, _, _, selfInfo) =>
+        selfInfo == symbol ||
+          selfInfo.isInstanceOf[Type] && name == nme.WILDCARD
+      case _ => false
+    }
+
+    /** Is this definition contained in `boundary`?
+     *  Same as `ownersIterator contains boundary` but more efficient.
+     */
+    final def isContainedIn(boundary: Symbol)(using Context): Boolean = {
+      def recur(sym: Symbol): Boolean =
+        if (sym eq boundary) true
+        else if (sym eq NoSymbol) false
+        else if (sym.is(PackageClass) && !boundary.is(PackageClass)) false
+        else recur(sym.owner)
+      recur(symbol)
+    }
+
+    final def isProperlyContainedIn(boundary: Symbol)(using Context): Boolean =
+      symbol != boundary && isContainedIn(boundary)
+
+    /** Is this denotation static (i.e. with no outer instance)? */
+    final def isStatic(using Context): Boolean =
+      (if (maybeOwner eq NoSymbol) isRoot else maybeOwner.originDenotation.isStaticOwner) ||
+        myFlags.is(JavaStatic)
+
+    /** Is this a package class or module class that defines static symbols? */
+    final def isStaticOwner(using Context): Boolean =
+      myFlags.is(ModuleClass) && (myFlags.is(PackageClass) || isStatic)
+
+    /** Is this denotation defined in the same scope and compilation unit as that symbol? */
+    final def isCoDefinedWith(other: Symbol)(using Context): Boolean =
+      (this.effectiveOwner == other.effectiveOwner) &&
+      (  !this.effectiveOwner.is(PackageClass)
+        || this.isAbsent(canForce = false) || other.isAbsent(canForce = false)
+        || { // check if they are defined in the same file(or a jar)
+           val thisFile = this.symbol.associatedFile
+           val thatFile = other.associatedFile
+           (  thisFile == null
+           || thatFile == null
+           || thisFile.path == thatFile.path // Cheap possibly wrong check, then expensive normalization
+           || thisFile.canonicalPath == thatFile.canonicalPath
+           )
+         }
+      )
+
+    /** Do this symbol and `cls` represent a pair of a given or implicit method and
+     *  its associated class that were defined by a single definition?
+     *  This can mean one of two things:
+     *   - the method and class are defined in a structural given instance, or
+     *   - the class is an implicit class and the method is its implicit conversion.
+	 */
+    final def isCoDefinedGiven(cls: Symbol)(using Context): Boolean =
+      is(Method) && isOneOf(GivenOrImplicit)
+      && ( is(Synthetic)                 // previous scheme used in 3.0
+         || cls.isOneOf(GivenOrImplicit) // new scheme from 3.1
+         )
+      && name == cls.name.toTermName && owner == cls.owner
+
+    /** Is this a denotation of a stable term (or an arbitrary type)?
+      * Terms are stable if they are idempotent (as in TreeInfo.Idempotent): that is, they always return the same value,
+      * if any.
+      *
+      * A *member* is stable, basically, if it behaves like a field projection: that is, it projects a constant result
+      * out of its owner.
+      *
+      * However, a stable member might not yet be initialized (if it is an object or anyhow lazy).
+      * So the first call to a stable member might fail and/or produce side effects.
+      */
+    final def isStableMember(using Context): Boolean = {
+      def isUnstableValue = isOneOf(UnstableValueFlags) || info.isInstanceOf[ExprType]
+      isType || is(StableRealizable) || exists && !isUnstableValue
+    }
+
+    /** Is this a denotation of a real class that does not have - either direct or inherited -
+     *  initialization code?
+     */
+    def isNoInitsRealClass(using Context): Boolean =
+      isRealClass &&
+      (asClass.baseClasses.forall(_.is(NoInits)) || defn.isAssuredNoInits(symbol))
+
+    /** Is this a "real" method? A real method is a method which is:
+     *  - not an accessor
+     *  - not an anonymous function
+     */
+    final def isRealMethod(using Context): Boolean =
+      this.is(Method, butNot = Accessor) && !isAnonymousFunction
+
+    /** Is this a getter? */
+    final def isGetter(using Context): Boolean =
+      this.is(Accessor) && !originalName.isSetterName && !(originalName.isScala2LocalSuffix && symbol.owner.is(Scala2x))
+
+    /** Is this a setter? */
+    final def isSetter(using Context): Boolean =
+      this.is(Accessor) &&
+      originalName.isSetterName &&
+      (!isCompleted || info.firstParamTypes.nonEmpty) // to avoid being fooled by   var x_= : Unit = ...
+
+    /** Is this a symbol representing an import? */
+    final def isImport: Boolean = name == nme.IMPORT
+
+    /** Is this the constructor of a class? */
+    final def isClassConstructor: Boolean = name == nme.CONSTRUCTOR
+
+    /** Is this the constructor of a trait or a class */
+    final def isConstructor: Boolean = name.isConstructorName
+
+    /** Is this a local template dummmy? */
+    final def isLocalDummy: Boolean = name.isLocalDummyName
+
+    /** Does this symbol denote the primary constructor of its enclosing class? */
+    final def isPrimaryConstructor(using Context): Boolean =
+      isConstructor && owner.primaryConstructor == symbol
+
+    /** Does this symbol denote the static constructor of its enclosing class? */
+    final def isStaticConstructor(using Context): Boolean =
+      name.isStaticConstructorName
+
+    /** Is this a subclass of the given class `base`? */
+    def isSubClass(base: Symbol)(using Context): Boolean = false
+
+    /** Is this a subclass of `base`,
+     *  and is the denoting symbol also different from `Null` or `Nothing`?
+     *  @note  erroneous classes are assumed to derive from all other classes
+     *         and all classes derive from them.
+     */
+    def derivesFrom(base: Symbol)(using Context): Boolean = false
+
+    /** Is this a Scala or Java annotation ? */
+    def isAnnotation(using Context): Boolean =
+      isClass && derivesFrom(defn.AnnotationClass)
+
+    /** Is this symbol a class that extends `java.io.Serializable` ? */
+    def isSerializable(using Context): Boolean =
+      isClass && derivesFrom(defn.JavaSerializableClass)
+
+    /** Is this symbol a class that extends `AnyVal`? */
+    final def isValueClass(using Context): Boolean =
+      val di = initial
+      di.isClass
+      && atPhase(di.validFor.firstPhaseId)(di.derivesFrom(defn.AnyValClass))
+        // We call derivesFrom at the initial phase both because AnyVal does not exist
+        // after Erasure and to avoid cyclic references caused by forcing denotations
+
+    /** Is this symbol a class of which `null` is a value? */
+    final def isNullableClass(using Context): Boolean =
+      if ctx.mode.is(Mode.SafeNulls) && !ctx.phase.erasedTypes
+      then symbol == defn.NullClass || symbol == defn.AnyClass || symbol == defn.MatchableClass
+      else isNullableClassAfterErasure
+
+    /** Is this symbol a class of which `null` is a value after erasure?
+     *  For example, if `-Yexplicit-nulls` is set, `String` is not nullable before erasure,
+     *  but it becomes nullable after erasure.
+     */
+    final def isNullableClassAfterErasure(using Context): Boolean =
+      isClass && !isValueClass && !is(ModuleClass) && symbol != defn.NothingClass
+
+    /** Is this definition accessible as a member of tree with type `pre`?
+     *  @param pre          The type of the tree from which the selection is made
+     *  @param superAccess  Access is via super
+     *  Everything is accessible if `pre` is `NoPrefix`.
+     *  A symbol with type `NoType` is not accessible for any other prefix.
+     *
+     *  As a side effect, drop Local flags of members that are not accessed via the ThisType
+     *  of their owner.
+     */
+    final def isAccessibleFrom(pre: Type, superAccess: Boolean = false, whyNot: StringBuffer | Null = null)(using Context): Boolean = {
+
+      /** Are we inside definition of `boundary`?
+       *  If this symbol is Java defined, package structure is interpreted to be flat.
+       */
+      def accessWithin(boundary: Symbol) =
+        ctx.owner.isContainedIn(boundary)
+        && !(is(JavaDefined) && boundary.is(PackageClass) && ctx.owner.enclosingPackageClass != boundary)
+
+      /** Are we within definition of linked class of `boundary`? */
+      def accessWithinLinked(boundary: Symbol) = {
+        val linked = boundary.linkedClass
+        (linked ne NoSymbol) && accessWithin(linked)
+      }
+
+      /** Is `pre` the same as C.thisThis, where C is exactly the owner of this symbol,
+       *  or, if this symbol is protected, a subclass of the owner?
+       */
+      def isCorrectThisType(pre: Type): Boolean = pre match {
+        case pre: ThisType =>
+          (pre.cls eq owner) || this.is(Protected) && pre.cls.derivesFrom(owner)
+        case pre: TermRef =>
+          pre.symbol.moduleClass == owner
+        case _ =>
+          false
+      }
+
+      /** Is protected access to target symbol permitted? */
+      def isProtectedAccessOK: Boolean =
+        inline def fail(str: String): false =
+          if whyNot != null then whyNot.nn.append(str)
+          false
+        val cls = owner.enclosingSubClass
+        if !cls.exists then
+          val encl = if ctx.owner.isConstructor then ctx.owner.enclosingClass.owner.enclosingClass else ctx.owner.enclosingClass
+          fail(i"""
+               | Access to protected $this not permitted because enclosing ${encl.showLocated}
+               | is not a subclass of ${owner.showLocated} where target is defined""")
+        else if isType || pre.derivesFrom(cls) || isConstructor || owner.is(ModuleClass) then
+          // allow accesses to types from arbitrary subclasses fixes #4737
+          // don't perform this check for static members
+          true
+        else
+          fail(i"""
+               | Access to protected ${symbol.show} not permitted because prefix type ${pre.widen.show}
+               | does not conform to ${cls.showLocated} where the access takes place""")
+      end isProtectedAccessOK
+
+      if pre eq NoPrefix then true
+      else if isAbsent() then false
+      else {
+        val boundary = accessBoundary(owner)
+
+        (  boundary.isTerm
+        || boundary.isRoot
+        || (accessWithin(boundary) || accessWithinLinked(boundary)) &&
+             (  !this.is(Local)
+             || isCorrectThisType(pre)
+             || canBeLocal(name, flags)
+                && {
+                  resetFlag(Local)
+                  true
+                }
+             )
+        || this.is(Protected) &&
+             (  superAccess
+             || pre.isInstanceOf[ThisType]
+             || ctx.phase.erasedTypes
+             || isProtectedAccessOK
+             )
+        )
+      }
+    }
+
+    /** Do members of this symbol need translation via asSeenFrom when
+     *  accessed via prefix `pre`?
+     */
+    def membersNeedAsSeenFrom(pre: Type)(using Context): Boolean =
+      def preIsThis = pre match
+        case pre: ThisType => pre.sameThis(thisType)
+        case _ => false
+      !(  this.isTerm
+       || this.isStaticOwner && !this.seesOpaques
+       || ctx.erasedTypes
+       || (pre eq NoPrefix)
+       || preIsThis
+       )
+
+    /** Is this symbol concrete, or that symbol deferred? */
+    def isAsConcrete(that: Symbol)(using Context): Boolean =
+      !this.is(Deferred) || that.is(Deferred)
+
+    /** Does this symbol have defined or inherited default parameters?
+     *  Default parameters are recognized until erasure.
+     */
+    def hasDefaultParams(using Context): Boolean =
+      if ctx.erasedTypes then false
+      else if is(HasDefaultParams) then true
+      else if is(NoDefaultParams) || !is(Method) then false
+      else
+        val result =
+          rawParamss.nestedExists(_.is(HasDefault))
+          || allOverriddenSymbols.exists(_.hasDefaultParams)
+        setFlag(if result then HasDefaultParams else NoDefaultParams)
+        result
+
+    /** Symbol is an owner that would be skipped by effectiveOwner. Skipped are
+     *   - package objects
+     *   - non-lazy valdefs
+     */
+    def isWeakOwner(using Context): Boolean =
+      isPackageObject ||
+      isTerm && !isOneOf(MethodOrLazy) && !isLocalDummy
+
+    def isSkolem: Boolean = name == nme.SKOLEM
+
+    def isInlineMethod(using Context): Boolean =
+      isAllOf(InlineMethod, butNot = Accessor)
+
+    /** Does this method or field need to be retained at runtime */
+    def isRetainedInline(using Context): Boolean =
+      is(Inline, butNot = Deferred)
+      && allOverriddenSymbols.exists(!_.is(Inline))
+
+    /** Does this method need to be retained at runtime */
+    def isRetainedInlineMethod(using Context): Boolean =
+      is(Method, butNot = Accessor) && isRetainedInline
+
+    /** Is this a Scala 2 macro */
+    final def isScala2Macro(using Context): Boolean =
+      isScala2MacroInScala3 || (is(Macro) && symbol.owner.is(Scala2x))
+
+    /** Is this a Scala 2 macro defined */
+    final def isScala2MacroInScala3(using Context): Boolean =
+      is(Macro, butNot = Inline) && is(Erased)
+      // Consider the macros of StringContext as plain Scala 2 macros when
+      // compiling the standard library with Dotty.
+      // This should be removed on Scala 3.x
+      && owner.ne(defn.StringContextClass)
+
+    /** An erased value or an erased inline method or field */
+    def isEffectivelyErased(using Context): Boolean =
+      isOneOf(EffectivelyErased)
+      || is(Inline) && !isRetainedInline && !hasAnnotation(defn.ScalaStaticAnnot)
+
+    /** ()T and => T types should be treated as equivalent for this symbol.
+     *  Note: For the moment, we treat Scala-2 compiled symbols as loose matching,
+     *  because the Scala library does not always follow the right conventions.
+     *  Examples are: isWhole(), toInt(), toDouble() in BigDecimal, Numeric, RichInt, ScalaNumberProxy.
+     */
+    def matchNullaryLoosely(using Context): Boolean = {
+      def test(sym: Symbol) =
+        sym.is(JavaDefined) ||
+        sym.owner == defn.AnyClass ||
+        sym == defn.Object_clone ||
+        sym.owner.is(Scala2x)
+      this.exists && (test(symbol) || allOverriddenSymbols.exists(test))
+    }
+
+    // ------ access to related symbols ---------------------------------
+
+    /* Modules and module classes are represented as follows:
+     *
+     * object X extends Y { def f() }
+     *
+     * <module> lazy val X: X$ = new X$
+     * <module> class X$ extends Y { this: X.type => def f() }
+     *
+     * During completion, references to moduleClass and sourceModules are stored in
+     * the completers.
+     */
+    /** If this a module, return the corresponding class, if this is a module, return itself,
+     *  otherwise NoSymbol
+     */
+    final def moduleClass(using Context): Symbol = {
+      def notFound = {
+      	if (Config.showCompletions) println(s"missing module class for $name: $myInfo")
+      	NoSymbol
+      }
+      if (this.is(ModuleVal))
+        myInfo match {
+          case info: TypeRef           => info.symbol
+          case ExprType(info: TypeRef) => info.symbol // needed after uncurry, when module terms might be accessor defs
+          case info: LazyType          => info.moduleClass
+          case t: MethodType           =>
+            t.resultType match {
+              case info: TypeRef => info.symbol
+              case _ => notFound
+            }
+          case _ => notFound
+        }
+      else if (this.is(ModuleClass))
+        symbol
+      else
+        NoSymbol
+    }
+
+    /** If this a module class, return the corresponding module, if this is a module, return itself,
+     *  otherwise NoSymbol
+     */
+    final def sourceModule(using Context): Symbol =
+      if (this.is(ModuleClass))
+        myInfo match {
+          case ClassInfo(_, _, _, _, selfType) =>
+            def sourceOfSelf(tp: TypeOrSymbol): Symbol = (tp: @unchecked) match {
+              case tp: TermRef => tp.symbol
+              case tp: Symbol => sourceOfSelf(tp.info)
+              case tp: RefinedType => sourceOfSelf(tp.parent)
+              case tp: AnnotatedType => sourceOfSelf(tp.parent)
+            }
+            sourceOfSelf(selfType)
+          case info: LazyType =>
+            info.sourceModule
+          case _ =>
+            NoSymbol
+        }
+      else if (this.is(ModuleVal))
+        symbol
+      else
+        NoSymbol
+
+    /** The field accessed by this getter or setter, or if it does not exist, the getter */
+    def accessedFieldOrGetter(using Context): Symbol = {
+      val fieldName = if (isSetter) name.asTermName.getterName else name
+      val d = owner.info.decl(fieldName)
+      val field = d.suchThat(!_.is(Method)).symbol
+      def getter = d.suchThat(_.info.isParameterless).symbol
+      field orElse getter
+    }
+
+    /** The field accessed by a getter or setter, or
+     *  if it does not exists, the getter of a setter, or
+     *  if that does not exist the symbol itself.
+     */
+    def underlyingSymbol(using Context): Symbol =
+      if (is(Accessor)) accessedFieldOrGetter orElse symbol else symbol
+
+    /** The chain of owners of this denotation, starting with the denoting symbol itself */
+    final def ownersIterator(using Context): Iterator[Symbol] = new Iterator[Symbol] {
+      private var current = symbol
+      def hasNext = current.exists
+      def next: Symbol = {
+        val result = current
+        current = current.owner
+        result
+      }
+    }
+
+    /** If this is a weak owner, its owner, otherwise the denoting symbol. */
+    final def skipWeakOwner(using Context): Symbol =
+      if (isWeakOwner) owner.skipWeakOwner else symbol
+
+    /** The owner, skipping package objects and non-lazy valdefs. */
+    final def effectiveOwner(using Context): Symbol = owner.skipWeakOwner
+
+    /** The class containing this denotation.
+     *  If this denotation is already a class, return itself
+     *  Definitions flagged with JavaStatic are treated specially.
+     *  Their enclosing class is not the lexically enclosing class,
+     *  but in turn the enclosing class of the latter. This reflects
+     *  the context created by `Context#superCallContext`, `Context#thisCallArgContext`
+     *  for these definitions.
+     *
+     *  Note, that as packages have ClassSymbols, top level classes will have an `enclosingClass`
+     *  with Package flag set.
+     */
+    final def enclosingClass(using Context): Symbol = {
+      def enclClass(sym: Symbol, skip: Boolean): Symbol = {
+        def newSkip = sym.is(JavaStaticTerm)
+        if (!sym.exists)
+          NoSymbol
+        else if (sym.isClass)
+          if (skip) enclClass(sym.owner, newSkip) else sym
+        else
+          enclClass(sym.owner, skip || newSkip)
+      }
+      enclClass(symbol, false)
+    }
+
+    /** Skips symbol that are not owned by a class */
+    def skipLocalOwners(using Context): Symbol =
+      if symbol.owner.isClass then symbol
+      else symbol.owner.skipLocalOwners
+
+    /** A class that in source code would be lexically enclosing */
+    final def lexicallyEnclosingClass(using Context): Symbol =
+      if (!exists || isClass) symbol else owner.lexicallyEnclosingClass
+
+    /** A class is extensible if it is not final, nor a module class,
+     *  nor an anonymous class.
+     */
+    final def isExtensibleClass(using Context): Boolean =
+      isClass && !isOneOf(FinalOrModuleClass) && !isAnonymousClass
+
+    /** A symbol is effectively final if it cannot be overridden in a subclass */
+    final def isEffectivelyFinal(using Context): Boolean =
+      isOneOf(EffectivelyFinalFlags)
+      || is(Inline, butNot = Deferred)
+      || is(JavaDefinedVal, butNot = Method)
+      || !owner.isExtensibleClass
+
+    /** A class is effectively sealed if has the `final` or `sealed` modifier, or it
+     *  is defined in Scala 3 and is neither abstract nor open.
+     */
+    final def isEffectivelySealed(using Context): Boolean =
+      isOneOf(FinalOrSealed) || isClass && !isOneOf(EffectivelyOpenFlags)
+
+    final def isTransparentTrait(using Context): Boolean =
+      isAllOf(TransparentTrait)
+      || defn.assumedTransparentTraits.contains(symbol)
+      || isClass && hasAnnotation(defn.TransparentTraitAnnot)
+
+    /** The class containing this denotation which has the given effective name. */
+    final def enclosingClassNamed(name: Name)(using Context): Symbol = {
+      val cls = enclosingClass
+      if (cls.effectiveName == name || !cls.exists) cls else cls.owner.enclosingClassNamed(name)
+    }
+
+    /** The closest enclosing method containing this definition.
+     *  A local dummy owner is mapped to the primary constructor of the class.
+     */
+    final def enclosingMethod(using Context): Symbol =
+      if (this.is(Method)) symbol
+      else if (this.isClass) primaryConstructor
+      else if (this.exists) owner.enclosingMethod
+      else NoSymbol
+
+    /** The closest enclosing extension method containing this definition,
+     *  including methods outside the current class.
+     */
+    final def enclosingExtensionMethod(using Context): Symbol =
+      if this.is(ExtensionMethod) then symbol
+      else if this.exists then owner.enclosingExtensionMethod
+      else NoSymbol
+
+    /** The top-level class containing this denotation,
+     *  except for a toplevel module, where its module class is returned.
+     */
+    final def topLevelClass(using Context): Symbol = {
+      @tailrec def topLevel(d: SymDenotation): Symbol =
+        if (d.isTopLevelClass) d.symbol
+        else topLevel(d.owner)
+
+      val sym = topLevel(this)
+      if (sym.isClass) sym else sym.moduleClass
+    }
+
+    final def isTopLevelClass(using Context): Boolean =
+      !this.exists || this.isEffectiveRoot || this.is(PackageClass) || this.owner.is(PackageClass)
+
+    /** The package class containing this denotation */
+    final def enclosingPackageClass(using Context): Symbol =
+      if (this.is(PackageClass)) symbol else owner.enclosingPackageClass
+
+    /** Register target as a companion; overridden in ClassDenotation */
+    def registerCompanion(target: Symbol)(using Context) = ()
+
+    /** The registered companion; overridden in ClassDenotation */
+    def registeredCompanion(using Context): Symbol = NoSymbol
+    def registeredCompanion_=(c: Symbol): Unit = ()
+
+    /** The module object with the same (term-) name as this class or module class,
+     *  and which is also defined in the same scope and compilation unit.
+     *  NoSymbol if this module does not exist.
+     */
+    final def companionModule(using Context): Symbol =
+      if (is(Module)) sourceModule
+      else if registeredCompanion.isAbsent() then NoSymbol
+      else registeredCompanion.sourceModule
+
+    private def companionType(using Context): Symbol =
+      if (is(Package)) NoSymbol
+      else if (is(ModuleVal)) moduleClass.denot.companionType
+      else if registeredCompanion.isAbsent() then NoSymbol
+      else registeredCompanion
+
+    /** The class with the same (type-) name as this module or module class,
+     *  and which is also defined in the same scope and compilation unit.
+     *  NoSymbol if this class does not exist.
+     */
+    final def companionClass(using Context): Symbol =
+      companionType.suchThat(_.isClass).symbol
+
+    final def scalacLinkedClass(using Context): Symbol =
+      if (this.is(ModuleClass)) companionNamed(effectiveName.toTypeName)
+      else if (this.isClass) companionNamed(effectiveName.moduleClassName)
+      else NoSymbol
+
+    /** Find companion class symbol with given name, or NoSymbol if none exists.
+     *  Three alternative strategies:
+     *  1. If owner is a class, look in its members, otherwise
+     *  2. If current compilation unit has a typed tree,
+     *     determine the defining statement sequence and search its trees, otherwise
+     *  3. If context has an enclosing scope which defines this symbol,
+     *     lookup its companion in the same scope.
+     */
+    private def companionNamed(name: TypeName)(using Context): Symbol =
+      val unit = ctx.compilationUnit
+      if (owner.isClass)
+        owner.unforcedDecls.lookup(name).suchThat(_.isCoDefinedWith(symbol)).symbol
+      else if (!owner.exists || (unit eq NoCompilationUnit))
+        NoSymbol
+      else if (!unit.tpdTree.isEmpty)
+        tpd.definingStats(symbol).iterator
+          .map(tpd.definedSym)
+          .find(_.name == name)
+          .getOrElse(NoSymbol)
+      else if (ctx.scope eq EmptyScope)
+        NoSymbol
+      else if (ctx.scope.lookup(this.name) == symbol)
+        ctx.scope.lookup(name)
+      else
+        companionNamed(name)(using ctx.outersIterator.dropWhile(_.scope eq ctx.scope).next())
+
+    /** Is this symbol the same or a linked class of `sym`? */
+    final def isLinkedWith(sym: Symbol)(using Context): Boolean =
+      (symbol eq sym) || (linkedClass eq sym)
+
+    /** If this is a class, the module class of its companion object.
+     *  If this is a module class, its companion class.
+     *  NoSymbol otherwise.
+     */
+    final def linkedClass(using Context): Symbol =
+      if (this.is(ModuleClass)) companionClass
+      else if (this.isClass) companionModule.moduleClass
+      else NoSymbol
+
+    /** The class that encloses the owner of the current context
+     *  and that is a subclass of this class. NoSymbol if no such class exists.
+     */
+    final def enclosingSubClass(using Context): Symbol =
+      ctx.owner.ownersIterator.findSymbol(_.isSubClass(symbol))
+
+    /** The alias of an opaque type alias that's stored in the self type of the
+     *  containing object.
+     */
+    def opaqueAlias(using Context): Type = {
+      def recur(tp: Type): Type = tp match {
+        case RefinedType(parent, rname, TypeAlias(alias)) =>
+          if rname == name then alias.stripLazyRef else recur(parent)
+        case _ =>
+          NoType
+      }
+      recur(owner.asClass.givenSelfType)
+    }
+
+    /** The non-private symbol whose name and type matches the type of this symbol
+     *  in the given class.
+     *  @param inClass   The class containing the result symbol's definition
+     *  @param site      The base type from which member types are computed
+     *
+     *  inClass <-- find denot.symbol      class C { <-- symbol is here
+     *
+     *                   site: Subtype of both inClass and C
+     */
+    final def matchingDecl(inClass: Symbol, site: Type)(using Context): Symbol = {
+      var denot = inClass.info.nonPrivateDecl(name)
+      if (denot.isTerm) // types of the same name always match
+        denot = denot.matchingDenotation(site, site.memberInfo(symbol), symbol.targetName)
+      denot.symbol
+    }
+
+    /** The non-private member of `site` whose name and type matches the type of this symbol
+     */
+    final def matchingMember(site: Type)(using Context): Symbol = {
+      var denot = site.nonPrivateMember(name)
+      if (denot.isTerm) // types of the same name always match
+        denot = denot.matchingDenotation(site, site.memberInfo(symbol), symbol.targetName)
+      denot.symbol
+    }
+
+    /** If false, this symbol cannot possibly participate in an override,
+     *  either as overrider or overridee.
+     */
+    final def canMatchInheritedSymbols(using Context): Boolean =
+      maybeOwner.isClass && memberCanMatchInheritedSymbols
+
+    /** If false, this class member cannot possibly participate in an override,
+     *  either as overrider or overridee.
+     */
+    final def memberCanMatchInheritedSymbols(using Context): Boolean =
+      !isConstructor && !is(Private)
+
+    /** The symbol, in class `inClass`, that is overridden by this denotation in class `siteClass`.*/
+    final def overriddenSymbol(inClass: ClassSymbol, siteClass: ClassSymbol = owner.asClass)(using Context): Symbol =
+      if (!canMatchInheritedSymbols && (owner ne inClass)) NoSymbol
+      else matchingDecl(inClass, siteClass.thisType)
+
+    /** All symbols overridden by this denotation. */
+    final def allOverriddenSymbols(using Context): Iterator[Symbol] =
+      if (!canMatchInheritedSymbols) Iterator.empty
+      else overriddenFromType(owner.info)
+
+    /** Equivalent to `allOverriddenSymbols.headOption.getOrElse(NoSymbol)` but more efficient. */
+    final def nextOverriddenSymbol(using Context): Symbol = {
+      val overridden = allOverriddenSymbols
+      if (overridden.hasNext)
+        overridden.next
+      else
+        NoSymbol
+    }
+
+    /** Returns all matching symbols defined in parents of the selftype. */
+    final def extendedOverriddenSymbols(using Context): Iterator[Symbol] =
+      if (!canMatchInheritedSymbols) Iterator.empty
+      else overriddenFromType(owner.asClass.classInfo.selfType)
+
+    private def overriddenFromType(tp: Type)(using Context): Iterator[Symbol] =
+      tp.baseClasses match {
+        case _ :: inherited => inherited.iterator.map(overriddenSymbol(_)).filter(_.exists)
+        case Nil => Iterator.empty
+      }
+
+    /** The symbol overriding this symbol in given subclass `ofclazz`.
+     *
+     *  @param ofclazz is a subclass of this symbol's owner
+     */
+    final def overridingSymbol(inClass: ClassSymbol)(using Context): Symbol =
+      if (canMatchInheritedSymbols) matchingDecl(inClass, inClass.thisType)
+      else NoSymbol
+
+    /** The symbol accessed by a super in the definition of this symbol when
+     *  seen from class `base`. This symbol is always concrete.
+     *  pre: `this.owner` is in the base class sequence of `base`.
+     */
+    final def superSymbolIn(base: Symbol)(using Context): Symbol = {
+      @tailrec def loop(bcs: List[ClassSymbol]): Symbol = bcs match {
+        case bc :: bcs1 =>
+          val sym = matchingDecl(bcs.head, base.thisType)
+            .suchThat(alt => !alt.is(Deferred)).symbol
+          if (sym.exists) sym else loop(bcs.tail)
+        case _ =>
+          NoSymbol
+      }
+      loop(base.info.baseClasses.dropWhile(owner != _).tail)
+    }
+
+    /** A member of class `base` is incomplete if
+     *  (1) it is declared deferred or
+     *  (2) it is abstract override and its super symbol in `base` is
+     *      nonexistent or incomplete.
+     */
+    @tailrec final def isIncompleteIn(base: Symbol)(using Context): Boolean =
+      this.is(Deferred) ||
+      this.is(AbsOverride) && {
+        val supersym = superSymbolIn(base)
+        supersym == NoSymbol || supersym.isIncompleteIn(base)
+      }
+
+    /** The class or term symbol up to which this symbol is accessible,
+     *  or RootClass if it is public.  As java protected statics are
+     *  otherwise completely inaccessible in scala, they are treated
+     *  as public.
+     *  @param base  The access boundary to assume if this symbol is protected
+     */
+    final def accessBoundary(base: Symbol)(using Context): Symbol =
+      if (this.is(Private)) owner
+      else if (this.isAllOf(StaticProtected)) defn.RootClass
+      else if (privateWithin.exists && (!ctx.phase.erasedTypes || this.is(JavaDefined))) privateWithin
+      else if (this.is(Protected)) base
+      else defn.RootClass
+
+    final def isPublic(using Context): Boolean =
+      accessBoundary(owner) == defn.RootClass
+
+    /** The primary constructor of a class or trait, NoSymbol if not applicable. */
+    def primaryConstructor(using Context): Symbol = NoSymbol
+
+    /** The current declaration in this symbol's class owner that has the same name
+     *  as this one, and, if there are several, also has the same signature.
+     */
+    def currentSymbol(using Context): Symbol = {
+      val candidates = owner.info.decls.lookupAll(name)
+      def test(sym: Symbol): Symbol =
+        if (sym == symbol || sym.signature == signature) sym
+        else if (candidates.hasNext) test(candidates.next)
+        else NoSymbol
+      if (candidates.hasNext) {
+        val sym = candidates.next
+        if (candidates.hasNext) test(sym) else sym
+      }
+      else NoSymbol
+    }
+
+    // ----- type-related ------------------------------------------------
+
+    /** The type parameters of a class symbol, Nil for all other symbols */
+    def typeParams(using Context): List[TypeSymbol] = Nil
+
+    /** The type This(cls), where cls is this class, NoPrefix for all other symbols */
+    def thisType(using Context): Type = NoPrefix
+
+    def typeRef(using Context): TypeRef =
+      TypeRef(maybeOwner.thisType, symbol)
+
+    def termRef(using Context): TermRef =
+      TermRef(maybeOwner.thisType, symbol)
+
+    /** The typeRef applied to its own type parameters */
+    def appliedRef(using Context): Type =
+      typeRef.appliedTo(symbol.typeParams.map(_.typeRef))
+
+    /** The NamedType representing this denotation at its original location.
+     *  Same as either `typeRef` or `termRef` depending whether this denotes a type or not.
+     */
+    def namedType(using Context): NamedType =
+      if (isType) typeRef else termRef
+
+    /** Like typeRef, but objects in the prefix are represented by their singleton type,
+     *  this means we output `pre.O.member` rather than `pre.O$.this.member`.
+     *
+     *  This is required to avoid owner crash in ExplicitOuter.
+     *  See tests/pos/i10769.scala
+     */
+     def reachableTypeRef(using Context) =
+       TypeRef(owner.reachableThisType, symbol)
+
+    /** Like termRef, but objects in the prefix are represented by their singleton type,
+     *  this means we output `pre.O.member` rather than `pre.O$.this.member`.
+     *
+     *  This is required to avoid owner crash in ExplicitOuter.
+     *  See tests/pos/i10769.scala
+     */
+    def reachableTermRef(using Context) =
+      TermRef(owner.reachableThisType, symbol)
+
+    /** Like thisType, but objects in the type are represented by their singleton type,
+     *  this means we output `pre.O.member` rather than `pre.O$.this.member`.
+     */
+    def reachableThisType(using Context): Type =
+      if this.is(Package) then
+        symbol.thisType
+      else if this.isTerm then
+        NoPrefix
+      else if this.is(Module) then
+        TermRef(owner.reachableThisType, this.sourceModule)
+      else
+        ThisType.raw(TypeRef(owner.reachableThisType, symbol.asType))
+
+    /** The variance of this type parameter or type member as a subset of
+     *  {Covariant, Contravariant}
+     */
+    final def variance(using Context): Variance =
+      if is(Covariant) then Covariant
+      else if is(Contravariant) then Contravariant
+      else EmptyFlags
+
+    /** The flags to be used for a type parameter owned by this symbol.
+     *  Overridden by ClassDenotation.
+     */
+    def typeParamCreationFlags: FlagSet = TypeParam
+
+    def kindString: String =
+      if myFlags.is(ModuleClass) then "module class"
+      else if myFlags.is(Trait)  then "trait"
+      else if isClass            then "class"
+      else if isType             then "type"
+      else if myFlags.is(Module) then "object"
+      else if myFlags.is(Method) then "method"
+      else                            "val"
+
+    override def toString: String = s"$kindString $name"
+
+    // ----- Sanity checks and debugging */
+
+    def debugString: String = toString + "#" + symbol.id // !!! DEBUG
+
+    def hasSkolems(tp: Type): Boolean = tp match {
+      case tp: SkolemType => true
+      case tp: NamedType => hasSkolems(tp.prefix)
+      case tp: RefinedType => hasSkolems(tp.parent) || hasSkolems(tp.refinedInfo)
+      case tp: RecType => hasSkolems(tp.parent)
+      case tp: TypeBounds => hasSkolems(tp.lo) || hasSkolems(tp.hi)
+      case tp: TypeVar => hasSkolems(tp.inst)
+      case tp: ExprType => hasSkolems(tp.resType)
+      case tp: AppliedType => hasSkolems(tp.tycon) || tp.args.exists(hasSkolems)
+      case tp: LambdaType => tp.paramInfos.exists(hasSkolems) || hasSkolems(tp.resType)
+      case tp: AndOrType => hasSkolems(tp.tp1) || hasSkolems(tp.tp2)
+      case tp: AnnotatedType => hasSkolems(tp.parent)
+      case _ => false
+    }
+
+    def assertNoSkolems(tp: Type): Unit =
+      if (!this.isSkolem)
+        assert(!hasSkolems(tp), s"assigning type $tp containing skolems to $this")
+
+    // ----- copies and transforms  ----------------------------------------
+
+    protected def newLikeThis(s: Symbol, i: Type, pre: Type, isRefinedMethod: Boolean): SingleDenotation =
+      if isRefinedMethod then
+        new JointRefDenotation(s, i, validFor, pre, isRefinedMethod)
+      else
+        new UniqueRefDenotation(s, i, validFor, pre)
+
+    /** Copy this denotation, overriding selective fields */
+    final def copySymDenotation(
+      symbol: Symbol = this.symbol,
+      owner: Symbol = this.owner,
+      name: Name = this.name,
+      initFlags: FlagSet = UndefinedFlags,
+      info: Type | Null = null,
+      privateWithin: Symbol | Null = null,
+      annotations: List[Annotation] | Null = null,
+      rawParamss: List[List[Symbol]] | Null = null)(
+        using Context): SymDenotation = {
+      // simulate default parameters, while also passing implicit context ctx to the default values
+      val initFlags1 = (if (initFlags != UndefinedFlags) initFlags else this.flags)
+      val info1 = if (info != null) info else this.info
+      if (ctx.isAfterTyper && changedClassParents(info, info1, completersMatter = false))
+        assert(ctx.phase.changesParents, i"undeclared parent change at ${ctx.phase} for $this, was: $info, now: $info1")
+      val privateWithin1 = if (privateWithin != null) privateWithin else this.privateWithin
+      val annotations1 = if (annotations != null) annotations else this.annotations
+      val rawParamss1 = if rawParamss != null then rawParamss else this.rawParamss
+      val d = SymDenotation(symbol, owner, name, initFlags1, info1, privateWithin1)
+      d.annotations = annotations1
+      d.rawParamss = rawParamss1
+      d.registeredCompanion = registeredCompanion
+      d
+    }
+
+    /** Copy mamberNames and baseData caches from given denotation, provided
+     *  they are valid at given `phase`.
+     */
+    def copyCaches(from: SymDenotation, phase: Phase)(using Context): this.type = this
+
+    /** Are `info1` and `info2` ClassInfo types with different parents?
+     *  @param completersMatter  if `true`, consider parents changed if `info1` or `info2 `is a type completer
+     */
+    protected def changedClassParents(info1: Type | Null, info2: Type | Null, completersMatter: Boolean): Boolean =
+      info2 match {
+        case info2: ClassInfo =>
+          info1 match {
+            case info1: ClassInfo => info1.declaredParents ne info2.declaredParents
+            case _ => completersMatter
+          }
+        case _ => completersMatter
+      }
+
+    override def initial: SymDenotation = super.initial.asSymDenotation
+
+    /** Install this denotation as the result of the given denotation transformer. */
+    override def installAfter(phase: DenotTransformer)(using Context): Unit =
+      super.installAfter(phase)
+
+    /** Apply a transformation `f` to all denotations in this group that start at or after
+     *  given phase. Denotations are replaced while keeping the same validity periods.
+     */
+    override def transformAfter(phase: DenotTransformer, f: SymDenotation => SymDenotation)(using Context): Unit =
+      super.transformAfter(phase, f)
+
+    /** Set flag `flags` in current phase and in all phases that follow */
+    def setFlagFrom(phase: DenotTransformer, flags: FlagSet)(using Context): Unit =
+      setFlag(flags)
+      transformAfter(phase, sd => { sd.setFlag(flags); sd })
+
+    /** If denotation is private, remove the Private flag and expand the name if necessary */
+    def ensureNotPrivate(using Context): SymDenotation =
+      if (is(Private))
+        copySymDenotation(name = expandedName, initFlags = this.flags &~ Private)
+      else this
+
+    /** If this is a sealed class, its known children in the order of textual occurrence
+     */
+    def children(using Context): List[Symbol] =
+
+      def completeChildrenIn(owner: Symbol)(using Context) =
+        // Possible children are: classes extending Scala classes and
+        // Scala or Java enum values that are defined in owner.
+        // If owner is a package, we complete only
+        // children that are defined in the same file as their parents.
+        def maybeChild(sym: Symbol) =
+          (sym.isClass && !this.is(JavaDefined) || sym.originDenotation.is(EnumVal))
+          && (!owner.is(Package)
+             || sym.originDenotation.infoOrCompleter.match
+                  case _: SymbolLoaders.SecondCompleter => sym.associatedFile == this.symbol.associatedFile
+                  case _ => false)
+
+        if owner.isClass then
+          for c <- owner.info.decls.toList if maybeChild(c) do
+            c.ensureCompleted()
+      end completeChildrenIn
+
+      if is(Sealed) || isAllOf(JavaEnumTrait) then
+        if !is(ChildrenQueried) then
+          // Make sure all visible children are completed, so that
+          // they show up in Child annotations. A possible child is visible if it
+          // is defined in the same scope as `cls` or in the companion object of `cls`.
+          completeChildrenIn(owner)
+          completeChildrenIn(companionClass)
+          setFlag(ChildrenQueried)
+
+      annotations.collect { case Annotation.Child(child) => child }.reverse
+    end children
+
+    /** Recursively assemble all children of this symbol, Preserves order of insertion.
+     */
+    final def sealedStrictDescendants(using Context): List[Symbol] =
+
+      @tailrec
+      def findLvlN(
+        explore: mutable.ArrayDeque[Symbol],
+        seen: util.HashSet[Symbol],
+        acc: mutable.ListBuffer[Symbol]
+      ): List[Symbol] =
+        if explore.isEmpty then
+          acc.toList
+        else
+          val sym      = explore.head
+          val explore1 = explore.dropInPlace(1)
+          val lvlN     = sym.children
+          val notSeen  = lvlN.filterConserve(!seen.contains(_))
+          if notSeen.isEmpty then
+            findLvlN(explore1, seen, acc)
+          else
+            findLvlN(explore1 ++= notSeen, {seen ++= notSeen; seen}, acc ++= notSeen)
+      end findLvlN
+
+      /** Scans through `explore` to see if there are recursive children.
+       *  If a symbol in `explore` has children that are not contained in
+       *  `lvl1`, fallback to `findLvlN`, or else return `lvl1`.
+       */
+      @tailrec
+      def findLvl2(
+        lvl1: List[Symbol], explore: List[Symbol], seenOrNull: util.HashSet[Symbol] | Null
+      ): List[Symbol] = explore match
+        case sym :: explore1 =>
+          val lvl2 = sym.children
+          if lvl2.isEmpty then // no children, scan rest of explore1
+            findLvl2(lvl1, explore1, seenOrNull)
+          else // check if we have seen the children before
+            val seen = // initialise the seen set if not already
+              if seenOrNull != null then seenOrNull
+              else util.HashSet.from(lvl1)
+            val notSeen = lvl2.filterConserve(!seen.contains(_))
+            if notSeen.isEmpty then // we found children, but we had already seen them, scan the rest of explore1
+              findLvl2(lvl1, explore1, seen)
+            else // found unseen recursive children, we should fallback to the loop
+              findLvlN(
+                explore = mutable.ArrayDeque.from(explore1).appendAll(notSeen),
+                seen = {seen ++= notSeen; seen},
+                acc = mutable.ListBuffer.from(lvl1).appendAll(notSeen)
+              )
+        case nil =>
+          lvl1
+      end findLvl2
+
+      val lvl1 = children
+      findLvl2(lvl1, lvl1, seenOrNull = null)
+    end sealedStrictDescendants
+
+    /** Same as `sealedStrictDescendants` but prepends this symbol as well.
+     */
+    final def sealedDescendants(using Context): List[Symbol] = this.symbol :: sealedStrictDescendants
+  }
+
+  /** The contents of a class definition during a period
+   */
+  class ClassDenotation private[SymDenotations] (
+    symbol: Symbol,
+    maybeOwner: Symbol,
+    name: Name,
+    initFlags: FlagSet,
+    initInfo: Type,
+    initPrivateWithin: Symbol)
+    extends SymDenotation(symbol, maybeOwner, name, initFlags, initInfo, initPrivateWithin) {
+
+    import util.EqHashMap
+
+    // ----- caches -------------------------------------------------------
+
+    private var myTypeParams: List[TypeSymbol] | Null = null
+    private var fullNameCache: SimpleIdentityMap[QualifiedNameKind, Name] = SimpleIdentityMap.empty
+
+    private var myMemberCache: EqHashMap[Name, PreDenotation] | Null = null
+    private var myMemberCachePeriod: Period = Nowhere
+
+    /** A cache from types T to baseType(T, C) */
+    type BaseTypeMap = EqHashMap[CachedType, Type]
+    private var myBaseTypeCache: BaseTypeMap | Null = null
+    private var myBaseTypeCachePeriod: Period = Nowhere
+
+    private var baseDataCache: BaseData = BaseData.None
+    private var memberNamesCache: MemberNames = MemberNames.None
+
+    private def memberCache(using Context): EqHashMap[Name, PreDenotation] = {
+      if (myMemberCachePeriod != ctx.period) {
+        myMemberCache = EqHashMap()
+        myMemberCachePeriod = ctx.period
+      }
+      myMemberCache.nn
+    }
+
+    private def baseTypeCache(using Context): BaseTypeMap = {
+      if !currentHasSameBaseTypesAs(myBaseTypeCachePeriod) then
+        myBaseTypeCache = new BaseTypeMap()
+        myBaseTypeCachePeriod = ctx.period
+      myBaseTypeCache.nn
+    }
+
+    private def invalidateBaseDataCache() = {
+      baseDataCache.invalidate()
+      baseDataCache = BaseData.None
+    }
+
+    private def invalidateMemberNamesCache() = {
+      memberNamesCache.invalidate()
+      memberNamesCache = MemberNames.None
+    }
+
+    def invalidateBaseTypeCache(): Unit = {
+      myBaseTypeCache = null
+      myBaseTypeCachePeriod = Nowhere
+    }
+
+    def invalidateMemberCaches()(using Context): Unit =
+      myMemberCachePeriod = Nowhere
+      invalidateMemberNamesCache()
+
+    def invalidateMemberCachesFor(sym: Symbol)(using Context): Unit =
+      if myMemberCache != null then myMemberCache.uncheckedNN.remove(sym.name)
+      if !sym.flagsUNSAFE.is(Private) then
+        invalidateMemberNamesCache()
+        if sym.isWrappedToplevelDef then
+          val outerCache = sym.owner.owner.asClass.classDenot.myMemberCache
+          if outerCache != null then outerCache.remove(sym.name)
+
+    override def copyCaches(from: SymDenotation, phase: Phase)(using Context): this.type = {
+      from match {
+        case from: ClassDenotation =>
+          if (from.memberNamesCache.isValidAt(phase)) memberNamesCache = from.memberNamesCache
+          if (from.baseDataCache.isValidAt(phase)) {
+            baseDataCache = from.baseDataCache
+            myBaseTypeCache = from.baseTypeCache
+          }
+        case _ =>
+      }
+      this
+    }
+
+    // ----- denotation fields and accessors ------------------------------
+
+    if (initFlags.is(Module, butNot = Package))
+      assert(name.is(ModuleClassName), s"module naming inconsistency: ${name.debugString}")
+
+    /** The symbol asserted to have type ClassSymbol */
+    def classSymbol: ClassSymbol = symbol.asInstanceOf[ClassSymbol]
+
+    /** The info asserted to have type ClassInfo */
+    def classInfo(using Context): ClassInfo = info.asInstanceOf[ClassInfo]
+
+    /** The type parameters in this class, in the order they appear in the current
+     *  scope `decls`. This might be temporarily the incorrect order when
+     *  reading Scala2 pickled info. The problem is fixed by `ensureTypeParamsInCorrectOrder`,
+     *  which is called once an unpickled symbol has been completed.
+     */
+    private def typeParamsFromDecls(using Context) =
+      unforcedDecls.filter(sym =>
+        sym.is(TypeParam) && sym.owner == symbol).asInstanceOf[List[TypeSymbol]]
+
+    /** The type parameters of this class */
+    override final def typeParams(using Context): List[TypeSymbol] = {
+      if (myTypeParams == null)
+        myTypeParams =
+          if (ctx.erasedTypes || is(Module)) Nil // fast return for modules to avoid scanning package decls
+          else {
+            val di = initial
+            if (this ne di) di.typeParams
+            else infoOrCompleter match {
+              case info: TypeParamsCompleter => info.completerTypeParams(symbol)
+              case _ => typeParamsFromDecls
+            }
+          }
+      myTypeParams.nn
+    }
+
+    override protected[dotc] final def info_=(tp: Type): Unit = {
+      if (changedClassParents(infoOrCompleter, tp, completersMatter = true))
+        invalidateBaseDataCache()
+      invalidateMemberNamesCache()
+      myTypeParams = null // changing the info might change decls, and with it typeParams
+      super.info_=(tp)
+    }
+
+    /** The symbols of the parent classes. */
+    def parentSyms(using Context): List[Symbol] = info match {
+      case classInfo: ClassInfo => classInfo.declaredParents.map(_.classSymbol)
+      case _ => Nil
+    }
+
+    /** The symbol of the superclass, NoSymbol if no superclass exists */
+    def superClass(using Context): Symbol = parentSyms match {
+      case parent :: _ =>
+        if (parent.is(Trait)) NoSymbol else parent
+      case _ =>
+        NoSymbol
+    }
+
+    /** The explicitly given self type (self types of modules are assumed to be
+     *  explcitly given here).
+     */
+    def givenSelfType(using Context): Type = classInfo.selfInfo match {
+      case tp: Type => tp
+      case self: Symbol => self.info
+    }
+
+   // ------ class-specific operations -----------------------------------
+
+    private var myThisType: Type | Null = null
+
+    /** The this-type depends on the kind of class:
+     *  - for a package class `p`:  ThisType(TypeRef(Noprefix, p))
+     *  - for a module class `m`: A term ref to m's source module.
+     *  - for all other classes `c` with owner `o`: ThisType(TypeRef(o.thisType, c))
+     */
+    override def thisType(using Context): Type = {
+      if (myThisType == null) myThisType = computeThisType
+      myThisType.nn
+    }
+
+    private def computeThisType(using Context): Type = {
+      val cls = symbol.asType
+      val pre = if (this.is(Package)) NoPrefix else owner.thisType
+      ThisType.raw(TypeRef(pre, cls))
+    }
+
+    private var myTypeRef: TypeRef | Null = null
+
+    override def typeRef(using Context): TypeRef = {
+      if (myTypeRef == null) myTypeRef = super.typeRef
+      myTypeRef.nn
+    }
+
+    override def appliedRef(using Context): Type = classInfo.appliedRef
+
+    private def baseData(implicit onBehalf: BaseData, ctx: Context): (List[ClassSymbol], BaseClassSet) = {
+      if (!baseDataCache.isValid) baseDataCache = BaseData.newCache()
+      baseDataCache(this)
+    }
+
+    /** The base classes of this class in linearization order,
+     *  with the class itself as first element.
+     */
+    def baseClasses(implicit onBehalf: BaseData, ctx: Context): List[ClassSymbol] =
+      baseData._1
+
+    /** Like `baseClasses.length` but more efficient. */
+    def baseClassesLength(using BaseData, Context): Int =
+      // `+ 1` because the baseClassSet does not include the current class unlike baseClasses
+      baseClassSet.classIds.length + 1
+
+    /** A bitset that contains the superId's of all base classes */
+    private def baseClassSet(implicit onBehalf: BaseData, ctx: Context): BaseClassSet =
+      baseData._2
+
+    def computeBaseData(implicit onBehalf: BaseData, ctx: Context): (List[ClassSymbol], BaseClassSet) = {
+      def emptyParentsExpected =
+        is(Package) || (symbol == defn.AnyClass) || ctx.erasedTypes && (symbol == defn.ObjectClass)
+      val psyms = parentSyms
+      if (psyms.isEmpty && !emptyParentsExpected)
+        onBehalf.signalProvisional()
+      val builder = new BaseDataBuilder
+      def traverse(parents: List[Symbol]): Unit = parents match {
+        case p :: parents1 =>
+          p match {
+            case pcls: ClassSymbol => builder.addAll(pcls.baseClasses)
+            case _ => assert(isRefinementClass || p.isError || ctx.mode.is(Mode.Interactive), s"$this has non-class parent: $p")
+          }
+          traverse(parents1)
+        case nil =>
+      }
+      traverse(psyms)
+      (classSymbol :: builder.baseClasses, builder.baseClassSet)
+    }
+
+    final override def derivesFrom(base: Symbol)(using Context): Boolean =
+      !isAbsent() &&
+      base.isClass &&
+      (  (symbol eq base)
+      || (baseClassSet contains base)
+      )
+
+    final override def isSubClass(base: Symbol)(using Context): Boolean =
+      derivesFrom(base)
+      || base.isClass
+         && (
+          (symbol eq defn.NothingClass)
+          || (symbol eq defn.NullClass)
+              && (!ctx.mode.is(Mode.SafeNulls) || ctx.phase.erasedTypes)
+              && (base ne defn.NothingClass)
+        )
+
+    /** Is it possible that a class inherits both `this` and `that`?
+     *
+     *  @note The test is based on single-class inheritance and the closed
+     *        hierarchy of final classes.
+     *
+     *  @return The result may contain false positives, but never false negatives.
+     */
+    final def mayHaveCommonChild(that: ClassSymbol)(using Context): Boolean =
+      !this.is(Final) && !that.is(Final) && (this.is(Trait) || that.is(Trait)) ||
+        this.derivesFrom(that) || that.derivesFrom(this.symbol)
+
+    final override def typeParamCreationFlags: FlagSet = ClassTypeParamCreationFlags
+
+    /** Hook to do a pre-enter test. Overridden in PackageDenotation */
+    protected def proceedWithEnter(sym: Symbol, mscope: MutableScope)(using Context): Boolean = true
+
+    /** Enter a symbol in current scope, and future scopes of same denotation.
+     *  Note: We require that this does not happen after the first time
+     *  someone does a findMember on a subclass.
+     *  @param scope   The scope in which symbol should be entered.
+     *                 If this is EmptyScope, the scope is `decls`.
+     */
+    def enter(sym: Symbol, scope: Scope = EmptyScope)(using Context): Unit = {
+      val mscope = scope match {
+        case scope: MutableScope => scope
+        case _ => unforcedDecls.openForMutations
+      }
+      if (proceedWithEnter(sym, mscope)) {
+        enterNoReplace(sym, mscope)
+        val nxt = this.nextInRun
+        if (nxt.validFor.code > this.validFor.code)
+          this.nextInRun.asSymDenotation.asClass.enter(sym)
+      }
+    }
+
+    /** Enter a symbol in given `scope` without potentially replacing the old copy. */
+    def enterNoReplace(sym: Symbol, scope: MutableScope)(using Context): Unit =
+      scope.enter(sym)
+      invalidateMemberCachesFor(sym)
+
+    /** Replace symbol `prev` (if defined in current class) by symbol `replacement`.
+     *  If `prev` is not defined in current class, do nothing.
+     *  @pre `prev` and `replacement` have the same name.
+     */
+    def replace(prev: Symbol, replacement: Symbol)(using Context): Unit = {
+      unforcedDecls.openForMutations.replace(prev, replacement)
+      if (myMemberCache != null) myMemberCache.uncheckedNN.remove(replacement.name)
+    }
+
+    /** Delete symbol from current scope.
+     *  Note: We require that this does not happen after the first time
+     *  someone does a findMember on a subclass.
+     */
+    def delete(sym: Symbol)(using Context): Unit = {
+      val scope = info.decls.openForMutations
+      scope.unlink(sym, sym.name)
+      if sym.name != sym.originalName then scope.unlink(sym, sym.originalName)
+      if (myMemberCache != null) myMemberCache.uncheckedNN.remove(sym.name)
+      if (!sym.flagsUNSAFE.is(Private)) invalidateMemberNamesCache()
+    }
+
+    /** Make sure the type parameters of this class appear in the order given
+     *  by `typeParams` in the scope of the class. Reorder definitions in scope if necessary.
+     */
+    def ensureTypeParamsInCorrectOrder()(using Context): Unit = {
+      val tparams = typeParams
+      if (!ctx.erasedTypes && !typeParamsFromDecls.corresponds(tparams)(_.name == _.name)) {
+        val decls = info.decls
+        val decls1 = newScope
+        for (tparam <- typeParams) decls1.enter(decls.lookup(tparam.name))
+        for (sym <- decls) if (!tparams.contains(sym)) decls1.enter(sym)
+        info = classInfo.derivedClassInfo(decls = decls1)
+        myTypeParams = null
+      }
+    }
+
+    /** All members of this class that have the given name.
+     *  The elements of the returned pre-denotation all
+     *  have existing symbols.
+     */
+    final def membersNamed(name: Name)(using Context): PreDenotation =
+      Stats.record("membersNamed")
+      if Config.cacheMembersNamed then
+        var denots: PreDenotation | Null = memberCache.lookup(name)
+        if denots == null then
+          denots = computeMembersNamed(name)
+          memberCache(name) = denots
+        else if Config.checkCacheMembersNamed then
+          val denots1 = computeMembersNamed(name)
+          assert(denots.exists == denots1.exists, s"cache inconsistency: cached: $denots, computed $denots1, name = $name, owner = $this")
+        denots
+      else computeMembersNamed(name)
+
+
+    /** All non-private members of this class that have the given name.
+     *  The elements of the returned pre-denotation all have existing symbols.
+     */
+    final def nonPrivateMembersNamed(name: Name)(using Context): PreDenotation =
+      membersNamedNoShadowingBasedOnFlags(name, excluded = Private)
+
+    /** All members of this class that have the given name and match the
+     *  `required` and `excluded` flag sets; members excluded based on the
+     *  flag sets do not shadow inherited members that would not be excluded.
+     *
+     *  The elements of the returned pre-denotation all have existing symbols.
+     */
+    final def membersNamedNoShadowingBasedOnFlags(name: Name,
+        required: FlagSet = EmptyFlags, excluded: FlagSet = EmptyFlags)(using Context): PreDenotation =
+      val mbr = membersNamed(name)
+      val filtered = mbr.filterWithFlags(required, excluded)
+      if filtered eq mbr then mbr
+      else addInherited(name, filtered, required, excluded)
+
+    private[core] def computeMembersNamed(name: Name)(using Context): PreDenotation =
+      Stats.record("computeMembersNamed")
+      val ownDenots = info.decls.denotsNamed(name)
+      if debugTrace then
+        println(s"$this.member($name), ownDenots = $ownDenots")
+      addInherited(name, ownDenots)
+
+    private def addInherited(name: Name, ownDenots: PreDenotation,
+        required: FlagSet = EmptyFlags, excluded: FlagSet = EmptyFlags)(using Context): PreDenotation =
+      def collect(denots: PreDenotation, parents: List[Type]): PreDenotation = parents match
+        case p :: ps =>
+          val denots1 = collect(denots, ps)
+          p.classSymbol.denot match
+            case parentd: ClassDenotation =>
+              val inherited = parentd.membersNamedNoShadowingBasedOnFlags(name, required, excluded | Private)
+              denots1.union(inherited.mapInherited(ownDenots, denots1, thisType))
+            case _ =>
+              denots1
+        case nil => denots
+      if name.isConstructorName then ownDenots
+      else collect(ownDenots, info.parents)
+
+    override final def findMember(name: Name, pre: Type, required: FlagSet, excluded: FlagSet)(using Context): Denotation =
+      val raw = if excluded.is(Private) then nonPrivateMembersNamed(name) else membersNamed(name)
+      val pre1 = pre match
+        case pre: OrType => pre.widenUnion
+        case _ => pre
+      raw.filterWithFlags(required, excluded).asSeenFrom(pre1).toDenot(pre1)
+
+    final def findMemberNoShadowingBasedOnFlags(name: Name, pre: Type,
+        required: FlagSet = EmptyFlags, excluded: FlagSet = EmptyFlags)(using Context): Denotation =
+      membersNamedNoShadowingBasedOnFlags(name, required, excluded).asSeenFrom(pre).toDenot(pre)
+
+    /** Compute tp.baseType(this) */
+    final def baseTypeOf(tp: Type)(using Context): Type = {
+      val btrCache = baseTypeCache
+      def inCache(tp: Type) = tp match
+        case tp: CachedType => btrCache.contains(tp)
+        case _ => false
+      def record(tp: CachedType, baseTp: Type) = {
+        if (Stats.monitored) {
+          Stats.record("basetype cache entries")
+          if (!baseTp.exists) Stats.record("basetype cache NoTypes")
+        }
+        if (!tp.isProvisional)
+          btrCache(tp) = baseTp
+        else
+          btrCache.remove(tp) // Remove any potential sentinel value
+      }
+
+      def ensureAcyclic(baseTp: Type) = {
+        if (baseTp `eq` NoPrefix) throw CyclicReference(this)
+        baseTp
+      }
+
+      def recur(tp: Type): Type = try {
+        tp match {
+          case tp: CachedType =>
+            val baseTp = btrCache.lookup(tp)
+            if (baseTp != null) return ensureAcyclic(baseTp)
+          case _ =>
+        }
+        if (Stats.monitored) {
+          Stats.record("computeBaseType, total")
+          Stats.record(s"computeBaseType, ${tp.getClass}")
+        }
+        val normed = tp.tryNormalize
+        if (normed.exists) return recur(normed)
+
+        tp match {
+          case tp @ TypeRef(prefix, _) =>
+            def foldGlb(bt: Type, ps: List[Type]): Type = ps match {
+              case p :: ps1 => foldGlb(bt & recur(p), ps1)
+              case _ => bt
+            }
+
+            def computeTypeRef = {
+              btrCache(tp) = NoPrefix
+              val tpSym = tp.symbol
+              tpSym.denot match {
+                case clsd: ClassDenotation =>
+                  def isOwnThis = prefix match {
+                    case prefix: ThisType => prefix.cls `eq` clsd.owner
+                    case NoPrefix => true
+                    case _ => false
+                  }
+                  val baseTp =
+                    if (tpSym eq symbol)
+                      tp
+                    else if (isOwnThis)
+                      if (clsd.baseClassSet.contains(symbol))
+                        if (symbol.isStatic && symbol.typeParams.isEmpty) symbol.typeRef
+                        else foldGlb(NoType, clsd.info.parents)
+                      else NoType
+                    else
+                      recur(clsd.typeRef).asSeenFrom(prefix, clsd.owner)
+                  record(tp, baseTp)
+                  baseTp
+                case _ =>
+                  val superTp = tp.superType
+                  val baseTp = recur(superTp)
+                  if (inCache(superTp))
+                    record(tp, baseTp)
+                  else
+                    btrCache.remove(tp)
+                  baseTp
+              }
+            }
+            computeTypeRef
+
+          case tp @ AppliedType(tycon, args) =>
+            def computeApplied = {
+              btrCache(tp) = NoPrefix
+              val baseTp =
+                if (tycon.typeSymbol eq symbol) tp
+                else (tycon.typeParams: @unchecked) match {
+                  case LambdaParam(_, _) :: _ =>
+                    recur(tp.superType)
+                  case tparams: List[Symbol @unchecked] =>
+                    recur(tycon).substApprox(tparams, args)
+                }
+              record(tp, baseTp)
+              baseTp
+            }
+            computeApplied
+
+          case tp: TypeParamRef =>  // uncachable, since baseType depends on context bounds
+            recur(TypeComparer.bounds(tp).hi)
+
+          case CapturingType(parent, refs) =>
+            tp.derivedCapturingType(recur(parent), refs)
+
+          case tp: TypeProxy =>
+            def computeTypeProxy = {
+              val superTp = tp.superType
+              val baseTp = recur(superTp)
+              tp match {
+                case tp: CachedType if baseTp.exists && inCache(superTp) =>
+                  record(tp, baseTp)
+                case _ =>
+              }
+              baseTp
+            }
+            computeTypeProxy
+
+          case tp: AndOrType =>
+            def computeAndOrType: Type =
+              val tp1 = tp.tp1
+              val tp2 = tp.tp2
+              if !tp.isAnd then
+                if tp1.isBottomType && (tp1 frozen_<:< tp2) then return recur(tp2)
+                if tp2.isBottomType && (tp2 frozen_<:< tp1) then return recur(tp1)
+              val baseTp =
+                if symbol.isStatic && tp.derivesFrom(symbol) && symbol.typeParams.isEmpty then
+                  symbol.typeRef
+                else
+                  val baseTp1 = recur(tp1)
+                  val baseTp2 = recur(tp2)
+                  val combined = if (tp.isAnd) baseTp1 & baseTp2 else baseTp1 | baseTp2
+                  combined match
+                    case combined: AndOrType
+                    if (combined.tp1 eq tp1) && (combined.tp2 eq tp2) && (combined.isAnd == tp.isAnd) => tp
+                    case _ => combined
+
+              if (baseTp.exists && inCache(tp1) && inCache(tp2)) record(tp, baseTp)
+              baseTp
+
+            computeAndOrType
+
+          case JavaArrayType(_) if symbol == defn.ObjectClass =>
+            this.typeRef
+
+          case _ =>
+            NoType
+        }
+      }
+      catch {
+        case ex: Throwable =>
+          tp match
+            case tp: CachedType => btrCache.remove(tp)
+            case _ =>
+          throw ex
+      }
+
+
+      trace.onDebug(s"$tp.baseType($this)") {
+        Stats.record("baseTypeOf")
+        recur(tp)
+      }
+    }
+
+    def memberNames(keepOnly: NameFilter)(implicit onBehalf: MemberNames, ctx: Context): Set[Name] =
+      if (this.is(PackageClass) || !Config.cacheMemberNames)
+        computeMemberNames(keepOnly) // don't cache package member names; they might change
+      else {
+        if (!memberNamesCache.isValid) memberNamesCache = MemberNames.newCache()
+        memberNamesCache(keepOnly, this)
+      }
+
+    def computeMemberNames(keepOnly: NameFilter)(implicit onBehalf: MemberNames, ctx: Context): Set[Name] = {
+      var names = Set[Name]()
+      def maybeAdd(name: Name) = if (keepOnly(thisType, name)) names += name
+      try {
+        for (p <- parentSyms if p.isClass)
+          for (name <- p.asClass.memberNames(keepOnly))
+            maybeAdd(name)
+        val ownSyms =
+          if (keepOnly eq implicitFilter)
+            if (this.is(Package)) Iterator.empty
+              // implicits in package objects are added by the overriding `memberNames` in `PackageClassDenotation`
+            else info.decls.iterator.filter(_.isOneOf(GivenOrImplicitVal))
+          else info.decls.iterator
+        for (sym <- ownSyms) maybeAdd(sym.name)
+        names
+      }
+      catch {
+        case ex: Throwable =>
+          handleRecursive("member names", i"of $this", ex)
+      }
+    }
+
+    override final def fullNameSeparated(kind: QualifiedNameKind)(using Context): Name = {
+      val cached = fullNameCache(kind)
+      if (cached != null) cached
+      else {
+        val fn = super.fullNameSeparated(kind)
+        fullNameCache = fullNameCache.updated(kind, fn)
+        fn
+      }
+    }
+
+    // to avoid overloading ambiguities
+    override def fullName(using Context): Name = super.fullName
+
+    override def primaryConstructor(using Context): Symbol = {
+      def constrNamed(cname: TermName) = info.decls.denotsNamed(cname).last.symbol
+        // denotsNamed returns Symbols in reverse order of occurrence
+      if (this.is(Package)) NoSymbol
+      else constrNamed(nme.CONSTRUCTOR).orElse(constrNamed(nme.TRAIT_CONSTRUCTOR))
+    }
+
+    /** The term parameter accessors of this class.
+     *  Both getters and setters are returned in this list.
+     */
+    def paramAccessors(using Context): List[Symbol] =
+      unforcedDecls.filter(_.is(ParamAccessor))
+
+    /** The term parameter getters of this class. */
+    def paramGetters(using Context): List[Symbol] =
+      paramAccessors.filterNot(_.isSetter)
+
+    /** If this class has the same `decls` scope reference in `phase` and
+     *  `phase.next`, install a new denotation with a cloned scope in `phase.next`.
+     */
+    def ensureFreshScopeAfter(phase: DenotTransformer)(using Context): Unit =
+      if (ctx.phaseId != phase.next.id) atPhase(phase.next)(ensureFreshScopeAfter(phase))
+      else {
+        val prevClassInfo = atPhase(phase) {
+          current.asInstanceOf[ClassDenotation].classInfo
+        }
+        val ClassInfo(pre, _, ps, decls, selfInfo) = classInfo
+        if (prevClassInfo.decls eq decls)
+          copySymDenotation(info = ClassInfo(pre, classSymbol, ps, decls.cloneScope, selfInfo))
+            .copyCaches(this, phase.next)
+            .installAfter(phase)
+      }
+
+    private var myCompanion: Symbol = NoSymbol
+
+    /** Register companion class */
+    override def registerCompanion(companion: Symbol)(using Context) =
+      if (companion.isClass && !isAbsent(canForce = false) && !companion.isAbsent(canForce = false))
+        myCompanion = companion
+
+    private[core] def unforcedRegisteredCompanion: Symbol = myCompanion
+
+    override def registeredCompanion(using Context) =
+      if !myCompanion.exists then
+        ensureCompleted()
+      myCompanion
+
+    override def registeredCompanion_=(c: Symbol) =
+      myCompanion = c
+  }
+
+  /** The denotation of a package class.
+   *  It overrides ClassDenotation to take account of package objects when looking for members
+   */
+  final class PackageClassDenotation private[SymDenotations] (
+    symbol: Symbol,
+    ownerIfExists: Symbol,
+    name: Name,
+    initFlags: FlagSet,
+    initInfo: Type,
+    initPrivateWithin: Symbol)
+    extends ClassDenotation(symbol, ownerIfExists, name, initFlags, initInfo, initPrivateWithin) {
+
+    private var packageObjsCache: List[ClassDenotation] = _
+    private var packageObjsRunId: RunId = NoRunId
+    private var ambiguityWarningIssued: Boolean = false
+
+    /** The package objects in this class */
+    def packageObjs(using Context): List[ClassDenotation] = {
+      if (packageObjsRunId != ctx.runId) {
+        packageObjsRunId = ctx.runId
+        packageObjsCache = Nil // break cycle in case we are looking for package object itself
+        packageObjsCache = {
+          val pkgObjBuf = new mutable.ListBuffer[ClassDenotation]
+          for (sym <- info.decls) { // don't use filter, since that loads classes with `$`s in their name
+            val denot = sym.lastKnownDenotation  // don't use `sym.denot`, as this brings forward classes too early
+            if (denot.isType && denot.name.isPackageObjectName)
+              pkgObjBuf += sym.asClass.classDenot
+          }
+          pkgObjBuf.toList
+        }
+      }
+      packageObjsCache
+    }
+
+    /** The package object (as a term symbol) in this package that might contain
+     *  `sym` as a member.
+     */
+    def packageObjFor(sym: Symbol)(using Context): Symbol = {
+      val owner = sym.maybeOwner
+      if (owner.is(Package)) NoSymbol
+      else if (owner.isPackageObject) owner.sourceModule
+      else // owner could be class inherited by package object (until package object inheritance is removed)
+        packageObjs.find(_.name == packageTypeName) match {
+          case Some(pobj) => pobj.sourceModule
+          case _ => NoSymbol
+        }
+    }
+
+    /** Looks in both the package object and the package for members. The precise algorithm
+     *  is as follows:
+     *
+     *  If this is the scala package look in the package first, and if nothing is found
+     *  there, look in the package object second. Otherwise, look in the both the package object
+     *  and the package and form a union of the results.
+     *
+     *  The reason for the special treatment of the scala package is that if we
+     *  complete it too early, we freeze its superclass Any, so that no members can
+     *  be entered in it. As a consequence, there should be no entry in the scala package
+     *  object that hides a class or object in the scala package of the same name, because
+     *  the behavior would then be unintuitive for such members.
+     */
+    override def computeMembersNamed(name: Name)(using Context): PreDenotation =
+
+      def recur(pobjs: List[ClassDenotation], acc: PreDenotation): PreDenotation = pobjs match
+        case pcls :: pobjs1 =>
+          if (pcls.isCompleting) recur(pobjs1, acc)
+          else
+            val pobjMembers = pcls.nonPrivateMembersNamed(name).filterWithPredicate { d =>
+              !defn.topClasses.contains(d.symbol.maybeOwner) // Drop members of top classes
+            }
+            recur(pobjs1, acc.union(pobjMembers))
+        case nil =>
+          val directMembers = super.computeMembersNamed(name)
+          if !acc.exists then directMembers
+          else acc.union(directMembers.filterWithPredicate(!_.symbol.isAbsent())) match
+            case d: DenotUnion => dropStale(d)
+            case d => d
+
+      /** Filter symbols making up a DenotUnion to remove alternatives from stale classfiles.
+       *  This proceeds as follow:
+       *
+       *   - prefer alternatives that are currently compiled over ones that have been compiled before.
+       *   - if no alternative is compiled now, and they all come from the same file, keep all of them
+       *   - if no alternative is compiled now, and they come from different files, keep the
+       *     ones from the youngest file, but issue a warning that one of the class files
+       *     should be removed from the classpath.
+       */
+      def dropStale(multi: DenotUnion): PreDenotation =
+        val compiledNow = multi.filterWithPredicate(d =>
+          d.symbol.isDefinedInCurrentRun || d.symbol.associatedFile == null
+            // if a symbol does not have an associated file, assume it is defined
+            // in the current run anyway. This is true for packages, and also can happen for pickling and
+            // from-tasty tests that generate a fresh symbol and then re-use it in the next run.
+          )
+        if compiledNow.exists then compiledNow
+        else
+          //val union = (d1: Set[AbstractFile], d2: Set[AbstractFile]) => d1.union(d2)
+          // !cc! need to break `u` out into separate definition, writing `_ union _` below gives an error
+          val assocFiles = multi.aggregate(d => Set(d.symbol.associatedFile.nn), _ union _)
+          if assocFiles.size == 1 then
+            multi // they are all overloaded variants from the same file
+          else
+            // pick the variant(s) from the youngest class file
+            val lastModDate = assocFiles.map(_.lastModified).max
+            val youngest = assocFiles.filter(_.lastModified == lastModDate)
+            val chosen = youngest.head
+            def ambiguousFilesMsg(f: AbstractFile) =
+              em"""Toplevel definition $name is defined in
+                  |  $chosen
+                  |and also in
+                  |  $f"""
+            if youngest.size > 1 then
+              throw TypeError(i"""${ambiguousFilesMsg(youngest.tail.head)}
+                                 |One of these files should be removed from the classpath.""")
+
+            // Warn if one of the older files comes from a different container.
+            // In that case picking the youngest file is not necessarily what we want,
+            // since the older file might have been loaded from a jar earlier in the
+            // classpath.
+            def sameContainer(f: AbstractFile): Boolean =
+              try f.container == chosen.container catch case NonFatal(ex) => true
+            if !ambiguityWarningIssued then
+              for conflicting <- assocFiles.find(!sameContainer(_)) do
+                report.warning(i"""${ambiguousFilesMsg(conflicting.nn)}
+                               |Keeping only the definition in $chosen""")
+                ambiguityWarningIssued = true
+            multi.filterWithPredicate(_.symbol.associatedFile == chosen)
+      end dropStale
+
+      if symbol eq defn.ScalaPackageClass then
+        val denots = super.computeMembersNamed(name)
+        if denots.exists || name == nme.CONSTRUCTOR then denots
+        else recur(packageObjs, NoDenotation)
+      else recur(packageObjs, NoDenotation)
+    end computeMembersNamed
+
+    /** The union of the member names of the package and the package object */
+    override def memberNames(keepOnly: NameFilter)(implicit onBehalf: MemberNames, ctx: Context): Set[Name] = {
+      def recur(pobjs: List[ClassDenotation], acc: Set[Name]): Set[Name] = pobjs match {
+        case pcls :: pobjs1 =>
+          recur(pobjs1, acc.union(pcls.memberNames(keepOnly)))
+        case nil =>
+          acc
+      }
+      recur(packageObjs, super.memberNames(keepOnly))
+    }
+
+    /** If another symbol with the same name is entered, unlink it.
+     *  If symbol is a package object, invalidate the packageObj cache.
+     *  @return  `sym` is not already entered
+     */
+    override def proceedWithEnter(sym: Symbol, mscope: MutableScope)(using Context): Boolean = {
+      val entry = mscope.lookupEntry(sym.name)
+      if (entry != null) {
+        if (entry.sym == sym) return false
+        mscope.unlink(entry)
+      }
+      if (sym.name.isPackageObjectName) packageObjsRunId = NoRunId
+      true
+    }
+
+    /** Unlink all package members defined in `file` in a previous run. */
+    def unlinkFromFile(file: AbstractFile)(using Context): Unit = {
+      val scope = unforcedDecls.openForMutations
+      for (sym <- scope.toList.iterator)
+        // We need to be careful to not force the denotation of `sym` here,
+        // otherwise it will be brought forward to the current run.
+        if (sym.defRunId != ctx.runId && sym.isClass && sym.asClass.assocFile == file)
+          scope.unlink(sym, sym.lastKnownDenotation.name)
+    }
+  }
+
+  @sharable object NoDenotation
+  extends SymDenotation(NoSymbol, NoSymbol, "<none>".toTermName, Permanent, NoType) {
+    override def isType: Boolean = false
+    override def isTerm: Boolean = false
+    override def exists: Boolean = false
+    override def owner: Symbol = throw new AssertionError("NoDenotation.owner")
+    override def computeAsSeenFrom(pre: Type)(using Context): SingleDenotation = this
+    override def mapInfo(f: Type => Type)(using Context): SingleDenotation = this
+    override def asSeenFrom(pre: Type)(using Context): AsSeenFromResult = this
+
+    override def matches(other: SingleDenotation)(using Context): Boolean = false
+    override def targetName(using Context): Name = EmptyTermName
+    override def mapInherited(ownDenots: PreDenotation, prevDenots: PreDenotation, pre: Type)(using Context): SingleDenotation = this
+    override def filterWithPredicate(p: SingleDenotation => Boolean): SingleDenotation = this
+    override def filterDisjoint(denots: PreDenotation)(using Context): SingleDenotation = this
+    override def filterWithFlags(required: FlagSet, excluded: FlagSet)(using Context): SingleDenotation = this
+
+    NoSymbol.denot = this
+    validFor = Period.allInRun(NoRunId)
+  }
+
+  /** Can a private symbol with given name and flags be inferred to be local,
+   *  if all references to such symbols are via `this`?
+   *  This holds for all symbols except
+   *   - constructors, since they can never be referred to as members of their
+   *     own, fully elaborated `this`.
+   *   - parameters and parameter accessors, since their Local status is already
+   *     determined by whether they have a `val` or `var` or not.
+   */
+  def canBeLocal(name: Name, flags: FlagSet)(using Context) =
+    !name.isConstructorName && !flags.is(Param) && !flags.is(ParamAccessor)
+
+  /** Factory method for SymDenotion creation. All creations
+   *  should be done via this method.
+   */
+  def SymDenotation(
+    symbol: Symbol,
+    owner: Symbol,
+    name: Name,
+    initFlags: FlagSet,
+    initInfo: Type,
+    initPrivateWithin: Symbol = NoSymbol)(using Context): SymDenotation = {
+    val result =
+      if (symbol.isClass)
+        if (initFlags.is(Package)) new PackageClassDenotation(symbol, owner, name, initFlags, initInfo, initPrivateWithin)
+        else new ClassDenotation(symbol, owner, name, initFlags, initInfo, initPrivateWithin)
+      else new SymDenotation(symbol, owner, name, initFlags, initInfo, initPrivateWithin)
+    result.validFor = currentStablePeriod
+    result
+  }
+
+  def stillValid(denot: SymDenotation)(using Context): Boolean =
+    if (denot.isOneOf(ValidForeverFlags) || denot.isRefinementClass || denot.isImport) true
+    else {
+      val initial = denot.initial
+      val firstPhaseId =
+        initial.validFor.firstPhaseId.max(typerPhase.id)
+      if firstPhaseId > ctx.lastPhaseId then
+        false
+      else if (initial ne denot) || ctx.phaseId != firstPhaseId then
+        atPhase(firstPhaseId)(stillValidInOwner(initial))
+      else
+        stillValidInOwner(denot)
+    }
+
+  private[SymDenotations] def stillValidInOwner(denot: SymDenotation)(using Context): Boolean = try
+    val owner = denot.maybeOwner.denot
+    stillValid(owner)
+    && (
+      !owner.isClass
+      || owner.isRefinementClass
+      || owner.is(Scala2x)
+      || owner.unforcedDecls.contains(denot.name, denot.symbol)
+      || (denot.is(Synthetic) && denot.is(ModuleClass) && stillValidInOwner(denot.companionClass))
+      || denot.isSelfSym
+      || denot.isLocalDummy)
+  catch case ex: StaleSymbol => false
+
+  /** Explain why symbol is invalid; used for debugging only */
+  def traceInvalid(denot: Denotation)(using Context): Boolean = {
+    def show(d: Denotation) = s"$d#${d.symbol.id}"
+    def explain(msg: String) = {
+      println(s"${show(denot)} is invalid at ${ctx.period} because $msg")
+      false
+    }
+    denot match {
+      case denot: SymDenotation =>
+        def explainSym(msg: String) = explain(s"$msg\ndefined = ${denot.definedPeriodsString}")
+        if (denot.isOneOf(ValidForeverFlags) || denot.isRefinementClass) true
+        else
+          val initial = denot.initial
+          if ((initial ne denot) || ctx.phaseId != initial.validFor.firstPhaseId)
+            atPhase(initial.validFor.firstPhaseId)(traceInvalid(initial))
+          else try {
+            val owner = denot.owner.denot
+            if (!traceInvalid(owner)) explainSym("owner is invalid")
+            else if (!owner.isClass || owner.isRefinementClass || denot.isSelfSym) true
+            else if (owner.unforcedDecls.lookupAll(denot.name) contains denot.symbol) true
+            else explainSym(s"decls of ${show(owner)} are ${owner.unforcedDecls.lookupAll(denot.name).toList}, do not contain ${denot.symbol}")
+          }
+          catch {
+            case ex: StaleSymbol => explainSym(s"$ex was thrown")
+          }
+      case _ =>
+        explain("denotation is not a SymDenotation")
+    }
+  }
+
+  /** Configurable: Accept stale symbol with warning if in IDE
+   *  Always accept stale symbols when testing pickling.
+   */
+  def staleOK(using Context): Boolean =
+    Config.ignoreStaleInIDE && ctx.mode.is(Mode.Interactive)
+    || ctx.settings.YtestPickler.value
+
+  /** Possibly accept stale symbol with warning if in IDE */
+  def acceptStale(denot: SingleDenotation)(using Context): Boolean =
+    staleOK && {
+      report.debugwarn(denot.staleSymbolMsg)
+      true
+    }
+
+// ---- Completion --------------------------------------------------------
+
+  /** Instances of LazyType are carried by uncompleted symbols.
+   *  Note: LazyTypes double up as (constant) functions from Symbol and
+   *  from (TermSymbol, ClassSymbol) to LazyType. That way lazy types can be
+   *  directly passed to symbol creation methods in Symbols that demand instances
+   *  of these function types.
+   */
+  abstract class LazyType extends UncachedGroundType
+    with (Symbol -> LazyType)
+    with ((TermSymbol, ClassSymbol) -> LazyType) { self =>
+
+    /** Sets all missing fields of given denotation */
+    def complete(denot: SymDenotation)(using Context): Unit
+
+    def apply(sym: Symbol): LazyType = this
+    def apply(module: TermSymbol, modcls: ClassSymbol): LazyType = this
+
+    private var myDecls: Scope = EmptyScope
+    private var mySourceModule: Symbol | Null = null
+    private var myModuleClass: Symbol | Null = null
+    private var mySourceModuleFn: Context ?-> Symbol = LazyType.NoSymbolFn
+    private var myModuleClassFn: Context ?-> Symbol = LazyType.NoSymbolFn
+
+    /** The type parameters computed by the completer before completion has finished */
+    def completerTypeParams(sym: Symbol)(using Context): List[TypeParamInfo] =
+      if (sym.is(Touched)) Nil // return `Nil` instead of throwing a cyclic reference
+      else sym.info.typeParams
+
+    def decls: Scope = myDecls
+    def sourceModule(using Context): Symbol =
+      if mySourceModule == null then mySourceModule = mySourceModuleFn
+      mySourceModule.nn
+    def moduleClass(using Context): Symbol =
+      if myModuleClass == null then myModuleClass = myModuleClassFn
+      myModuleClass.nn
+
+    def withDecls(decls: Scope): this.type = { myDecls = decls; this }
+    def withSourceModule(sourceModuleFn: Context ?-> Symbol): this.type = { mySourceModuleFn = sourceModuleFn; this }
+    def withModuleClass(moduleClassFn: Context ?-> Symbol): this.type = { myModuleClassFn = moduleClassFn; this }
+
+    override def toString: String = getClass.toString
+
+    /** A hook that is called before trying to complete a symbol with its
+     *  associated cycle detection via the Touched flag. This is overridden
+     *  for Type definitions in Namer, where we make sure that owners are
+     *  completed before nested types.
+     */
+    def needsCompletion(symd: SymDenotation)(using Context): Boolean = true
+  }
+
+  object LazyType:
+    private val NoSymbolFn = (_: Context) ?=> NoSymbol
+
+  /** A subtrait of LazyTypes where completerTypeParams yields a List[TypeSymbol], which
+   *  should be completed independently of the info.
+   */
+  trait TypeParamsCompleter extends LazyType {
+    override def completerTypeParams(sym: Symbol)(using Context): List[TypeSymbol] =
+      unsupported("completerTypeParams") // should be abstract, but Scala-2 will then compute the wrong type for it
+  }
+
+  /** A missing completer */
+  trait NoCompleter extends LazyType {
+    def complete(denot: SymDenotation)(using Context): Unit = unsupported("complete")
+  }
+
+  @sharable object NoCompleter extends NoCompleter
+
+  /** A lazy type for modules that points to the module class.
+   *  Needed so that `moduleClass` works before completion.
+   *  Completion of modules is always completion of the underlying
+   *  module class, followed by copying the relevant fields to the module.
+   */
+  class ModuleCompleter(_moduleClass: ClassSymbol) extends LazyType {
+    override def moduleClass(using Context): ClassSymbol = _moduleClass
+    def complete(denot: SymDenotation)(using Context): Unit = {
+      val from = moduleClass.denot.asClass
+      denot.setFlag(from.flags.toTermFlags & RetainedModuleValFlags)
+      denot.annotations = from.annotations filter (_.appliesToModule)
+        // !!! ^^^ needs to be revised later. The problem is that annotations might
+        // only apply to the module but not to the module class. The right solution
+        // is to have the module class completer set the annotations of both the
+        // class and the module.
+      denot.info = moduleClass.typeRef
+      denot.setPrivateWithin(from.privateWithin)
+    }
+  }
+
+  /** A completer for missing references */
+  class StubInfo() extends LazyType {
+
+    def initializeToDefaults(denot: SymDenotation, errMsg: Message)(using Context): Unit = {
+      denot.info = denot match {
+        case denot: ClassDenotation =>
+          ClassInfo(denot.owner.thisType, denot.classSymbol, Nil, EmptyScope)
+        case _ =>
+          ErrorType(errMsg)
+      }
+      denot.setPrivateWithin(NoSymbol)
+    }
+
+    def complete(denot: SymDenotation)(using Context): Unit = {
+      val sym = denot.symbol
+      val errMsg = BadSymbolicReference(denot)
+      report.error(errMsg, sym.srcPos)
+      if (ctx.debug) throw new scala.Error()
+      initializeToDefaults(denot, errMsg)
+    }
+  }
+
+  // ---- Caches for inherited info -----------------------------------------
+
+  /** Base trait for caches that keep info dependent on inherited classes */
+  trait InheritedCache {
+
+    /** Is the cache valid in current period? */
+    def isValid(using Context): Boolean
+
+    /** is the cache valid in current run at given phase? */
+    def isValidAt(phase: Phase)(using Context): Boolean
+
+    /** Render invalid this cache and all caches that depend on it */
+    def invalidate(): Unit
+  }
+
+  /** A cache for sets of member names, indexed by a NameFilter */
+  trait MemberNames extends InheritedCache {
+    def apply(keepOnly: NameFilter, clsd: ClassDenotation)
+             (implicit onBehalf: MemberNames, ctx: Context): Set[Name]
+  }
+
+  object MemberNames {
+    implicit val None: MemberNames = new InvalidCache with MemberNames {
+      def apply(keepOnly: NameFilter, clsd: ClassDenotation)(implicit onBehalf: MemberNames, ctx: Context) = ???
+    }
+    def newCache()(using Context): MemberNames = new MemberNamesImpl(ctx.period)
+  }
+
+  /** A cache for baseclasses, as a sequence in linearization order and as a set that
+   *  can be queried efficiently for containment.
+   */
+  trait BaseData extends InheritedCache {
+    def apply(clsd: ClassDenotation)
+             (implicit onBehalf: BaseData, ctx: Context): (List[ClassSymbol], BaseClassSet)
+    def signalProvisional(): Unit
+  }
+
+  object BaseData {
+    implicit val None: BaseData = new InvalidCache with BaseData {
+      def apply(clsd: ClassDenotation)(implicit onBehalf: BaseData, ctx: Context) = ???
+      def signalProvisional() = ()
+    }
+    def newCache()(using Context): BaseData = new BaseDataImpl(ctx.period)
+  }
+
+  private abstract class InheritedCacheImpl(val createdAt: Period) extends InheritedCache {
+    protected def sameGroup(p1: Phase, p2: Phase): Boolean
+
+    private var dependent: WeakHashMap[InheritedCache, Unit] | Null = null
+    private var checkedPeriod: Period = Nowhere
+
+    protected def invalidateDependents() = {
+      import scala.language.unsafeNulls
+      if (dependent != null) {
+        val it = dependent.keySet.iterator()
+        while (it.hasNext()) it.next().invalidate()
+      }
+      dependent = null
+    }
+
+    protected def addDependent(dep: InheritedCache) = {
+      if (dependent == null) dependent = new WeakHashMap
+      dependent.nn.put(dep, ())
+    }
+
+    def isValidAt(phase: Phase)(using Context) =
+      checkedPeriod == ctx.period ||
+        createdAt.runId == ctx.runId &&
+        createdAt.phaseId < unfusedPhases.length &&
+        sameGroup(unfusedPhases(createdAt.phaseId), phase) &&
+        { checkedPeriod = ctx.period; true }
+  }
+
+  private class InvalidCache extends InheritedCache {
+    def isValid(using Context) = false
+    def isValidAt(phase: Phase)(using Context) = false
+    def invalidate(): Unit = ()
+  }
+
+  private class MemberNamesImpl(createdAt: Period) extends InheritedCacheImpl(createdAt) with MemberNames {
+    private var cache: SimpleIdentityMap[NameFilter, Set[Name]] | Null = SimpleIdentityMap.empty
+
+    final def isValid(using Context): Boolean =
+      cache != null && isValidAt(ctx.phase)
+
+    private var locked = false
+
+    /** Computing parent member names might force parents, which could invalidate
+     *  the cache itself. In that case we should cancel invalidation and
+     *  proceed as usual. However, all cache entries should be cleared.
+     */
+    def invalidate(): Unit =
+      if (cache != null)
+        if (locked) cache = SimpleIdentityMap.empty
+        else {
+          cache = null
+          invalidateDependents()
+        }
+
+    def apply(keepOnly: NameFilter, clsd: ClassDenotation)(implicit onBehalf: MemberNames, ctx: Context) = {
+      assert(isValid)
+      val cached = cache.nn(keepOnly)
+      try
+        if (cached != null) cached
+        else {
+          locked = true
+          val computed =
+            try clsd.computeMemberNames(keepOnly)(this, ctx)
+            finally locked = false
+          cache = cache.nn.updated(keepOnly, computed)
+          computed
+        }
+      finally addDependent(onBehalf)
+    }
+
+    def sameGroup(p1: Phase, p2: Phase) = p1.sameMembersStartId == p2.sameMembersStartId
+  }
+
+  private class BaseDataImpl(createdAt: Period) extends InheritedCacheImpl(createdAt) with BaseData {
+    private var cache: (List[ClassSymbol], BaseClassSet) | Null = null
+
+    private var valid = true
+    private var locked = false
+    private var provisional = false
+
+    final def isValid(using Context): Boolean =
+      valid && createdAt.runId == ctx.runId
+        // Note: We rely on the fact that whenever base types of classes change,
+        // the affected classes will get new denotations with new basedata caches.
+        // So basedata caches can become invalid only if the run changes.
+
+    def invalidate(): Unit =
+      if (valid && !locked) {
+        cache = null
+        valid = false
+        invalidateDependents()
+      }
+
+    def signalProvisional() = provisional = true
+
+    def apply(clsd: ClassDenotation)(implicit onBehalf: BaseData, ctx: Context)
+        : (List[ClassSymbol], BaseClassSet) = {
+      assert(isValid)
+      try
+        if (cache != null) cache.uncheckedNN
+        else {
+          if (locked) throw CyclicReference(clsd)
+          locked = true
+          provisional = false
+          val computed =
+            try clsd.computeBaseData(this, ctx)
+            finally locked = false
+          if (!provisional) cache = computed
+          else onBehalf.signalProvisional()
+          computed
+        }
+      finally addDependent(onBehalf)
+    }
+
+    def sameGroup(p1: Phase, p2: Phase) = p1.sameParentsStartId == p2.sameParentsStartId
+  }
+
+  class BaseClassSet(val classIds: Array[Int]) extends AnyVal {
+    def contains(sym: Symbol, limit: Int): Boolean = {
+      val id = sym.id
+      var i = 0
+      while (i < limit && classIds(i) != id) i += 1
+      i < limit && {
+        if (i > 0) {
+          val t = classIds(i)
+          classIds(i) = classIds(i - 1)
+          classIds(i - 1) = t
+        }
+        true
+      }
+    }
+    def contains(sym: Symbol): Boolean = contains(sym, classIds.length)
+  }
+
+  object BaseClassSet {
+    def apply(bcs: List[ClassSymbol]): BaseClassSet =
+      new BaseClassSet(bcs.toArray.map(_.id))
+  }
+
+  /** A class to combine base data from parent types */
+  class BaseDataBuilder {
+    private var classes: List[ClassSymbol] = Nil
+    private var classIds = new Array[Int](32)
+    private var length = 0
+
+    private def resize(size: Int) = {
+      val classIds1 = new Array[Int](size)
+      System.arraycopy(classIds, 0, classIds1, 0, classIds.length min size)
+      classIds = classIds1
+    }
+
+    private def add(sym: Symbol): Unit = {
+      if (length == classIds.length) resize(length * 2)
+      classIds(length) = sym.id
+      length += 1
+    }
+
+    def addAll(bcs: List[ClassSymbol]): this.type = {
+      val len = length
+      bcs match {
+        case bc :: bcs1 =>
+          addAll(bcs1)
+          if (!new BaseClassSet(classIds).contains(bc, len)) {
+            add(bc)
+            classes = bc :: classes
+          }
+        case nil =>
+      }
+      this
+    }
+
+    def baseClassSet: BaseClassSet = {
+      if (length != classIds.length) resize(length)
+      new BaseClassSet(classIds)
+    }
+
+    def baseClasses: List[ClassSymbol] = classes
+  }
+
+  private val packageTypeName = ModuleClassName(nme.PACKAGE).toTypeName
+
+  @sharable private var indent = 0 // for completions printing
+}
diff --git a/tests/pos-with-compiler-cc/dotc/core/SymbolLoaders.scala b/tests/pos-with-compiler-cc/dotc/core/SymbolLoaders.scala
new file mode 100644
index 000000000000..5af45a016891
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/core/SymbolLoaders.scala
@@ -0,0 +1,444 @@
+package dotty.tools
+package dotc
+package core
+
+import java.io.{IOException, File}
+import java.nio.channels.ClosedByInterruptException
+
+import scala.util.control.NonFatal
+
+import dotty.tools.io.{ ClassPath, ClassRepresentation, AbstractFile }
+import dotty.tools.backend.jvm.DottyBackendInterface.symExtensions
+
+import Contexts._, Symbols._, Flags._, SymDenotations._, Types._, Scopes._, Names._
+import NameOps._
+import StdNames._
+import classfile.ClassfileParser
+import Decorators._
+
+import util.Stats
+import reporting.trace
+
+import ast.desugar
+
+import parsing.JavaParsers.OutlineJavaParser
+import parsing.Parsers.OutlineParser
+import language.experimental.pureFunctions
+
+
+object SymbolLoaders {
+  import ast.untpd._
+
+  /** A marker trait for a completer that replaces the original
+   *  Symbol loader for an unpickled root.
+   */
+  trait SecondCompleter
+
+  private def enterNew(
+      owner: Symbol, member: Symbol,
+      completer: SymbolLoader, scope: Scope = EmptyScope)(using Context): Symbol = {
+    val comesFromScan =
+      completer.isInstanceOf[SourcefileLoader]
+    assert(comesFromScan || scope.lookup(member.name) == NoSymbol,
+           s"${owner.fullName}.${member.name} already has a symbol")
+    owner.asClass.enter(member, scope)
+    member
+  }
+
+  /** Enter class with given `name` into scope of `owner`.
+   */
+  def enterClass(
+      owner: Symbol, name: PreName, completer: SymbolLoader,
+      flags: FlagSet = EmptyFlags, scope: Scope = EmptyScope)(using Context): Symbol = {
+    val cls = newClassSymbol(owner, name.toTypeName.unmangleClassName.decode, flags, completer, assocFile = completer.sourceFileOrNull)
+    enterNew(owner, cls, completer, scope)
+  }
+
+  /** Enter module with given `name` into scope of `owner`.
+   */
+  def enterModule(
+      owner: Symbol, name: PreName, completer: SymbolLoader,
+      modFlags: FlagSet = EmptyFlags, clsFlags: FlagSet = EmptyFlags, scope: Scope = EmptyScope)(using Context): Symbol = {
+    val module = newModuleSymbol(
+      owner, name.toTermName.decode, modFlags, clsFlags,
+      (module, _) => completer.proxy.withDecls(newScope).withSourceModule(module),
+      assocFile = completer.sourceFileOrNull)
+    enterNew(owner, module, completer, scope)
+    enterNew(owner, module.moduleClass, completer, scope)
+  }
+
+  /** Enter package with given `name` into scope of `owner`
+   *  and give them `completer` as type.
+   */
+  def enterPackage(owner: Symbol, pname: TermName, completer: (TermSymbol, ClassSymbol) => PackageLoader)(using Context): Symbol = {
+    val preExisting = owner.info.decls lookup pname
+    if (preExisting != NoSymbol)
+      // Some jars (often, obfuscated ones) include a package and
+      // object with the same name. Rather than render them unusable,
+      // offer a setting to resolve the conflict one way or the other.
+      // This was motivated by the desire to use YourKit probes, which
+      // require yjp.jar at runtime. See SI-2089.
+      if (ctx.settings.YtermConflict.value == "package" || ctx.mode.is(Mode.Interactive)) {
+        report.warning(
+          s"Resolving package/object name conflict in favor of package ${preExisting.fullName}. The object will be inaccessible.")
+        owner.asClass.delete(preExisting)
+      }
+      else if (ctx.settings.YtermConflict.value == "object") {
+        report.warning(
+          s"Resolving package/object name conflict in favor of object ${preExisting.fullName}.  The package will be inaccessible.")
+        return NoSymbol
+      }
+      else
+        throw new TypeError(
+          i"""$owner contains object and package with same name: $pname
+             |one of them needs to be removed from classpath""")
+    newModuleSymbol(owner, pname, PackageCreationFlags, PackageCreationFlags,
+      completer).entered
+  }
+
+  /** Enter class and module with given `name` into scope of `owner`
+   *  and give them `completer` as type.
+   */
+  def enterClassAndModule(
+      owner: Symbol, name: PreName, completer: SymbolLoader,
+      flags: FlagSet = EmptyFlags, scope: Scope = EmptyScope)(using Context): Unit = {
+    val clazz = enterClass(owner, name, completer, flags, scope)
+    val module = enterModule(
+      owner, name, completer,
+      modFlags = flags.toTermFlags & RetainedModuleValFlags,
+      clsFlags = flags.toTypeFlags & RetainedModuleClassFlags,
+      scope = scope)
+  }
+
+  /** Enter all toplevel classes and objects in file `src` into package `owner`, provided
+   *  they are in the right package. Issue a warning if a class or object is in the wrong
+   *  package, i.e. if the file path differs from the declared package clause.
+   *
+   *  All entered symbols are given a source completer of `src` as info.
+   */
+  def enterToplevelsFromSource(
+      owner: Symbol, name: PreName, src: AbstractFile,
+      scope: Scope = EmptyScope)(using Context): Unit =
+    if src.exists && !src.isDirectory then
+      val completer = new SourcefileLoader(src)
+      val filePath = owner.ownersIterator.takeWhile(!_.isRoot).map(_.name.toTermName).toList
+
+      def addPrefix(pid: RefTree, path: List[TermName]): List[TermName] = pid match {
+        case Ident(name: TermName) => name :: path
+        case Select(qual: RefTree, name: TermName) => name :: addPrefix(qual, path)
+        case _ => path
+      }
+
+      def enterScanned(unit: CompilationUnit)(using Context) = {
+
+        def checkPathMatches(path: List[TermName], what: String, tree: NameTree): Boolean = {
+          val ok = filePath == path
+          if (!ok)
+            report.warning(i"""$what ${tree.name} is in the wrong directory.
+                           |It was declared to be in package ${path.reverse.mkString(".")}
+                           |But it is found in directory     ${filePath.reverse.mkString(File.separator.nn)}""",
+              tree.srcPos.focus)
+          ok
+        }
+
+        /** Run the subset of desugaring necessary to record the correct symbols */
+        def simpleDesugar(tree: Tree): Tree = tree match
+          case tree: PackageDef =>
+            desugar.packageDef(tree)
+          case tree: ModuleDef =>
+            desugar.packageModuleDef(tree)
+          case _ =>
+            tree
+
+        def traverse(tree: Tree, path: List[TermName]): Unit = simpleDesugar(tree) match {
+          case tree @ PackageDef(pid, body) =>
+            val path1 = addPrefix(pid, path)
+            for (stat <- body) traverse(stat, path1)
+          case tree: TypeDef if tree.isClassDef =>
+            if (checkPathMatches(path, "class", tree))
+              // It might be a case class or implicit class,
+              // so enter class and module to be on the safe side
+              enterClassAndModule(owner, tree.name, completer, scope = scope)
+          case tree: ModuleDef =>
+            if (checkPathMatches(path, "object", tree))
+              enterModule(owner, tree.name, completer, scope = scope)
+          case _ =>
+        }
+
+        traverse(
+          if (unit.isJava) new OutlineJavaParser(unit.source).parse()
+          else new OutlineParser(unit.source).parse(),
+          Nil)
+      }
+
+      val unit = CompilationUnit(ctx.getSource(src))
+      enterScanned(unit)(using ctx.fresh.setCompilationUnit(unit))
+
+  /** The package objects of scala and scala.reflect should always
+   *  be loaded in binary if classfiles are available, even if sourcefiles
+   *  are newer. Late-compiling these objects from source leads to compilation
+   *  order issues.
+   *  Note: We do a name-base comparison here because the method is called before we even
+   *  have ReflectPackage defined.
+   */
+  def binaryOnly(owner: Symbol, name: TermName)(using Context): Boolean =
+    name == nme.PACKAGEkw &&
+      (owner.name == nme.scala || owner.name == nme.reflect && owner.owner.name == nme.scala)
+
+  /** Initialize toplevel class and module symbols in `owner` from class path representation `classRep`
+   */
+  def initializeFromClassPath(owner: Symbol, classRep: ClassRepresentation)(using Context): Unit =
+    ((classRep.binary, classRep.source): @unchecked) match {
+      case (Some(bin), Some(src)) if needCompile(bin, src) && !binaryOnly(owner, nameOf(classRep)) =>
+        if (ctx.settings.verbose.value) report.inform("[symloader] picked up newer source file for " + src.path)
+        enterToplevelsFromSource(owner, nameOf(classRep), src)
+      case (None, Some(src)) =>
+        if (ctx.settings.verbose.value) report.inform("[symloader] no class, picked up source file for " + src.path)
+        enterToplevelsFromSource(owner, nameOf(classRep), src)
+      case (Some(bin), _) =>
+        enterClassAndModule(owner, nameOf(classRep), ctx.platform.newClassLoader(bin))
+    }
+
+  def needCompile(bin: AbstractFile, src: AbstractFile): Boolean =
+    src.lastModified >= bin.lastModified
+
+  private def nameOf(classRep: ClassRepresentation)(using Context): TermName =
+    classRep.fileName.sliceToTermName(0, classRep.nameLength)
+
+  /** Load contents of a package
+   */
+  class PackageLoader(_sourceModule: TermSymbol, classPath: ClassPath) extends SymbolLoader {
+    override def sourceFileOrNull: AbstractFile | Null = null
+    override def sourceModule(using Context): TermSymbol = _sourceModule
+    def description(using Context): String = "package loader " + sourceModule.fullName
+
+    private var enterFlatClasses: Option[() -> Context ?-> Unit] = None
+      // Having a pure function type returning `Unit` does look weird.
+      // The point is that the function should not have any effect that matters for
+      // the compiler, in particular it should not capture a context.
+
+    Stats.record("package scopes")
+
+    /** The scope of a package. This is different from a normal scope
+  	 *  in that names of scope entries are kept in mangled form.
+  	 */
+    final class PackageScope extends MutableScope(0) {
+      override def newScopeEntry(name: Name, sym: Symbol)(using Context): ScopeEntry =
+        super.newScopeEntry(name.mangled, sym)
+
+      override def lookupEntry(name: Name)(using Context): ScopeEntry | Null = {
+        val mangled = name.mangled
+        val e = super.lookupEntry(mangled)
+        if (e != null) e
+        else if (isFlatName(mangled.toSimpleName) && enterFlatClasses.isDefined) {
+          Stats.record("package scopes with flatnames entered")
+          enterFlatClasses.get()
+          lookupEntry(name)
+        }
+        else e
+      }
+
+      override def ensureComplete()(using Context): Unit =
+        for (enter <- enterFlatClasses) enter()
+
+      override def newScopeLikeThis(): PackageScope = new PackageScope
+    }
+
+    private[core] val currentDecls: MutableScope = new PackageScope()
+
+    private def isFlatName(name: SimpleName): Boolean = {
+      val idx = name.lastIndexOf('$', name.length - 2)
+      idx >= 0 &&
+      (idx + str.TOPLEVEL_SUFFIX.length + 1 != name.length || !name.endsWith(str.TOPLEVEL_SUFFIX))
+    }
+
+    /** Name of class contains `$`, excepted names ending in `$package` */
+    def hasFlatName(classRep: ClassRepresentation): Boolean = {
+      val name = classRep.name
+      val idx = name.lastIndexOf('$', name.length - 2)
+      idx >= 0 &&
+      (idx + str.TOPLEVEL_SUFFIX.length + 1 != name.length || !name.endsWith(str.TOPLEVEL_SUFFIX))
+    }
+
+    def maybeModuleClass(classRep: ClassRepresentation): Boolean = classRep.name.last == '$'
+
+    private def enterClasses(root: SymDenotation, packageName: String, flat: Boolean)(using Context) = {
+      def isAbsent(classRep: ClassRepresentation) =
+        !root.unforcedDecls.lookup(classRep.name.toTypeName).exists
+
+      if (!root.isRoot) {
+        val classReps = classPath.list(packageName).classesAndSources
+
+        for (classRep <- classReps)
+          if (!maybeModuleClass(classRep) && hasFlatName(classRep) == flat &&
+            (!flat || isAbsent(classRep))) // on 2nd enter of flat names, check that the name has not been entered before
+            initializeFromClassPath(root.symbol, classRep)
+        for (classRep <- classReps)
+          if (maybeModuleClass(classRep) && hasFlatName(classRep) == flat &&
+              isAbsent(classRep))
+            initializeFromClassPath(root.symbol, classRep)
+      }
+    }
+
+    def doComplete(root: SymDenotation)(using Context): Unit = {
+      assert(root is PackageClass, root)
+      val pre = root.owner.thisType
+      root.info = ClassInfo(pre, root.symbol.asClass, Nil, currentDecls, pre select sourceModule)
+      if (!sourceModule.isCompleted)
+        sourceModule.completer.complete(sourceModule)
+
+      val packageName = if (root.isEffectiveRoot) "" else root.symbol.javaClassName
+
+      enterFlatClasses = Some { () =>
+        enterFlatClasses = None
+        inContext(ctx){enterClasses(root, packageName, flat = true)}
+      }
+      enterClasses(root, packageName, flat = false)
+      if (!root.isEmptyPackage)
+        for (pkg <- classPath.packages(packageName)) {
+          val fullName = pkg.name
+          val name =
+            if (packageName.isEmpty) fullName
+            else fullName.substring(packageName.length + 1).nn
+
+          enterPackage(root.symbol, name.toTermName,
+            (module, modcls) => new PackageLoader(module, classPath))
+        }
+    }
+  }
+}
+
+/** A lazy type that completes itself by calling parameter doComplete.
+ *  Any linked modules/classes or module classes are also initialized.
+ */
+abstract class SymbolLoader extends LazyType { self =>
+  /** Load source or class file for `root`, return */
+  def doComplete(root: SymDenotation)(using Context): Unit
+
+  def sourceFileOrNull: AbstractFile | Null
+
+  /** Description of the resource (ClassPath, AbstractFile)
+   *  being processed by this loader
+   */
+  def description(using Context): String
+
+  /** A proxy to this loader that keeps the doComplete operation
+   *  but provides fresh slots for scope/sourceModule/moduleClass
+   */
+  def proxy: SymbolLoader = new SymbolLoader {
+    export self.{doComplete, sourceFileOrNull}
+    def description(using Context): String = s"proxy to ${self.description}"
+  }
+
+  override def complete(root: SymDenotation)(using Context): Unit = {
+    def signalError(ex: Exception): Unit = {
+      if (ctx.debug) ex.printStackTrace()
+      val msg = ex.getMessage()
+      report.error(
+        if (msg == null) "i/o error while loading " + root.name
+        else "error while loading " + root.name + ",\n" + msg)
+    }
+    try {
+      val start = System.currentTimeMillis
+      trace.onDebug("loading") {
+        doComplete(root)
+      }
+      report.informTime("loaded " + description, start)
+    }
+    catch {
+      case ex: InterruptedException =>
+        throw ex
+      case ex: ClosedByInterruptException =>
+        throw new InterruptedException
+      case ex: IOException =>
+        signalError(ex)
+      case NonFatal(ex: TypeError) =>
+        println(s"exception caught when loading $root: ${ex.toMessage}")
+        throw ex
+      case NonFatal(ex) =>
+        println(s"exception caught when loading $root: $ex")
+        throw ex
+    }
+    finally {
+      def postProcess(denot: SymDenotation, other: Symbol) =
+        if !denot.isCompleted &&
+           !denot.completer.isInstanceOf[SymbolLoaders.SecondCompleter] then
+          if denot.is(ModuleClass) && NamerOps.needsConstructorProxies(other) then
+            NamerOps.makeConstructorCompanion(denot.sourceModule.asTerm, other.asClass)
+            denot.resetFlag(Touched)
+          else
+            denot.markAbsent()
+
+      val other = if root.isRoot then NoSymbol else root.scalacLinkedClass
+      postProcess(root, other)
+      if (!root.isRoot)
+        postProcess(other, root.symbol)
+    }
+  }
+
+  protected def rootDenots(rootDenot: ClassDenotation)(using Context): (ClassDenotation, ClassDenotation) = {
+    val linkedDenot = rootDenot.scalacLinkedClass.denot match {
+      case d: ClassDenotation => d
+      case d =>
+        // this can happen if the companion if shadowed by a val or type
+        // in a package object; in this case, we make up some dummy denotation
+        // as a stand in for loading.
+        // An example for this situation is scala.reflect.Manifest, which exists
+        // as a class in scala.reflect and as a val in scala.reflect.package.
+        if (rootDenot.is(ModuleClass))
+          newClassSymbol(
+            rootDenot.owner, rootDenot.name.stripModuleClassSuffix.asTypeName, Synthetic,
+              _ => NoType).classDenot
+        else
+          newModuleSymbol(
+            rootDenot.owner, rootDenot.name.toTermName, Synthetic, Synthetic,
+            (module, _) => NoLoader().withDecls(newScope).withSourceModule(module))
+            .moduleClass.denot.asClass
+    }
+    if (rootDenot.is(ModuleClass)) (linkedDenot, rootDenot)
+    else (rootDenot, linkedDenot)
+  }
+}
+
+class ClassfileLoader(val classfile: AbstractFile) extends SymbolLoader {
+
+  override def sourceFileOrNull: AbstractFile | Null = classfile
+
+  def description(using Context): String = "class file " + classfile.toString
+
+  override def doComplete(root: SymDenotation)(using Context): Unit =
+    load(root)
+
+  def load(root: SymDenotation)(using Context): Unit = {
+    val (classRoot, moduleRoot) = rootDenots(root.asClass)
+    val classfileParser = new ClassfileParser(classfile, classRoot, moduleRoot)(ctx)
+    val result = classfileParser.run()
+    if (mayLoadTreesFromTasty)
+      result match {
+        case Some(unpickler: tasty.DottyUnpickler) =>
+          classRoot.classSymbol.rootTreeOrProvider = unpickler
+          moduleRoot.classSymbol.rootTreeOrProvider = unpickler
+        case _ =>
+      }
+  }
+
+  private def mayLoadTreesFromTasty(using Context): Boolean =
+    ctx.settings.YretainTrees.value || ctx.settings.fromTasty.value
+}
+
+class SourcefileLoader(val srcfile: AbstractFile) extends SymbolLoader {
+  def description(using Context): String = "source file " + srcfile.toString
+  override def sourceFileOrNull: AbstractFile | Null = srcfile
+  def doComplete(root: SymDenotation)(using Context): Unit =
+    ctx.run.nn.lateCompile(srcfile, typeCheck = ctx.settings.YretainTrees.value)
+}
+
+/** A NoCompleter which is also a SymbolLoader. */
+class NoLoader extends SymbolLoader with NoCompleter {
+  def description(using Context): String = "NoLoader"
+  override def sourceFileOrNull: AbstractFile | Null = null
+  override def complete(root: SymDenotation)(using Context): Unit =
+    super[NoCompleter].complete(root)
+  def doComplete(root: SymDenotation)(using Context): Unit =
+    unsupported("doComplete")
+}
diff --git a/tests/pos-with-compiler-cc/dotc/core/Symbols.scala b/tests/pos-with-compiler-cc/dotc/core/Symbols.scala
new file mode 100644
index 000000000000..775062c26b0c
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/core/Symbols.scala
@@ -0,0 +1,920 @@
+package dotty.tools
+package dotc
+package core
+
+import Periods._
+import Names._
+import Scopes._
+import Flags._
+import Decorators._
+import Contexts._
+import Phases._
+import SymDenotations._
+import Denotations._
+import printing.Texts._
+import printing.Printer
+import Types._
+import util.Spans._
+import DenotTransformers._
+import StdNames._
+import NameOps._
+import transform.SymUtils._
+import NameKinds.LazyImplicitName
+import ast.tpd
+import tpd.{Tree, TreeProvider, TreeOps}
+import ast.TreeTypeMap
+import Constants.Constant
+import Variances.Variance
+import reporting.Message
+import collection.mutable
+import io.AbstractFile
+import util.{SourceFile, NoSource, Property, SourcePosition, SrcPos, EqHashMap}
+import scala.annotation.internal.sharable
+import config.Printers.typr
+
+object Symbols {
+
+  implicit def eqSymbol: CanEqual[Symbol, Symbol] = CanEqual.derived
+
+  /** Tree attachment containing the identifiers in a tree as a sorted array */
+  val Ids: Property.Key[Array[String]] = new Property.Key
+
+  /** A Symbol represents a Scala definition/declaration or a package.
+   *  @param coord  The coordinates of the symbol (a position or an index)
+   *  @param id     A unique identifier of the symbol (unique per ContextBase)
+   */
+  class Symbol private[Symbols] (private var myCoord: Coord, val id: Int, val nestingLevel: Int)
+    extends Designator, ParamInfo, SrcPos, printing.Showable {
+
+    type ThisName <: Name
+
+    //assert(id != 723)
+
+    def coord: Coord = myCoord
+
+    /** Set the coordinate of this class, this is only useful when the coordinate is
+     *  not known at symbol creation. This is the case for root symbols
+     *  unpickled from TASTY.
+     *
+     *  @pre coord == NoCoord
+     */
+    private[core] def coord_=(c: Coord): Unit = {
+      // assert(myCoord == NoCoord)
+        // This assertion fails for CommentPickling test.
+        // TODO: figure out what's wrong in the setup of CommentPicklingTest and re-enable assertion.
+      myCoord = c
+    }
+
+    private var myDefTree: Tree | Null = null
+
+    /** The tree defining the symbol at pickler time, EmptyTree if none was retained */
+    def defTree: Tree =
+      if (myDefTree == null) tpd.EmptyTree else myDefTree.nn
+
+    /** Set defining tree if this symbol retains its definition tree */
+    def defTree_=(tree: Tree)(using Context): Unit =
+      if (retainsDefTree) myDefTree = tree
+
+    /** Does this symbol retain its definition tree?
+     *  A good policy for this needs to balance costs and benefits, where
+     *  costs are mainly memoty leaks, in particular across runs.
+     */
+    def retainsDefTree(using Context): Boolean =
+      ctx.settings.YretainTrees.value ||
+      denot.owner.isTerm ||                // no risk of leaking memory after a run for these
+      denot.isOneOf(InlineOrProxy) ||      // need to keep inline info
+      ctx.settings.YcheckInit.value        // initialization check
+
+    /** The last denotation of this symbol */
+    private var lastDenot: SymDenotation = _
+    private var checkedPeriod: Period = Nowhere
+
+    private[core] def invalidateDenotCache(): Unit = { checkedPeriod = Nowhere }
+
+    /** Set the denotation of this symbol
+     *  `denot` should always be initialized when a new Symbol is created.
+     */
+    private[core] def denot_=(d: SymDenotation): Unit = {
+      util.Stats.record("Symbol.denot_=")
+      lastDenot = d
+      checkedPeriod = Nowhere
+    }
+
+    /** The current denotation of this symbol */
+    final def denot(using Context): SymDenotation = {
+      util.Stats.record("Symbol.denot")
+      if (checkedPeriod == ctx.period) lastDenot
+      else computeDenot(lastDenot)
+    }
+
+    private def computeDenot(lastd: SymDenotation)(using Context): SymDenotation = {
+      util.Stats.record("Symbol.computeDenot")
+      val now = ctx.period
+      checkedPeriod = now
+      if (lastd.validFor contains now) lastd else recomputeDenot(lastd)
+    }
+
+    /** Overridden in NoSymbol */
+    protected def recomputeDenot(lastd: SymDenotation)(using Context): SymDenotation = {
+      util.Stats.record("Symbol.recomputeDenot")
+      val newd = lastd.current.asInstanceOf[SymDenotation]
+      lastDenot = newd
+      newd
+    }
+
+    /** The original denotation of this symbol, without forcing anything */
+    final def originDenotation: SymDenotation =
+      lastDenot.initial
+
+    /** The last known denotation of this symbol, without going through `current` */
+    final def lastKnownDenotation: SymDenotation =
+      lastDenot
+
+    private[core] def defRunId: RunId =
+      lastDenot.validFor.runId
+
+    private inline def associatedFileMatches(inline filter: AbstractFile => Boolean)(using Context): Boolean =
+      try
+        val file = associatedFile
+        file != null && filter(file)
+      catch case ex: StaleSymbol =>
+        // can happen for constructor proxy companions. Test case is pos-macros/i9484.
+        false
+
+    /** Does this symbol come from a currently compiled source file? */
+    final def isDefinedInCurrentRun(using Context): Boolean =
+      span.exists && defRunId == ctx.runId && associatedFileMatches(ctx.run.nn.files.contains)
+
+    /** Is this symbol valid in the current run and has an associated file that is
+      * not a binary file. e.g. This will return true for
+      * symbols defined by the user in a prior run of the REPL, that are still valid.
+      */
+    final def isDefinedInSource(using Context): Boolean =
+      span.exists && isValidInCurrentRun && associatedFileMatches(_.extension != "class")
+
+    /** Is symbol valid in current run? */
+    final def isValidInCurrentRun(using Context): Boolean =
+      (lastDenot.validFor.runId == ctx.runId || stillValid(lastDenot)) &&
+      (lastDenot.symbol eq this)
+        // the last condition is needed because under ctx.staleOK overwritten
+        // members keep denotations pointing to the new symbol, so the validity
+        // periods check out OK. But once a package member is overridden it is not longer
+        // valid. If the option would be removed, the check would be no longer needed.
+
+    final def isTerm(using Context): Boolean =
+      (if (defRunId == ctx.runId) lastDenot else denot).isTerm
+    final def isType(using Context): Boolean =
+      (if (defRunId == ctx.runId) lastDenot else denot).isType
+    final def asTerm(using Context): TermSymbol = {
+      assert(isTerm, s"asTerm called on not-a-Term $this" );
+      asInstanceOf[TermSymbol]
+    }
+    final def asType(using Context): TypeSymbol = {
+      assert(isType, s"isType called on not-a-Type $this");
+      asInstanceOf[TypeSymbol]
+    }
+
+    final def isClass: Boolean = isInstanceOf[ClassSymbol]
+    final def asClass: ClassSymbol = asInstanceOf[ClassSymbol]
+
+    /** Test whether symbol is private. This
+     *  conservatively returns `false` if symbol does not yet have a denotation, or denotation
+     *  is a class that is not yet read.
+     */
+    final def isPrivate(using Context): Boolean =
+      lastDenot.flagsUNSAFE.is(Private)
+
+    /** Is the symbol a pattern bound symbol?
+     */
+    final def isPatternBound(using Context): Boolean =
+      !isClass && this.is(Case, butNot = Enum | Module)
+
+    /** The symbol's signature if it is completed or a method, NotAMethod otherwise. */
+    final def signature(using Context): Signature =
+      if lastDenot.uncheckedNN.isCompleted || lastDenot.uncheckedNN.is(Method) then
+        denot.signature
+      else
+        Signature.NotAMethod
+
+    /** Special cased here, because it may be used on naked symbols in substituters */
+    final def isStatic(using Context): Boolean =
+      lastDenot.initial.isStatic
+
+    /** This symbol entered into owner's scope (owner must be a class). */
+    final def entered(using Context): this.type = {
+      if (this.owner.isClass) {
+        this.owner.asClass.enter(this)
+        if (this.is(Module)) this.owner.asClass.enter(this.moduleClass)
+      }
+      this
+    }
+
+    /** Enter this symbol in its class owner after given `phase`. Create a fresh
+     *  denotation for its owner class if the class does not already have one
+     *  that starts being valid after `phase`.
+     *  @pre  Symbol is a class member
+     */
+    def enteredAfter(phase: DenotTransformer)(using Context): this.type =
+      if ctx.phaseId != phase.next.id then
+        atPhase(phase.next)(enteredAfter(phase))
+      else this.owner match {
+        case owner: ClassSymbol =>
+          if (owner.is(Package)) {
+            denot.validFor |= InitialPeriod
+            if (this.is(Module)) this.moduleClass.validFor |= InitialPeriod
+          }
+          else owner.ensureFreshScopeAfter(phase)
+          assert(isPrivate || phase.changesMembers, i"$this entered in $owner at undeclared phase $phase")
+          entered
+        case _ => this
+      }
+
+    /** Remove symbol from scope of owning class */
+    final def drop()(using Context): Unit = {
+      this.owner.asClass.delete(this)
+      if (this.is(Module)) this.owner.asClass.delete(this.moduleClass)
+    }
+
+    /** Remove symbol from scope of owning class after given `phase`. Create a fresh
+     *  denotation for its owner class if the class does not already have one that starts being valid after `phase`.
+     *  @pre  Symbol is a class member
+     */
+    def dropAfter(phase: DenotTransformer)(using Context): Unit =
+      if ctx.phaseId != phase.next.id then
+        atPhase(phase.next)(dropAfter(phase))
+      else {
+        assert (!this.owner.is(Package))
+        this.owner.asClass.ensureFreshScopeAfter(phase)
+        assert(isPrivate || phase.changesMembers, i"$this deleted in ${this.owner} at undeclared phase $phase")
+        drop()
+      }
+
+    /** This symbol, if it exists, otherwise the result of evaluating `that` */
+    inline def orElse(inline that: Symbol)(using Context): Symbol =
+      if (this.exists) this else that
+
+    /** If this symbol satisfies predicate `p` this symbol, otherwise `NoSymbol` */
+    def filter(p: Symbol => Boolean): Symbol = if (p(this)) this else NoSymbol
+
+    /** The current name of this symbol */
+    final def name(using Context): ThisName = denot.name.asInstanceOf[ThisName]
+
+    /** The source or class file from which this class or
+     *  the class containing this symbol was generated, null if not applicable.
+     *  Note that this the returned classfile might be the top-level class
+     *  containing this symbol instead of the directly enclosing class.
+     *  Overridden in ClassSymbol
+     */
+    def associatedFile(using Context): AbstractFile | Null =
+      lastDenot.topLevelClass.associatedFile
+
+    /** The class file from which this class was generated, null if not applicable. */
+    final def binaryFile(using Context): AbstractFile | Null = {
+      val file = associatedFile
+      if (file != null && file.extension == "class") file else null
+    }
+
+    /** A trap to avoid calling x.symbol on something that is already a symbol.
+     *  This would be expanded to `toDenot(x).symbol` which is guaraneteed to be
+     *  the same as `x`.
+     *  With the given setup, all such calls will give implicit-not found errors
+     */
+    final def symbol(implicit ev: DontUseSymbolOnSymbol): Nothing = unsupported("symbol")
+    type DontUseSymbolOnSymbol
+
+    final def source(using Context): SourceFile = {
+      def valid(src: SourceFile): SourceFile =
+        if (src.exists && src.file.extension != "class") src
+        else NoSource
+
+      if (!denot.exists) NoSource
+      else
+        valid(defTree.source) match {
+          case NoSource =>
+            valid(denot.owner.source) match {
+              case NoSource =>
+                this match {
+                  case cls: ClassSymbol      => valid(cls.sourceOfClass)
+                  case _ if denot.is(Module) => valid(denot.moduleClass.source)
+                  case _ => NoSource
+                }
+              case src => src
+            }
+          case src => src
+        }
+    }
+
+    /** A symbol related to `sym` that is defined in source code.
+     *
+     *  @see enclosingSourceSymbols
+     */
+    @annotation.tailrec final def sourceSymbol(using Context): Symbol =
+      if (!denot.exists)
+        this
+      else if (denot.is(ModuleVal))
+        this.moduleClass.sourceSymbol // The module val always has a zero-extent position
+      else if (denot.is(Synthetic)) {
+        val linked = denot.linkedClass
+        if (linked.exists && !linked.is(Synthetic))
+          linked
+        else
+          denot.owner.sourceSymbol
+      }
+      else if (denot.isPrimaryConstructor)
+        denot.owner.sourceSymbol
+      else this
+
+    /** The position of this symbol, or NoSpan if the symbol was not loaded
+     *  from source or from TASTY. This is always a zero-extent position.
+     */
+    final def span: Span = if (coord.isSpan) coord.toSpan else NoSpan
+
+    final def sourcePos(using Context): SourcePosition = {
+      val src = source
+      (if (src.exists) src else ctx.source).atSpan(span)
+    }
+
+    /** This positioned item, widened to `SrcPos`. Used to make clear we only need the
+     *  position, typically for error reporting.
+     */
+    final def srcPos: SrcPos = this
+
+    // ParamInfo types and methods
+    def isTypeParam(using Context): Boolean = denot.is(TypeParam)
+    def paramName(using Context): ThisName = name.asInstanceOf[ThisName]
+    def paramInfo(using Context): Type = denot.info
+    def paramInfoAsSeenFrom(pre: Type)(using Context): Type = pre.memberInfo(this)
+    def paramInfoOrCompleter(using Context): Type = denot.infoOrCompleter
+    def paramVariance(using Context): Variance = denot.variance
+    def paramRef(using Context): TypeRef = denot.typeRef
+
+    /** Copy a symbol, overriding selective fields.
+     *  Note that `coord` and `associatedFile` will be set from the fields in `owner`, not
+     *  the fields in `sym`. */
+    def copy(using Context)(
+        owner: Symbol = this.owner,
+        name: ThisName = name,
+        flags: FlagSet = this.flags,
+        info: Type = this.info,
+        privateWithin: Symbol = this.privateWithin,
+        coord: Coord = NoCoord, // Can be `= owner.coord` once we bootstrap
+        associatedFile: AbstractFile | Null = null // Can be `= owner.associatedFile` once we bootstrap
+    ): Symbol = {
+      val coord1 = if (coord == NoCoord) owner.coord else coord
+      val associatedFile1 = if (associatedFile == null) owner.associatedFile else associatedFile
+
+      if isClass then
+        newClassSymbol(owner, name.asTypeName, flags, _ => info, privateWithin, coord1, associatedFile1)
+      else
+        newSymbol(owner, name, flags, info, privateWithin, coord1)
+    }
+
+// -------- Printing --------------------------------------------------------
+
+    /** The prefix string to be used when displaying this symbol without denotation */
+    protected def prefixString: String = "Symbol"
+
+    override def toString: String =
+      lastDenot.toString // + "#" + id // !!! DEBUG
+
+    def toText(printer: Printer): Text = printer.toText(this)
+
+    def showLocated(using Context): String = ctx.printer.locatedText(this).show
+    def showExtendedLocation(using Context): String = ctx.printer.extendedLocationText(this).show
+    def showDcl(using Context): String = ctx.printer.dclText(this).show
+    def showKind(using Context): String = ctx.printer.kindString(this)
+    def showName(using Context): String = ctx.printer.nameString(this)
+    def showFullName(using Context): String = ctx.printer.fullNameString(this)
+
+    override def hashCode(): Int = id // for debugging.
+  }
+
+  type TermSymbol = Symbol { type ThisName = TermName }
+  type TypeSymbol = Symbol { type ThisName = TypeName }
+
+  class ClassSymbol private[Symbols] (coord: Coord, val assocFile: AbstractFile | Null, id: Int, nestingLevel: Int)
+    extends Symbol(coord, id, nestingLevel) {
+
+    type ThisName = TypeName
+
+    type TreeOrProvider = tpd.TreeProvider | tpd.Tree
+
+    private var myTree: TreeOrProvider = tpd.EmptyTree
+
+    /** If this is a top-level class and `-Yretain-trees` (or `-from-tasty`) is set.
+      * Returns the TypeDef tree (possibly wrapped inside PackageDefs) for this class, otherwise EmptyTree.
+      * This will force the info of the class.
+      */
+    def rootTree(using Context): Tree = rootTreeContaining("")
+
+    /** Same as `tree` but load tree only if `id == ""` or the tree might contain `id`.
+     *  For Tasty trees this means consulting whether the name table defines `id`.
+     *  For already loaded trees, we maintain the referenced ids in an attachment.
+     */
+    def rootTreeContaining(id: String)(using Context): Tree = {
+      denot.infoOrCompleter match {
+        case _: NoCompleter =>
+        case _ => denot.ensureCompleted()
+      }
+      myTree match {
+        case fn: TreeProvider =>
+          if (id.isEmpty || fn.mightContain(id)) {
+            val tree = fn.tree
+            myTree = tree
+            tree
+          }
+          else tpd.EmptyTree
+        case tree: Tree @ unchecked =>
+          if (id.isEmpty || mightContain(tree, id)) tree else tpd.EmptyTree
+      }
+    }
+
+    def rootTreeOrProvider: TreeOrProvider = myTree
+
+    private[dotc] def rootTreeOrProvider_=(t: TreeOrProvider)(using Context): Unit =
+      myTree = t
+
+    private def mightContain(tree: Tree, id: String)(using Context): Boolean = {
+      val ids = tree.getAttachment(Ids) match {
+        case Some(ids) => ids
+        case None =>
+          val idSet = mutable.SortedSet[String]()
+          tree.foreachSubTree {
+            case tree: tpd.NameTree if tree.name.toTermName.isInstanceOf[SimpleName] =>
+              idSet += tree.name.toString
+            case _ =>
+          }
+          val ids = idSet.toArray
+          tree.putAttachment(Ids, ids)
+          ids
+      }
+      ids.binarySearch(id) >= 0
+    }
+
+    /** The source or class file from which this class was generated, null if not applicable. */
+    override def associatedFile(using Context): AbstractFile | Null =
+      if assocFile != null || this.is(Package) || this.owner.is(Package) then assocFile
+      else super.associatedFile
+
+    private var mySource: SourceFile = NoSource
+
+    final def sourceOfClass(using Context): SourceFile = {
+      if !mySource.exists && !denot.is(Package) then
+        // this allows sources to be added in annotations after `sourceOfClass` is first called
+        val file = associatedFile
+        if file != null && file.extension != "class" then
+          mySource = ctx.getSource(file)
+        else
+          mySource = defn.patchSource(this)
+          if !mySource.exists then
+            mySource = atPhaseNoLater(flattenPhase) {
+              denot.topLevelClass.unforcedAnnotation(defn.SourceFileAnnot) match
+                case Some(sourceAnnot) => sourceAnnot.argumentConstant(0) match
+                  case Some(Constant(path: String)) => ctx.getSource(path)
+                  case none => NoSource
+                case none => NoSource
+            }
+      mySource
+    }
+
+    final def classDenot(using Context): ClassDenotation =
+      denot.asInstanceOf[ClassDenotation]
+
+    override protected def prefixString: String = "ClassSymbol"
+  }
+
+  @sharable object NoSymbol extends Symbol(NoCoord, 0, 0) {
+    override def associatedFile(using Context): AbstractFile | Null = NoSource.file
+    override def recomputeDenot(lastd: SymDenotation)(using Context): SymDenotation = NoDenotation
+  }
+
+  NoDenotation // force it in order to set `denot` field of NoSymbol
+
+  /** Makes all denotation operations available on symbols */
+  implicit def toDenot(sym: Symbol)(using Context): SymDenotation = sym.denot
+
+  /** Makes all class denotation operations available on class symbols */
+  implicit def toClassDenot(cls: ClassSymbol)(using Context): ClassDenotation = cls.classDenot
+
+  /** The Definitions object */
+  def defn(using Context): Definitions = ctx.definitions
+
+  /** The current class */
+  def currentClass(using Context): ClassSymbol = ctx.owner.enclosingClass.asClass
+
+  type MutableSymbolMap[T] = EqHashMap[Symbol, T]
+  def MutableSymbolMap[T](): EqHashMap[Symbol, T] = EqHashMap[Symbol, T]()
+  def MutableSymbolMap[T](initialCapacity: Int): EqHashMap[Symbol, T] = EqHashMap[Symbol, T](initialCapacity)
+
+// ---- Symbol creation methods ----------------------------------
+
+  /** Create a symbol from its fields (info may be lazy) */
+  def newSymbol[N <: Name](using Context)(
+      owner: Symbol,
+      name: N,
+      flags: FlagSet,
+      info: Type,
+      privateWithin: Symbol = NoSymbol,
+      coord: Coord = NoCoord,
+      nestingLevel: Int = ctx.nestingLevel): Symbol { type ThisName = N } = {
+    val sym = new Symbol(coord, ctx.base.nextSymId, nestingLevel).asInstanceOf[Symbol { type ThisName = N }]
+    val denot = SymDenotation(sym, owner, name, flags, info, privateWithin)
+    sym.denot = denot
+    sym
+  }
+
+  /** Create a class symbol from its non-info fields and a function
+   *  producing its info (the produced info may be lazy).
+   */
+  def newClassSymbol(
+      owner: Symbol,
+      name: TypeName,
+      flags: FlagSet,
+      infoFn: ClassSymbol => Type,
+      privateWithin: Symbol = NoSymbol,
+      coord: Coord = NoCoord,
+      assocFile: AbstractFile | Null = null)(using Context): ClassSymbol
+  = {
+    val cls = new ClassSymbol(coord, assocFile, ctx.base.nextSymId, ctx.nestingLevel)
+    val denot = SymDenotation(cls, owner, name, flags, infoFn(cls), privateWithin)
+    cls.denot = denot
+    cls
+  }
+
+  /** Create a class symbol from its non-info fields and the fields of its info. */
+  def newCompleteClassSymbol(
+      owner: Symbol,
+      name: TypeName,
+      flags: FlagSet,
+      parents: List[TypeRef],
+      decls: Scope,
+      selfInfo: Type = NoType,
+      privateWithin: Symbol = NoSymbol,
+      coord: Coord = NoCoord,
+      assocFile: AbstractFile | Null = null)(using Context): ClassSymbol =
+    newClassSymbol(
+        owner, name, flags,
+        ClassInfo(owner.thisType, _, parents, decls, selfInfo),
+        privateWithin, coord, assocFile)
+
+  /** Same as `newCompleteClassSymbol` except that `parents` can be a list of arbitrary
+   *  types which get normalized into type refs and parameter bindings.
+   */
+  def newNormalizedClassSymbol(
+      owner: Symbol,
+      name: TypeName,
+      flags: FlagSet,
+      parentTypes: List[Type],
+      selfInfo: Type = NoType,
+      privateWithin: Symbol = NoSymbol,
+      coord: Coord = NoCoord,
+      assocFile: AbstractFile | Null = null)(using Context): ClassSymbol = {
+    def completer = new LazyType {
+      def complete(denot: SymDenotation)(using Context): Unit = {
+        val cls = denot.asClass.classSymbol
+        val decls = newScope
+        denot.info = ClassInfo(owner.thisType, cls, parentTypes.map(_.dealias), decls, selfInfo)
+      }
+    }
+    newClassSymbol(owner, name, flags, completer, privateWithin, coord, assocFile)
+  }
+
+  def newRefinedClassSymbol(coord: Coord = NoCoord)(using Context): ClassSymbol =
+    newCompleteClassSymbol(ctx.owner, tpnme.REFINE_CLASS, NonMember, parents = Nil, newScope, coord = coord)
+
+  /** Create a module symbol with associated module class
+   *  from its non-info fields and a function producing the info
+   *  of the module class (this info may be lazy).
+   */
+  def newModuleSymbol(
+      owner: Symbol,
+      name: TermName,
+      modFlags: FlagSet,
+      clsFlags: FlagSet,
+      infoFn: (TermSymbol, ClassSymbol) => Type, // typically a ModuleClassCompleterWithDecls
+      privateWithin: Symbol = NoSymbol,
+      coord: Coord = NoCoord,
+      assocFile: AbstractFile | Null = null)(using Context): TermSymbol
+  = {
+    val base = owner.thisType
+    val modclsFlags = clsFlags | ModuleClassCreationFlags
+    val modclsName = name.toTypeName.adjustIfModuleClass(modclsFlags)
+    val module = newSymbol(
+      owner, name, modFlags | ModuleValCreationFlags, NoCompleter, privateWithin, coord)
+    val modcls = newClassSymbol(
+      owner, modclsName, modclsFlags, infoFn(module, _), privateWithin, coord, assocFile)
+    module.info =
+      if (modcls.isCompleted) TypeRef(owner.thisType, modcls)
+      else new ModuleCompleter(modcls)
+    module
+  }
+
+  /** Create a module symbol with associated module class
+   *  from its non-info fields and the fields of the module class info.
+   *  @param flags  The combined flags of the module and the module class
+   *                These are masked with RetainedModuleValFlags/RetainedModuleClassFlags.
+   */
+  def newCompleteModuleSymbol(
+      owner: Symbol,
+      name: TermName,
+      modFlags: FlagSet,
+      clsFlags: FlagSet,
+      parents: List[TypeRef],
+      decls: Scope,
+      privateWithin: Symbol = NoSymbol,
+      coord: Coord = NoCoord,
+      assocFile: AbstractFile | Null = null)(using Context): TermSymbol =
+    newModuleSymbol(
+        owner, name, modFlags, clsFlags,
+        (module, modcls) => ClassInfo(
+          owner.thisType, modcls, parents, decls, TermRef(owner.thisType, module)),
+        privateWithin, coord, assocFile)
+
+  /** Create a package symbol with associated package class
+   *  from its non-info fields and a lazy type for loading the package's members.
+   */
+  def newPackageSymbol(
+      owner: Symbol,
+      name: TermName,
+      infoFn: (TermSymbol, ClassSymbol) => LazyType)(using Context): TermSymbol =
+    newModuleSymbol(owner, name, PackageCreationFlags, PackageCreationFlags, infoFn)
+  /** Create a package symbol with associated package class
+   *  from its non-info fields its member scope.
+   */
+  def newCompletePackageSymbol(
+      owner: Symbol,
+      name: TermName,
+      modFlags: FlagSet = EmptyFlags,
+      clsFlags: FlagSet = EmptyFlags,
+      decls: Scope = newScope(0))(using Context): TermSymbol =
+    newCompleteModuleSymbol(
+      owner, name,
+      modFlags | PackageCreationFlags, clsFlags | PackageCreationFlags,
+      Nil, decls)
+
+  /** Define a new symbol associated with a Bind or pattern wildcard and, by default, make it gadt narrowable. */
+  def newPatternBoundSymbol(
+      name: Name,
+      info: Type,
+      span: Span,
+      addToGadt: Boolean = true,
+      flags: FlagSet = EmptyFlags)(using Context): Symbol = {
+    val sym = newSymbol(ctx.owner, name, Case | flags, info, coord = span)
+    if (addToGadt && name.isTypeName) ctx.gadt.addToConstraint(sym)
+    sym
+  }
+
+  /** Create a stub symbol that will issue a missing reference error
+   *  when attempted to be completed.
+   */
+  def newStubSymbol(owner: Symbol, name: Name, file: AbstractFile | Null = null)(using Context): Symbol = {
+    def stubCompleter = new StubInfo()
+    val normalizedOwner = if (owner.is(ModuleVal)) owner.moduleClass else owner
+    typr.println(s"creating stub for ${name.show}, owner = ${normalizedOwner.denot.debugString}, file = $file")
+    typr.println(s"decls = ${normalizedOwner.unforcedDecls.toList.map(_.debugString).mkString("\n  ")}") // !!! DEBUG
+    //if (base.settings.debug.value) throw new Error()
+    val stub = name match {
+      case name: TermName =>
+        newModuleSymbol(normalizedOwner, name, EmptyFlags, EmptyFlags, stubCompleter, assocFile = file)
+      case name: TypeName =>
+        newClassSymbol(normalizedOwner, name, EmptyFlags, stubCompleter, assocFile = file)
+    }
+    stub
+  }
+
+  /** Create the local template dummy of given class `cls`.
+   *  In a template
+   *
+   *     trait T { val fld: Int; { val x: int = 2 }; val fld2 = { val y = 2; y }}
+   *
+   *  the owner of `x` is the local dummy of the template. The owner of the local
+   *  dummy is then the class of the template itself. By contrast, the owner of `y`
+   *  would be `fld2`. There is a single local dummy per template.
+   */
+  def newLocalDummy(cls: Symbol, coord: Coord = NoCoord)(using Context): TermSymbol =
+    newSymbol(cls, nme.localDummyName(cls), NonMember, NoType)
+
+  /** Create an import symbol pointing back to given qualifier `expr`. */
+  def newImportSymbol(owner: Symbol, expr: Tree, coord: Coord = NoCoord)(using Context): TermSymbol =
+    newImportSymbol(owner, ImportType(expr), coord = coord)
+
+  /** Create an import symbol with given `info`. */
+  def newImportSymbol(owner: Symbol, info: Type, coord: Coord)(using Context): TermSymbol =
+    newSymbol(owner, nme.IMPORT, Synthetic | NonMember, info, coord = coord)
+
+  /** Create a class constructor symbol for given class `cls`. */
+  def newConstructor(
+      cls: ClassSymbol,
+      flags: FlagSet,
+      paramNames: List[TermName],
+      paramTypes: List[Type],
+      privateWithin: Symbol = NoSymbol,
+      coord: Coord = NoCoord)(using Context): TermSymbol =
+    newSymbol(cls, nme.CONSTRUCTOR, flags | Method, MethodType(paramNames, paramTypes, cls.typeRef), privateWithin, coord)
+
+  /** Create an anonymous function symbol */
+  def newAnonFun(owner: Symbol, info: Type, coord: Coord = NoCoord)(using Context): TermSymbol =
+    newSymbol(owner, nme.ANON_FUN, Synthetic | Method, info, coord = coord)
+
+  /** Create an empty default constructor symbol for given class `cls`. */
+  def newDefaultConstructor(cls: ClassSymbol)(using Context): TermSymbol =
+    newConstructor(cls, EmptyFlags, Nil, Nil)
+
+  def newLazyImplicit(info: Type, coord: Coord = NoCoord)(using Context): TermSymbol =
+    newSymbol(ctx.owner, LazyImplicitName.fresh(), EmptyFlags, info, coord = coord)
+
+  /** Create a symbol representing a selftype declaration for class `cls`. */
+  def newSelfSym(
+      cls: ClassSymbol,
+      name: TermName = nme.WILDCARD,
+      selfInfo: Type = NoType)(using Context): TermSymbol =
+    newSymbol(cls, name, SelfSymFlags, selfInfo orElse cls.classInfo.selfType, coord = cls.coord)
+
+  /** Create new type parameters with given owner, names, and flags.
+   *  @param boundsFn  A function that, given type refs to the newly created
+   *                   parameters returns a list of their bounds.
+   */
+  def newTypeParams(
+    owner: Symbol,
+    names: List[TypeName],
+    flags: FlagSet,
+    boundsFn: List[TypeRef] => List[Type])(using Context): List[TypeSymbol] = {
+
+    val tparamBuf = new mutable.ListBuffer[TypeSymbol]
+    val trefBuf = new mutable.ListBuffer[TypeRef]
+    for (name <- names) {
+      val tparam = newSymbol(
+        owner, name, flags | owner.typeParamCreationFlags, NoType, coord = owner.coord)
+      tparamBuf += tparam
+      trefBuf += TypeRef(owner.thisType, tparam)
+    }
+    val tparams = tparamBuf.toList
+    val bounds = boundsFn(trefBuf.toList)
+    for (tparam, bound) <- tparams.lazyZip(bounds) do
+      tparam.info = bound
+    tparams
+  }
+
+  /** Create a new skolem symbol. This is not the same as SkolemType, even though the
+   *  motivation (create a singleton referencing to a type) is similar.
+   */
+  def newSkolem(tp: Type)(using Context): TermSymbol =
+    newSymbol(defn.RootClass, nme.SKOLEM, SyntheticArtifact | NonMember | Permanent, tp)
+
+  def newErrorSymbol(owner: Symbol, name: Name, msg: Message)(using Context): Symbol = {
+    val errType = ErrorType(msg)
+    newSymbol(owner, name, SyntheticArtifact,
+        if (name.isTypeName) TypeAlias(errType) else errType)
+  }
+
+  /** Map given symbols, subjecting their attributes to the mappings
+   *  defined in the given TreeTypeMap `ttmap`.
+   *  Cross symbol references are brought over from originals to copies.
+   *  Do not copy any symbols if all attributes of all symbols stay the same.
+   */
+  def mapSymbols(originals: List[Symbol], ttmap: TreeTypeMap, mapAlways: Boolean = false)(using Context): List[Symbol] =
+    if (originals.forall(sym =>
+        (ttmap.mapType(sym.info) eq sym.info) &&
+        !(ttmap.oldOwners contains sym.owner)) && !mapAlways)
+      originals
+    else {
+      val copies: List[Symbol] = for (original <- originals) yield
+        val odenot = original.denot
+        original.copy(
+          owner = ttmap.mapOwner(odenot.owner),
+          flags = odenot.flags &~ Touched,
+          info = NoCompleter,
+          privateWithin = ttmap.mapOwner(odenot.privateWithin),
+          coord = original.coord)
+      val ttmap1 = ttmap.withSubstitution(originals, copies)
+      originals.lazyZip(copies) foreach { (original, copy) =>
+        val odenot = original.denot
+        val completer = new LazyType:
+
+          def complete(denot: SymDenotation)(using Context): Unit =
+
+            val oinfo = original.info match
+              case ClassInfo(pre, _, parents, decls, selfInfo) =>
+                assert(original.isClass)
+                val parents1 = parents.mapConserve(ttmap.mapType)
+                val otypeParams = original.typeParams
+                if otypeParams.isEmpty then
+                  ClassInfo(pre, copy.asClass, parents1, decls.cloneScope, selfInfo)
+                else
+                  // copy type params, enter other definitions unchanged
+                  // type parameters need to be copied early, since other type
+                  // computations depend on them.
+                  val decls1 = newScope
+                  val newTypeParams = mapSymbols(original.typeParams, ttmap1, mapAlways = true)
+                  newTypeParams.foreach(decls1.enter)
+                  for sym <- decls do if !sym.is(TypeParam) then decls1.enter(sym)
+                  val parents2 = parents1.map(_.substSym(otypeParams, newTypeParams))
+                  val selfInfo1 = selfInfo match
+                    case selfInfo: Type => selfInfo.substSym(otypeParams, newTypeParams)
+                    case _ => selfInfo
+                  ClassInfo(pre, copy.asClass, parents2, decls1, selfInfo1)
+              case oinfo => oinfo
+
+            denot.info = oinfo // needed as otherwise we won't be able to go from Sym -> parents & etc
+                               // Note that this is a hack, but hack commonly used in Dotty
+                               // The same thing is done by other completers all the time
+            denot.info = ttmap1.mapType(oinfo)
+            denot.annotations = odenot.annotations.mapConserve(ttmap1.apply)
+
+        end completer
+
+        copy.info = completer
+        copy.denot match
+          case cd: ClassDenotation =>
+            cd.registeredCompanion = original.registeredCompanion.subst(originals, copies)
+          case _ =>
+      }
+
+      copies.foreach(_.ensureCompleted()) // avoid memory leak
+
+      // Update Child annotations of classes encountered previously to new values
+      // if some child is among the mapped symbols
+      for orig <- ttmap1.substFrom do
+        if orig.is(Sealed) && orig.children.exists(originals.contains) then
+          val sealedCopy = orig.subst(ttmap1.substFrom, ttmap1.substTo)
+          sealedCopy.annotations = sealedCopy.annotations.mapConserve(ttmap1.apply)
+
+      copies
+    }
+
+  /** Matches lists of term symbols, including the empty list.
+   *  All symbols in the list are assumed to be of the same kind.
+   */
+  object TermSymbols:
+    def unapply(xs: List[Symbol])(using Context): Option[List[TermSymbol]] = xs match
+      case (x: Symbol) :: _ if x.isType => None
+      case _ => Some(xs.asInstanceOf[List[TermSymbol]])
+
+  /** Matches lists of type symbols, excluding the empty list.
+   *  All symbols in the list are assumed to be of the same kind.
+   */
+  object TypeSymbols:
+    def unapply(xs: List[Symbol])(using Context): Option[List[TypeSymbol]] = xs match
+      case (x: Symbol) :: _ if x.isType => Some(xs.asInstanceOf[List[TypeSymbol]])
+      case _ => None
+
+// ----- Locating predefined symbols ----------------------------------------
+
+  def requiredPackage(path: PreName)(using Context): TermSymbol = {
+    val name = path.toTermName
+    staticRef(name, isPackage = true).requiredSymbol("package", name)(_.is(Package)).asTerm
+  }
+
+  def requiredPackageRef(path: PreName)(using Context): TermRef = requiredPackage(path).termRef
+
+  def requiredClass(path: PreName)(using Context): ClassSymbol = {
+    val name = path.toTypeName
+    staticRef(name).requiredSymbol("class", name)(_.isClass) match {
+      case cls: ClassSymbol => cls
+      case sym => defn.AnyClass
+    }
+  }
+
+  def requiredClassRef(path: PreName)(using Context): TypeRef = requiredClass(path).typeRef
+
+  /** Get ClassSymbol if class is either defined in current compilation run
+   *  or present on classpath. Returns NoSymbol otherwise.
+   */
+  def getClassIfDefined(path: PreName)(using Context): Symbol =
+    staticRef(path.toTypeName, generateStubs = false)
+      .disambiguate(_.isClass).symbol
+
+  /** Get a List of ClassSymbols which are either defined in current compilation
+   *  run or present on classpath.
+   */
+  def getClassesIfDefined(paths: List[PreName])(using Context): List[ClassSymbol] =
+    paths.map(getClassIfDefined).filter(_.exists).map(_.asInstanceOf[ClassSymbol])
+
+  /** Get ClassSymbol if package is either defined in current compilation run
+   *  or present on classpath. Returns NoSymbol otherwise.
+   */
+  def getPackageClassIfDefined(path: PreName)(using Context): Symbol =
+    staticRef(path.toTypeName, isPackage = true, generateStubs = false)
+      .disambiguate(_ is PackageClass).symbol
+
+  def requiredModule(path: PreName)(using Context): TermSymbol = {
+    val name = path.toTermName
+    staticRef(name).requiredSymbol("object", name)(_.is(Module)).asTerm
+  }
+
+  /** Get module symbol if the module is either defined in current compilation run
+   *  or present on classpath. Returns NoSymbol otherwise.
+   */
+  def getModuleIfDefined(path: PreName)(using Context): Symbol =
+    staticRef(path.toTermName, generateStubs = false)
+      .disambiguate(_.is(Module)).symbol
+
+  def requiredModuleRef(path: PreName)(using Context): TermRef = requiredModule(path).termRef
+
+  def requiredMethod(path: PreName)(using Context): TermSymbol = {
+    val name = path.toTermName
+    staticRef(name).requiredSymbol("method", name)(_.is(Method)).asTerm
+  }
+
+  def requiredMethodRef(path: PreName)(using Context): TermRef = requiredMethod(path).termRef
+}
diff --git a/tests/pos-with-compiler-cc/dotc/core/TypeApplications.scala b/tests/pos-with-compiler-cc/dotc/core/TypeApplications.scala
new file mode 100644
index 000000000000..81f822811456
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/core/TypeApplications.scala
@@ -0,0 +1,538 @@
+package dotty.tools
+package dotc
+package core
+
+import Types._
+import Contexts._
+import Symbols._
+import SymDenotations.LazyType
+import Decorators._
+import util.Stats._
+import Names._
+import Flags.{Module, Provisional}
+import dotty.tools.dotc.config.Config
+import cc.boxedUnlessFun
+
+object TypeApplications {
+
+  type TypeParamInfo = ParamInfo.Of[TypeName]
+
+  /** Assert type is not a TypeBounds instance and return it unchanged */
+  def noBounds(tp: Type): Type = tp match {
+    case tp: TypeBounds => throw new AssertionError("no TypeBounds allowed")
+    case _ => tp
+  }
+
+  /** Extractor for
+   *
+   *    [X1: B1, ..., Xn: Bn] -> C[X1, ..., Xn]
+   *
+   *  where B1, ..., Bn are bounds of the type parameters of the class C.
+   *
+   *  @param tycon     C
+   */
+  object EtaExpansion:
+
+    def apply(tycon: Type)(using Context): Type =
+      assert(tycon.typeParams.nonEmpty, tycon)
+      tycon.EtaExpand(tycon.typeParamSymbols)
+
+    /** Test that the parameter bounds in a hk type lambda `[X1,...,Xn] => C[X1, ..., Xn]`
+     *  contain the bounds of the type parameters of `C`. This is necessary to be able to
+     *  contract the hk lambda to `C`.
+     */
+    private def weakerBounds(tp: HKTypeLambda, tparams: List[ParamInfo])(using Context): Boolean =
+      val onlyEmptyBounds = tp.typeParams.forall(_.paramInfo == TypeBounds.empty)
+      onlyEmptyBounds
+        // Note: this pre-test helps efficiency. It is also necessary to workaround  #9965 since in some cases
+        // tparams is empty. This can happen when we change the owners of inlined local
+        // classes in mapSymbols. See pos/reference/delegates.scala for an example.
+        // In this case, we can still return true if we know that the hk lambda bounds
+        // are empty anyway.
+      || {
+        val paramRefs = tparams.map(_.paramRef)
+        tp.typeParams.corresponds(tparams) { (param1, param2) =>
+          param2.paramInfo frozen_<:< param1.paramInfo.substParams(tp, paramRefs)
+        }
+      }
+
+    def unapply(tp: Type)(using Context): Option[Type] = tp match
+      case tp @ HKTypeLambda(tparams, AppliedType(fn: Type, args))
+      if fn.typeSymbol.isClass
+         && tparams.hasSameLengthAs(args)
+         && args.lazyZip(tparams).forall((arg, tparam) => arg == tparam.paramRef)
+         && weakerBounds(tp, fn.typeParams) => Some(fn)
+      case _ => None
+
+  end EtaExpansion
+
+   /** Adapt all arguments to possible higher-kinded type parameters using etaExpandIfHK
+   */
+  def EtaExpandIfHK(tparams: List[TypeParamInfo], args: List[Type])(using Context): List[Type] =
+    if (tparams.isEmpty) args
+    else args.zipWithConserve(tparams)((arg, tparam) => arg.EtaExpandIfHK(tparam.paramInfoOrCompleter))
+
+  /** A type map that tries to reduce (part of) the result type of the type lambda `tycon`
+   *  with the given `args`(some of which are wildcard arguments represented by type bounds).
+   *  Non-wildcard arguments are substituted everywhere as usual. A wildcard argument
+   *  `>: L <: H` is substituted for a type lambda parameter `X` only under certain conditions.
+   *
+   *  1. If Mode.AllowLambdaWildcardApply is set:
+   *  The wildcard argument is substituted only if `X` appears in a toplevel application of the form
+   *
+   *        C[..., X, ...]
+   *
+   *  and there are no other occurrences of `X` in the reduced type. In that case
+   *  the refinement above is replaced by
+   *
+   *        C[..., ? >: L <: H, ...]
+   *
+   *  The `allReplaced` field indicates whether all occurrences of type lambda parameters
+   *  in the reduced type have been replaced with arguments.
+   *
+   *  2. If Mode.AllowLambdaWildcardApply is not set:
+   *  All `X` arguments are replaced by:
+   *
+   *        ? >: L <: H
+   *
+   *  Any other occurrence of `X` in `tycon` is replaced by `U`, if the
+   *  occurrence of `X` in `tycon` is covariant, or nonvariant, or by `L`,
+   *  if the occurrence is contravariant.
+   *
+   *  The idea is that the `AllowLambdaWildcardApply` mode is used to check whether
+   *  a type can be soundly reduced, and to give an error or warning if that
+   *  is not the case. By contrast, the default mode, with `AllowLambdaWildcardApply`
+   *  not set, reduces all applications even if this yields a different type, so
+   *  its postcondition is that no type parameters of `tycon` appear in the
+   *  result type. Using this mode, we can guarantee that `appliedTo` will never
+   *  produce a higher-kinded application with a type lambda as type constructor.
+   */
+  class Reducer(tycon: TypeLambda, args: List[Type])(using Context) extends TypeMap {
+    private var available = (0 until args.length).toSet
+    var allReplaced: Boolean = true
+    def hasWildcardArg(p: TypeParamRef): Boolean =
+      p.binder == tycon && isBounds(args(p.paramNum))
+    def canReduceWildcard(p: TypeParamRef): Boolean =
+      !ctx.mode.is(Mode.AllowLambdaWildcardApply) || available.contains(p.paramNum)
+    def atNestedLevel(op: => Type): Type = {
+      val saved = available
+      available = Set()
+      try op
+      finally available = saved
+    }
+
+    // If this is a reference to a reducable type parameter corresponding to a
+    // wildcard argument, return the wildcard argument, otherwise apply recursively.
+    def applyArg(arg: Type): Type = arg match {
+      case p: TypeParamRef if hasWildcardArg(p) && canReduceWildcard(p) =>
+        available -= p.paramNum
+        args(p.paramNum)
+      case _ =>
+        atNestedLevel(apply(arg))
+    }
+
+    def apply(t: Type): Type = t match {
+      case t @ AppliedType(tycon, args1) if tycon.typeSymbol.isClass =>
+        t.derivedAppliedType(apply(tycon), args1.mapConserve(applyArg))
+      case t @ RefinedType(parent, name, TypeAlias(info)) =>
+        t.derivedRefinedType(apply(parent), name, applyArg(info).bounds)
+      case p: TypeParamRef if p.binder == tycon =>
+        args(p.paramNum) match {
+          case TypeBounds(lo, hi) =>
+            if (ctx.mode.is(Mode.AllowLambdaWildcardApply)) { allReplaced = false; p }
+            else if (variance < 0) lo
+            else hi
+          case arg =>
+            arg
+        }
+      case _: TypeBounds | _: AppliedType =>
+        atNestedLevel(mapOver(t))
+      case _ =>
+        mapOver(t)
+    }
+  }
+}
+
+import TypeApplications._
+
+/** A decorator that provides methods for modeling type application */
+class TypeApplications(val self: Type) extends AnyVal {
+
+  /** The type parameters of this type are:
+   *  For a ClassInfo type, the type parameters of its class.
+   *  For a typeref referring to a class, the type parameters of the class.
+   *  For a refinement type, the type parameters of its parent, dropping
+   *  any type parameter that is-rebound by the refinement.
+   */
+  final def typeParams(using Context): List[TypeParamInfo] = {
+    record("typeParams")
+    def isTrivial(prefix: Type, tycon: Symbol) = prefix match {
+      case prefix: ThisType =>
+        prefix.cls eq tycon.owner
+      case prefix: TermRef =>
+        val sym = prefix.symbol
+        sym.is(Module) && sym.isStatic && (sym.moduleClass eq tycon.owner)
+      case NoPrefix => true
+      case _ => false
+    }
+    try self match {
+      case self: TypeRef =>
+        val tsym = self.symbol
+        if (tsym.isClass) tsym.typeParams
+        else tsym.infoOrCompleter match {
+          case info: LazyType if isTrivial(self.prefix, tsym) => info.completerTypeParams(tsym)
+          case _ => self.info.typeParams
+        }
+      case self: AppliedType =>
+        if (self.tycon.typeSymbol.isClass) Nil
+        else self.superType.typeParams
+      case self: ClassInfo =>
+        self.cls.typeParams
+      case self: HKTypeLambda =>
+        self.typeParams
+      case _: SingletonType | _: RefinedType | _: RecType =>
+        Nil
+      case self: WildcardType =>
+        self.optBounds.typeParams
+      case self: TypeProxy =>
+        self.superType.typeParams
+      case _ =>
+        Nil
+    }
+    catch {
+      case ex: Throwable => handleRecursive("type parameters of", self.show, ex)
+    }
+  }
+
+  /** Substitute in `self` the type parameters of `tycon` by some other types. */
+  final def substTypeParams(tycon: Type, to: List[Type])(using Context): Type =
+    (tycon.typeParams: @unchecked) match
+      case LambdaParam(lam, _) :: _ => self.substParams(lam, to)
+      case params: List[Symbol @unchecked] => self.subst(params, to)
+
+  /** If `self` is a higher-kinded type, its type parameters, otherwise Nil */
+  final def hkTypeParams(using Context): List[TypeParamInfo] =
+    if (isLambdaSub) typeParams else Nil
+
+  /** If `self` is a generic class, its type parameter symbols, otherwise Nil */
+  final def typeParamSymbols(using Context): List[TypeSymbol] = typeParams match {
+    case tparams @ (_: Symbol) :: _ =>
+      assert(tparams.forall(_.isInstanceOf[Symbol]))
+      tparams.asInstanceOf[List[TypeSymbol]]
+        // Note: Two successive calls to typeParams can yield different results here because
+        // of different completion status. I.e. the first call might produce some symbols,
+        // whereas the second call gives some LambdaParams. This was observed
+        // for ticket0137.scala
+    case _ => Nil
+  }
+
+  /** Is self type bounded by a type lambda or AnyKind? */
+  def isLambdaSub(using Context): Boolean = hkResult.exists
+
+  /** Is self type of kind "*"? */
+  def hasSimpleKind(using Context): Boolean =
+    typeParams.isEmpty && !self.hasAnyKind || {
+      val alias = self.dealias
+      (alias ne self) && alias.hasSimpleKind
+    }
+
+  /** The top type with the same kind as `self`. This is largest type capturing
+   *  the parameter shape of a type without looking at precise bounds.
+   *    - The top-type of simple-kinded types is Any
+   *    - A kind like (* -> *) -> * is represented by the top type [X1 <: [X2] =>> Any] =>> Any
+   */
+  def topType(using Context): Type =
+    if self.hasSimpleKind then
+      defn.AnyType
+    else EtaExpand(self.typeParams) match
+      case tp: HKTypeLambda =>
+        tp.derivedLambdaType(resType = tp.resultType.topType)
+      case _ =>
+        defn.AnyKindType
+
+  /** If self type is higher-kinded, its result type, otherwise NoType.
+   *  Note: The hkResult of an any-kinded type is again AnyKind.
+   */
+  def hkResult(using Context): Type = self.dealias match {
+    case self: TypeRef =>
+      if (self.symbol == defn.AnyKindClass) self else self.info.hkResult
+    case self: AppliedType =>
+      if (self.tycon.typeSymbol.isClass) NoType else self.superType.hkResult
+    case self: HKTypeLambda => self.resultType
+    case _: SingletonType | _: RefinedType | _: RecType => NoType
+    case self: WildcardType => self.optBounds.hkResult
+    case self: TypeVar =>
+      // Using `origin` instead of `underlying`, as is done for typeParams,
+      // avoids having to set ephemeral in some cases.
+      self.origin.hkResult
+    case self: TypeProxy => self.superType.hkResult
+    case _ => NoType
+  }
+
+  /** Do self and other have the same kinds (not counting bounds and variances)?
+   *  Note: An any-kinded type "has the same kind" as any other type.
+   */
+  def hasSameKindAs(other: Type)(using Context): Boolean = {
+    def isAnyKind(tp: Type) = tp match {
+      case tp: TypeRef => tp.symbol == defn.AnyKindClass
+      case _ => false
+    }
+    val selfResult = self.hkResult
+    val otherResult = other.hkResult
+    isAnyKind(selfResult) || isAnyKind(otherResult) ||
+    { if (selfResult.exists)
+        otherResult.exists &&
+        selfResult.hasSameKindAs(otherResult) &&
+        self.typeParams.corresponds(other.typeParams)((sparam, oparam) =>
+          sparam.paramInfo.hasSameKindAs(oparam.paramInfo))
+      else !otherResult.exists
+    }
+  }
+
+  /** Dealias type if it can be done without forcing the TypeRef's info */
+  def safeDealias(using Context): Type = self match {
+    case self: TypeRef
+    if self.denot.exists && self.symbol.isAliasType && !self.symbol.isProvisional =>
+      self.superType.stripTypeVar.safeDealias
+    case _ =>
+      self
+  }
+
+  /** Convert a type constructor `TC` which has type parameters `X1, ..., Xn`
+   *  to `[X1, ..., Xn] -> TC[X1, ..., Xn]`.
+   */
+  def EtaExpand(tparams: List[TypeParamInfo])(using Context): Type =
+    HKTypeLambda.fromParams(tparams, self.appliedTo(tparams.map(_.paramRef)))
+      //.ensuring(res => res.EtaReduce =:= self, s"res = $res, core = ${res.EtaReduce}, self = $self, hc = ${res.hashCode}")
+
+  /** If self is not lambda-bound, eta expand it. */
+  def ensureLambdaSub(using Context): Type =
+    if (isLambdaSub) self else EtaExpansion(self)
+
+  /** Eta expand if `self` is a (non-lambda) class reference and `bound` is a higher-kinded type */
+  def EtaExpandIfHK(bound: Type)(using Context): Type = {
+    val hkParams = bound.hkTypeParams
+    if (hkParams.isEmpty) self
+    else self match {
+      case self: TypeRef if self.symbol.isClass && self.typeParams.length == hkParams.length =>
+        EtaExpansion(self)
+      case _ => self
+    }
+  }
+
+  /** The type representing
+   *
+   *     T[U1, ..., Un]
+   *
+   *  where
+   *  @param  self   = `T`
+   *  @param  args   = `U1,...,Un`
+   */
+  final def appliedTo(args: List[Type])(using Context): Type = {
+    record("appliedTo")
+    val typParams = self.typeParams
+    val stripped = self.stripTypeVar
+    val dealiased = stripped.safeDealias
+    if (args.isEmpty || ctx.erasedTypes) self
+    else dealiased match {
+      case dealiased: HKTypeLambda =>
+        def tryReduce =
+          if (!args.exists(isBounds)) {
+            val followAlias = Config.simplifyApplications && {
+              dealiased.resType match {
+                case AppliedType(tyconBody, dealiasedArgs) =>
+                  // Reduction should not affect type inference when it's
+                  // just eta-reduction (ignoring variance annotations).
+                  // See i2201*.scala for examples where more aggressive
+                  // reduction would break type inference.
+                  dealiased.paramRefs == dealiasedArgs ||
+                  defn.isCompiletimeAppliedType(tyconBody.typeSymbol)
+                case _ => false
+              }
+            }
+            if ((dealiased eq stripped) || followAlias)
+              try
+                val instantiated = dealiased.instantiate(args.mapConserve(_.boxedUnlessFun(self)))
+                if (followAlias) instantiated.normalized else instantiated
+              catch
+                case ex: IndexOutOfBoundsException =>
+                  AppliedType(self, args)
+                case ex: Throwable =>
+                  handleRecursive("try to instantiate", i"$dealiased[$args%, %]", ex)
+
+            else AppliedType(self, args)
+          }
+          else dealiased.resType match {
+            case AppliedType(tycon, args1) if tycon.safeDealias ne tycon =>
+              // In this case we should always dealias since we cannot handle
+              // higher-kinded applications to wildcard arguments.
+              dealiased
+                .derivedLambdaType(resType = tycon.safeDealias.appliedTo(args1))
+                .appliedTo(args)
+            case _ =>
+              val reducer = new Reducer(dealiased, args)
+              val reduced = reducer(dealiased.resType)
+              if (reducer.allReplaced) reduced
+              else AppliedType(dealiased, args)
+          }
+        tryReduce
+      case dealiased: PolyType =>
+        dealiased.instantiate(args)
+      case dealiased: AndType =>
+        dealiased.derivedAndType(dealiased.tp1.appliedTo(args), dealiased.tp2.appliedTo(args))
+      case dealiased: OrType =>
+        dealiased.derivedOrType(dealiased.tp1.appliedTo(args), dealiased.tp2.appliedTo(args))
+      case dealiased: AliasingBounds =>
+        dealiased.derivedAlias(dealiased.alias.appliedTo(args))
+      case dealiased: TypeBounds =>
+        dealiased.derivedTypeBounds(dealiased.lo.appliedTo(args), dealiased.hi.appliedTo(args))
+      case dealiased: LazyRef =>
+        LazyRef.of(dealiased.ref.appliedTo(args))
+      case dealiased: WildcardType =>
+        WildcardType(dealiased.optBounds.orElse(TypeBounds.empty).appliedTo(args).bounds)
+      case dealiased: TypeRef if dealiased.symbol == defn.NothingClass =>
+        dealiased
+      case dealiased =>
+        AppliedType(self, args)
+    }
+  }
+
+  final def appliedTo(arg: Type)(using Context): Type = appliedTo(arg :: Nil)
+  final def appliedTo(arg1: Type, arg2: Type)(using Context): Type = appliedTo(arg1 :: arg2 :: Nil)
+
+  final def applyIfParameterized(args: List[Type])(using Context): Type =
+    if (typeParams.nonEmpty) appliedTo(args) else self
+
+  /** A cycle-safe version of `appliedTo` where computing type parameters do not force
+   *  the typeconstructor. Instead, if the type constructor is completing, we make
+   *  up hk type parameters matching the arguments. This is needed when unpickling
+   *  Scala2 files such as `scala.collection.generic.Mapfactory`.
+   */
+  final def safeAppliedTo(args: List[Type])(using Context): Type = self match {
+    case self: TypeRef if !self.symbol.isClass && self.symbol.isCompleting =>
+      AppliedType(self, args)
+    case _ =>
+      appliedTo(args)
+  }
+
+  /** Turns non-bounds types to type bounds.
+   *  A (possible lambda abstracted) match type is turned into a match alias.
+   *  Every other type is turned into a type alias
+   */
+  final def toBounds(using Context): TypeBounds = self match {
+    case self: TypeBounds => self // this can happen for wildcard args
+    case _ => if (self.isMatch) MatchAlias(self) else TypeAlias(self)
+  }
+
+  /** Translate a type of the form From[T] to either To[T] or To[? <: T] (if `wildcardArg` is set). Keep other types as they are.
+   *  `from` and `to` must be static classes, both with one type parameter, and the same variance.
+   *  Do the same for by name types => From[T] and => To[T]
+   */
+  def translateParameterized(from: ClassSymbol, to: ClassSymbol, wildcardArg: Boolean = false)(using Context): Type = self match {
+    case self @ ExprType(tp) =>
+      self.derivedExprType(tp.translateParameterized(from, to))
+    case _ =>
+      if (self.derivesFrom(from)) {
+        def elemType(tp: Type): Type = tp.widenDealias match
+          case tp: OrType =>
+            if tp.tp1.isBottomType then elemType(tp.tp2)
+            else if tp.tp2.isBottomType then elemType(tp.tp1)
+            else tp.derivedOrType(elemType(tp.tp1), elemType(tp.tp2))
+          case tp: AndType => tp.derivedAndType(elemType(tp.tp1), elemType(tp.tp2))
+          case _ => tp.baseType(from).argInfos.headOption.getOrElse(defn.NothingType)
+        val arg = elemType(self)
+        val arg1 = if (wildcardArg) TypeBounds.upper(arg) else arg
+        to.typeRef.appliedTo(arg1)
+      }
+      else self
+  }
+
+  /** If this is a repeated parameter `*T`, translate it to either `Seq[T]` or
+   *  `Array[? <: T]` depending on the value of `toArray`.
+   *  Additionally, if `translateWildcard` is true, a wildcard type
+   *  will be translated to `*<?>`.
+   *  Other types are kept as-is.
+   */
+  def translateFromRepeated(toArray: Boolean, translateWildcard: Boolean = false)(using Context): Type =
+    val seqClass = if (toArray) defn.ArrayClass else defn.SeqClass
+    if translateWildcard && self.isInstanceOf[WildcardType] then
+      seqClass.typeRef.appliedTo(WildcardType)
+    else if self.isRepeatedParam then
+      // We want `Array[? <: T]` because arrays aren't covariant until after
+      // erasure. See `tests/pos/i5140`.
+      translateParameterized(defn.RepeatedParamClass, seqClass, wildcardArg = toArray)
+    else self
+
+  /** Translate a `From[T]` into a `*T`. */
+  def translateToRepeated(from: ClassSymbol)(using Context): Type =
+    translateParameterized(from, defn.RepeatedParamClass)
+
+  /** Translate `T` to `T & Object` in the situations where an `Array[T]`
+   *  coming from Java would need to be interpreted as an `Array[T & Object]`
+   *  to be erased correctly.
+   *
+   *  `Object` is the top-level type in Java, but when it appears in a Java
+   *  signature we replace it by a special `FromJavaObject` type for
+   *  convenience, this in turns requires us to special-case generic arrays as
+   *  described in case 3 in the documentation of `FromJavaObjectSymbol`. This
+   *  is necessary because a fully generic Java array erases to an array of
+   *  Object, whereas a fully generic Scala array erases to Object to allow
+   *  primitive arrays as subtypes.
+   *
+   *  Note: According to
+   *  <http://cr.openjdk.java.net/~briangoetz/valhalla/sov/02-object-model.html>,
+   *  it's possible that future JVMs will consider that:
+   *
+   *      int[] <: Integer[] <: Object[]
+   *
+   *  So hopefully our grand-children will not have to deal with this non-sense!
+   */
+  def translateJavaArrayElementType(using Context): Type =
+    // A type parameter upper-bounded solely by `FromJavaObject` has `ObjectClass` as its classSymbol
+    if self.typeSymbol.isAbstractOrParamType && (self.classSymbol eq defn.ObjectClass) then
+      // The order is important here since Java intersections erase to their first operand
+      AndType(defn.ObjectType, self)
+    else
+      self
+
+  /** If this is an encoding of a (partially) applied type, return its arguments,
+   *  otherwise return Nil.
+   *  Existential types in arguments are returned as TypeBounds instances.
+   */
+  final def argInfos(using Context): List[Type] = self.stripped match
+    case AppliedType(tycon, args) => args.boxedUnlessFun(tycon)
+    case _ => Nil
+
+  /** Argument types where existential types in arguments are disallowed */
+  def argTypes(using Context): List[Type] = argInfos mapConserve noBounds
+
+  /** Argument types where existential types in arguments are approximated by their lower bound */
+  def argTypesLo(using Context): List[Type] = argInfos.mapConserve(_.loBound)
+
+  /** Argument types where existential types in arguments are approximated by their upper bound  */
+  def argTypesHi(using Context): List[Type] = argInfos.mapConserve(_.hiBound)
+
+  /** If this is the image of a type argument; recover the type argument,
+   *  otherwise NoType.
+   */
+  final def argInfo(using Context): Type = self match {
+    case self: TypeAlias => self.alias
+    case self: TypeBounds => self
+    case _ => NoType
+  }
+
+  /** If this is a type alias, its underlying type, otherwise the type itself */
+  def dropAlias(using Context): Type = self match {
+    case TypeAlias(alias) => alias
+    case _ => self
+  }
+
+  /** The element type of a sequence or array */
+  def elemType(using Context): Type = self.widenDealias match {
+    case defn.ArrayOf(elemtp) => elemtp
+    case JavaArrayType(elemtp) => elemtp
+    case tp: OrType if tp.tp1.isBottomType => tp.tp2.elemType
+    case tp: OrType if tp.tp2.isBottomType => tp.tp1.elemType
+    case _ => self.baseType(defn.SeqClass).argInfos.headOption.getOrElse(NoType)
+  }
+}
diff --git a/tests/pos-with-compiler-cc/dotc/core/TypeComparer.scala b/tests/pos-with-compiler-cc/dotc/core/TypeComparer.scala
new file mode 100644
index 000000000000..aa42785ecf78
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/core/TypeComparer.scala
@@ -0,0 +1,3259 @@
+package dotty.tools
+package dotc
+package core
+
+import Types._, Contexts._, Symbols._, Flags._, Names._, NameOps._, Denotations._
+import Decorators._
+import Phases.{gettersPhase, elimByNamePhase}
+import StdNames.nme
+import TypeOps.refineUsingParent
+import collection.mutable
+import util.{Stats, NoSourcePosition, EqHashMap}
+import config.Config
+import config.Feature.migrateTo3
+import config.Printers.{subtyping, gadts, matchTypes, noPrinter}
+import TypeErasure.{erasedLub, erasedGlb}
+import TypeApplications._
+import Variances.{Variance, variancesConform}
+import Constants.Constant
+import transform.TypeUtils._
+import transform.SymUtils._
+import scala.util.control.NonFatal
+import typer.ProtoTypes.constrained
+import typer.Applications.productSelectorTypes
+import reporting.trace
+import annotation.constructorOnly
+import cc.{CapturingType, derivedCapturingType, CaptureSet, stripCapturing, isBoxedCapturing, boxed, boxedUnlessFun, boxedIfTypeParam, isAlwaysPure}
+import language.experimental.pureFunctions
+
+/** Provides methods to compare types.
+ */
+class TypeComparer(@constructorOnly initctx: Context) extends ConstraintHandling, PatternTypeConstrainer {
+  import TypeComparer._
+  Stats.record("TypeComparer")
+
+  private var myContext: Context = initctx
+  def comparerContext: Context = myContext
+
+  protected given [DummySoItsADef]: Context = myContext
+
+  protected var state: TyperState = compiletime.uninitialized
+  def constraint: Constraint = state.constraint
+  def constraint_=(c: Constraint): Unit = state.constraint = c
+
+  def init(c: Context): Unit =
+    myContext = c
+    state = c.typerState
+    monitored = false
+    GADTused = false
+    recCount = 0
+    needsGc = false
+    if Config.checkTypeComparerReset then checkReset()
+
+  private var pendingSubTypes: util.MutableSet[(Type, Type)] | Null = null
+  private var recCount = 0
+  private var monitored = false
+
+  private var needsGc = false
+
+  private var canCompareAtoms: Boolean = true // used for internal consistency checking
+
+  /** Indicates whether the subtype check used GADT bounds */
+  private var GADTused: Boolean = false
+
+  private var myInstance: TypeComparer = this
+  def currentInstance: TypeComparer = myInstance
+
+  /** Is a subtype check in progress? In that case we may not
+   *  permanently instantiate type variables, because the corresponding
+   *  constraint might still be retracted and the instantiation should
+   *  then be reversed.
+   */
+  def subtypeCheckInProgress: Boolean = {
+    val result = recCount > 0
+    if (result) {
+      constr.println("*** needsGC ***")
+      needsGc = true
+    }
+    result
+  }
+
+  /** For statistics: count how many isSubTypes are part of successful comparisons */
+  private var successCount = 0
+  private var totalCount = 0
+
+  protected val AnyClass     = defn.AnyClass
+  protected val AnyKindClass = defn.AnyKindClass
+  protected val NothingClass = defn.NothingClass
+  protected val NullClass    = defn.NullClass
+  protected val ObjectClass  = defn.ObjectClass
+  protected val AnyType      = AnyClass.typeRef
+  protected val AnyKindType  = AnyKindClass.typeRef
+  protected val NothingType  = NothingClass.typeRef
+
+  override def checkReset() =
+    super.checkReset()
+    assert(pendingSubTypes == null || pendingSubTypes.uncheckedNN.isEmpty)
+    assert(canCompareAtoms == true)
+    assert(successCount == 0)
+    assert(totalCount == 0)
+    assert(approx == ApproxState.Fresh)
+    assert(leftRoot == null)
+    assert(frozenGadt == false)
+
+  /** Record that GADT bounds of `sym` were used in a subtype check.
+   *  But exclude constructor type parameters, as these are aliased
+   *  to the corresponding class parameters, which does not constitute
+   *  a true usage of a GADT symbol.
+   */
+  private def GADTusage(sym: Symbol): true = recordGadtUsageIf(!sym.owner.isConstructor)
+
+  private def recordGadtUsageIf(cond: Boolean): true = {
+    if cond then
+      GADTused = true
+    true
+  }
+
+  private def isBottom(tp: Type) = tp.widen.isRef(NothingClass)
+
+  protected def gadtBounds(sym: Symbol)(using Context) = ctx.gadt.bounds(sym)
+  protected def gadtAddBound(sym: Symbol, b: Type, isUpper: Boolean): Boolean = ctx.gadt.addBound(sym, b, isUpper)
+
+  protected def typeVarInstance(tvar: TypeVar)(using Context): Type = tvar.underlying
+
+  // Subtype testing `<:<`
+
+  def topLevelSubType(tp1: Type, tp2: Type): Boolean = {
+    if (tp2 eq NoType) return false
+    if ((tp2 eq tp1) || (tp2 eq WildcardType)) return true
+    try isSubType(tp1, tp2)
+    finally {
+      monitored = false
+      if (Config.checkConstraintsSatisfiable)
+        assert(isSatisfiable, constraint.show)
+    }
+  }
+
+  def necessarySubType(tp1: Type, tp2: Type): Boolean =
+    val saved = myNecessaryConstraintsOnly
+    myNecessaryConstraintsOnly = true
+    try topLevelSubType(tp1, tp2)
+    finally myNecessaryConstraintsOnly = saved
+
+  def testSubType(tp1: Type, tp2: Type): CompareResult =
+    GADTused = false
+    if !topLevelSubType(tp1, tp2) then CompareResult.Fail
+    else if GADTused then CompareResult.OKwithGADTUsed
+    else CompareResult.OK
+
+  /** The current approximation state. See `ApproxState`. */
+  private var approx: ApproxState = ApproxState.Fresh
+  protected def approxState: ApproxState = approx
+
+  /** The original left-hand type of the comparison. Gets reset
+   *  every time we compare components of the previous pair of types.
+   *  This type is used for capture conversion in `isSubArgs`.
+   */
+  private [this] var leftRoot: Type | Null = null
+
+  /** Are we forbidden from recording GADT constraints? */
+  private var frozenGadt = false
+  private inline def inFrozenGadt[T](inline op: T): T =
+    inFrozenGadtIf(true)(op)
+
+  /** A flag to prevent recursive joins when comparing AndTypes on the left */
+  private var joined = false
+
+  /** A variable to keep track of number of outstanding isSameType tests */
+  private var sameLevel = 0
+
+  /** A map that records successful isSameType comparisons.
+   *  Used together with `sameLevel` to avoid exponential blowUp of isSameType
+   *  comparisons for deeply nested invariant applied types.
+   */
+  private var sames: util.EqHashMap[Type, Type] | Null = null
+
+  /** The `sameLevel` nesting depth from which on we want to keep track
+   *  of isSameTypes suucesses using `sames`
+   */
+  val startSameTypeTrackingLevel = 3
+
+  private inline def inFrozenGadtIf[T](cond: Boolean)(inline op: T): T = {
+    val savedFrozenGadt = frozenGadt
+    frozenGadt ||= cond
+    try op finally frozenGadt = savedFrozenGadt
+  }
+
+  private inline def inFrozenGadtAndConstraint[T](inline op: T): T =
+    inFrozenGadtIf(true)(inFrozenConstraint(op))
+
+  extension (sym: Symbol)
+    private inline def onGadtBounds(inline op: TypeBounds => Boolean): Boolean =
+      val bounds = gadtBounds(sym)
+      bounds != null && op(bounds)
+
+  private inline def comparingTypeLambdas(tl1: TypeLambda, tl2: TypeLambda)(op: => Boolean): Boolean =
+    val saved = comparedTypeLambdas
+    comparedTypeLambdas += tl1
+    comparedTypeLambdas += tl2
+    try op finally comparedTypeLambdas = saved
+
+  protected def isSubType(tp1: Type, tp2: Type, a: ApproxState): Boolean = {
+    val savedApprox = approx
+    val savedLeftRoot = leftRoot
+    if (a == ApproxState.Fresh) {
+      this.approx = ApproxState.None
+      this.leftRoot = tp1
+    }
+    else this.approx = a
+    try recur(tp1, tp2)
+    catch {
+      case ex: Throwable => handleRecursive("subtype", i"$tp1 <:< $tp2", ex, weight = 2)
+    }
+    finally {
+      this.approx = savedApprox
+      this.leftRoot = savedLeftRoot
+    }
+  }
+
+  def isSubType(tp1: Type, tp2: Type): Boolean = isSubType(tp1, tp2, ApproxState.Fresh)
+
+  override protected def isSub(tp1: Type, tp2: Type)(using Context): Boolean = isSubType(tp1, tp2)
+
+  /** The inner loop of the isSubType comparison.
+   *  Recursive calls from recur should go to recur directly if the two types
+   *  compared in the callee are essentially the same as the types compared in the
+   *  caller. "The same" means: represent essentially the same sets of values.
+   * `recur` should not be used to compare components of types. In this case
+   *  one should use `isSubType(_, _)`.
+   *  `recur` should also not be used to compare approximated versions of the original
+   *  types (as when we go from an abstract type to one of its bounds). In that case
+   *  one should use `isSubType(_, _, a)` where `a` defines the kind of approximation.
+   *
+   *  Note: Logically, `recur` could be nested in `isSubType`, which would avoid
+   *  the instance state consisting `approx` and `leftRoot`. But then the implemented
+   *  code would have two extra parameters for each of the many calls that go from
+   *  one sub-part of isSubType to another.
+   */
+  protected def recur(tp1: Type, tp2: Type): Boolean = trace(s"isSubType ${traceInfo(tp1, tp2)}${approx.show}", subtyping) {
+
+    def monitoredIsSubType = {
+      if (pendingSubTypes == null) {
+        pendingSubTypes = util.HashSet[(Type, Type)]()
+        report.log(s"!!! deep subtype recursion involving ${tp1.show} <:< ${tp2.show}, constraint = ${state.constraint.show}")
+        report.log(s"!!! constraint = ${constraint.show}")
+        //if (ctx.settings.YnoDeepSubtypes.value) {
+        //  new Error("deep subtype").printStackTrace()
+        //}
+        assert(!ctx.settings.YnoDeepSubtypes.value)
+        if (Config.traceDeepSubTypeRecursions && !this.isInstanceOf[ExplainingTypeComparer])
+          report.log(explained(_.isSubType(tp1, tp2, approx)))
+      }
+      // Eliminate LazyRefs before checking whether we have seen a type before
+      val normalize = new TypeMap {
+        val DerefLimit = 10
+        var derefCount = 0
+        def apply(t: Type) = t match {
+          case t: LazyRef =>
+            // Dereference a lazyref to detect underlying matching types, but
+            // be careful not to get into an infinite recursion. If recursion count
+            // exceeds `DerefLimit`, approximate with `t` instead.
+            derefCount += 1
+            if t.evaluating || derefCount >= DerefLimit then t
+            else try mapOver(t.ref) finally derefCount -= 1
+          case tp: TypeVar =>
+            tp
+          case _ =>
+            mapOver(t)
+        }
+      }
+      val p = (normalize(tp1), normalize(tp2))
+      !pendingSubTypes.nn.contains(p) && {
+        try {
+          pendingSubTypes.nn += p
+          firstTry
+        }
+        finally
+          pendingSubTypes.nn -= p
+      }
+    }
+
+    def firstTry: Boolean = tp2 match {
+      case tp2: NamedType =>
+        def compareNamed(tp1: Type, tp2: NamedType): Boolean =
+          val ctx = comparerContext
+          given Context = ctx // optimization for performance
+          val info2 = tp2.info
+          info2 match
+            case info2: TypeAlias =>
+              if recur(tp1, info2.alias) then return true
+              if tp2.asInstanceOf[TypeRef].canDropAlias then return false
+            case _ =>
+          tp1 match
+            case tp1: NamedType =>
+              tp1.info match {
+                case info1: TypeAlias =>
+                  if recur(info1.alias, tp2) then return true
+                  if tp1.asInstanceOf[TypeRef].canDropAlias then return false
+                case _ =>
+              }
+              val sym2 = tp2.symbol
+              var sym1 = tp1.symbol
+              if (sym1.is(ModuleClass) && sym2.is(ModuleVal))
+                // For convenience we want X$ <:< X.type
+                // This is safe because X$ self-type is X.type
+                sym1 = sym1.companionModule
+              if ((sym1 ne NoSymbol) && (sym1 eq sym2))
+                ctx.erasedTypes ||
+                sym1.isStaticOwner ||
+                isSubPrefix(tp1.prefix, tp2.prefix) ||
+                thirdTryNamed(tp2)
+              else
+                (  (tp1.name eq tp2.name)
+                && tp2.isPrefixDependentMemberRef
+                && isSubPrefix(tp1.prefix, tp2.prefix)
+                && tp1.signature == tp2.signature
+                && !(sym1.isClass && sym2.isClass)  // class types don't subtype each other
+                ) ||
+                thirdTryNamed(tp2)
+            case _ =>
+              secondTry
+        end compareNamed
+        // See the documentation of `FromJavaObjectSymbol`
+        if !ctx.erasedTypes && tp2.isFromJavaObject then
+          recur(tp1, defn.AnyType)
+        else
+          compareNamed(tp1, tp2)
+      case tp2: ProtoType =>
+        isMatchedByProto(tp2, tp1)
+      case tp2: BoundType =>
+        tp2 == tp1 || secondTry
+      case tp2: TypeVar =>
+        recur(tp1, typeVarInstance(tp2))
+      case tp2: WildcardType =>
+        def compareWild = tp2.optBounds match {
+          case TypeBounds(_, hi) => recur(tp1, hi)
+          case NoType => true
+        }
+        compareWild
+      case tp2: LazyRef =>
+        isBottom(tp1) || !tp2.evaluating && recur(tp1, tp2.ref)
+      case CapturingType(_, _) =>
+        secondTry
+      case tp2: AnnotatedType if !tp2.isRefining =>
+        recur(tp1, tp2.parent)
+      case tp2: ThisType =>
+        def compareThis = {
+          val cls2 = tp2.cls
+          tp1 match {
+            case tp1: ThisType =>
+              tp1.cls eq cls2
+            case tp1: NamedType if cls2.is(Module) && cls2.eq(tp1.typeSymbol) =>
+              cls2.isStaticOwner ||
+              recur(tp1.prefix, cls2.owner.thisType) ||
+              secondTry
+            case _ =>
+              secondTry
+          }
+        }
+        compareThis
+      case tp2: SuperType =>
+        def compareSuper = tp1 match {
+          case tp1: SuperType =>
+            recur(tp1.thistpe, tp2.thistpe) &&
+            isSameType(tp1.supertpe, tp2.supertpe)
+          case _ =>
+            secondTry
+        }
+        compareSuper
+      case AndType(tp21, tp22) =>
+        recur(tp1, tp21) && recur(tp1, tp22)
+      case OrType(tp21, tp22) =>
+        if (tp21.stripTypeVar eq tp22.stripTypeVar) recur(tp1, tp21)
+        else secondTry
+      case TypeErasure.ErasedValueType(tycon1, underlying2) =>
+        def compareErasedValueType = tp1 match {
+          case TypeErasure.ErasedValueType(tycon2, underlying1) =>
+            (tycon1.symbol eq tycon2.symbol) && isSubType(underlying1, underlying2)
+          case _ =>
+            secondTry
+        }
+        compareErasedValueType
+      case ConstantType(v2) =>
+        tp1 match {
+          case ConstantType(v1) => v1.value == v2.value && recur(v1.tpe, v2.tpe)
+          case _ => secondTry
+        }
+      case tp2: AnyConstantType =>
+        if (tp2.tpe.exists) recur(tp1, tp2.tpe)
+        else tp1 match {
+          case tp1: ConstantType =>
+            tp2.tpe = tp1
+            true
+          case _ =>
+            secondTry
+        }
+      case _: FlexType =>
+        true
+      case _ =>
+        secondTry
+    }
+
+    def secondTry: Boolean = tp1 match {
+      case tp1: NamedType =>
+        tp1.info match {
+          case info1: TypeAlias =>
+            if (recur(info1.alias, tp2)) return true
+            if (tp1.prefix.isStable) return tryLiftedToThis1
+          case _ =>
+            if (tp1 eq NothingType) || isBottom(tp1) then return true
+        }
+        thirdTry
+      case tp1: TypeParamRef =>
+        def flagNothingBound = {
+          if (!frozenConstraint && isBottom(tp2) && state.isGlobalCommittable) {
+            def msg = s"!!! instantiated to Nothing: $tp1, constraint = ${constraint.show}"
+            if (Config.failOnInstantiationToNothing) assert(false, msg)
+            else report.log(msg)
+          }
+          true
+        }
+        def compareTypeParamRef =
+          assumedTrue(tp1) ||
+          tp2.match {
+            case tp2: TypeParamRef => constraint.isLess(tp1, tp2)
+            case _ => false
+          } ||
+          isSubTypeWhenFrozen(bounds(tp1).hi.boxed, tp2) || {
+            if (canConstrain(tp1) && !approx.high)
+              addConstraint(tp1, tp2, fromBelow = false) && flagNothingBound
+            else thirdTry
+          }
+        compareTypeParamRef
+      case tp1: ThisType =>
+        val cls1 = tp1.cls
+        tp2 match {
+          case tp2: TermRef if cls1.is(Module) && cls1.eq(tp2.typeSymbol) =>
+            cls1.isStaticOwner ||
+            recur(cls1.owner.thisType, tp2.prefix) ||
+            thirdTry
+          case _ =>
+            thirdTry
+        }
+      case tp1: SkolemType =>
+        tp2 match {
+          case tp2: SkolemType if !ctx.phase.isTyper && recur(tp1.info, tp2.info) => true
+          case _ => thirdTry
+        }
+      case tp1: TypeVar =>
+        recur(typeVarInstance(tp1), tp2)
+      case tp1: WildcardType =>
+        def compareWild = tp1.optBounds match {
+          case bounds: TypeBounds => recur(bounds.lo, tp2)
+          case _ => true
+        }
+        compareWild
+      case tp1: LazyRef =>
+        // If `tp1` is in train of being evaluated, don't force it
+        // because that would cause an assertionError. Return false instead.
+        // See i859.scala for an example where we hit this case.
+        tp2.isRef(AnyClass, skipRefined = false)
+        || !tp1.evaluating && recur(tp1.ref, tp2)
+      case AndType(tp11, tp12) =>
+        if (tp11.stripTypeVar eq tp12.stripTypeVar) recur(tp11, tp2)
+        else thirdTry
+      case tp1 @ OrType(tp11, tp12) =>
+        compareAtoms(tp1, tp2) match
+          case Some(b) => return b
+          case None =>
+
+        def widenOK =
+          (tp2.widenSingletons eq tp2)
+          && (tp1.widenSingletons ne tp1)
+          && inFrozenGadtAndConstraint(recur(tp1.widenSingletons, tp2))
+
+        def joinOK = tp2.dealiasKeepRefiningAnnots match {
+          case tp2: AppliedType if !tp2.tycon.typeSymbol.isClass =>
+            // If we apply the default algorithm for `A[X] | B[Y] <: C[Z]` where `C` is a
+            // type parameter, we will instantiate `C` to `A` and then fail when comparing
+            // with `B[Y]`. To do the right thing, we need to instantiate `C` to the
+            // common superclass of `A` and `B`.
+            inFrozenGadtAndConstraint(recur(tp1.join, tp2))
+          case _ =>
+            false
+        }
+
+        /** Mark toplevel type vars in `tp2` as hard in the current constraint */
+        def hardenTypeVars(tp2: Type): Unit = tp2.dealiasKeepRefiningAnnots match
+          case tvar: TypeVar if constraint.contains(tvar.origin) =>
+            constraint = constraint.withHard(tvar)
+          case tp2: TypeParamRef if constraint.contains(tp2) =>
+            hardenTypeVars(constraint.typeVarOfParam(tp2))
+          case tp2: AndOrType =>
+            hardenTypeVars(tp2.tp1)
+            hardenTypeVars(tp2.tp2)
+          case _ =>
+
+        val res = widenOK || joinOK
+          || recur(tp11, tp2) && recur(tp12, tp2)
+          || containsAnd(tp1)
+              && !joined
+              && {
+                joined = true
+                try inFrozenGadt(recur(tp1.join, tp2))
+                finally joined = false
+              }
+              // An & on the left side loses information. We compensate by also trying the join.
+              // This is less ad-hoc than it looks since we produce joins in type inference,
+              // and then need to check that they are indeed supertypes of the original types
+              // under -Ycheck. Test case is i7965.scala.
+              // On the other hand, we could get a combinatorial explosion by applying such joins
+              // recursively, so we do it only once. See i14870.scala as a test case, which would
+              // loop for a very long time without the recursion brake.
+
+        if res && !tp1.isSoft && state.isCommittable then
+          // We use a heuristic here where every toplevel type variable on the right hand side
+          // is marked so that it converts all soft unions in its lower bound to hard unions
+          // before it is instantiated. The reason is that the variable's instance type will
+          // be a supertype of (decomposed and reconstituted) `tp1`.
+          hardenTypeVars(tp2)
+
+        res
+
+      case CapturingType(parent1, refs1) =>
+        if tp2.isAny then true
+        else if subCaptures(refs1, tp2.captureSet, frozenConstraint).isOK && sameBoxed(tp1, tp2, refs1)
+          || !ctx.mode.is(Mode.CheckBoundsOrSelfType) && tp1.isAlwaysPure
+        then recur(parent1, tp2)
+        else thirdTry
+      case tp1: AnnotatedType if !tp1.isRefining =>
+        recur(tp1.parent, tp2)
+      case tp1: MatchType =>
+        val reduced = tp1.reduced
+        if reduced.exists then
+          recur(reduced, tp2) && recordGadtUsageIf { MatchType.thatReducesUsingGadt(tp1) }
+        else thirdTry
+      case _: FlexType =>
+        true
+      case _ =>
+        thirdTry
+    }
+
+    def thirdTryNamed(tp2: NamedType): Boolean = tp2.info match {
+      case info2: TypeBounds =>
+        def compareGADT: Boolean =
+          tp2.symbol.onGadtBounds(gbounds2 =>
+            isSubTypeWhenFrozen(tp1, gbounds2.lo)
+            || tp1.match
+                case tp1: NamedType if ctx.gadt.contains(tp1.symbol) =>
+                  // Note: since we approximate constrained types only with their non-param bounds,
+                  // we need to manually handle the case when we're comparing two constrained types,
+                  // one of which is constrained to be a subtype of another.
+                  // We do not need similar code in fourthTry, since we only need to care about
+                  // comparing two constrained types, and that case will be handled here first.
+                  ctx.gadt.isLess(tp1.symbol, tp2.symbol) && GADTusage(tp1.symbol) && GADTusage(tp2.symbol)
+                case _ => false
+            || narrowGADTBounds(tp2, tp1, approx, isUpper = false))
+          && (isBottom(tp1) || GADTusage(tp2.symbol))
+
+        isSubApproxHi(tp1, info2.lo.boxedIfTypeParam(tp2.symbol)) && (trustBounds || isSubApproxHi(tp1, info2.hi))
+        || compareGADT
+        || tryLiftedToThis2
+        || fourthTry
+
+      case _ =>
+        val cls2 = tp2.symbol
+        if (cls2.isClass)
+          if (cls2.typeParams.isEmpty) {
+            if (cls2 eq AnyKindClass) return true
+            if (isBottom(tp1)) return true
+            if (tp1.isLambdaSub) return false
+              // Note: We would like to replace this by `if (tp1.hasHigherKind)`
+              // but right now we cannot since some parts of the standard library rely on the
+              // idiom that e.g. `List <: Any`. We have to bootstrap without scalac first.
+            if cls2 eq AnyClass then return true
+            if cls2 == defn.SingletonClass && tp1.isStable then return true
+            return tryBaseType(cls2)
+          }
+          else if (cls2.is(JavaDefined)) {
+            // If `cls2` is parameterized, we are seeing a raw type, so we need to compare only the symbol
+            val base = nonExprBaseType(tp1, cls2)
+            if (base.typeSymbol == cls2) return true
+          }
+          else if tp1.isLambdaSub && !tp1.isAnyKind then
+            return recur(tp1, EtaExpansion(tp2))
+        fourthTry
+    }
+
+    def compareTypeParamRef(tp2: TypeParamRef): Boolean =
+      assumedTrue(tp2) || {
+        val alwaysTrue =
+          // The following condition is carefully formulated to catch all cases
+          // where the subtype relation is true without needing to add a constraint
+          // It's tricky because we might need to either approximate tp2 by its
+          // lower bound or else widen tp1 and check that the result is a subtype of tp2.
+          // So if the constraint is not yet frozen, we do the same comparison again
+          // with a frozen constraint, which means that we get a chance to do the
+          // widening in `fourthTry` before adding to the constraint.
+          if (frozenConstraint) recur(tp1, bounds(tp2).lo.boxed)
+          else isSubTypeWhenFrozen(tp1, tp2)
+        alwaysTrue || {
+          if (canConstrain(tp2) && !approx.low)
+            addConstraint(tp2, tp1.widenExpr, fromBelow = true)
+          else fourthTry
+        }
+      }
+
+    def thirdTry: Boolean = tp2 match {
+      case tp2 @ AppliedType(tycon2, args2) =>
+        compareAppliedType2(tp2, tycon2, args2)
+      case tp2: NamedType =>
+        thirdTryNamed(tp2)
+      case tp2: TypeParamRef =>
+        compareTypeParamRef(tp2)
+      case tp2: RefinedType =>
+        def compareRefinedSlow: Boolean =
+          val name2 = tp2.refinedName
+          recur(tp1, tp2.parent)
+          && (name2 == nme.WILDCARD || hasMatchingMember(name2, tp1, tp2))
+
+        def compareRefined: Boolean =
+          val tp1w = tp1.widen
+
+          if ctx.phase == Phases.checkCapturesPhase then
+
+            // A relaxed version of subtyping for dependent functions where method types
+            // are treated as contravariant.
+            // TODO: Merge with isSubInfo in hasMatchingMember. Currently, we can't since
+            // the isSubinfo of hasMatchingMember has problems dealing with PolyTypes
+            // (---> orphan params during pickling)
+            def isSubInfo(info1: Type, info2: Type): Boolean = (info1, info2) match
+              case (info1: PolyType, info2: PolyType) =>
+                info1.paramNames.hasSameLengthAs(info2.paramNames)
+                && isSubInfo(info1.resultType, info2.resultType.subst(info2, info1))
+              case (info1: MethodType, info2: MethodType) =>
+                matchingMethodParams(info1, info2, precise = false)
+                && isSubInfo(info1.resultType, info2.resultType.subst(info2, info1))
+              case (info1 @ CapturingType(parent1, refs1), info2: Type) =>
+                subCaptures(refs1, info2.captureSet, frozenConstraint).isOK && sameBoxed(info1, info2, refs1)
+                  && isSubInfo(parent1, info2)
+              case (info1: Type, CapturingType(parent2, refs2)) =>
+                val refs1 = info1.captureSet
+                (refs1.isAlwaysEmpty || subCaptures(refs1, refs2, frozenConstraint).isOK) && sameBoxed(info1, info2, refs1)
+                  && isSubInfo(info1, parent2)
+              case _ =>
+                isSubType(info1, info2)
+
+            if defn.isFunctionType(tp2) then
+              tp1w.widenDealias match
+                case tp1: RefinedType =>
+                  return isSubInfo(tp1.refinedInfo, tp2.refinedInfo)
+                case _ =>
+            else if tp2.parent.typeSymbol == defn.PolyFunctionClass then
+              tp1.member(nme.apply).info match
+                case info1: PolyType =>
+                  return isSubInfo(info1, tp2.refinedInfo)
+                case _ =>
+
+          val skipped2 = skipMatching(tp1w, tp2)
+          if (skipped2 eq tp2) || !Config.fastPathForRefinedSubtype then
+            if containsAnd(tp1) then
+              tp2.parent match
+                case _: RefinedType | _: AndType =>
+                  // maximally decompose RHS to limit the bad effects of the `either` that is necessary
+                  // since LHS contains an AndType
+                  recur(tp1, decomposeRefinements(tp2, Nil))
+                case _ =>
+                  // Delay calling `compareRefinedSlow` because looking up a member
+                  // of an `AndType` can lead to a cascade of subtyping checks
+                  // This twist is needed to make collection/generic/ParFactory.scala compile
+                  fourthTry || compareRefinedSlow
+            else if tp1.isInstanceOf[HKTypeLambda] then
+              // HKTypeLambdas do not have members.
+              fourthTry
+            else
+              compareRefinedSlow || fourthTry
+          else // fast path, in particular for refinements resulting from parameterization.
+            isSubRefinements(tp1w.asInstanceOf[RefinedType], tp2, skipped2) &&
+            recur(tp1, skipped2)
+        end compareRefined
+
+        compareRefined
+      case tp2: RecType =>
+        def compareRec = tp1.safeDealias match {
+          case tp1: RecType =>
+            val rthis1 = tp1.recThis
+            recur(tp1.parent, tp2.parent.substRecThis(tp2, rthis1))
+          case NoType => false
+          case _ =>
+            val tp1stable = ensureStableSingleton(tp1)
+            recur(fixRecs(tp1stable, tp1stable.widenExpr), tp2.parent.substRecThis(tp2, tp1stable))
+        }
+        compareRec
+      case tp2: HKTypeLambda =>
+        def compareTypeLambda: Boolean = tp1.stripTypeVar match {
+          case tp1: HKTypeLambda =>
+           /* Don't compare bounds of lambdas under language:Scala2, or t2994 will fail.
+            * The issue is that, logically, bounds should compare contravariantly,
+            * but that would invalidate a pattern exploited in t2994:
+            *
+            *    [X0 <: Number] -> Number   <:<    [X0] -> Any
+            *
+            * Under the new scheme, `[X0] -> Any` is NOT a kind that subsumes
+            * all other bounds. You'd have to write `[X0 >: Any <: Nothing] -> Any` instead.
+            * This might look weird, but is the only logically correct way to do it.
+            *
+            * Note: it would be nice if this could trigger a migration warning, but I
+            * am not sure how, since the code is buried so deep in subtyping logic.
+            */
+            def boundsOK =
+              migrateTo3 ||
+              tp1.typeParams.corresponds(tp2.typeParams)((tparam1, tparam2) =>
+                isSubType(tparam2.paramInfo.subst(tp2, tp1), tparam1.paramInfo))
+            comparingTypeLambdas(tp1, tp2) {
+              val variancesOK = variancesConform(tp1.typeParams, tp2.typeParams)
+              variancesOK && boundsOK && isSubType(tp1.resType, tp2.resType.subst(tp2, tp1))
+            }
+          case _ =>
+            val tparams1 = tp1.typeParams
+            if (tparams1.nonEmpty)
+              return recur(tp1.EtaExpand(tparams1), tp2) || fourthTry
+            tp2 match {
+              case EtaExpansion(tycon2: TypeRef) if tycon2.symbol.isClass && tycon2.symbol.is(JavaDefined) =>
+                recur(tp1, tycon2) || fourthTry
+              case _ =>
+                fourthTry
+            }
+        }
+        compareTypeLambda
+      case tp2 @ OrType(tp21, tp22) =>
+        compareAtoms(tp1, tp2) match
+          case Some(b) => return b
+          case _ =>
+
+        // The next clause handles a situation like the one encountered in i2745.scala.
+        // We have:
+        //
+        //   x: A | B, x.type <:< A | X   where X is a type variable
+        //
+        // We should instantiate X to B instead of x.type or A | B. To do this, we widen
+        // the LHS to A | B and recur *without indicating that this is a lowApprox*. The
+        // latter point is important since otherwise we would not get to instantiate X.
+        // If that succeeds, fine. If not we continue and hit the `either` below.
+        // That second path is important to handle comparisons with unions of singletons,
+        // as in `1 <:< 1 | 2`.
+        val tp1w = tp1.widen
+        if ((tp1w ne tp1) && recur(tp1w, tp2))
+          return true
+
+        val tp1a = tp1.dealiasKeepRefiningAnnots
+        if (tp1a ne tp1)
+          // Follow the alias; this might lead to an OrType on the left which needs to be split
+          return recur(tp1a, tp2)
+
+        // Rewrite T1 <: (T211 & T212) | T22 to T1 <: (T211 | T22) and T1 <: (T212 | T22)
+        // and analogously for T1 <: T21 | (T221 & T222)
+        // `|' types to the right of <: are problematic, because
+        // we have to choose one constraint set or another, which might cut off
+        // solutions. The rewriting delays the point where we have to choose.
+        tp21 match {
+          case AndType(tp211, tp212) =>
+            return recur(tp1, OrType(tp211, tp22, tp2.isSoft)) && recur(tp1, OrType(tp212, tp22, tp2.isSoft))
+          case _ =>
+        }
+        tp22 match {
+          case AndType(tp221, tp222) =>
+            return recur(tp1, OrType(tp21, tp221, tp2.isSoft)) && recur(tp1, OrType(tp21, tp222, tp2.isSoft))
+          case _ =>
+        }
+        either(recur(tp1, tp21), recur(tp1, tp22)) || fourthTry
+      case tp2: MatchType =>
+        val reduced = tp2.reduced
+        if reduced.exists then
+          recur(tp1, reduced) && recordGadtUsageIf { MatchType.thatReducesUsingGadt(tp2) }
+        else
+          fourthTry
+      case tp2: MethodType =>
+        def compareMethod = tp1 match {
+          case tp1: MethodType =>
+            (tp1.signature consistentParams tp2.signature) &&
+            matchingMethodParams(tp1, tp2) &&
+            (!tp2.isImplicitMethod || tp1.isImplicitMethod) &&
+            isSubType(tp1.resultType, tp2.resultType.subst(tp2, tp1))
+          case _ => false
+        }
+        compareMethod
+      case tp2: PolyType =>
+        def comparePoly = tp1 match {
+          case tp1: PolyType =>
+            comparingTypeLambdas(tp1, tp2) {
+              (tp1.signature consistentParams tp2.signature)
+              && matchingPolyParams(tp1, tp2)
+              && isSubType(tp1.resultType, tp2.resultType.subst(tp2, tp1))
+            }
+          case _ => false
+        }
+        comparePoly
+      case tp2 @ ExprType(restpe2) =>
+        def compareExpr = tp1 match {
+          // We allow ()T to be a subtype of => T.
+          // We need some subtype relationship between them so that e.g.
+          // def toString   and   def toString()   don't clash when seen
+          // as members of the same type. And it seems most logical to take
+          // ()T <:< => T, since everything one can do with a => T one can
+          // also do with a ()T by automatic () insertion.
+          case tp1 @ MethodType(Nil) => isSubType(tp1.resultType, restpe2)
+          case tp1 @ ExprType(restpe1) => isSubType(restpe1, restpe2)
+          case _ => fourthTry
+        }
+        compareExpr
+      case tp2 @ TypeBounds(lo2, hi2) =>
+        def compareTypeBounds = tp1 match {
+          case tp1 @ TypeBounds(lo1, hi1) =>
+            ((lo2 eq NothingType) || isSubType(lo2, lo1)) &&
+            ((hi2 eq AnyType) && !hi1.isLambdaSub
+             || (hi2 eq AnyKindType)
+             || isSubType(hi1, hi2))
+          case tp1: ClassInfo =>
+            tp2 contains tp1
+          case _ =>
+            false
+        }
+        compareTypeBounds
+      case CapturingType(parent2, refs2) =>
+        def compareCapturing =
+          val refs1 = tp1.captureSet
+          try
+            if refs1.isAlwaysEmpty then recur(tp1, parent2)
+            else subCaptures(refs1, refs2, frozenConstraint).isOK
+              && sameBoxed(tp1, tp2, refs1)
+              && (recur(tp1.widen.stripCapturing, parent2)
+                 || tp1.isInstanceOf[SingletonType] && recur(tp1, parent2)
+                    // this alternative is needed in case the right hand side is a
+                    // capturing type that contains the lhs as an |-alternative.
+                 )
+          catch case ex: AssertionError =>
+            println(i"assertion failed while compare captured $tp1 <:< $tp2")
+            throw ex
+        compareCapturing || fourthTry
+      case tp2: AnnotatedType if tp2.isRefining =>
+        (tp1.derivesAnnotWith(tp2.annot.sameAnnotation) || tp1.isBottomType) &&
+        recur(tp1, tp2.parent)
+      case ClassInfo(pre2, cls2, _, _, _) =>
+        def compareClassInfo = tp1 match {
+          case ClassInfo(pre1, cls1, _, _, _) =>
+            (cls1 eq cls2) && isSubType(pre1, pre2)
+          case _ =>
+            false
+        }
+        compareClassInfo
+      case _ =>
+        fourthTry
+    }
+
+    def tryBaseType(cls2: Symbol) = {
+      val base = nonExprBaseType(tp1, cls2).boxedIfTypeParam(tp1.typeSymbol)
+      if base.exists && (base ne tp1)
+        && (!caseLambda.exists || canWidenAbstract || tp1.widen.underlyingClassRef(refinementOK = true).exists)
+      then
+        isSubType(base, tp2, if (tp1.isRef(cls2)) approx else approx.addLow)
+        && recordGadtUsageIf { MatchType.thatReducesUsingGadt(tp1) }
+        || base.isInstanceOf[OrType] && fourthTry
+          // if base is a disjunction, this might have come from a tp1 type that
+          // expands to a match type. In this case, we should try to reduce the type
+          // and compare the redux. This is done in fourthTry
+      else fourthTry
+    }
+
+    def fourthTry: Boolean = tp1 match {
+      case tp1: TypeRef =>
+        tp1.info match {
+          case info1 @ TypeBounds(lo1, hi1) =>
+            def compareGADT =
+              tp1.symbol.onGadtBounds(gbounds1 =>
+                isSubTypeWhenFrozen(gbounds1.hi, tp2)
+                || narrowGADTBounds(tp1, tp2, approx, isUpper = true))
+              && (tp2.isAny || GADTusage(tp1.symbol))
+
+            (!caseLambda.exists || canWidenAbstract)
+                && isSubType(hi1.boxedIfTypeParam(tp1.symbol), tp2, approx.addLow) && (trustBounds || isSubType(lo1, tp2, approx.addLow))
+            || compareGADT
+            || tryLiftedToThis1
+          case _ =>
+            // `Mode.RelaxedOverriding` is only enabled when checking Java overriding
+            // in explicit nulls, and `Null` becomes a bottom type, which allows
+            // `T | Null` being a subtype of `T`.
+            // A type variable `T` from Java is translated to `T >: Nothing <: Any`.
+            // However, `null` can always be a value of `T` for Java side.
+            // So the best solution here is to let `Null` be a subtype of non-primitive
+            // value types temporarily.
+            def isNullable(tp: Type): Boolean = tp.widenDealias match
+              case tp: TypeRef =>
+                val tpSym = tp.symbol
+                ctx.mode.is(Mode.RelaxedOverriding) && !tpSym.isPrimitiveValueClass ||
+                tpSym.isNullableClass
+              case tp: RefinedOrRecType => isNullable(tp.parent)
+              case tp: AppliedType => isNullable(tp.tycon)
+              case AndType(tp1, tp2) => isNullable(tp1) && isNullable(tp2)
+              case OrType(tp1, tp2) => isNullable(tp1) || isNullable(tp2)
+              case AnnotatedType(tp1, _) => isNullable(tp1)
+              case _ => false
+            val sym1 = tp1.symbol
+            (sym1 eq NothingClass) && tp2.isValueTypeOrLambda ||
+            (sym1 eq NullClass) && isNullable(tp2)
+        }
+      case tp1 @ AppliedType(tycon1, args1) =>
+        compareAppliedType1(tp1, tycon1, args1)
+      case tp1: SingletonType =>
+        def comparePaths = tp2 match
+          case tp2: TermRef =>
+            compareAtoms(tp1, tp2, knownSingletons = true).getOrElse(false)
+            || { // needed to make from-tasty work. test cases: pos/i1753.scala, pos/t839.scala
+              tp2.info.widenExpr.dealias match
+                case tp2i: SingletonType => recur(tp1, tp2i)
+                case _ => false
+            }
+          case _ => false
+
+        def tp1widened =
+          val tp1w = tp1.underlying.widenExpr
+          tp1 match
+            case tp1: CaptureRef if tp1.isTracked =>
+              CapturingType(tp1w.stripCapturing, tp1.singletonCaptureSet)
+            case _ =>
+              tp1w
+
+        comparePaths || isSubType(tp1widened, tp2, approx.addLow)
+      case tp1: RefinedType =>
+        isNewSubType(tp1.parent)
+      case tp1: RecType =>
+        isNewSubType(tp1.parent)
+      case tp1: HKTypeLambda =>
+        def compareHKLambda = tp1 match {
+          case EtaExpansion(tycon1: TypeRef) if tycon1.symbol.isClass && tycon1.symbol.is(JavaDefined) =>
+            // It's a raw type that was mistakenly eta-expanded to a hk-type.
+            // This can happen because we do not cook types coming from Java sources
+            recur(tycon1, tp2)
+          case _ => tp2 match {
+            case tp2: HKTypeLambda => false // this case was covered in thirdTry
+            case _ => tp2.typeParams.hasSameLengthAs(tp1.paramRefs) && isSubType(tp1.resultType, tp2.appliedTo(tp1.paramRefs))
+          }
+        }
+        compareHKLambda
+      case AndType(tp11, tp12) =>
+        val tp2a = tp2.dealiasKeepRefiningAnnots
+        if (tp2a ne tp2) // Follow the alias; this might avoid truncating the search space in the either below
+          return recur(tp1, tp2a)
+
+        // Rewrite (T111 | T112) & T12 <: T2 to (T111 & T12) <: T2 and (T112 | T12) <: T2
+        // and analogously for T11 & (T121 | T122) & T12 <: T2
+        // `&' types to the left of <: are problematic, because
+        // we have to choose one constraint set or another, which might cut off
+        // solutions. The rewriting delays the point where we have to choose.
+        tp11 match {
+          case OrType(tp111, tp112) =>
+            return recur(AndType(tp111, tp12), tp2) && recur(AndType(tp112, tp12), tp2)
+          case _ =>
+        }
+        tp12 match {
+          case OrType(tp121, tp122) =>
+            return recur(AndType(tp11, tp121), tp2) && recur(AndType(tp11, tp122), tp2)
+          case _ =>
+        }
+        val tp1norm = simplifyAndTypeWithFallback(tp11, tp12, tp1)
+        if (tp1 ne tp1norm) recur(tp1norm, tp2)
+        else either(recur(tp11, tp2), recur(tp12, tp2))
+      case tp1: MatchType =>
+        def compareMatch = tp2 match {
+          case tp2: MatchType =>
+            isSameType(tp1.scrutinee, tp2.scrutinee) &&
+            tp1.cases.corresponds(tp2.cases)(isSubType)
+          case _ => false
+        }
+        recur(tp1.underlying, tp2) || compareMatch
+      case tp1: AnnotatedType if tp1.isRefining =>
+        isNewSubType(tp1.parent)
+      case JavaArrayType(elem1) =>
+        def compareJavaArray = tp2 match {
+          case JavaArrayType(elem2) => isSubType(elem1, elem2)
+          case _ => tp2.isAnyRef
+        }
+        compareJavaArray
+      case tp1: ExprType if ctx.phaseId > gettersPhase.id =>
+        // getters might have converted T to => T, need to compensate.
+        recur(tp1.widenExpr, tp2)
+      case _ =>
+        false
+    }
+
+    /** When called from `pre1.A <:< pre2.A` does `pre1` relate to `pre2` so that
+     *  the subtype test is true? This is the case if
+     *
+     *    1. `pre1 <:< pre2`, or
+     *    2. One of `pre1` and `pre2` refers to a package and the other to a
+     *       package object in that package, or
+     *    3. `pre1` and `pre2` are both this-types of related classes.
+     *
+     *  Here, two classes are related if each of them has a self type that derives from the other.
+     *  The third criterion is a bit dubious. I.e. in the test
+     *
+     *      A.this.T <:< B.this.T
+     *
+     *  where `T` is the same type, what relationship must exist between A and B
+     *  for the test to be guaranteed true? The problem is we can't tell without additional
+     *  info. One could be an outer this at the point where we do the test, but that
+     *  location is unknown to us.
+     *
+     *  The conservative choice would be to require A == B, but then some tests involving
+     *  self types fail. Specifically, t360, t361 and pat_iuli fail the pickling test, and
+     *  Namer fails to compile. At line 203, we get
+     *
+     *    val Deriver         : Property.Key[typer.Deriver]       = new Property.Key
+     *        ^
+     *  value Deriver in class Namer is not a legal implementation of `Deriver` in class Namer.
+     *  its type             dotty.tools.dotc.util.Property.Key[Namer.this.Deriver]
+    |*  does not conform to  dotty.tools.dotc.util.Property.Key[Typer.this.Deriver & Namer.this.Deriver]
+     */
+    def isSubPrefix(pre1: Type, pre2: Type): Boolean =
+      def samePkg(sym1: Symbol, sym2: Symbol) =
+           sym2.is(Package) && sym1.isPackageObject && sym1.owner == sym2.moduleClass
+        || sym1.is(Package) && sym2.isPackageObject && sym2.owner == sym1.moduleClass
+      pre1 match
+        case pre1: ThisType =>
+          pre2 match
+            case pre2: ThisType =>
+              if samePkg(pre1.cls, pre2.cls) then return true
+              if pre1.cls.classInfo.selfType.derivesFrom(pre2.cls)
+                 && pre2.cls.classInfo.selfType.derivesFrom(pre1.cls)
+              then
+                subtyping.println(i"assume equal prefixes $pre1 $pre2")
+                return true
+            case pre2: TermRef =>
+              if samePkg(pre1.cls, pre2.symbol) then return true
+            case _ =>
+        case pre1: TermRef =>
+          pre2 match
+            case pre2: TermRef =>
+              if samePkg(pre1.symbol, pre2.symbol) then return true
+            case pre2: ThisType =>
+              if samePkg(pre1.symbol, pre2.cls) then return true
+            case _ =>
+        case _ =>
+      isSubType(pre1, pre2)
+    end isSubPrefix
+
+    /** Compare `tycon[args]` with `other := otherTycon[otherArgs]`, via `>:>` if fromBelow is true, `<:<` otherwise
+     *  (we call this relationship `~:~` in the rest of this comment).
+     *
+     *  This method works by:
+     *
+     *  1. Choosing an appropriate type constructor `adaptedTycon`
+     *  2. Constraining `tycon` such that `tycon ~:~ adaptedTycon`
+     *  3. Recursing on `adaptedTycon[args] ~:~ other`
+     *
+     *  So, how do we pick `adaptedTycon`? When `args` and `otherArgs` have the
+     *  same length the answer is simply:
+     *
+     *    adaptedTycon := otherTycon
+     *
+     *  But we also handle having `args.length < otherArgs.length`, in which
+     *  case we need to make up a type constructor of the right kind. For
+     *  example, if `fromBelow = false` and we're comparing:
+     *
+     *    ?F[A] <:< Either[String, B] where `?F <: [X] =>> Any`
+     *
+     *  we will choose:
+     *
+     *    adaptedTycon := [X] =>> Either[String, X]
+     *
+     *  this allows us to constrain:
+     *
+     *    ?F <: adaptedTycon
+     *
+     *  and then recurse on:
+     *
+     *    adaptedTycon[A] <:< Either[String, B]
+     *
+     *  In general, given:
+     *
+     *  - k := args.length
+     *  - d := otherArgs.length - k
+     *  - T_0, ..., T_k-1 fresh type parameters
+     *  - bodyArgs := otherArgs.take(d), T_0, ..., T_k-1
+     *
+     *  Then,
+     *
+     *    adaptedTycon := [T_0, ..., T_k-1] =>> otherTycon[bodyArgs]
+     *
+     *  where the bounds of `T_i` are set based on the bounds of `otherTycon.typeParams(d+i)`
+     *  after substituting type parameter references by the corresponding argument
+     *  in `bodyArgs` (see `adaptedBounds` in the implementation).
+     *
+     *  Historical note: this strategy is known in Scala as "partial unification"
+     *  (even though the type constructor variable isn't actually unified but only
+     *  has one of its bounds constrained), for background see:
+     *  - The infamous SI-2712: https://github.com/scala/bug/issues/2712
+     *  - The PR against Scala 2.12 implementing -Ypartial-unification: https://github.com/scala/scala/pull/5102
+     *  - Some explanations on how this impacts API design: https://gist.github.com/djspiewak/7a81a395c461fd3a09a6941d4cd040f2
+     */
+    def compareAppliedTypeParamRef(tycon: TypeParamRef, args: List[Type], other: AppliedType, fromBelow: Boolean): Boolean =
+      def directionalIsSubType(tp1: Type, tp2: Type): Boolean =
+        if fromBelow then isSubType(tp2, tp1) else isSubType(tp1, tp2)
+      def directionalRecur(tp1: Type, tp2: Type): Boolean =
+        if fromBelow then recur(tp2, tp1) else recur(tp1, tp2)
+
+      val otherTycon = other.tycon
+      val otherArgs = other.args
+
+      val d = otherArgs.length - args.length
+      d >= 0 && {
+        val tparams = tycon.typeParams
+        val remainingTparams = otherTycon.typeParams.drop(d)
+        variancesConform(remainingTparams, tparams) && {
+          val adaptedTycon =
+            if d > 0 then
+              val initialArgs = otherArgs.take(d)
+              /** The arguments passed to `otherTycon` in the body of `tl` */
+              def bodyArgs(tl: HKTypeLambda) = initialArgs ++ tl.paramRefs
+              /** The bounds of the type parameters of `tl` */
+              def adaptedBounds(tl: HKTypeLambda) =
+                val bodyArgsComputed = bodyArgs(tl)
+                remainingTparams.map(_.paramInfo)
+                  .mapconserve(_.substTypeParams(otherTycon, bodyArgsComputed).bounds)
+
+              HKTypeLambda(remainingTparams.map(_.paramName))(
+                adaptedBounds,
+                tl => otherTycon.appliedTo(bodyArgs(tl)))
+            else
+              otherTycon
+          (assumedTrue(tycon) || directionalIsSubType(tycon, adaptedTycon)) &&
+          directionalRecur(adaptedTycon.appliedTo(args), other)
+        }
+      }
+    end compareAppliedTypeParamRef
+
+    /** Subtype test for the hk application `tp2 = tycon2[args2]`.
+     */
+    def compareAppliedType2(tp2: AppliedType, tycon2: Type, args2: List[Type]): Boolean = {
+      val tparams = tycon2.typeParams
+      if (tparams.isEmpty) return false // can happen for ill-typed programs, e.g. neg/tcpoly_overloaded.scala
+
+      /** True if `tp1` and `tp2` have compatible type constructors and their
+       *  corresponding arguments are subtypes relative to their variance (see `isSubArgs`).
+       */
+      def isMatchingApply(tp1: Type): Boolean = tp1.widen match {
+        case tp1 @ AppliedType(tycon1, args1) =>
+          // We intentionally do not automatically dealias `tycon1` or `tycon2` here.
+          // `TypeApplications#appliedTo` already takes care of dealiasing type
+          // constructors when this can be done without affecting type
+          // inference, doing it here would not only prevent code from compiling
+          // but could also result in the wrong thing being inferred later, for example
+          // in `tests/run/hk-alias-unification.scala` we end up checking:
+          //
+          //   Foo[?F, ?T] <:< Foo[[X] =>> (X, String), Int]
+          //
+          // where
+          //
+          //   type Foo[F[_], T] = ErasedFoo[F[T]]
+          //
+          // Naturally, we'd like to infer:
+          //
+          //   ?F := [X] => (X, String)
+          //
+          // but if we dealias `Foo` then we'll end up trying to check:
+          //
+          //   ErasedFoo[?F[?T]] <:< ErasedFoo[(Int, String)]
+          //
+          // Because of partial unification, this will succeed, but will produce the constraint:
+          //
+          //   ?F := [X] =>> (Int, X)
+          //
+          // Which is not what we wanted!
+          // On the other hand, we are not allowed to always stop at the present arguments either.
+          // An example is i10129.scala. Here, we have the following situation:
+          //
+          //    type Lifted[A] = Err | A
+          //    def point[O](o: O): Lifted[O] = o
+          //    extension [O, U](o: Lifted[O]) def map(f: O => U): Lifted[U] = ???
+          //    point("a").map(_ => if true then 1 else error)
+          //
+          // This leads to the constraint Lifted[U] <: Lifted[Int]. If we just
+          // check the arguments this gives `U <: Int`. But this is wrong. Dealiasing
+          // `Lifted` gives `Err | U <: Err | Int`, hence it should be `U <: Err | Int`.
+          //
+          // So it's a conundrum. We need to check the immediate arguments for hk type inference,
+          // but this could narrow the constraint too much. The solution is to also
+          // check the constraint arising from the dealiased subtype test
+          // in the case where isSubArgs adds a constraint. If that second constraint
+          // is weaker than the first, we keep it in place of the first.
+          // Note that if the isSubArgs test fails, we will proceed anyway by
+          // dealising by doing a compareLower.
+          def loop(tycon1: Type, args1: List[Type]): Boolean = tycon1 match {
+            case tycon1: TypeParamRef =>
+              (tycon1 == tycon2 ||
+               canConstrain(tycon1) && isSubType(tycon1, tycon2)) &&
+              isSubArgs(args1, args2, tp1, tparams)
+            case tycon1: TypeRef =>
+              tycon2 match {
+                case tycon2: TypeRef =>
+                  val tycon1sym = tycon1.symbol
+                  val tycon2sym = tycon2.symbol
+
+                  var touchedGADTs = false
+                  var gadtIsInstantiated = false
+
+                  extension (sym: Symbol)
+                    inline def byGadtBounds(inline op: TypeBounds => Boolean): Boolean =
+                      touchedGADTs = true
+                      sym.onGadtBounds(
+                        b => op(b) && { gadtIsInstantiated = b.isInstanceOf[TypeAlias]; true })
+
+                  def byGadtOrdering: Boolean =
+                    ctx.gadt.contains(tycon1sym)
+                    && ctx.gadt.contains(tycon2sym)
+                    && ctx.gadt.isLess(tycon1sym, tycon2sym)
+
+                  val res = (
+                    tycon1sym == tycon2sym && isSubPrefix(tycon1.prefix, tycon2.prefix)
+                    || tycon1sym.byGadtBounds(b => isSubTypeWhenFrozen(b.hi, tycon2))
+                    || tycon2sym.byGadtBounds(b => isSubTypeWhenFrozen(tycon1, b.lo))
+                    || byGadtOrdering
+                  ) && {
+                    // There are two cases in which we can assume injectivity.
+                    // First we check if either sym is a class.
+                    // Then:
+                    // 1) if we didn't touch GADTs, then both symbols are the same
+                    //    (b/c of an earlier condition) and both are the same class
+                    // 2) if we touched GADTs, then the _other_ symbol (class syms
+                    //    cannot have GADT constraints), the one w/ GADT cstrs,
+                    //    must be instantiated, making the two tycons equal
+                    val tyconIsInjective =
+                      (tycon1sym.isClass || tycon2sym.isClass)
+                      && (!touchedGADTs || gadtIsInstantiated)
+
+                    inFrozenGadtIf(!tyconIsInjective) {
+                      if tycon1sym == tycon2sym && tycon1sym.isAliasType then
+                        val preConstraint = constraint
+                        isSubArgs(args1, args2, tp1, tparams)
+                        && tryAlso(preConstraint, recur(tp1.superTypeNormalized, tp2.superTypeNormalized))
+                      else
+                        isSubArgs(args1, args2, tp1, tparams)
+                    }
+                  }
+                  res && recordGadtUsageIf(touchedGADTs)
+                case _ =>
+                  false
+              }
+            case tycon1: TypeVar =>
+              loop(tycon1.underlying, args1)
+            case tycon1: AnnotatedType if !tycon1.isRefining =>
+              loop(tycon1.underlying, args1)
+            case _ =>
+              false
+          }
+          loop(tycon1, args1)
+        case _ =>
+          false
+      }
+
+      /** `param2` can be instantiated to a type application prefix of the LHS
+       *  or to a type application prefix of one of the LHS base class instances
+       *  and the resulting type application is a supertype of `tp1`.
+       */
+      def canInstantiate(tycon2: TypeParamRef): Boolean = {
+        def appOK(tp1base: Type) = tp1base match {
+          case tp1base: AppliedType =>
+            compareAppliedTypeParamRef(tycon2, args2, tp1base, fromBelow = true)
+          case _ => false
+        }
+
+        val tp1w = tp1.widen
+        appOK(tp1w) || tp1w.typeSymbol.isClass && {
+          val classBounds = tycon2.classSymbols
+          def liftToBase(bcs: List[ClassSymbol]): Boolean = bcs match {
+            case bc :: bcs1 =>
+              classBounds.exists(bc.derivesFrom) && appOK(nonExprBaseType(tp1, bc))
+              || liftToBase(bcs1)
+            case _ =>
+              false
+          }
+          liftToBase(tp1w.baseClasses)
+        }
+      }
+
+      /** Fall back to comparing either with `fourthTry` or against the lower
+       *  approximation of the rhs.
+       *  @param   tyconLo   The type constructor's lower approximation.
+       */
+      def fallback(tyconLo: Type) =
+        either(fourthTry, isSubApproxHi(tp1, tyconLo.applyIfParameterized(args2)))
+
+      /** Let `tycon2bounds` be the bounds of the RHS type constructor `tycon2`.
+       *  Let `app2 = tp2` where the type constructor of `tp2` is replaced by
+       *  `tycon2bounds.lo`.
+       *  If both bounds are the same, continue with `tp1 <:< app2`.
+       *  otherwise continue with either
+       *
+       *    tp1 <:< tp2    using fourthTry (this might instantiate params in tp1)
+       *    tp1 <:< app2   using isSubType (this might instantiate params in tp2)
+       */
+      def compareLower(tycon2bounds: TypeBounds, tyconIsTypeRef: Boolean): Boolean =
+        if ((tycon2bounds.lo `eq` tycon2bounds.hi) && !tycon2bounds.isInstanceOf[MatchAlias])
+          if (tyconIsTypeRef) recur(tp1, tp2.superTypeNormalized) && recordGadtUsageIf(MatchType.thatReducesUsingGadt(tp2))
+          else isSubApproxHi(tp1, tycon2bounds.lo.applyIfParameterized(args2))
+        else
+          fallback(tycon2bounds.lo)
+
+      def byGadtBounds: Boolean =
+        {
+          tycon2 match
+            case tycon2: TypeRef =>
+              val tycon2sym = tycon2.symbol
+              tycon2sym.onGadtBounds { bounds2 =>
+                inFrozenGadt { compareLower(bounds2, tyconIsTypeRef = false) }
+              }
+            case _ => false
+        } && recordGadtUsageIf(true)
+
+      tycon2 match {
+        case param2: TypeParamRef =>
+          isMatchingApply(tp1) ||
+          canConstrain(param2) && canInstantiate(param2) ||
+          compareLower(bounds(param2), tyconIsTypeRef = false)
+        case tycon2: TypeRef =>
+          isMatchingApply(tp1) ||
+          byGadtBounds ||
+          defn.isCompiletimeAppliedType(tycon2.symbol) && compareCompiletimeAppliedType(tp2, tp1, fromBelow = true) || {
+            tycon2.info match {
+              case info2: TypeBounds =>
+                compareLower(info2, tyconIsTypeRef = true)
+              case info2: ClassInfo =>
+                tycon2.name.startsWith("Tuple") &&
+                  defn.isTupleNType(tp2) && recur(tp1, tp2.toNestedPairs) ||
+                tryBaseType(info2.cls)
+              case _ =>
+                fourthTry
+            }
+          } || tryLiftedToThis2
+
+        case _: TypeVar =>
+          recur(tp1, tp2.superType)
+        case tycon2: AnnotatedType if !tycon2.isRefining =>
+          recur(tp1, tp2.superType)
+        case tycon2: AppliedType =>
+          fallback(tycon2.lowerBound)
+        case _ =>
+          false
+      }
+    }
+
+    /** Subtype test for the application `tp1 = tycon1[args1]`.
+     */
+    def compareAppliedType1(tp1: AppliedType, tycon1: Type, args1: List[Type]): Boolean =
+      tycon1 match {
+        case param1: TypeParamRef =>
+          def canInstantiate = tp2 match {
+            case tp2base: AppliedType =>
+              compareAppliedTypeParamRef(param1, args1, tp2base, fromBelow = false)
+            case _ =>
+              false
+          }
+          canConstrain(param1) && canInstantiate ||
+            isSubType(bounds(param1).hi.applyIfParameterized(args1), tp2, approx.addLow)
+        case tycon1: TypeRef =>
+          val sym = tycon1.symbol
+
+          def byGadtBounds: Boolean =
+            sym.onGadtBounds { bounds1 =>
+              inFrozenGadt { isSubType(bounds1.hi.applyIfParameterized(args1), tp2, approx.addLow) }
+            } && recordGadtUsageIf(true)
+
+
+          !sym.isClass && {
+            defn.isCompiletimeAppliedType(sym) && compareCompiletimeAppliedType(tp1, tp2, fromBelow = false) ||
+            { recur(tp1.superTypeNormalized, tp2) && recordGadtUsageIf(MatchType.thatReducesUsingGadt(tp1)) } ||
+            tryLiftedToThis1
+          } || byGadtBounds
+        case tycon1: TypeProxy =>
+          recur(tp1.superTypeNormalized, tp2)
+        case _ =>
+          false
+      }
+
+    /** Compare `tp` of form `S[arg]` with `other`, via ">:>" if fromBelow is true, "<:<" otherwise.
+     *  If `arg` is a Nat constant `n`, proceed with comparing `n + 1` and `other`.
+     *  Otherwise, if `other` is a Nat constant `n`, proceed with comparing `arg` and `n - 1`.
+     */
+    def compareS(tp: AppliedType, other: Type, fromBelow: Boolean): Boolean = tp.args match {
+      case arg :: Nil =>
+        natValue(arg) match {
+          case Some(n) if n != Int.MaxValue =>
+            val succ = ConstantType(Constant(n + 1))
+            if (fromBelow) recur(other, succ) else recur(succ, other)
+          case none =>
+            natValue(other) match {
+              case Some(n) if n > 0 =>
+                val pred = ConstantType(Constant(n - 1))
+                if (fromBelow) recur(pred, arg) else recur(arg, pred)
+              case none =>
+                false
+            }
+        }
+      case _ => false
+    }
+
+    /** Compare `tp` of form `tycon[...args]`, where `tycon` is a scala.compiletime type,
+     *  with `other` via ">:>" if fromBelow is true, "<:<" otherwise.
+     *  Delegates to compareS if `tycon` is scala.compiletime.S. Otherwise, constant folds if possible.
+     */
+    def compareCompiletimeAppliedType(tp: AppliedType, other: Type, fromBelow: Boolean): Boolean = {
+      if (defn.isCompiletime_S(tp.tycon.typeSymbol)) compareS(tp, other, fromBelow)
+      else {
+        val folded = tp.tryCompiletimeConstantFold
+        if (fromBelow) recur(other, folded) else recur(folded, other)
+      }
+    }
+
+    /** Like tp1 <:< tp2, but returns false immediately if we know that
+     *  the case was covered previously during subtyping.
+     */
+    def isNewSubType(tp1: Type): Boolean =
+      if (isCovered(tp1) && isCovered(tp2))
+        //println(s"useless subtype: $tp1 <:< $tp2")
+        false
+      else isSubType(tp1, tp2, approx.addLow)
+
+    def isSubApproxHi(tp1: Type, tp2: Type): Boolean =
+      tp1.eq(tp2) || tp2.ne(NothingType) && isSubType(tp1, tp2, approx.addHigh)
+
+    def tryLiftedToThis1: Boolean = {
+      val tp1a = liftToThis(tp1)
+      (tp1a ne tp1) && recur(tp1a, tp2)
+    }
+
+    def tryLiftedToThis2: Boolean = {
+      val tp2a = liftToThis(tp2)
+      (tp2a ne tp2) && recur(tp1, tp2a)
+    }
+
+    // begin recur
+    if tp2 eq NoType then false
+    else if tp1 eq tp2 then true
+    else
+      val saved = constraint
+      val savedGadt = ctx.gadt.fresh
+      inline def restore() =
+        state.constraint = saved
+        ctx.gadt.restore(savedGadt)
+      val savedSuccessCount = successCount
+      try
+        recCount += 1
+        if recCount >= Config.LogPendingSubTypesThreshold then monitored = true
+        val result = if monitored then monitoredIsSubType else firstTry
+        recCount -= 1
+        if !result then restore()
+        else if recCount == 0 && needsGc then
+          state.gc()
+          needsGc = false
+        if (Stats.monitored) recordStatistics(result, savedSuccessCount)
+        result
+      catch case NonFatal(ex) =>
+        if ex.isInstanceOf[AssertionError] then showGoal(tp1, tp2)
+        recCount -= 1
+        restore()
+        successCount = savedSuccessCount
+        throw ex
+  }
+
+  private def nonExprBaseType(tp: Type, cls: Symbol)(using Context): Type =
+    if tp.isInstanceOf[ExprType] then NoType
+    else tp.baseType(cls)
+
+  /** If `tp` is an external reference to an enclosing module M that contains opaque types,
+   *  convert to M.this.
+   *  Note: It would be legal to do the lifting also if M does not contain opaque types,
+   *  but in this case the retries in tryLiftedToThis would be redundant.
+   */
+  private def liftToThis(tp: Type): Type = {
+
+    def findEnclosingThis(moduleClass: Symbol, from: Symbol): Type =
+      if ((from.owner eq moduleClass) && from.isPackageObject && from.is(Opaque)) from.thisType
+      else if (from.is(Package)) tp
+      else if ((from eq moduleClass) && from.is(Opaque)) from.thisType
+      else if (from eq NoSymbol) tp
+      else findEnclosingThis(moduleClass, from.owner)
+
+    tp match {
+      case tp: TermRef if tp.symbol.is(Module) =>
+        findEnclosingThis(tp.symbol.moduleClass, ctx.owner)
+      case tp: TypeRef =>
+        val pre1 = liftToThis(tp.prefix)
+        if ((pre1 ne tp.prefix) && pre1.exists) tp.withPrefix(pre1) else tp
+      case tp: ThisType if tp.cls.is(Package) =>
+        findEnclosingThis(tp.cls, ctx.owner)
+      case tp: AppliedType =>
+        val tycon1 = liftToThis(tp.tycon)
+        if (tycon1 ne tp.tycon) tp.derivedAppliedType(tycon1, tp.args) else tp
+      case tp: TypeVar if tp.isInstantiated =>
+        liftToThis(tp.inst)
+      case tp: AnnotatedType =>
+        val parent1 = liftToThis(tp.parent)
+        if (parent1 ne tp.parent) tp.derivedAnnotatedType(parent1, tp.annot) else tp
+      case _ =>
+        tp
+    }
+  }
+
+  /** Optionally, the `n` such that `tp <:< ConstantType(Constant(n: Int))` */
+  def natValue(tp: Type): Option[Int] = constValue(tp) match {
+    case Some(Constant(n: Int)) if n >= 0 => Some(n)
+    case _ => None
+  }
+
+  /** Optionally, the constant `c` such that `tp <:< ConstantType(c)` */
+  def constValue(tp: Type): Option[Constant] = {
+    val ct = new AnyConstantType
+    if (isSubTypeWhenFrozen(tp, ct))
+      ct.tpe match {
+        case ConstantType(c) => Some(c)
+        case _ => None
+      }
+    else None
+  }
+
+  /** If both `tp1` and `tp2` have atoms information, compare the atoms
+   *  in a Some, otherwise None.
+   *  @param knownSingletons  If true, we are coming from a comparison of two singleton types
+   *                          This influences the comparison as shown below:
+   *
+   *  Say you have singleton types p.type and q.type the atoms of p.type are `{p.type}..{p.type}`,
+   *  and the atoms of `q.type` are `{}..{p.type}`. Normally the atom comparison between p's
+   *  atoms and q's atoms gives false. But in this case we know that `q.type` is an alias of `p.type`
+   *  so we are still allowed to conclude that `p.type <:< q.type`. A situation where this happens
+   *  is in i6635.scala. Here,
+   *
+   *     p: A, q: B & p.type   and we want to conclude that p.type <: q.type.
+   */
+  def compareAtoms(tp1: Type, tp2: Type, knownSingletons: Boolean = false): Option[Boolean] =
+
+    /** Check whether we can compare the given set of atoms with another to determine
+     *  a subtype test between OrTypes. There is one situation where this is not
+     *  the case, which has to do with SkolemTypes. TreeChecker sometimes expects two
+     *  types to be equal that have different skolems. To account for this, we identify
+     *  two different skolems in all phases `p`, where `p.isTyper` is false.
+     *  But in that case comparing two sets of atoms that contain skolems
+     *  for equality would give the wrong result, so we should not use the sets
+     *  for comparisons.
+     */
+    def canCompare(ts: Set[Type]) =
+      ctx.phase.isTyper
+      || !ts.exists(_.existsPart(_.isInstanceOf[SkolemType], StopAt.Static))
+
+    def verified(result: Boolean): Boolean =
+      if Config.checkAtomsComparisons then
+        try
+          canCompareAtoms = false
+          val regular = recur(tp1, tp2)
+          assert(result == regular,
+            i"""Atoms inconsistency for $tp1 <:< $tp2
+              |atoms predicted $result
+              |atoms1 = ${tp1.atoms}
+              |atoms2 = ${tp2.atoms}""")
+        finally canCompareAtoms = true
+      result
+
+    tp2.atoms match
+      case Atoms.Range(lo2, hi2) if canCompareAtoms && canCompare(hi2) =>
+        tp1.atoms match
+          case Atoms.Range(lo1, hi1) =>
+            if hi1.subsetOf(lo2) || knownSingletons && hi2.size == 1 && hi1 == hi2 then
+              Some(verified(true))
+            else if !lo1.subsetOf(hi2) then
+              Some(verified(false))
+            else
+              None
+          case _ => Some(verified(recur(tp1, NothingType)))
+      case _ => None
+
+  /** Subtype test for corresponding arguments in `args1`, `args2` according to
+   *  variances in type parameters `tparams2`.
+   *
+   *  @param  tp1       The applied type containing `args1`
+   *  @param  tparams2  The type parameters of the type constructor applied to `args2`
+   */
+  def isSubArgs(args1: List[Type], args2: List[Type], tp1: Type, tparams2: List[ParamInfo]): Boolean = {
+    /** The bounds of parameter `tparam`, where all references to type paramneters
+     *  are replaced by corresponding arguments (or their approximations in the case of
+     *  wildcard arguments).
+     */
+    def paramBounds(tparam: Symbol): TypeBounds =
+      tparam.info.substApprox(tparams2.asInstanceOf[List[Symbol]], args2).bounds
+
+    def recurArgs(args1: List[Type], args2: List[Type], tparams2: List[ParamInfo]): Boolean =
+      if (args1.isEmpty) args2.isEmpty
+      else args2.nonEmpty && tparams2.nonEmpty && {
+        val tparam = tparams2.head
+        val v = tparam.paramVarianceSign
+
+        /** Try a capture conversion:
+         *  If the original left-hand type `leftRoot` is a path `p.type`,
+         *  and the current widened left type is an application with wildcard arguments
+         *  such as `C[?]`, where `X` is `C`'s type parameter corresponding to the `_` argument,
+         *  compare with `C[p.X]` instead. Otherwise approximate based on variance.
+         *  Also do a capture conversion in either of the following cases:
+         *
+         *   - If we are after typer. We generally relax soundness requirements then.
+         *     We need the relaxed condition to correctly compute overriding relationships.
+         *     Missing this case led to AbstractMethod errors in the bootstrap.
+         *
+         *   - If we are in mode TypevarsMissContext, which means we test implicits
+         *     for eligibility. In this case, we can be more permissive, since it's
+         *     just a pre-check. This relaxation is needed since the full
+         *     implicit typing might perform an adaptation that skolemizes the
+         *     type of a synthesized tree before comparing it with an expected type.
+         *     But no such adaptation is applied for implicit eligibility
+         *     testing, so we have to compensate.
+         *
+         *  Note: Doing the capture conversion on path types is actually not necessary
+         *  since we can already deal with the situation through skolemization in Typer#captureWildcards.
+         *  But performance tests indicate that it's better to do it, since we avoid
+         *  skolemizations, which are more expensive . And, besides, capture conversion on
+         *  paths is less intrusive than skolemization.
+         */
+        def compareCaptured(arg1: TypeBounds, arg2: Type) = tparam match {
+          case tparam: Symbol =>
+            val leftr = leftRoot.nn
+            if (leftr.isStable || ctx.isAfterTyper || ctx.mode.is(Mode.TypevarsMissContext))
+                && leftr.isValueType
+                && leftr.member(tparam.name).exists
+            then
+              val captured = TypeRef(leftr, tparam)
+              try isSubArg(captured, arg2)
+              catch case ex: TypeError =>
+                // The captured reference could be illegal and cause a
+                // TypeError to be thrown in argDenot
+                false
+            else if (v > 0)
+              isSubType(paramBounds(tparam).hi, arg2)
+            else if (v < 0)
+              isSubType(arg2, paramBounds(tparam).lo)
+            else
+              false
+          case _ =>
+            false
+        }
+
+        def isSubArg(arg1: Type, arg2: Type): Boolean = arg2 match
+          case arg2: TypeBounds =>
+            val arg1norm = arg1 match {
+              case arg1: TypeBounds =>
+                tparam match {
+                  case tparam: Symbol => arg1 & paramBounds(tparam)
+                  case _ => arg1 // This case can only arise when a hk-type is illegally instantiated with a wildcard
+                }
+              case _ => arg1
+            }
+            arg2.contains(arg1norm)
+          case ExprType(arg2res)
+          if ctx.phaseId > elimByNamePhase.id && !ctx.erasedTypes
+               && defn.isByNameFunction(arg1.dealias) =>
+            // ElimByName maps `=> T` to `()? => T`, but only in method parameters. It leaves
+            // embedded `=> T` arguments alone. This clause needs to compensate for that.
+            isSubArg(arg1.dealias.argInfos.head, arg2res)
+          case _ =>
+            arg1 match
+              case arg1: TypeBounds =>
+                CaptureSet.subCapturesRange(arg1, arg2)
+                  // subCapturesRange is important for invariant arguments that get expanded
+                  // to TypeBounds where each bound is obtained by adding a captureset variable
+                  // to the argument type. If subCapturesRange returns true we know that arg1's'
+                  // capture set can be unified with arg2's capture set, so it only remains to
+                  // check the underlying types with `isSubArg`.
+                  && isSubArg(arg1.hi.stripCapturing, arg2.stripCapturing)
+                || compareCaptured(arg1, arg2)
+              case ExprType(arg1res)
+              if ctx.phaseId > elimByNamePhase.id && !ctx.erasedTypes
+                   && defn.isByNameFunction(arg2.dealias) =>
+                 isSubArg(arg1res, arg2.argInfos.head)
+              case _ =>
+                if v < 0 then isSubType(arg2, arg1)
+                else if v > 0 then isSubType(arg1, arg2)
+                else isSameType(arg2, arg1)
+
+        isSubArg(args1.head.boxedUnlessFun(tp1), args2.head.boxedUnlessFun(tp1))
+      } && recurArgs(args1.tail, args2.tail, tparams2.tail)
+
+    recurArgs(args1, args2, tparams2)
+  }
+
+  /** Test whether `tp1` has a base type of the form `B[T1, ..., Tn]` where
+   *   - `B` derives from one of the class symbols of `tp2`,
+   *   - the type parameters of `B` match one-by-one the variances of `tparams`,
+   *   - `B` satisfies predicate `p`.
+   */
+  private def testLifted(tp1: Type, tp2: Type, tparams: List[TypeParamInfo], p: Type => Boolean): Boolean = {
+    val classBounds = tp2.classSymbols
+    def recur(bcs: List[ClassSymbol]): Boolean = bcs match {
+      case bc :: bcs1 =>
+        (classBounds.exists(bc.derivesFrom) &&
+          variancesConform(bc.typeParams, tparams) &&
+          p(nonExprBaseType(tp1, bc))
+        ||
+        recur(bcs1))
+      case nil =>
+        false
+    }
+    recur(tp1.baseClasses)
+  }
+
+  /** Replace any top-level recursive type `{ z => T }` in `tp` with
+   *  `[z := anchor]T`.
+   */
+  private def fixRecs(anchor: SingletonType, tp: Type): Type = {
+    def fix(tp: Type): Type = tp.stripTypeVar match {
+      case tp: RecType => fix(tp.parent).substRecThis(tp, anchor)
+      case tp @ RefinedType(parent, rname, rinfo) => tp.derivedRefinedType(fix(parent), rname, rinfo)
+      case tp: TypeParamRef => fixOrElse(bounds(tp).hi, tp)
+      case tp: TypeProxy => fixOrElse(tp.superType, tp)
+      case tp: AndType => tp.derivedAndType(fix(tp.tp1), fix(tp.tp2))
+      case tp: OrType  => tp.derivedOrType (fix(tp.tp1), fix(tp.tp2))
+      case tp => tp
+    }
+    def fixOrElse(tp: Type, fallback: Type) = {
+      val tp1 = fix(tp)
+      if (tp1 ne tp) tp1 else fallback
+    }
+    fix(tp)
+  }
+
+  /** Returns true iff the result of evaluating either `op1` or `op2` is true and approximates resulting constraints.
+   *
+   *  If `necessaryConstraintsOnly` is true, we keep the smaller constraint if
+   *  any, or no constraint at all.
+   *
+   *  Otherwise, we infer _sufficient_ constraints: we try to keep the smaller of
+   *  the two constraints, but if never is smaller than the other, we just pick
+   *  the first one.
+   */
+  protected def either(op1: => Boolean, op2: => Boolean): Boolean =
+    Stats.record("TypeComparer.either")
+    if necessaryConstraintsOnly then
+      necessaryEither(op1, op2)
+    else
+      sufficientEither(op1, op2)
+
+  /** Returns true iff the result of evaluating either `op1` or `op2` is true,
+   *  trying at the same time to keep the constraint as wide as possible.
+   *  E.g, if
+   *
+   *    tp11 <:< tp12 = true   with post-constraint c1
+   *    tp12 <:< tp22 = true   with post-constraint c2
+   *
+   *  and c1 subsumes c2, then c2 is kept as the post-constraint of the result,
+   *  otherwise c1 is kept.
+   *
+   *  This method is used to approximate a solution in one of the following cases
+   *
+   *     T1 & T2 <:< T3
+   *     T1 <:< T2 | T3
+   *
+   *  In the first case (the second one is analogous), we have a choice whether we
+   *  want to establish the subtyping judgement using
+   *
+   *     T1 <:< T3   or    T2 <:< T3
+   *
+   *  as a precondition. Either precondition might constrain type variables.
+   *  The purpose of this method is to pick the precondition that constrains less.
+   *  The method is not complete, because sometimes there is no best solution. Example:
+   *
+   *     A? & B?  <:  T
+   *
+   *  Here, each precondition leads to a different constraint, and neither of
+   *  the two post-constraints subsumes the other.
+   *
+   *  Note that to be complete when it comes to typechecking, we would instead need to backtrack
+   *  and attempt to typecheck with the other constraint.
+   *
+   *  Method name comes from the notion that we are keeping a constraint which is sufficient to satisfy
+   *  one of subtyping relationships.
+   */
+  private def sufficientEither(op1: => Boolean, op2: => Boolean): Boolean =
+    val preConstraint = constraint
+    if op1 then tryAlso(preConstraint, op2) else op2
+
+  /** Check whether `op` generates a weaker constraint than the
+   *  current constraint if we run it starting with `preConstraint`.
+   *  If that's the case, replace the current constraint with the
+   *  constraint generated by `op`.
+   */
+  private def tryAlso(preConstraint: Constraint, op: => Boolean): true =
+    if constraint ne preConstraint then
+      // check whether `op2` generates a weaker constraint than `op1`
+      val leftConstraint = constraint
+      constraint = preConstraint
+      if !(op && subsumes(leftConstraint, constraint, preConstraint)) then
+        if constr != noPrinter && !subsumes(constraint, leftConstraint, preConstraint) then
+          constr.println(i"CUT - prefer $leftConstraint over $constraint")
+        constraint = leftConstraint
+    true
+
+  /** Returns true iff the result of evaluating either `op1` or `op2` is true, keeping the smaller constraint if any.
+   *  E.g., if
+   *
+   *    tp11 <:< tp12 = true   with constraint c1 and GADT constraint g1
+   *    tp12 <:< tp22 = true   with constraint c2 and GADT constraint g2
+   *
+   *  We keep:
+   *    - (c1, g1) if c2 subsumes c1 and g2 subsumes g1
+   *    - (c2, g2) if c1 subsumes c2 and g1 subsumes g2
+   *    - neither constraint pair otherwise.
+   *
+   *  Like [[sufficientEither]], this method is used to approximate a solution in one of the following cases:
+   *
+   *     T1 & T2 <:< T3
+   *     T1 <:< T2 | T3
+   *
+   *  But this method is used when `useNecessaryEither` is true, like when we are attempting
+   *  to infer GADT constraints that necessarily follow from the subtyping relationship. For instance, if we have
+   *
+   *     enum Expr[T] {
+   *       case IntExpr(i: Int) extends Expr[Int]
+   *       case StrExpr(s: String) extends Expr[String]
+   *     }
+   *
+   *  and `A` is an abstract type and we know that
+   *
+   *     Expr[A] <: IntExpr | StrExpr
+   *
+   *  (the case with &-type is analogous) then this may follow either from
+   *
+   *     Expr[A] <: IntExpr    or    Expr[A] <: StrExpr
+   *
+   *  Since we don't know which branch is true, we need to give up and not keep either constraint. OTOH, if one
+   *  constraint pair is subsumed by the other, we know that it is necessary for both cases and therefore we can
+   *  keep it.
+   *
+   *  Like [[sufficientEither]], this method is not complete because sometimes, the necessary constraint
+   *  is neither of the pairs. For instance, if
+   *
+   *     g1 = { A = Int, B = String }
+   *     g2 = { A = Int, B = Int }
+   *
+   *  then the necessary constraint is { A = Int }, but correctly inferring that is, as far as we know, too expensive.
+   *
+   *  This method is also used in ConstrainResult mode
+   *  to avoid inference getting stuck due to lack of backtracking,
+   *  see or-inf.scala and and-inf.scala for examples.
+   *
+   *  Method name comes from the notion that we are keeping the constraint which is necessary to satisfy both
+   *  subtyping relationships.
+   */
+  private def necessaryEither(op1: => Boolean, op2: => Boolean): Boolean =
+    val preConstraint = constraint
+    val preGadt = ctx.gadt.fresh
+
+    def allSubsumes(leftGadt: GadtConstraint, rightGadt: GadtConstraint, left: Constraint, right: Constraint): Boolean =
+      subsumes(left, right, preConstraint) && preGadt.subsumes(leftGadt, rightGadt, preGadt)
+
+    if op1 then
+      val op1Constraint = constraint
+      val op1Gadt = ctx.gadt.fresh
+      constraint = preConstraint
+      ctx.gadt.restore(preGadt)
+      if op2 then
+        if allSubsumes(op1Gadt, ctx.gadt, op1Constraint, constraint) then
+          gadts.println(i"GADT CUT - prefer ${ctx.gadt} over $op1Gadt")
+          constr.println(i"CUT - prefer $constraint over $op1Constraint")
+        else if allSubsumes(ctx.gadt, op1Gadt, constraint, op1Constraint) then
+          gadts.println(i"GADT CUT - prefer $op1Gadt over ${ctx.gadt}")
+          constr.println(i"CUT - prefer $op1Constraint over $constraint")
+          constraint = op1Constraint
+          ctx.gadt.restore(op1Gadt)
+        else
+          gadts.println(i"GADT CUT - no constraint is preferable, reverting to $preGadt")
+          constr.println(i"CUT - no constraint is preferable, reverting to $preConstraint")
+          constraint = preConstraint
+          ctx.gadt.restore(preGadt)
+      else
+        constraint = op1Constraint
+        ctx.gadt.restore(op1Gadt)
+      true
+    else op2
+  end necessaryEither
+
+  /** Decompose into conjunction of types each of which has only a single refinement */
+  def decomposeRefinements(tp: Type, refines: List[(Name, Type)]): Type = tp match
+    case RefinedType(parent, rname, rinfo) =>
+      decomposeRefinements(parent, (rname, rinfo) :: refines)
+    case AndType(tp1, tp2) =>
+      AndType(decomposeRefinements(tp1, refines), decomposeRefinements(tp2, refines))
+    case _ =>
+      refines.map(RefinedType(tp, _, _): Type).reduce(AndType(_, _))
+
+  /** Can comparing this type on the left lead to an either? This is the case if
+   *  the type is and AndType or contains embedded occurrences of AndTypes
+   */
+  def containsAnd(tp: Type): Boolean = tp match
+    case tp: AndType => true
+    case OrType(tp1, tp2) => containsAnd(tp1) || containsAnd(tp2)
+    case tp: TypeParamRef => containsAnd(bounds(tp).hi)
+    case tp: TypeRef => containsAnd(tp.info.hiBound) || tp.symbol.onGadtBounds(gbounds => containsAnd(gbounds.hi))
+    case tp: TypeProxy => containsAnd(tp.superType)
+    case _ => false
+
+  /** Does type `tp1` have a member with name `name` whose normalized type is a subtype of
+   *  the normalized type of the refinement of `tp2`?
+   *  Normalization is as follows: If `tp2` contains a skolem to its refinement type,
+   *  rebase both itself and the member info of `tp` on a freshly created skolem type.
+   */
+  def hasMatchingMember(name: Name, tp1: Type, tp2: RefinedType): Boolean =
+    trace(i"hasMatchingMember($tp1 . $name :? ${tp2.refinedInfo}), mbr: ${tp1.member(name).info}", subtyping) {
+
+      // If the member is an abstract type and the prefix is a path, compare the member itself
+      // instead of its bounds. This case is needed situations like:
+      //
+      //    class C { type T }
+      //    val foo: C
+      //    foo.type <: C { type T {= , <: , >:} foo.T }
+      //
+      // or like:
+      //
+      //    class C[T]
+      //    C[?] <: C[TV]
+      //
+      // where TV is a type variable. See i2397.scala for an example of the latter.
+      def matchAbstractTypeMember(info1: Type): Boolean = info1 match {
+        case TypeBounds(lo, hi) if lo ne hi =>
+          tp2.refinedInfo match {
+            case rinfo2: TypeBounds if tp1.isStable =>
+              val ref1 = tp1.widenExpr.select(name)
+              isSubType(rinfo2.lo, ref1) && isSubType(ref1, rinfo2.hi)
+            case _ =>
+              false
+          }
+        case _ => false
+      }
+
+      // An additional check for type member matching: If the refinement of the
+      // supertype `tp2` does not refer to a member symbol defined in the parent of `tp2`.
+      // then the symbol referred to in the subtype must have a signature that coincides
+      // in its parameters with the refinement's signature. The reason for the check
+      // is that if the refinement does not refer to a member symbol, we will have to
+      // resort to reflection to invoke the member. And Java reflection needs to know exact
+      // erased parameter types. See neg/i12211.scala. Other reflection algorithms could
+      // conceivably dispatch without knowning precise parameter signatures. One can signal
+      // this by inheriting from the `scala.reflect.SignatureCanBeImprecise` marker trait,
+      // in which case the signature test is elided.
+      def sigsOK(symInfo: Type, info2: Type) =
+        tp2.underlyingClassRef(refinementOK = true).member(name).exists
+        || tp2.derivesFrom(defn.WithoutPreciseParameterTypesClass)
+        || symInfo.isInstanceOf[MethodType]
+            && symInfo.signature.consistentParams(info2.signature)
+
+      def tp1IsSingleton: Boolean = tp1.isInstanceOf[SingletonType]
+
+      // A relaxed version of isSubType, which compares method types
+      // under the standard arrow rule which is contravarient in the parameter types,
+      // but under the condition that signatures might have to match (see sigsOK)
+      // This relaxed version is needed to correctly compare dependent function types.
+      // See pos/i12211.scala.
+      def isSubInfo(info1: Type, info2: Type, symInfo: Type): Boolean =
+        info2 match
+          case info2: MethodType =>
+            info1 match
+              case info1: MethodType =>
+                val symInfo1 = symInfo.stripPoly
+                matchingMethodParams(info1, info2, precise = false)
+                && isSubInfo(info1.resultType, info2.resultType.subst(info2, info1), symInfo1.resultType)
+                && sigsOK(symInfo1, info2)
+              case _ => inFrozenGadtIf(tp1IsSingleton) { isSubType(info1, info2) }
+          case _ => inFrozenGadtIf(tp1IsSingleton) { isSubType(info1, info2) }
+
+      def qualifies(m: SingleDenotation): Boolean =
+        val info1 = m.info.widenExpr
+        isSubInfo(info1, tp2.refinedInfo.widenExpr, m.symbol.info.orElse(info1))
+        || matchAbstractTypeMember(m.info)
+        || (tp1.isStable && isSubType(TermRef(tp1, m.symbol), tp2.refinedInfo))
+
+      tp1.member(name) match // inlined hasAltWith for performance
+        case mbr: SingleDenotation => qualifies(mbr)
+        case mbr => mbr hasAltWith qualifies
+    }
+
+  final def ensureStableSingleton(tp: Type): SingletonType = tp.stripTypeVar match {
+    case tp: SingletonType if tp.isStable => tp
+    case tp: ValueType => SkolemType(tp)
+    case tp: TypeProxy => ensureStableSingleton(tp.superType)
+    case tp => assert(ctx.reporter.errorsReported); SkolemType(tp)
+  }
+
+  /** Skip refinements in `tp2` which match corresponding refinements in `tp1`.
+   *  "Match" means:
+   *   - they appear in the same order,
+   *   - they refine the same names,
+   *   - the refinement in `tp1` is an alias type, and
+   *   - neither refinement refers back to the refined type via a refined this.
+   *  @return  The parent type of `tp2` after skipping the matching refinements.
+   */
+  private def skipMatching(tp1: Type, tp2: RefinedType): Type = tp1 match {
+    case tp1 @ RefinedType(parent1, name1, rinfo1: TypeAlias) if name1 == tp2.refinedName =>
+      tp2.parent match {
+        case parent2: RefinedType => skipMatching(parent1, parent2)
+        case parent2 => parent2
+      }
+    case _ => tp2
+  }
+
+  /** Are refinements in `tp1` pairwise subtypes of the refinements of `tp2`
+   *  up to parent type `limit`?
+   *  @pre `tp1` has the necessary number of refinements, they are type aliases,
+   *       and their names match the corresponding refinements in `tp2`.
+   *       Further, no refinement refers back to the refined type via a refined this.
+   *  The precondition is established by `skipMatching`.
+   */
+  private def isSubRefinements(tp1: RefinedType, tp2: RefinedType, limit: Type): Boolean =
+    isSubType(tp1.refinedInfo, tp2.refinedInfo)
+    && ((tp2.parent eq limit)
+       || isSubRefinements(
+            tp1.parent.asInstanceOf[RefinedType],
+            tp2.parent.asInstanceOf[RefinedType], limit))
+
+  /** A type has been covered previously in subtype checking if it
+   *  is some combination of TypeRefs that point to classes, where the
+   *  combiners are AppliedTypes, RefinedTypes, RecTypes, And/Or-Types or AnnotatedTypes.
+   */
+  private def isCovered(tp: Type): Boolean = tp.dealiasKeepRefiningAnnots.stripTypeVar match {
+    case tp: TypeRef => tp.symbol.isClass && tp.symbol != NothingClass && tp.symbol != NullClass
+    case tp: AppliedType => isCovered(tp.tycon)
+    case tp: RefinedOrRecType => isCovered(tp.parent)
+    case tp: AndType => isCovered(tp.tp1) && isCovered(tp.tp2)
+    case tp: OrType  => isCovered(tp.tp1) && isCovered(tp.tp2)
+    case _ => false
+  }
+
+  /** Defer constraining type variables when compared against prototypes */
+  def isMatchedByProto(proto: ProtoType, tp: Type): Boolean = tp.stripTypeVar match {
+    case tp: TypeParamRef if constraint contains tp => true
+    case _ => proto.isMatchedBy(tp, keepConstraint = true)
+  }
+
+  /** Narrow gadt.bounds for the type parameter referenced by `tr` to include
+   *  `bound` as an upper or lower bound (which depends on `isUpper`).
+   *  Test that the resulting bounds are still satisfiable.
+   */
+  private def narrowGADTBounds(tr: NamedType, bound: Type, approx: ApproxState, isUpper: Boolean): Boolean = {
+    val boundImprecise = approx.high || approx.low
+    ctx.mode.is(Mode.GadtConstraintInference) && !frozenGadt && !frozenConstraint && !boundImprecise && {
+      val tparam = tr.symbol
+      gadts.println(i"narrow gadt bound of $tparam: ${tparam.info} from ${if (isUpper) "above" else "below"} to $bound ${bound.toString} ${bound.isRef(tparam)}")
+      if (bound.isRef(tparam)) false
+      else
+        val savedGadt = ctx.gadt.fresh
+        val success = gadtAddBound(tparam, bound, isUpper)
+        if !success then ctx.gadt.restore(savedGadt)
+        success
+    }
+  }
+
+  // Tests around `matches`
+
+  /** A function implementing `tp1` matches `tp2`. */
+  final def matchesType(tp1: Type, tp2: Type, relaxed: Boolean): Boolean = tp1.widen match {
+    case tp1: MethodType =>
+      tp2.widen match {
+        case tp2: MethodType =>
+          // implicitness is ignored when matching
+          matchingMethodParams(tp1, tp2) &&
+          matchesType(tp1.resultType, tp2.resultType.subst(tp2, tp1), relaxed)
+        case tp2 =>
+          relaxed && tp1.paramNames.isEmpty &&
+            matchesType(tp1.resultType, tp2, relaxed)
+      }
+    case tp1: PolyType =>
+      tp2.widen match {
+        case tp2: PolyType =>
+          tp1.paramNames.hasSameLengthAs(tp2.paramNames) &&
+          matchesType(tp1.resultType, tp2.resultType.subst(tp2, tp1), relaxed)
+        case _ =>
+          false
+      }
+    case _ =>
+      tp2.widen match {
+        case _: PolyType =>
+          false
+        case tp2: MethodType =>
+          relaxed && tp2.paramNames.isEmpty &&
+            matchesType(tp1, tp2.resultType, relaxed)
+        case tp2 =>
+          relaxed || isSameType(tp1, tp2)
+      }
+  }
+
+  /** Do the parameter types of `tp1` and `tp2` match in a way that allows `tp1`
+   *  to override `tp2` ? Two modes: precise or not.
+   *  If `precise` is set (which is the default) this is the case if they're pairwise `=:=`.
+   *  Otherwise parameters in `tp2` must be subtypes of corresponding parameters in `tp1`.
+   */
+  def matchingMethodParams(tp1: MethodType, tp2: MethodType, precise: Boolean = true): Boolean = {
+    def loop(formals1: List[Type], formals2: List[Type]): Boolean = formals1 match {
+      case formal1 :: rest1 =>
+        formals2 match {
+          case formal2 :: rest2 =>
+            val formal2a = if (tp2.isParamDependent) formal2.subst(tp2, tp1) else formal2
+            val paramsMatch =
+              if precise then
+                isSameTypeWhenFrozen(formal1, formal2a)
+              else if ctx.phase == Phases.checkCapturesPhase then
+                // allow to constrain capture set variables
+                isSubType(formal2a, formal1)
+              else
+                isSubTypeWhenFrozen(formal2a, formal1)
+            paramsMatch && loop(rest1, rest2)
+          case nil =>
+            false
+        }
+      case nil =>
+        formals2.isEmpty
+    }
+    loop(tp1.paramInfos, tp2.paramInfos)
+  }
+
+  /** Do the parameter types of `tp1` and `tp2` match in a way that allows `tp1`
+   *  to override `tp2` ? This is the case if they're pairwise >:>.
+   */
+  def matchingPolyParams(tp1: PolyType, tp2: PolyType): Boolean = {
+    def loop(formals1: List[Type], formals2: List[Type]): Boolean = formals1 match {
+      case formal1 :: rest1 =>
+        formals2 match {
+          case formal2 :: rest2 =>
+            val formal2a = formal2.subst(tp2, tp1)
+            isSubTypeWhenFrozen(formal2a, formal1) &&
+            loop(rest1, rest2)
+          case nil =>
+            false
+        }
+      case nil =>
+        formals2.isEmpty
+    }
+    loop(tp1.paramInfos, tp2.paramInfos)
+  }
+
+  // Type equality =:=
+
+  /** Two types are the same if they are mutual subtypes of each other.
+   *  To avoid exponential blowup for deeply nested invariant applied types,
+   *  we cache successes once the stack of outstanding isSameTypes reaches
+   *  depth `startSameTypeTrackingLevel`. See pos/i15525.scala, where this matters.
+   */
+  def isSameType(tp1: Type, tp2: Type): Boolean =
+    if tp1 eq NoType then false
+    else if tp1 eq tp2 then true
+    else if sames != null && (sames.nn.lookup(tp1) eq tp2) then true
+    else
+      val savedSames = sames
+      sameLevel += 1
+      if sameLevel >= startSameTypeTrackingLevel then
+        Stats.record("cache same type")
+        sames = new util.EqHashMap()
+      val res =
+        try isSubType(tp1, tp2) && isSubType(tp2, tp1)
+        finally
+          sameLevel -= 1
+          sames = savedSames
+      if res && sames != null then sames.nn(tp2) = tp1
+      res
+
+  override protected def isSame(tp1: Type, tp2: Type)(using Context): Boolean = isSameType(tp1, tp2)
+
+  /** Same as `isSameType` but also can be applied to overloaded TermRefs, where
+   *  two overloaded refs are the same if they have pairwise equal alternatives
+   */
+  def isSameRef(tp1: Type, tp2: Type): Boolean = trace(s"isSameRef($tp1, $tp2") {
+    def isSubRef(tp1: Type, tp2: Type): Boolean = tp1 match {
+      case tp1: TermRef if tp1.isOverloaded =>
+        tp1.alternatives forall (isSubRef(_, tp2))
+      case _ =>
+        tp2 match {
+          case tp2: TermRef if tp2.isOverloaded =>
+            tp2.alternatives exists (isSubRef(tp1, _))
+          case _ =>
+            isSubType(tp1, tp2)
+        }
+    }
+    isSubRef(tp1, tp2) && isSubRef(tp2, tp1)
+  }
+
+  /** If the range `tp1..tp2` consist of a single type, that type, otherwise NoType`.
+   *  This is the case if `tp1 =:= tp2`, but also if `tp1 <:< tp2`, `tp1` is a singleton type,
+   *  and `tp2` derives from `scala.Singleton` (or vice-versa). Examples of the latter case:
+   *
+   *     "name".type .. Singleton
+   *     "name".type .. String & Singleton
+   *     Singleton .. "name".type
+   *     String & Singleton .. "name".type
+   *
+   *  All consist of the single type `"name".type`.
+   */
+  def singletonInterval(tp1: Type, tp2: Type): Type = {
+    def isSingletonBounds(lo: Type, hi: Type) =
+      lo.isSingleton && hi.derivesFrom(defn.SingletonClass) && isSubTypeWhenFrozen(lo, hi)
+    if (isSameTypeWhenFrozen(tp1, tp2)) tp1
+    else if (isSingletonBounds(tp1, tp2)) tp1
+    else if (isSingletonBounds(tp2, tp1)) tp2
+    else NoType
+  }
+
+  /** The greatest lower bound of two types */
+  def glb(tp1: Type, tp2: Type): Type = /*>|>*/ trace(s"glb(${tp1.show}, ${tp2.show})", subtyping, show = true) /*<|<*/ {
+    if (tp1 eq tp2) tp1
+    else if !tp1.exists || (tp1 eq WildcardType) then tp2
+    else if !tp2.exists || (tp2 eq WildcardType) then tp1
+    else if tp1.isAny && !tp2.isLambdaSub || tp1.isAnyKind || isBottom(tp2) then tp2
+    else if tp2.isAny && !tp1.isLambdaSub || tp2.isAnyKind || isBottom(tp1) then tp1
+    else tp2 match
+      case tp2: LazyRef =>
+        glb(tp1, tp2.ref)
+      case _ =>
+        tp1 match
+          case tp1: LazyRef =>
+            glb(tp1.ref, tp2)
+          case _ =>
+            val tp1a = dropIfSuper(tp1, tp2)
+            if tp1a ne tp1 then glb(tp1a, tp2)
+            else
+              val tp2a = dropIfSuper(tp2, tp1)
+              if tp2a ne tp2 then glb(tp1, tp2a)
+              else tp2 match // normalize to disjunctive normal form if possible.
+                case tp2 @ OrType(tp21, tp22) =>
+                  lub(tp1 & tp21, tp1 & tp22, isSoft = tp2.isSoft)
+                case _ =>
+                  tp1 match
+                    case tp1 @ OrType(tp11, tp12) =>
+                      lub(tp11 & tp2, tp12 & tp2, isSoft = tp1.isSoft)
+                    case tp1: ConstantType =>
+                      tp2 match
+                        case tp2: ConstantType =>
+                          // Make use of the fact that the intersection of two constant types
+                          // types which are not subtypes of each other is known to be empty.
+                          // Note: The same does not apply to singleton types in general.
+                          // E.g. we could have a pattern match against `x.type & y.type`
+                          // which might succeed if `x` and `y` happen to be the same ref
+                          // at run time. It would not work to replace that with `Nothing`.
+                          // However, maybe we can still apply the replacement to
+                          // types which are not explicitly written.
+                          NothingType
+                        case _ => andType(tp1, tp2)
+                    case _ => andType(tp1, tp2)
+  }
+
+  def widenInUnions(using Context): Boolean =
+    migrateTo3 || ctx.erasedTypes
+
+  /** The least upper bound of two types
+   *  @param canConstrain  If true, new constraints might be added to simplify the lub.
+   *  @param isSoft        If the lub is a union, this determines whether it's a soft union.
+   *  @note  We do not admit singleton types in or-types as lubs.
+   */
+  def lub(tp1: Type, tp2: Type, canConstrain: Boolean = false, isSoft: Boolean = true): Type = /*>|>*/ trace(s"lub(${tp1.show}, ${tp2.show}, canConstrain=$canConstrain, isSoft=$isSoft)", subtyping, show = true) /*<|<*/ {
+    if (tp1 eq tp2) tp1
+    else if !tp1.exists || (tp2 eq WildcardType) then tp1
+    else if !tp2.exists || (tp1 eq WildcardType) then tp2
+    else if tp1.isAny && !tp2.isLambdaSub || tp1.isAnyKind || isBottom(tp2) then tp1
+    else if tp2.isAny && !tp1.isLambdaSub || tp2.isAnyKind || isBottom(tp1) then tp2
+    else
+      def mergedLub(tp1: Type, tp2: Type): Type = {
+        tp1.atoms match
+          case Atoms.Range(lo1, hi1) if !widenInUnions =>
+            tp2.atoms match
+              case Atoms.Range(lo2, hi2) =>
+                if hi1.subsetOf(lo2) then return tp2
+                if hi2.subsetOf(lo1) then return tp1
+                if (hi1 & hi2).isEmpty then return orType(tp1, tp2)
+              case none =>
+          case none =>
+        val t1 = mergeIfSuper(tp1, tp2, canConstrain)
+        if (t1.exists) return t1
+
+        val t2 = mergeIfSuper(tp2, tp1, canConstrain)
+        if (t2.exists) return t2
+
+        def widen(tp: Type) = if (widenInUnions) tp.widen else tp.widenIfUnstable
+        val tp1w = widen(tp1)
+        val tp2w = widen(tp2)
+        if ((tp1 ne tp1w) || (tp2 ne tp2w)) lub(tp1w, tp2w, canConstrain = canConstrain, isSoft = isSoft)
+        else orType(tp1w, tp2w, isSoft = isSoft) // no need to check subtypes again
+      }
+      mergedLub(tp1.stripLazyRef, tp2.stripLazyRef)
+  }
+
+  /** Try to produce joint arguments for a lub `A[T_1, ..., T_n] | A[T_1', ..., T_n']` using
+   *  the following strategies:
+   *
+   *    - if arguments are the same, that argument.
+   *    - if corresponding parameter variance is co/contra-variant, the lub/glb.
+   *    - otherwise a TypeBounds containing both arguments
+   */
+  def lubArgs(args1: List[Type], args2: List[Type], tparams: List[TypeParamInfo], canConstrain: Boolean = false): List[Type] =
+    tparams match {
+      case tparam :: tparamsRest =>
+        val arg1 :: args1Rest = args1: @unchecked
+        val arg2 :: args2Rest = args2: @unchecked
+        val common = singletonInterval(arg1, arg2)
+        val v = tparam.paramVarianceSign
+        val lubArg =
+          if (common.exists) common
+          else if (v > 0) lub(arg1.hiBound, arg2.hiBound, canConstrain)
+          else if (v < 0) glb(arg1.loBound, arg2.loBound)
+          else TypeBounds(glb(arg1.loBound, arg2.loBound),
+                          lub(arg1.hiBound, arg2.hiBound, canConstrain))
+        lubArg :: lubArgs(args1Rest, args2Rest, tparamsRest, canConstrain)
+      case nil =>
+        Nil
+    }
+
+  /** Try to produce joint arguments for a glb `A[T_1, ..., T_n] & A[T_1', ..., T_n']` using
+   *  the following strategies:
+   *
+   *    - if arguments are the same, that argument.
+   *    - if corresponding parameter variance is co/contra-variant, the glb/lub.
+   *    - if at least one of the arguments if a TypeBounds, the union of
+   *      the bounds.
+   *    - if homogenizeArgs is set, and arguments can be unified by instantiating
+   *      type parameters, the unified argument.
+   *    - otherwise NoType
+   *
+   *  The unification rule is contentious because it cuts the constraint set.
+   *  Therefore it is subject to Config option `alignArgsInAnd`.
+   */
+  def glbArgs(args1: List[Type], args2: List[Type], tparams: List[TypeParamInfo]): List[Type] =
+    tparams match {
+      case tparam :: tparamsRest =>
+        val arg1 :: args1Rest = args1: @unchecked
+        val arg2 :: args2Rest = args2: @unchecked
+        val common = singletonInterval(arg1, arg2)
+        val v = tparam.paramVarianceSign
+        val glbArg =
+          if (common.exists) common
+          else if (v > 0) glb(arg1.hiBound, arg2.hiBound)
+          else if (v < 0) lub(arg1.loBound, arg2.loBound)
+          else if (isBounds(arg1) || isBounds(arg2))
+            TypeBounds(lub(arg1.loBound, arg2.loBound),
+                       glb(arg1.hiBound, arg2.hiBound))
+          else if (homogenizeArgs && !frozenConstraint && isSameType(arg1, arg2)) arg1
+          else NoType
+        glbArg :: glbArgs(args1Rest, args2Rest, tparamsRest)
+      case nil =>
+        Nil
+    }
+
+  private def recombineAnd(tp: AndType, tp1: Type, tp2: Type) =
+    if (!tp1.exists) tp2
+    else if (!tp2.exists) tp1
+    else tp.derivedAndType(tp1, tp2)
+
+  /** If some (&-operand of) `tp` is a supertype of `sub` replace it with `NoType`.
+   */
+  private def dropIfSuper(tp: Type, sub: Type): Type =
+    if (isSubTypeWhenFrozen(sub, tp)) NoType
+    else tp match {
+      case tp @ AndType(tp1, tp2) =>
+        recombineAnd(tp, dropIfSuper(tp1, sub), dropIfSuper(tp2, sub))
+      case _ =>
+        tp
+    }
+
+  /** Merge `t1` into `tp2` if t1 is a subtype of some &-summand of tp2.
+   */
+  private def mergeIfSub(tp1: Type, tp2: Type): Type =
+    if (isSubTypeWhenFrozen(tp1, tp2)) tp1
+    else tp2 match {
+      case tp2 @ AndType(tp21, tp22) =>
+        val lower1 = mergeIfSub(tp1, tp21)
+        if (lower1 eq tp21) tp2
+        else if (lower1.exists) lower1 & tp22
+        else {
+          val lower2 = mergeIfSub(tp1, tp22)
+          if (lower2 eq tp22) tp2
+          else if (lower2.exists) tp21 & lower2
+          else NoType
+        }
+      case _ =>
+        NoType
+    }
+
+  /** Merge `tp1` into `tp2` if tp1 is a supertype of some |-summand of tp2.
+   *  @param canConstrain  If true, new constraints might be added to make the merge possible.
+   */
+  private def mergeIfSuper(tp1: Type, tp2: Type, canConstrain: Boolean): Type =
+    if (isSubType(tp2, tp1, whenFrozen = !canConstrain)) tp1
+    else tp2 match {
+      case tp2 @ OrType(tp21, tp22) =>
+        val higher1 = mergeIfSuper(tp1, tp21, canConstrain)
+        if (higher1 eq tp21) tp2
+        else if (higher1.exists) lub(higher1, tp22, isSoft = tp2.isSoft)
+        else {
+          val higher2 = mergeIfSuper(tp1, tp22, canConstrain)
+          if (higher2 eq tp22) tp2
+          else if (higher2.exists) lub(tp21, higher2, isSoft = tp2.isSoft)
+          else NoType
+        }
+      case _ =>
+        NoType
+    }
+
+  private def andTypeGen(tp1: Type, tp2: Type, op: (Type, Type) -> Type,
+      original: (Type, Type) -> Type = _ & _, isErased: Boolean = ctx.erasedTypes): Type = trace(s"andTypeGen(${tp1.show}, ${tp2.show})", subtyping, show = true) {
+    val t1 = distributeAnd(tp1, tp2)
+    if (t1.exists) t1
+    else {
+      val t2 = distributeAnd(tp2, tp1)
+      if (t2.exists) t2
+      else if (isErased) erasedGlb(tp1, tp2)
+      else liftIfHK(tp1, tp2, op, original, _ | _)
+        // The ` | ` on variances is needed since variances are associated with bounds
+        // not lambdas. Example:
+        //
+        //    trait A { def F[-X] }
+        //    trait B { def F[+X] }
+        //    object O extends A, B { ... }
+        //
+        // Here, `F` is treated as bivariant in `O`. That is, only bivariant implementation
+        // of `F` are allowed. See neg/hk-variance2s.scala test.
+    }
+  }
+
+  /** Form a normalized conjunction of two types.
+   *  Note: For certain types, `&` is distributed inside the type. This holds for
+   *  all types which are not value types (e.g. TypeBounds, ClassInfo,
+   *  ExprType, LambdaType). Also, when forming an `&`,
+   *  instantiated TypeVars are dereferenced and annotations are stripped.
+   *  Finally, refined types with the same refined name are
+   *  opportunistically merged.
+   */
+  final def andType(tp1: Type, tp2: Type, isErased: Boolean = ctx.erasedTypes): Type =
+    andTypeGen(tp1, tp2, AndType.balanced(_, _), isErased = isErased)
+
+  final def simplifyAndTypeWithFallback(tp1: Type, tp2: Type, fallback: Type): Type =
+    andTypeGen(tp1, tp2, (_, _) => fallback)
+
+  /** Form a normalized conjunction of two types.
+   *  Note: For certain types, `|` is distributed inside the type. This holds for
+   *  all types which are not value types (e.g. TypeBounds, ClassInfo,
+   *  ExprType, LambdaType). Also, when forming an `|`,
+   *  instantiated TypeVars are dereferenced and annotations are stripped.
+   *
+   *  @param isSoft   If the result is a union, this determines whether it's a soft union.
+   *  @param isErased Apply erasure semantics. If erased is true, instead of creating
+   *                  an OrType, the lub will be computed using TypeCreator#erasedLub.
+   */
+  final def orType(tp1: Type, tp2: Type, isSoft: Boolean = true, isErased: Boolean = ctx.erasedTypes): Type = {
+    val t1 = distributeOr(tp1, tp2, isSoft)
+    if (t1.exists) t1
+    else {
+      val t2 = distributeOr(tp2, tp1, isSoft)
+      if (t2.exists) t2
+      else if (isErased) erasedLub(tp1, tp2)
+      else liftIfHK(tp1, tp2, OrType.balanced(_, _, soft = isSoft), _ | _, _ & _)
+    }
+  }
+
+  /** `op(tp1, tp2)` unless `tp1` and `tp2` are type-constructors.
+   *  In the latter case, combine `tp1` and `tp2` under a type lambda like this:
+   *
+   *    [X1, ..., Xn] -> op(tp1[X1, ..., Xn], tp2[X1, ..., Xn])
+   */
+  def liftIfHK(tp1: Type, tp2: Type,
+      op: (Type, Type) -> Type, original: (Type, Type) -> Type, combineVariance: (Variance, Variance) -> Variance) = {
+    val tparams1 = tp1.typeParams
+    val tparams2 = tp2.typeParams
+    def applied(tp: Type) = tp.appliedTo(tp.typeParams.map(_.paramInfoAsSeenFrom(tp)))
+    if (tparams1.isEmpty)
+      if (tparams2.isEmpty) op(tp1, tp2)
+      else original(tp1, applied(tp2))
+    else if (tparams2.isEmpty)
+      original(applied(tp1), tp2)
+    else if (tparams1.hasSameLengthAs(tparams2))
+      HKTypeLambda(
+        paramNames = HKTypeLambda.syntheticParamNames(tparams1.length),
+        variances =
+          if tp1.isDeclaredVarianceLambda && tp2.isDeclaredVarianceLambda then
+            tparams1.lazyZip(tparams2).map((p1, p2) => combineVariance(p1.paramVariance, p2.paramVariance))
+          else Nil
+      )(
+        paramInfosExp = tl => tparams1.lazyZip(tparams2).map((tparam1, tparam2) =>
+          tl.integrate(tparams1, tparam1.paramInfoAsSeenFrom(tp1)).bounds &
+          tl.integrate(tparams2, tparam2.paramInfoAsSeenFrom(tp2)).bounds),
+        resultTypeExp = tl =>
+          original(tp1.appliedTo(tl.paramRefs), tp2.appliedTo(tl.paramRefs)))
+    else original(applied(tp1), applied(tp2))
+  }
+
+  /** Try to distribute `&` inside type, detect and handle conflicts
+   *  @pre !(tp1 <: tp2) && !(tp2 <:< tp1) -- these cases were handled before
+   */
+  private def distributeAnd(tp1: Type, tp2: Type): Type = tp1 match {
+    case tp1 @ AppliedType(tycon1, args1) =>
+      tp2 match {
+        case AppliedType(tycon2, args2)
+        if tycon1.typeSymbol == tycon2.typeSymbol && tycon1 =:= tycon2 =>
+          val jointArgs = glbArgs(args1, args2, tycon1.typeParams)
+          if (jointArgs.forall(_.exists)) (tycon1 & tycon2).appliedTo(jointArgs)
+          else NoType
+        case _ =>
+          NoType
+      }
+    case tp1: RefinedType =>
+      // opportunistically merge same-named refinements
+      // this does not change anything semantically (i.e. merging or not merging
+      // gives =:= types), but it keeps the type smaller.
+      tp2 match {
+        case tp2: RefinedType if tp1.refinedName == tp2.refinedName =>
+          val jointInfo = Denotations.infoMeet(tp1.refinedInfo, tp2.refinedInfo, safeIntersection = false)
+          if jointInfo.exists then
+            tp1.derivedRefinedType(tp1.parent & tp2.parent, tp1.refinedName, jointInfo)
+          else
+            NoType
+        case _ =>
+          NoType
+      }
+    case tp1: RecType =>
+      tp1.rebind(distributeAnd(tp1.parent, tp2))
+    case ExprType(rt1) =>
+      tp2 match {
+        case ExprType(rt2) =>
+          ExprType(rt1 & rt2)
+        case _ =>
+          NoType
+      }
+    case tp1: TypeVar if tp1.isInstantiated =>
+      tp1.underlying & tp2
+    case CapturingType(parent1, refs1) =>
+      if subCaptures(tp2.captureSet, refs1, frozen = true).isOK
+        && tp1.isBoxedCapturing == tp2.isBoxedCapturing
+      then
+        parent1 & tp2
+      else
+        tp1.derivedCapturingType(parent1 & tp2, refs1)
+    case tp1: AnnotatedType if !tp1.isRefining =>
+      tp1.underlying & tp2
+    case _ =>
+      NoType
+  }
+
+  /** Try to distribute `|` inside type, detect and handle conflicts
+   *  Note that, unlike for `&`, a disjunction cannot be pushed into
+   *  a refined or applied type. Example:
+   *
+   *     List[T] | List[U] is not the same as List[T | U].
+   *
+   *  The rhs is a proper supertype of the lhs.
+   */
+  private def distributeOr(tp1: Type, tp2: Type, isSoft: Boolean = true): Type = tp1 match {
+    case ExprType(rt1) =>
+      tp2 match {
+        case ExprType(rt2) =>
+          ExprType(lub(rt1, rt2, isSoft = isSoft))
+        case _ =>
+          NoType
+      }
+    case tp1: TypeVar if tp1.isInstantiated =>
+      lub(tp1.underlying, tp2, isSoft = isSoft)
+    case tp1: AnnotatedType if !tp1.isRefining =>
+      lub(tp1.underlying, tp2, isSoft = isSoft)
+    case _ =>
+      NoType
+  }
+
+  /** A comparison function to pick a winner in case of a merge conflict */
+  private def isAsGood(tp1: Type, tp2: Type): Boolean = tp1 match {
+    case tp1: ClassInfo =>
+      tp2 match {
+        case tp2: ClassInfo =>
+          isSubTypeWhenFrozen(tp1.prefix, tp2.prefix) || (tp1.cls.owner derivesFrom tp2.cls.owner)
+        case _ =>
+          false
+      }
+    case tp1: PolyType =>
+      tp2 match {
+        case tp2: PolyType =>
+          tp1.typeParams.length == tp2.typeParams.length &&
+          isAsGood(tp1.resultType, tp2.resultType.subst(tp2, tp1))
+        case _ =>
+          false
+      }
+    case tp1: MethodType =>
+      tp2 match {
+        case tp2: MethodType =>
+          def asGoodParams(formals1: List[Type], formals2: List[Type]) =
+            (formals2 corresponds formals1)(isSubTypeWhenFrozen)
+          asGoodParams(tp1.paramInfos, tp2.paramInfos) &&
+          (!asGoodParams(tp2.paramInfos, tp1.paramInfos) ||
+           isAsGood(tp1.resultType, tp2.resultType))
+        case _ =>
+          false
+      }
+    case _ =>
+      false
+  }
+
+  protected def subCaptures(refs1: CaptureSet, refs2: CaptureSet, frozen: Boolean)(using Context): CaptureSet.CompareResult =
+    refs1.subCaptures(refs2, frozen)
+
+  /** Is the boxing status of tp1 and tp2 the same, or alternatively, is
+   *  the capture sets `refs1` of `tp1` a subcapture of the empty set?
+   *  In the latter case, boxing status does not matter.
+   */
+  protected def sameBoxed(tp1: Type, tp2: Type, refs1: CaptureSet)(using Context): Boolean =
+    (tp1.isBoxedCapturing == tp2.isBoxedCapturing)
+    || refs1.subCaptures(CaptureSet.empty, frozenConstraint).isOK
+
+  // ----------- Diagnostics --------------------------------------------------
+
+  /** A hook for showing subtype traces. Overridden in ExplainingTypeComparer */
+  def traceIndented[T](str: String)(op: => T): T = op
+
+  private def traceInfo(tp1: Type, tp2: Type) =
+    s"${tp1.show} <:< ${tp2.show}" + {
+      if (ctx.settings.verbose.value || Config.verboseExplainSubtype)
+        s" ${tp1.getClass}, ${tp2.getClass}" +
+        (if (frozenConstraint) " frozen" else "") +
+        (if (ctx.mode is Mode.TypevarsMissContext) " tvars-miss-ctx" else "")
+      else ""
+    }
+
+  /** Show subtype goal that led to an assertion failure */
+  def showGoal(tp1: Type, tp2: Type)(using Context): Unit =
+    try
+      report.echo(i"assertion failure for ${show(tp1)} <:< ${show(tp2)}, frozen = $frozenConstraint")
+      def explainPoly(tp: Type) = tp match {
+        case tp: TypeParamRef => report.echo(s"TypeParamRef ${tp.show} found in ${tp.binder.show}")
+        case tp: TypeRef if tp.symbol.exists => report.echo(s"typeref ${tp.show} found in ${tp.symbol.owner.show}")
+        case tp: TypeVar => report.echo(s"typevar ${tp.show}, origin = ${tp.origin}")
+        case _ => report.echo(s"${tp.show} is a ${tp.getClass}")
+      }
+      if (Config.verboseExplainSubtype) {
+        explainPoly(tp1)
+        explainPoly(tp2)
+      }
+    catch case NonFatal(ex) =>
+      report.echo(s"assertion failure [[cannot display since $ex was thrown]]")
+
+  /** Record statistics about the total number of subtype checks
+   *  and the number of "successful" subtype checks, i.e. checks
+   *  that form part of a subtype derivation tree that's ultimately successful.
+   */
+  def recordStatistics(result: Boolean, prevSuccessCount: Int): Unit = {
+    // Stats.record(s"isSubType ${tp1.show} <:< ${tp2.show}")
+    totalCount += 1
+    if (result) successCount += 1 else successCount = prevSuccessCount
+    if (recCount == 0) {
+      Stats.record("successful subType", successCount)
+      Stats.record("total subType", totalCount)
+      successCount = 0
+      totalCount = 0
+    }
+  }
+
+  /** Does `tycon` have a field with type `tparam`? Special cased for `scala.*:`
+   *  as that type is artificially added to tuples. */
+  private def typeparamCorrespondsToField(tycon: Type, tparam: TypeParamInfo): Boolean =
+    productSelectorTypes(tycon, NoSourcePosition).exists {
+      case tp: TypeRef =>
+        tp.designator.eq(tparam) // Bingo!
+      case _ =>
+        false
+    } || tycon.derivesFrom(defn.PairClass)
+
+  /** Is `tp` an empty type?
+   *
+   *  `true` implies that we found a proof; uncertainty defaults to `false`.
+   */
+  def provablyEmpty(tp: Type): Boolean =
+    tp.dealias match {
+      case tp if tp.isExactlyNothing => true
+      case AndType(tp1, tp2) => provablyDisjoint(tp1, tp2)
+      case OrType(tp1, tp2) => provablyEmpty(tp1) && provablyEmpty(tp2)
+      case at @ AppliedType(tycon, args) =>
+        args.lazyZip(tycon.typeParams).exists { (arg, tparam) =>
+          tparam.paramVarianceSign >= 0
+          && provablyEmpty(arg)
+          && typeparamCorrespondsToField(tycon, tparam)
+        }
+      case tp: TypeProxy =>
+        provablyEmpty(tp.underlying)
+      case _ => false
+    }
+
+  /** Are `tp1` and `tp2` provablyDisjoint types?
+   *
+   *  `true` implies that we found a proof; uncertainty defaults to `false`.
+   *
+   *  Proofs rely on the following properties of Scala types:
+   *
+   *  1. Single inheritance of classes
+   *  2. Final classes cannot be extended
+   *  3. ConstantTypes with distinct values are non intersecting
+   *  4. TermRefs with distinct values are non intersecting
+   *  5. There is no value of type Nothing
+   *
+   *  Note on soundness: the correctness of match types relies on on the
+   *  property that in all possible contexts, the same match type expression
+   *  is either stuck or reduces to the same case.
+   */
+  def provablyDisjoint(tp1: Type, tp2: Type)(using Context): Boolean = trace(i"provable disjoint $tp1, $tp2", matchTypes) {
+    // println(s"provablyDisjoint(${tp1.show}, ${tp2.show})")
+
+    def isEnumValue(ref: TermRef): Boolean =
+      val sym = ref.termSymbol
+      sym.isAllOf(EnumCase, butNot=JavaDefined)
+
+    def isEnumValueOrModule(ref: TermRef): Boolean =
+      isEnumValue(ref) || ref.termSymbol.is(Module) || (ref.info match {
+        case tp: TermRef => isEnumValueOrModule(tp)
+        case _ => false
+      })
+
+    def fullyInstantiated(tp: Type): Boolean = new TypeAccumulator[Boolean] {
+      override def apply(x: Boolean, t: Type) =
+        x && {
+          t.dealias match {
+            case tp: TypeRef if !tp.symbol.isClass => false
+            case _: SkolemType | _: TypeVar | _: TypeParamRef => false
+            case _ => foldOver(x, t)
+          }
+        }
+    }.apply(true, tp)
+
+    (tp1.dealias, tp2.dealias) match {
+      case _ if !ctx.erasedTypes && tp2.isFromJavaObject =>
+        provablyDisjoint(tp1, defn.AnyType)
+      case _ if !ctx.erasedTypes && tp1.isFromJavaObject =>
+        provablyDisjoint(defn.AnyType, tp2)
+      case (tp1: TypeRef, _) if tp1.symbol == defn.SingletonClass =>
+        false
+      case (_, tp2: TypeRef) if tp2.symbol == defn.SingletonClass =>
+        false
+      case (tp1: ConstantType, tp2: ConstantType) =>
+        tp1 != tp2
+      case (tp1: TypeRef, tp2: TypeRef) if tp1.symbol.isClass && tp2.symbol.isClass =>
+        val cls1 = tp1.classSymbol
+        val cls2 = tp2.classSymbol
+        def isDecomposable(tp: Symbol): Boolean =
+           tp.is(Sealed) && !tp.hasAnonymousChild
+        def decompose(sym: Symbol, tp: Type): List[Type] =
+          sym.children.map(x => refineUsingParent(tp, x)).filter(_.exists)
+        if (cls1.derivesFrom(cls2) || cls2.derivesFrom(cls1))
+          false
+        else
+          if (cls1.is(Final) || cls2.is(Final))
+            // One of these types is final and they are not mutually
+            // subtype, so they must be unrelated.
+            true
+          else if (!cls2.is(Trait) && !cls1.is(Trait))
+            // Both of these types are classes and they are not mutually
+            // subtype, so they must be unrelated by single inheritance
+            // of classes.
+            true
+          else if (isDecomposable(cls1))
+            // At this point, !cls1.derivesFrom(cls2): we know that direct
+            // instantiations of `cls1` (terms of the form `new cls1`) are not
+            // of type `tp2`. Therefore, we can safely decompose `cls1` using
+            // `.children`, even if `cls1` is non abstract.
+            decompose(cls1, tp1).forall(x => provablyDisjoint(x, tp2))
+          else if (isDecomposable(cls2))
+            decompose(cls2, tp2).forall(x => provablyDisjoint(x, tp1))
+          else
+            false
+      case (AppliedType(tycon1, args1), AppliedType(tycon2, args2)) if isSame(tycon1, tycon2) =>
+        // It is possible to conclude that two types applies are disjoint by
+        // looking at covariant type parameters if the said type parameters
+        // are disjoin and correspond to fields.
+        // (Type parameter disjointness is not enough by itself as it could
+        // lead to incorrect conclusions for phantom type parameters).
+        def covariantDisjoint(tp1: Type, tp2: Type, tparam: TypeParamInfo): Boolean =
+          provablyDisjoint(tp1, tp2) && typeparamCorrespondsToField(tycon1, tparam)
+
+        // In the invariant case, we also use a stronger notion of disjointness:
+        // we consider fully instantiated types not equal wrt =:= to be disjoint
+        // (under any context). This is fine because it matches the runtime
+        // semantics of pattern matching. To implement a pattern such as
+        // `case Inv[T] => ...`, one needs a type tag for `T` and the compiler
+        // is used at runtime to check it the scrutinee's type is =:= to `T`.
+        // Note that this is currently a theoretical concern since Dotty
+        // doesn't have type tags, meaning that users cannot write patterns
+        // that do type tests on higher kinded types.
+        def invariantDisjoint(tp1: Type, tp2: Type, tparam: TypeParamInfo): Boolean =
+          provablyDisjoint(tp1, tp2) ||
+          !isSameType(tp1, tp2) &&
+          fullyInstantiated(tp1) && // We can only trust a "no" from `isSameType` when
+          fullyInstantiated(tp2)    // both `tp1` and `tp2` are fully instantiated.
+
+        args1.lazyZip(args2).lazyZip(tycon1.typeParams).exists {
+          (arg1, arg2, tparam) =>
+            val v = tparam.paramVarianceSign
+            if (v > 0)
+              covariantDisjoint(arg1, arg2, tparam)
+            else if (v < 0)
+              // Contravariant case: a value where this type parameter is
+              // instantiated to `Any` belongs to both types.
+              false
+            else
+              invariantDisjoint(arg1, arg2, tparam)
+        }
+      case (tp1: HKLambda, tp2: HKLambda) =>
+        provablyDisjoint(tp1.resType, tp2.resType)
+      case (_: HKLambda, _) =>
+        // The intersection of these two types would be ill kinded, they are therefore provablyDisjoint.
+        true
+      case (_, _: HKLambda) =>
+        true
+      case (tp1: OrType, _)  =>
+        provablyDisjoint(tp1.tp1, tp2) && provablyDisjoint(tp1.tp2, tp2)
+      case (_, tp2: OrType)  =>
+        provablyDisjoint(tp1, tp2.tp1) && provablyDisjoint(tp1, tp2.tp2)
+      case (tp1: AndType, _) =>
+        !(tp1 <:< tp2)
+        && (provablyDisjoint(tp1.tp2, tp2) || provablyDisjoint(tp1.tp1, tp2))
+      case (_, tp2: AndType) =>
+        !(tp2 <:< tp1)
+        && (provablyDisjoint(tp1, tp2.tp2) || provablyDisjoint(tp1, tp2.tp1))
+      case (tp1: NamedType, _) if gadtBounds(tp1.symbol) != null =>
+        provablyDisjoint(gadtBounds(tp1.symbol).uncheckedNN.hi, tp2)
+        || provablyDisjoint(tp1.superTypeNormalized, tp2)
+      case (_, tp2: NamedType) if gadtBounds(tp2.symbol) != null =>
+        provablyDisjoint(tp1, gadtBounds(tp2.symbol).uncheckedNN.hi)
+        || provablyDisjoint(tp1, tp2.superTypeNormalized)
+      case (tp1: TermRef, tp2: TermRef) if isEnumValueOrModule(tp1) && isEnumValueOrModule(tp2) =>
+        tp1.termSymbol != tp2.termSymbol
+      case (tp1: TermRef, tp2: TypeRef) if isEnumValue(tp1) =>
+        fullyInstantiated(tp2) && !tp1.classSymbols.exists(_.derivesFrom(tp2.symbol))
+      case (tp1: TypeRef, tp2: TermRef) if isEnumValue(tp2) =>
+        fullyInstantiated(tp1) && !tp2.classSymbols.exists(_.derivesFrom(tp1.symbol))
+      case (tp1: RefinedType, tp2: RefinedType) if tp1.refinedName == tp2.refinedName =>
+        provablyDisjoint(tp1.parent, tp2.parent) || provablyDisjoint(tp1.refinedInfo, tp2.refinedInfo)
+      case (tp1: TypeAlias, tp2: TypeAlias) =>
+        provablyDisjoint(tp1.alias, tp2.alias)
+      case (tp1: Type, tp2: Type) if defn.isTupleNType(tp1) =>
+        provablyDisjoint(tp1.toNestedPairs, tp2)
+      case (tp1: Type, tp2: Type) if defn.isTupleNType(tp2) =>
+        provablyDisjoint(tp1, tp2.toNestedPairs)
+      case (tp1: TypeProxy, tp2: TypeProxy) =>
+        provablyDisjoint(tp1.superTypeNormalized, tp2) || provablyDisjoint(tp1, tp2.superTypeNormalized)
+      case (tp1: TypeProxy, _) =>
+        provablyDisjoint(tp1.superTypeNormalized, tp2)
+      case (_, tp2: TypeProxy) =>
+        provablyDisjoint(tp1, tp2.superTypeNormalized)
+      case _ =>
+        false
+    }
+  }
+
+  protected def explainingTypeComparer = ExplainingTypeComparer(comparerContext)
+  protected def trackingTypeComparer = TrackingTypeComparer(comparerContext)
+
+  private def inSubComparer[T, Cmp <: TypeComparer](comparer: Cmp)(op: Cmp => T): T =
+    val saved = myInstance
+    myInstance = comparer
+    try op(comparer)
+    finally myInstance = saved
+
+  /** The trace of comparison operations when performing `op` */
+  def explained[T](op: ExplainingTypeComparer => T, header: String = "Subtype trace:")(using Context): String =
+    val cmp = explainingTypeComparer
+    inSubComparer(cmp)(op)
+    cmp.lastTrace(header)
+
+  def tracked[T](op: TrackingTypeComparer => T)(using Context): T =
+    inSubComparer(trackingTypeComparer)(op)
+}
+
+object TypeComparer {
+
+  enum CompareResult:
+    case OK, Fail, OKwithGADTUsed
+
+  /** Class for unification variables used in `natValue`. */
+  private class AnyConstantType extends UncachedGroundType with ValueType {
+    var tpe: Type = NoType
+  }
+
+  private[core] def show(res: Any)(using Context): String =
+    if ctx.settings.YexplainLowlevel.value then String.valueOf(res).nn
+    else res match
+      case ClassInfo(_, cls, _, _, _) => cls.showLocated
+      case bounds: TypeBounds => i"type bounds [$bounds]"
+      case CaptureSet.CompareResult.OK => "OK"
+      case res: printing.Showable => res.show
+      case _ => String.valueOf(res).nn
+
+  /** The approximation state indicates how the pair of types currently compared
+   *  relates to the types compared originally.
+   *   - `None`    : They are still the same types
+   *   - `LoApprox`: The left type is approximated (i.e widened)"
+   *   - `HiApprox`: The right type is approximated (i.e narrowed)"
+   */
+  object ApproxState:
+    opaque type Repr = Int
+
+    val None: Repr = 0
+    private val LoApprox = 1
+    private val HiApprox = 2
+
+    /** A special approximation state to indicate that this is the first time we
+     *  compare (approximations of) this pair of types. It's converted to `None`
+     *  in `isSubType`, but also leads to `leftRoot` being set there.
+     */
+    val Fresh: Repr = 4
+
+    object Repr:
+      extension (approx: Repr)
+        def low: Boolean = (approx & LoApprox) != 0
+        def high: Boolean = (approx & HiApprox) != 0
+        def addLow: Repr = approx | LoApprox
+        def addHigh: Repr = approx | HiApprox
+        def show: String =
+          val lo = if low then " (left is approximated)" else ""
+          val hi = if high then " (right is approximated)" else ""
+          lo ++ hi
+  end ApproxState
+  type ApproxState = ApproxState.Repr
+
+  def topLevelSubType(tp1: Type, tp2: Type)(using Context): Boolean =
+    comparing(_.topLevelSubType(tp1, tp2))
+
+  def necessarySubType(tp1: Type, tp2: Type)(using Context): Boolean =
+    comparing(_.necessarySubType(tp1, tp2))
+
+  def isSubType(tp1: Type, tp2: Type)(using Context): Boolean =
+    comparing(_.isSubType(tp1, tp2))
+
+  def isSameType(tp1: Type, tp2: Type)(using Context): Boolean =
+    comparing(_.isSameType(tp1, tp2))
+
+  def isSubTypeWhenFrozen(tp1: Type, tp2: Type)(using Context): Boolean =
+    comparing(_.isSubTypeWhenFrozen(tp1, tp2))
+
+  def testSubType(tp1: Type, tp2: Type)(using Context): CompareResult =
+    comparing(_.testSubType(tp1, tp2))
+
+  def isSameTypeWhenFrozen(tp1: Type, tp2: Type)(using Context): Boolean =
+    comparing(_.isSameTypeWhenFrozen(tp1, tp2))
+
+  def isSameRef(tp1: Type, tp2: Type)(using Context): Boolean =
+    comparing(_.isSameRef(tp1, tp2))
+
+  def matchesType(tp1: Type, tp2: Type, relaxed: Boolean)(using Context): Boolean =
+    comparing(_.matchesType(tp1, tp2, relaxed))
+
+  def hasMatchingMember(name: Name, tp1: Type, tp2: RefinedType)(using Context): Boolean =
+    comparing(_.hasMatchingMember(name, tp1, tp2))
+
+  def matchingMethodParams(tp1: MethodType, tp2: MethodType)(using Context): Boolean =
+    comparing(_.matchingMethodParams(tp1, tp2))
+
+  def lub(tp1: Type, tp2: Type, canConstrain: Boolean = false, isSoft: Boolean = true)(using Context): Type =
+    comparing(_.lub(tp1, tp2, canConstrain = canConstrain, isSoft = isSoft))
+
+  /** The least upper bound of a list of types */
+  final def lub(tps: List[Type])(using Context): Type =
+    tps.foldLeft(defn.NothingType: Type)(lub(_,_))
+
+  def lubArgs(args1: List[Type], args2: List[Type], tparams: List[TypeParamInfo], canConstrain: Boolean = false)(using Context): List[Type] =
+    comparing(_.lubArgs(args1, args2, tparams, canConstrain))
+
+  def glb(tp1: Type, tp2: Type)(using Context): Type =
+    comparing(_.glb(tp1, tp2))
+
+  /** The greatest lower bound of a list types */
+  def glb(tps: List[Type])(using Context): Type =
+    tps.foldLeft(defn.AnyType: Type)(glb)
+
+  def orType(using Context)(tp1: Type, tp2: Type, isSoft: Boolean = true, isErased: Boolean = ctx.erasedTypes): Type =
+    comparing(_.orType(tp1, tp2, isSoft = isSoft, isErased = isErased))
+
+  def andType(using Context)(tp1: Type, tp2: Type, isErased: Boolean = ctx.erasedTypes): Type =
+    comparing(_.andType(tp1, tp2, isErased))
+
+  def provablyDisjoint(tp1: Type, tp2: Type)(using Context): Boolean =
+    comparing(_.provablyDisjoint(tp1, tp2))
+
+  def liftIfHK(tp1: Type, tp2: Type,
+      op: (Type, Type) -> Type, original: (Type, Type) -> Type,
+      combineVariance: (Variance, Variance) -> Variance)(using Context): Type =
+    comparing(_.liftIfHK(tp1, tp2, op, original, combineVariance))
+
+  def constValue(tp: Type)(using Context): Option[Constant] =
+    comparing(_.constValue(tp))
+
+  def subtypeCheckInProgress(using Context): Boolean =
+    comparing(_.subtypeCheckInProgress)
+
+  def instanceType(param: TypeParamRef, fromBelow: Boolean, widenUnions: Boolean, maxLevel: Int = Int.MaxValue)(using Context): Type =
+    comparing(_.instanceType(param, fromBelow, widenUnions, maxLevel))
+
+  def approximation(param: TypeParamRef, fromBelow: Boolean, maxLevel: Int = Int.MaxValue)(using Context): Type =
+    comparing(_.approximation(param, fromBelow, maxLevel))
+
+  def bounds(param: TypeParamRef)(using Context): TypeBounds =
+    comparing(_.bounds(param))
+
+  def fullBounds(param: TypeParamRef)(using Context): TypeBounds =
+    comparing(_.fullBounds(param))
+
+  def fullLowerBound(param: TypeParamRef)(using Context): Type =
+    comparing(_.fullLowerBound(param))
+
+  def fullUpperBound(param: TypeParamRef)(using Context): Type =
+    comparing(_.fullUpperBound(param))
+
+  def addToConstraint(tl: TypeLambda, tvars: List[TypeVar])(using Context): Boolean =
+    comparing(_.addToConstraint(tl, tvars))
+
+  def widenInferred(inst: Type, bound: Type, widenUnions: Boolean)(using Context): Type =
+    comparing(_.widenInferred(inst, bound, widenUnions))
+
+  def dropTransparentTraits(tp: Type, bound: Type)(using Context): Type =
+    comparing(_.dropTransparentTraits(tp, bound))
+
+  def constrainPatternType(pat: Type, scrut: Type, forceInvariantRefinement: Boolean = false)(using Context): Boolean =
+    comparing(_.constrainPatternType(pat, scrut, forceInvariantRefinement))
+
+  def explained[T](op: ExplainingTypeComparer => T, header: String = "Subtype trace:")(using Context): String =
+    comparing(_.explained(op, header))
+
+  def tracked[T](op: TrackingTypeComparer => T)(using Context): T =
+    comparing(_.tracked(op))
+}
+
+object TrackingTypeComparer:
+  import printing.*, Texts.*
+  enum MatchResult extends Showable:
+    case Reduced(tp: Type)
+    case Disjoint
+    case Stuck
+    case NoInstance(fails: List[(Name, TypeBounds)])
+
+    def toText(p: Printer): Text = this match
+      case Reduced(tp)       => "Reduced(" ~ p.toText(tp) ~ ")"
+      case Disjoint          => "Disjoint"
+      case Stuck             => "Stuck"
+      case NoInstance(fails) => "NoInstance(" ~ Text(fails.map(p.toText(_) ~ p.toText(_)), ", ") ~ ")"
+
+class TrackingTypeComparer(initctx: Context) extends TypeComparer(initctx) {
+  import TrackingTypeComparer.*
+
+  init(initctx)
+
+  override def trackingTypeComparer = this
+
+  val footprint: mutable.Set[Type] = mutable.Set[Type]()
+
+  override def bounds(param: TypeParamRef)(using Context): TypeBounds = {
+    if (param.binder `ne` caseLambda) footprint += param
+    super.bounds(param)
+  }
+
+  override def addOneBound(param: TypeParamRef, bound: Type, isUpper: Boolean)(using Context): Boolean = {
+    if (param.binder `ne` caseLambda) footprint += param
+    super.addOneBound(param, bound, isUpper)
+  }
+
+  override def gadtBounds(sym: Symbol)(using Context): TypeBounds | Null = {
+    if (sym.exists) footprint += sym.typeRef
+    super.gadtBounds(sym)
+  }
+
+  override def gadtAddBound(sym: Symbol, b: Type, isUpper: Boolean): Boolean =
+    if (sym.exists) footprint += sym.typeRef
+    super.gadtAddBound(sym, b, isUpper)
+
+  override def typeVarInstance(tvar: TypeVar)(using Context): Type = {
+    footprint += tvar
+    super.typeVarInstance(tvar)
+  }
+
+  def matchCases(scrut: Type, cases: List[Type])(using Context): Type = {
+
+    def paramInstances(canApprox: Boolean) = new TypeAccumulator[Array[Type]]:
+      def apply(insts: Array[Type], t: Type) = t match
+        case param @ TypeParamRef(b, n) if b eq caseLambda =>
+          insts(n) =
+            if canApprox then
+              approximation(param, fromBelow = variance >= 0, Int.MaxValue).simplified
+            else constraint.entry(param) match
+              case entry: TypeBounds =>
+                val lo = fullLowerBound(param)
+                val hi = fullUpperBound(param)
+                if isSubType(hi, lo) then lo.simplified else Range(lo, hi)
+              case inst =>
+                assert(inst.exists, i"param = $param\nconstraint = $constraint")
+                inst.simplified
+          insts
+        case _ =>
+          foldOver(insts, t)
+
+    def instantiateParams(insts: Array[Type]) = new ApproximatingTypeMap {
+      variance = 0
+      def apply(t: Type) = t match {
+        case t @ TypeParamRef(b, n) if b `eq` caseLambda => insts(n)
+        case t: LazyRef => apply(t.ref)
+        case _ => mapOver(t)
+      }
+    }
+
+    /** Match a single case. */
+    def matchCase(cas: Type): MatchResult = trace(i"$scrut match ${MatchTypeTrace.caseText(cas)}", matchTypes, show = true) {
+      val cas1 = cas match {
+        case cas: HKTypeLambda =>
+          caseLambda = constrained(cas)
+          caseLambda.resultType
+        case _ =>
+          cas
+      }
+
+      val defn.MatchCase(pat, body) = cas1: @unchecked
+
+      def matches(canWidenAbstract: Boolean): Boolean =
+        val saved = this.canWidenAbstract
+        this.canWidenAbstract = canWidenAbstract
+        try necessarySubType(scrut, pat)
+        finally this.canWidenAbstract = saved
+
+      def redux(canApprox: Boolean): MatchResult =
+        caseLambda match
+          case caseLambda: HKTypeLambda =>
+            val instances = paramInstances(canApprox)(Array.fill(caseLambda.paramNames.length)(NoType), pat)
+            instantiateParams(instances)(body) match
+              case Range(lo, hi) =>
+                MatchResult.NoInstance {
+                  caseLambda.paramNames.zip(instances).collect {
+                    case (name, Range(lo, hi)) => (name, TypeBounds(lo, hi))
+                  }
+                }
+              case redux =>
+                MatchResult.Reduced(redux.simplified)
+          case _ =>
+            MatchResult.Reduced(body)
+
+      if caseLambda.exists && matches(canWidenAbstract = false) then
+        redux(canApprox = true)
+      else if matches(canWidenAbstract = true) then
+        redux(canApprox = false)
+      else if (provablyDisjoint(scrut, pat))
+        // We found a proof that `scrut` and `pat` are incompatible.
+        // The search continues.
+        MatchResult.Disjoint
+      else
+        MatchResult.Stuck
+    }
+
+    def recur(remaining: List[Type]): Type = remaining match
+      case cas :: remaining1 =>
+        matchCase(cas) match
+          case MatchResult.Disjoint =>
+            recur(remaining1)
+          case MatchResult.Stuck =>
+            MatchTypeTrace.stuck(scrut, cas, remaining1)
+            NoType
+          case MatchResult.NoInstance(fails) =>
+            MatchTypeTrace.noInstance(scrut, cas, fails)
+            NoType
+          case MatchResult.Reduced(tp) =>
+            tp
+      case Nil =>
+        val casesText = MatchTypeTrace.noMatchesText(scrut, cases)
+        throw new TypeError(s"Match type reduction $casesText")
+
+    inFrozenConstraint {
+      // Empty types break the basic assumption that if a scrutinee and a
+      // pattern are disjoint it's OK to reduce passed that pattern. Indeed,
+      // empty types viewed as a set of value is always a subset of any other
+      // types. As a result, we first check that the scrutinee isn't empty
+      // before proceeding with reduction. See `tests/neg/6570.scala` and
+      // `6570-1.scala` for examples that exploit emptiness to break match
+      // type soundness.
+
+      // If we revered the uncertainty case of this empty check, that is,
+      // `!provablyNonEmpty` instead of `provablyEmpty`, that would be
+      // obviously sound, but quite restrictive. With the current formulation,
+      // we need to be careful that `provablyEmpty` covers all the conditions
+      // used to conclude disjointness in `provablyDisjoint`.
+      if (provablyEmpty(scrut))
+        MatchTypeTrace.emptyScrutinee(scrut)
+        NoType
+      else
+        recur(cases)
+    }
+  }
+}
+
+/** A type comparer that can record traces of subtype operations */
+class ExplainingTypeComparer(initctx: Context) extends TypeComparer(initctx) {
+  import TypeComparer._
+
+  init(initctx)
+
+  override def explainingTypeComparer = this
+
+  private var indent = 0
+  private val b = new StringBuilder
+
+  private var skipped = false
+
+  override def traceIndented[T](str: String)(op: => T): T =
+    if (skipped) op
+    else {
+      indent += 2
+      val str1 = str.replace('\n', ' ')
+      b.append("\n").append(" " * indent).append("==> ").append(str1)
+      val res = op
+      b.append("\n").append(" " * indent).append("<== ").append(str1).append(" = ").append(show(res))
+      indent -= 2
+      res
+    }
+
+  private def frozenNotice: String =
+    if frozenConstraint then " in frozen constraint" else ""
+
+  override def recur(tp1: Type, tp2: Type): Boolean =
+    def moreInfo =
+      if Config.verboseExplainSubtype || ctx.settings.verbose.value
+      then s" ${tp1.getClass} ${tp2.getClass}"
+      else ""
+    val approx = approxState
+    traceIndented(s"${show(tp1)}  <:  ${show(tp2)}$moreInfo${approx.show}$frozenNotice") {
+      super.recur(tp1, tp2)
+    }
+
+  override def hasMatchingMember(name: Name, tp1: Type, tp2: RefinedType): Boolean =
+    traceIndented(s"hasMatchingMember(${show(tp1)} . $name, ${show(tp2.refinedInfo)}), member = ${show(tp1.member(name).info)}") {
+      super.hasMatchingMember(name, tp1, tp2)
+    }
+
+  override def lub(tp1: Type, tp2: Type, canConstrain: Boolean, isSoft: Boolean): Type =
+    traceIndented(s"lub(${show(tp1)}, ${show(tp2)}, canConstrain=$canConstrain, isSoft=$isSoft)") {
+      super.lub(tp1, tp2, canConstrain, isSoft)
+    }
+
+  override def glb(tp1: Type, tp2: Type): Type =
+    traceIndented(s"glb(${show(tp1)}, ${show(tp2)})") {
+      super.glb(tp1, tp2)
+    }
+
+  override def addConstraint(param: TypeParamRef, bound: Type, fromBelow: Boolean)(using Context): Boolean =
+    traceIndented(s"add constraint ${show(param)} ${if (fromBelow) ">:" else "<:"} ${show(bound)} $frozenNotice, constraint = ${show(ctx.typerState.constraint)}") {
+      super.addConstraint(param, bound, fromBelow)
+    }
+
+  override def gadtAddBound(sym: Symbol, b: Type, isUpper: Boolean): Boolean =
+    traceIndented(s"add GADT constraint ${show(sym)} ${if isUpper then "<:" else ">:"} ${show(b)} $frozenNotice, GADT constraint = ${show(ctx.gadt)}") {
+      super.gadtAddBound(sym, b, isUpper)
+    }
+
+  override def subCaptures(refs1: CaptureSet, refs2: CaptureSet, frozen: Boolean)(using Context): CaptureSet.CompareResult =
+    traceIndented(i"subcaptures $refs1 <:< $refs2 ${if frozen then "frozen" else ""}") {
+      super.subCaptures(refs1, refs2, frozen)
+    }
+
+  def lastTrace(header: String): String = header + { try b.toString finally b.clear() }
+}
diff --git a/tests/pos-with-compiler-cc/dotc/core/TypeErasure.scala b/tests/pos-with-compiler-cc/dotc/core/TypeErasure.scala
new file mode 100644
index 000000000000..1fc7ee5d22a8
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/core/TypeErasure.scala
@@ -0,0 +1,877 @@
+package dotty.tools
+package dotc
+package core
+
+import Symbols._, Types._, Contexts._, Flags._, Names._, StdNames._, Phases._
+import Flags.JavaDefined
+import Uniques.unique
+import TypeOps.makePackageObjPrefixExplicit
+import backend.sjs.JSDefinitions
+import transform.ExplicitOuter._
+import transform.ValueClasses._
+import transform.TypeUtils._
+import transform.ContextFunctionResults._
+import unpickleScala2.Scala2Erasure
+import Decorators._
+import Definitions.MaxImplementedFunctionArity
+import scala.annotation.tailrec
+
+/** The language in which the definition being erased was written. */
+enum SourceLanguage:
+  case Java, Scala2, Scala3
+  def isJava: Boolean = this eq Java
+  def isScala2: Boolean = this eq Scala2
+  def isScala3: Boolean = this eq Scala3
+object SourceLanguage:
+  /** The language in which `sym` was defined. */
+  def apply(sym: Symbol)(using Context): SourceLanguage =
+    if sym.is(JavaDefined) then
+      SourceLanguage.Java
+    // Scala 2 methods don't have Inline set, except for the ones injected with `patchStdlibClass`
+    // which are really Scala 3 methods.
+    else if sym.isClass && sym.is(Scala2x) || (sym.maybeOwner.is(Scala2x) && !sym.is(Inline)) then
+      SourceLanguage.Scala2
+    else
+      SourceLanguage.Scala3
+
+  /** Number of bits needed to represent this enum. */
+  def bits: Int =
+    val len = values.length
+    val log2 = 31 - Integer.numberOfLeadingZeros(len)
+    if len == 1 << log2 then
+      log2
+    else
+      log2 + 1
+
+   /** A common language to use when matching definitions written in different
+    *  languages.
+    */
+  def commonLanguage(x: SourceLanguage, y: SourceLanguage): SourceLanguage =
+    if x.ordinal > y.ordinal then x else y
+end SourceLanguage
+
+/** Erased types are:
+ *
+ *  ErasedValueType
+ *  TypeRef(prefix is ignored, denot is ClassDenotation)
+ *  TermRef(prefix is ignored, denot is SymDenotation)
+ *  JavaArrayType
+ *  AnnotatedType
+ *  MethodType
+ *  ThisType
+ *  SuperType
+ *  ClassInfo (NoPrefix, ...)
+ *  NoType
+ *  NoPrefix
+ *  WildcardType
+ *  ErrorType
+ *
+ *  only for isInstanceOf, asInstanceOf: PolyType, TypeParamRef, TypeBounds
+ *
+ */
+object TypeErasure {
+
+  private def erasureDependsOnArgs(sym: Symbol)(using Context) =
+    sym == defn.ArrayClass || sym == defn.PairClass || isDerivedValueClass(sym)
+
+  def normalizeClass(cls: ClassSymbol)(using Context): ClassSymbol = {
+    if (cls.owner == defn.ScalaPackageClass) {
+      if (defn.specialErasure.contains(cls))
+        return defn.specialErasure(cls).uncheckedNN
+      if (cls == defn.UnitClass)
+        return defn.BoxedUnitClass
+    }
+    cls
+  }
+
+  /** A predicate that tests whether a type is a legal erased type. Only asInstanceOf and
+   *  isInstanceOf may have types that do not satisfy the predicate.
+   *  ErasedValueType is considered an erased type because it is valid after Erasure (it is
+   *  eliminated by ElimErasedValueType).
+   */
+  def isErasedType(tp: Type)(using Context): Boolean = tp match {
+    case _: ErasedValueType =>
+      true
+    case tp: TypeRef =>
+      val sym = tp.symbol
+      sym.isClass &&
+      (!erasureDependsOnArgs(sym) || isDerivedValueClass(sym)) &&
+      !defn.specialErasure.contains(sym) &&
+      !defn.isSyntheticFunctionClass(sym)
+    case _: TermRef =>
+      true
+    case JavaArrayType(elem) =>
+      isErasedType(elem)
+    case AnnotatedType(tp, _) =>
+      isErasedType(tp)
+    case ThisType(tref) =>
+      isErasedType(tref)
+    case tp: MethodType =>
+      tp.paramInfos.forall(isErasedType) && isErasedType(tp.resultType)
+    case tp @ ClassInfo(pre, _, parents, decls, _) =>
+      isErasedType(pre) && parents.forall(isErasedType) //&& decls.forall(sym => isErasedType(sym.info)) && isErasedType(tp.selfType)
+    case NoType | NoPrefix | WildcardType | _: ErrorType | SuperType(_, _) =>
+      true
+    case _ =>
+      false
+  }
+
+  /** A type representing the semi-erasure of a derived value class, see SIP-15
+   *  where it's called "C$unboxed" for a class C.
+   *  Derived value classes are erased to this type during Erasure (when
+   *  semiEraseVCs = true) and subsequently erased to their underlying type
+   *  during ElimErasedValueType. This type is outside the normal Scala class
+   *  hierarchy: it is a subtype of no other type and is a supertype only of
+   *  Nothing. This is because this type is only useful for type adaptation (see
+   *  [[Erasure.Boxing#adaptToType]]).
+   *
+   *  @param   tycon             A TypeRef referring to the value class symbol
+   *  @param   erasedUnderlying  The erased type of the single field of the value class
+   */
+  abstract case class ErasedValueType(tycon: TypeRef, erasedUnderlying: Type)
+  extends CachedGroundType with ValueType {
+    override def computeHash(bs: Hashable.Binders): Int = doHash(bs, tycon, erasedUnderlying)
+  }
+
+  final class CachedErasedValueType(tycon: TypeRef, erasedUnderlying: Type)
+    extends ErasedValueType(tycon, erasedUnderlying)
+
+  object ErasedValueType {
+    def apply(tycon: TypeRef, erasedUnderlying: Type)(using Context): ErasedValueType = {
+      assert(erasedUnderlying.exists)
+      unique(new CachedErasedValueType(tycon, erasedUnderlying))
+    }
+  }
+
+  private def erasureIdx(sourceLanguage: SourceLanguage, semiEraseVCs: Boolean, isConstructor: Boolean, isSymbol: Boolean, wildcardOK: Boolean) =
+    extension (b: Boolean) def toInt = if b then 1 else 0
+    wildcardOK.toInt
+    + (isSymbol.toInt         << 1)
+    + (isConstructor.toInt    << 2)
+    + (semiEraseVCs.toInt     << 3)
+    + (sourceLanguage.ordinal << 4)
+
+  private val erasures = new Array[TypeErasure](1 << (SourceLanguage.bits + 4))
+
+  for
+    sourceLanguage <- SourceLanguage.values
+    semiEraseVCs <- List(false, true)
+    isConstructor <- List(false, true)
+    isSymbol <- List(false, true)
+    wildcardOK <- List(false, true)
+  do
+    erasures(erasureIdx(sourceLanguage, semiEraseVCs, isConstructor, isSymbol, wildcardOK)) =
+      new TypeErasure(sourceLanguage, semiEraseVCs, isConstructor, isSymbol, wildcardOK)
+
+  /** Produces an erasure function. See the documentation of the class [[TypeErasure]]
+   *  for a description of each parameter.
+   */
+  private def erasureFn(sourceLanguage: SourceLanguage, semiEraseVCs: Boolean, isConstructor: Boolean, isSymbol: Boolean, wildcardOK: Boolean): TypeErasure =
+    erasures(erasureIdx(sourceLanguage, semiEraseVCs, isConstructor, isSymbol, wildcardOK))
+
+  /** The current context with a phase no later than erasure */
+  def preErasureCtx(using Context) =
+    if (ctx.erasedTypes) ctx.withPhase(erasurePhase) else ctx
+
+  /** The standard erasure of a Scala type. Value classes are erased as normal classes.
+   *
+   *  @param tp            The type to erase.
+  */
+  def erasure(tp: Type)(using Context): Type =
+    erasureFn(sourceLanguage = SourceLanguage.Scala3, semiEraseVCs = false, isConstructor = false, isSymbol = false, wildcardOK = false)(tp)(using preErasureCtx)
+
+  /** The value class erasure of a Scala type, where value classes are semi-erased to
+   *  ErasedValueType (they will be fully erased in [[ElimErasedValueType]]).
+   *
+   *  @param tp            The type to erase.
+   */
+  def valueErasure(tp: Type)(using Context): Type =
+    erasureFn(sourceLanguage = SourceLanguage.Scala3, semiEraseVCs = true, isConstructor = false, isSymbol = false, wildcardOK = false)(tp)(using preErasureCtx)
+
+  /** The erasure that Scala 2 would use for this type. */
+  def scala2Erasure(tp: Type)(using Context): Type =
+    erasureFn(sourceLanguage = SourceLanguage.Scala2, semiEraseVCs = true, isConstructor = false, isSymbol = false, wildcardOK = false)(tp)(using preErasureCtx)
+
+  /** Like value class erasure, but value classes erase to their underlying type erasure */
+  def fullErasure(tp: Type)(using Context): Type =
+    valueErasure(tp) match
+      case ErasedValueType(_, underlying) => erasure(underlying)
+      case etp => etp
+
+  def sigName(tp: Type, sourceLanguage: SourceLanguage)(using Context): TypeName = {
+    val normTp = tp.translateFromRepeated(toArray = sourceLanguage.isJava)
+    val erase = erasureFn(sourceLanguage, semiEraseVCs = !sourceLanguage.isJava, isConstructor = false, isSymbol = false, wildcardOK = true)
+    erase.sigName(normTp)(using preErasureCtx)
+  }
+
+  /** The erasure of a top-level reference. Differs from normal erasure in that
+   *  TermRefs are kept instead of being widened away.
+   */
+  def erasedRef(tp: Type)(using Context): Type = tp match {
+    case tp: TermRef =>
+      assert(tp.symbol.exists, tp)
+      val tp1 = makePackageObjPrefixExplicit(tp)
+      if (tp1 ne tp) erasedRef(tp1)
+      else TermRef(erasedRef(tp.prefix), tp.symbol.asTerm)
+    case tp: ThisType =>
+      tp
+    case tp =>
+      valueErasure(tp)
+  }
+
+  /**  The symbol's erased info. This is the type's erasure, except for the following symbols:
+   *
+   *   - For $asInstanceOf           : [T]T
+   *   - For $isInstanceOf           : [T]Boolean
+   *   - For all abstract types      : = ?
+   *
+   *   `sourceLanguage`, `isConstructor` and `semiEraseVCs` are set based on the symbol.
+   */
+  def transformInfo(sym: Symbol, tp: Type)(using Context): Type = {
+    val sourceLanguage = SourceLanguage(sym)
+    val semiEraseVCs = !sourceLanguage.isJava // Java sees our value classes as regular classes.
+    val erase = erasureFn(sourceLanguage, semiEraseVCs, sym.isConstructor, isSymbol = true, wildcardOK = false)
+
+    def eraseParamBounds(tp: PolyType): Type =
+      tp.derivedLambdaType(
+        tp.paramNames, tp.paramNames map (Function.const(TypeBounds.upper(defn.ObjectType))), tp.resultType)
+
+    if (defn.isPolymorphicAfterErasure(sym)) eraseParamBounds(sym.info.asInstanceOf[PolyType])
+    else if (sym.isAbstractType) TypeAlias(WildcardType)
+    else if sym.is(ConstructorProxy) then NoType
+    else if (sym.isConstructor) outer.addParam(sym.owner.asClass, erase(tp)(using preErasureCtx))
+    else if (sym.is(Label)) erase.eraseResult(sym.info)(using preErasureCtx)
+    else erase.eraseInfo(tp, sym)(using preErasureCtx) match {
+      case einfo: MethodType =>
+        if (sym.isGetter && einfo.resultType.isRef(defn.UnitClass))
+          MethodType(Nil, defn.BoxedUnitClass.typeRef)
+        else if (sym.isAnonymousFunction && einfo.paramInfos.length > MaxImplementedFunctionArity)
+          MethodType(nme.ALLARGS :: Nil, JavaArrayType(defn.ObjectType) :: Nil, einfo.resultType)
+        else if (sym.name == nme.apply && sym.owner.derivesFrom(defn.PolyFunctionClass))
+          // The erasure of `apply` in subclasses of PolyFunction has to match
+          // the erasure of FunctionN#apply, since after `ElimPolyFunction` we replace
+          // a `PolyFunction` parent by a `FunctionN` parent.
+          einfo.derivedLambdaType(
+            paramInfos = einfo.paramInfos.map(_ => defn.ObjectType),
+            resType = defn.ObjectType
+          )
+        else
+          einfo
+      case einfo =>
+        // Erase the parameters of `apply` in subclasses of PolyFunction
+        // Preserve PolyFunction argument types to support PolyFunctions with
+        // PolyFunction arguments
+        if (sym.is(TermParam) && sym.owner.name == nme.apply
+            && sym.owner.owner.derivesFrom(defn.PolyFunctionClass)
+            && !(tp <:< defn.PolyFunctionType))
+          defn.ObjectType
+        else
+          einfo
+    }
+  }
+
+  /** Is `Array[tp]` a generic Array that needs to be erased to `Object`?
+   *  This is true if among the subtypes of `Array[tp]` there is either:
+   *  - both a reference array type and a primitive array type
+   *    (e.g. `Array[_ <: Int | String]`, `Array[_ <: Any]`)
+   *  - or two different primitive array types (e.g. `Array[_ <: Int | Double]`)
+   *  In both cases the erased lub of those array types on the JVM is `Object`.
+   *
+   *  In addition, if `isScala2` is true, we mimic the Scala 2 erasure rules and
+   *  also return true for element types upper-bounded by a non-reference type
+   *  such as in `Array[_ <: Int]` or `Array[_ <: UniversalTrait]`.
+   */
+  def isGenericArrayElement(tp: Type, isScala2: Boolean)(using Context): Boolean = {
+    /** A symbol that represents the sort of JVM array that values of type `t` can be stored in:
+     *  - If we can always store such values in a reference array, return Object
+     *  - If we can always store them in a specific primitive array, return the
+     *    corresponding primitive class
+     *  - Otherwise, return `NoSymbol`.
+     */
+    def arrayUpperBound(t: Type): Symbol = t.dealias match
+      case t: TypeRef if t.symbol.isClass =>
+        val sym = t.symbol
+        // Only a few classes have both primitives and references as subclasses.
+        if (sym eq defn.AnyClass) || (sym eq defn.AnyValClass) || (sym eq defn.MatchableClass) || (sym eq defn.SingletonClass)
+           || isScala2 && !(t.derivesFrom(defn.ObjectClass) || t.isNullType) then
+          NoSymbol
+        // We only need to check for primitives because derived value classes in arrays are always boxed.
+        else if sym.isPrimitiveValueClass then
+          sym
+        else
+          defn.ObjectClass
+      case tp: TypeProxy =>
+        arrayUpperBound(tp.translucentSuperType)
+      case tp: AndOrType =>
+        val repr1 = arrayUpperBound(tp.tp1)
+        val repr2 = arrayUpperBound(tp.tp2)
+        if repr1 eq repr2 then
+          repr1
+        else if tp.isAnd then
+          repr1.orElse(repr2)
+        else
+          NoSymbol
+      case _ =>
+        NoSymbol
+
+    /** Can one of the JVM Array type store all possible values of type `t`?  */
+    def fitsInJVMArray(t: Type): Boolean = arrayUpperBound(t).exists
+
+    tp.dealias match {
+      case tp: TypeRef if !tp.symbol.isOpaqueAlias =>
+        !tp.symbol.isClass &&
+        !tp.symbol.is(JavaDefined) && // In Java code, Array[T] can never erase to Object
+        !fitsInJVMArray(tp)
+      case tp: TypeParamRef =>
+        !fitsInJVMArray(tp)
+      case tp: TypeAlias =>
+        isGenericArrayElement(tp.alias, isScala2)
+      case tp: TypeBounds =>
+        !fitsInJVMArray(tp.hi)
+      case tp: MatchType =>
+        val alts = tp.alternatives
+        alts.nonEmpty && !fitsInJVMArray(alts.reduce(OrType(_, _, soft = true)))
+      case tp: TypeProxy =>
+        isGenericArrayElement(tp.translucentSuperType, isScala2)
+      case tp: AndType =>
+        isGenericArrayElement(tp.tp1, isScala2) && isGenericArrayElement(tp.tp2, isScala2)
+      case tp: OrType =>
+        isGenericArrayElement(tp.tp1, isScala2) || isGenericArrayElement(tp.tp2, isScala2)
+      case _ => false
+    }
+  }
+
+  /** Is `tp` an abstract type or polymorphic type parameter, or another unbounded generic type? */
+  def isGeneric(tp: Type)(using Context): Boolean = tp.dealias match {
+    case tp: TypeRef if !tp.symbol.isOpaqueAlias => !tp.symbol.isClass
+    case tp: TypeParamRef => true
+    case tp: TypeProxy => isGeneric(tp.translucentSuperType)
+    case tp: AndType => isGeneric(tp.tp1) || isGeneric(tp.tp2)
+    case tp: OrType => isGeneric(tp.tp1) || isGeneric(tp.tp2)
+    case _ => false
+  }
+
+  /** The erased least upper bound of two erased types is computed as follows
+   *  - if both argument are arrays of objects, an array of the erased lub of the element types
+   *  - if both arguments are arrays of same primitives, an array of this primitive
+   *  - if one argument is array of primitives and the other is array of objects, Object
+   *  - if one argument is an array, Object
+   *  - otherwise a common superclass or trait S of the argument classes, with the
+   *    following two properties:
+   *      S is minimal: no other common superclass or trait derives from S
+   *      S is last   : in the linearization of the first argument type `tp1`
+   *                    there are no minimal common superclasses or traits that
+   *                    come after S.
+   *  The reason to pick last is that we prefer classes over traits that way,
+   *  which leads to more predictable bytecode and (?) faster dynamic dispatch.
+   */
+  def erasedLub(tp1: Type, tp2: Type)(using Context): Type = {
+    // We need to short-circuit the following 2 case because the regular lub logic in the else relies on
+    // the class hierarchy, which doesn't properly capture `Nothing`/`Null` subtyping behaviour.
+    if tp1.isRef(defn.NothingClass) || (tp1.isRef(defn.NullClass) && tp2.derivesFrom(defn.ObjectClass)) then
+      tp2 // After erasure, Nothing | T is just T and Null | C is just C, if C is a reference type.
+    else if tp2.isRef(defn.NothingClass) || (tp2.isRef(defn.NullClass) && tp1.derivesFrom(defn.ObjectClass)) then
+      tp1 // After erasure, T | Nothing is just T and C | Null is just C, if C is a reference type.
+    else tp1 match {
+      case JavaArrayType(elem1) =>
+        import dotty.tools.dotc.transform.TypeUtils._
+        tp2 match {
+          case JavaArrayType(elem2) =>
+            if (elem1.isPrimitiveValueType || elem2.isPrimitiveValueType)
+              if (elem1.classSymbol eq elem2.classSymbol) // same primitive
+                JavaArrayType(elem1)
+              else defn.ObjectType
+            else JavaArrayType(erasedLub(elem1, elem2))
+          case _ => defn.ObjectType
+        }
+      case _ =>
+        tp2 match {
+          case JavaArrayType(_) => defn.ObjectType
+          case _ =>
+            val cls2 = tp2.classSymbol
+
+            /** takeWhile+1 */
+            def takeUntil[T](l: List[T])(f: T => Boolean): List[T] = {
+              @tailrec def loop(tail: List[T], acc: List[T]): List[T] =
+                tail match {
+                  case h :: t => loop(if (f(h)) t else Nil, h :: acc)
+                  case Nil    => acc.reverse
+                }
+              loop(l, Nil)
+            }
+
+            // We are not interested in anything that is not a supertype of tp2
+            val tp2superclasses = tp1.baseClasses.filter(cls2.derivesFrom)
+
+            // From the spec, "Linearization also satisfies the property that a
+            // linearization of a class always contains the linearization of its
+            // direct superclass as a suffix"; it's enough to consider every
+            // candidate up to the first class.
+            val candidates = takeUntil(tp2superclasses)(!_.is(Trait))
+
+            // Candidates st "no other common superclass or trait derives from S"
+            // Also, drop `PairClass` since it is not valid after erasue
+            val minimums = candidates.filter { cand =>
+              cand != defn.PairClass
+              && candidates.forall(x => !x.derivesFrom(cand) || x.eq(cand))
+            }
+
+            // Pick the last minimum to prioritise classes over traits
+            minimums.lastOption match {
+              case Some(lub) => valueErasure(lub.typeRef)
+              case _ => defn.ObjectType
+            }
+        }
+    }
+  }
+
+  /** The erased greatest lower bound of two erased type picks one of the two argument types.
+   *
+   *  This operation has the following the properties:
+   *  - Associativity and commutativity, because this method acts as the minimum
+   *    of the total order induced by `compareErasedGlb`.
+   */
+  def erasedGlb(tp1: Type, tp2: Type)(using Context): Type =
+    if compareErasedGlb(tp1, tp2) <= 0 then tp1 else tp2
+
+  /** Overload of `erasedGlb` to compare more than two types at once. */
+  def erasedGlb(tps: List[Type])(using Context): Type =
+    tps.min(using (a,b) => compareErasedGlb(a, b))
+
+  /** A comparison function that induces a total order on erased types,
+   *  where `A <= B` implies that the erasure of `A & B` should be A.
+   *
+   *  This order respects the following properties:
+   *  - ErasedValueTypes <= non-ErasedValueTypes
+   *  - arrays <= non-arrays
+   *  - primitives <= non-primitives
+   *  - real classes <= traits
+   *  - subtypes <= supertypes
+   *
+   *  Since this isn't enough to order to unrelated classes, we use
+   *  lexicographic ordering of the class symbol full name as a tie-breaker.
+   *  This ensure that `A <= B && B <= A` iff `A =:= B`.
+   *
+   *  @see erasedGlb
+   */
+  private def compareErasedGlb(tp1: Type, tp2: Type)(using Context): Int =
+    // this check is purely an optimization.
+    if tp1 eq tp2 then
+      return 0
+
+    val isEVT1 = tp1.isInstanceOf[ErasedValueType]
+    val isEVT2 = tp2.isInstanceOf[ErasedValueType]
+    if isEVT1 && isEVT2 then
+      return compareErasedGlb(tp1.asInstanceOf[ErasedValueType].tycon, tp2.asInstanceOf[ErasedValueType].tycon)
+    else if isEVT1 then
+      return -1
+    else if isEVT2 then
+      return 1
+
+    val isArray1 = tp1.isInstanceOf[JavaArrayType]
+    val isArray2 = tp2.isInstanceOf[JavaArrayType]
+    if isArray1 && isArray2 then
+      return compareErasedGlb(tp1.asInstanceOf[JavaArrayType].elemType, tp2.asInstanceOf[JavaArrayType].elemType)
+    else if isArray1 then
+      return -1
+    else if isArray2 then
+      return 1
+
+    val sym1 = tp1.classSymbol
+    val sym2 = tp2.classSymbol
+    def compareClasses: Int =
+      if sym1.isSubClass(sym2) then
+        -1
+      else if sym2.isSubClass(sym1) then
+        1
+      // Intentionally compare Strings and not Names, since the ordering on
+      // Names depends on implementation details like `NameKind#tag`.
+      else
+        sym1.fullName.toString.compareTo(sym2.fullName.toString)
+
+    val isPrimitive1 = sym1.isPrimitiveValueClass
+    val isPrimitive2 = sym2.isPrimitiveValueClass
+    if isPrimitive1 && isPrimitive2 then
+      return compareClasses
+    else if isPrimitive1 then
+      return -1
+    else if isPrimitive2 then
+      return 1
+
+    val isRealClass1 = sym1.isRealClass
+    val isRealClass2 = sym2.isRealClass
+    if isRealClass1 && isRealClass2 then
+      return compareClasses
+    else if isRealClass1 then
+      return -1
+    else if isRealClass2 then
+      return 1
+
+    compareClasses
+  end compareErasedGlb
+
+  /** Does the (possibly generic) type `tp` have the same erasure in all its
+   *  possible instantiations?
+   */
+  def hasStableErasure(tp: Type)(using Context): Boolean = tp match {
+    case tp: TypeRef if !tp.symbol.isOpaqueAlias =>
+      tp.info match {
+        case TypeAlias(alias) => hasStableErasure(alias)
+        case _: ClassInfo => true
+        case _ => false
+      }
+    case tp: TypeParamRef => false
+    case tp: TypeBounds => false
+    case tp: TypeProxy => hasStableErasure(tp.translucentSuperType)
+    case tp: AndType => hasStableErasure(tp.tp1) && hasStableErasure(tp.tp2)
+    case tp: OrType  => hasStableErasure(tp.tp1) && hasStableErasure(tp.tp2)
+    case _ => false
+  }
+
+  /** The erasure of `PolyFunction { def apply: $applyInfo }` */
+  def erasePolyFunctionApply(applyInfo: Type)(using Context): Type =
+    assert(applyInfo.isInstanceOf[PolyType])
+    val res = applyInfo.resultType
+    val paramss = res.paramNamess
+    assert(paramss.length == 1)
+    erasure(defn.FunctionType(paramss.head.length,
+      isContextual = res.isImplicitMethod, isErased = res.isErasedMethod))
+}
+
+import TypeErasure._
+
+/**
+ *  @param sourceLanguage Adapt our erasure rules to mimic what the given language
+ *                        would do.
+ *  @param semiEraseVCs   If true, value classes are semi-erased to ErasedValueType
+ *                        (they will be fully erased in [[ElimErasedValueType]]).
+ *                        If false, they are erased like normal classes.
+ *  @param isConstructor  Argument forms part of the type of a constructor
+ *  @param isSymbol       If true, the type being erased is the info of a symbol.
+ *  @param wildcardOK     Wildcards are acceptable (true when using the erasure
+ *                        for computing a signature name).
+ */
+class TypeErasure(sourceLanguage: SourceLanguage, semiEraseVCs: Boolean, isConstructor: Boolean, isSymbol: Boolean, wildcardOK: Boolean) {
+
+  /**  The erasure |T| of a type T. This is:
+   *
+   *   - For a refined type scala.Array+[T]:
+   *      - if T is Nothing or Null, []Object
+   *      - otherwise, if T <: Object, []|T|
+   *      - otherwise, if T is a type parameter coming from Java, []Object
+   *      - otherwise, Object
+   *   - For a term ref p.x, the type <noprefix> # x.
+   *   - For a refined type scala.PolyFunction { def apply[...](x_1, ..., x_N): R }, scala.FunctionN
+   *   - For a typeref scala.Any, scala.AnyVal, scala.Singleton, scala.Tuple, or scala.*: : |java.lang.Object|
+   *   - For a typeref scala.Unit, |scala.runtime.BoxedUnit|.
+   *   - For a typeref scala.FunctionN, where N > MaxImplementedFunctionArity, scala.FunctionXXL
+   *   - For a typeref scala.ContextFunctionN, | scala.FunctionN |
+   *   - For a typeref P.C where C refers to a class, <noprefix> # C.
+   *   - For a typeref P.C where C refers to an alias type, the erasure of C's alias.
+   *   - For a typeref P.C where C refers to an abstract type, the erasure of C's upper bound.
+   *   - For a this-type C.this, the type itself.
+   *   - For all other type proxies: The erasure of the underlying type.
+   *   - For T1 & T2, the erased glb of |T1| and |T2| (see erasedGlb)
+   *   - For T1 | T2, the first base class in the linearization of T which is also a base class of T2
+   *   - For => T, ()T
+   *   - For a method type (Fs)scala.Unit, (|Fs|)scala.Unit.
+   *   - For any other uncurried method type (Fs)T, (|Fs|)|T|.
+   *   - For a curried method type (Fs1)(Fs2)T, (|Fs1|,Es2)ET where (Es2)ET = |(Fs2)T|.
+   *   - For a polymorphic type [Ts](Ps)T, |(Ps)T|
+   *   _ For a polymorphic type [Ts]T where T is not a method type, ()|T|
+   *   - For the class info type of java.lang.Object, the same type without any parents.
+   *   - For a class info type of a value class, the same type without any parents.
+   *   - For any other class info type with parents Ps, the same type with
+   *     parents |Ps|, but with duplicate references of Object removed.
+   *   - For NoType or NoPrefix, the type itself.
+   *   - For any other type, exception.
+   */
+  private def apply(tp: Type)(using Context): Type = tp match {
+    case _: ErasedValueType =>
+      tp
+    case tp: TypeRef =>
+      val sym = tp.symbol
+      if (!sym.isClass) this(tp.translucentSuperType)
+      else if (semiEraseVCs && isDerivedValueClass(sym)) eraseDerivedValueClass(tp)
+      else if (defn.isSyntheticFunctionClass(sym)) defn.functionTypeErasure(sym)
+      else eraseNormalClassRef(tp)
+    case tp: AppliedType =>
+      val tycon = tp.tycon
+      if (tycon.isRef(defn.ArrayClass)) eraseArray(tp)
+      else if (tycon.isRef(defn.PairClass)) erasePair(tp)
+      else if (tp.isRepeatedParam) apply(tp.translateFromRepeated(toArray = sourceLanguage.isJava))
+      else if (semiEraseVCs && isDerivedValueClass(tycon.classSymbol)) eraseDerivedValueClass(tp)
+      else apply(tp.translucentSuperType)
+    case tp: TermRef =>
+      this(underlyingOfTermRef(tp))
+    case _: ThisType =>
+      this(tp.widen)
+    case SuperType(thistpe, supertpe) =>
+      SuperType(this(thistpe), this(supertpe))
+    case ExprType(rt) =>
+      defn.FunctionType(0)
+    case RefinedType(parent, nme.apply, refinedInfo) if parent.typeSymbol eq defn.PolyFunctionClass =>
+      erasePolyFunctionApply(refinedInfo)
+    case tp: TypeProxy =>
+      this(tp.underlying)
+    case tp @ AndType(tp1, tp2) =>
+      if sourceLanguage.isJava then
+        this(tp1)
+      else if sourceLanguage.isScala2 then
+        this(Scala2Erasure.intersectionDominator(Scala2Erasure.flattenedParents(tp)))
+      else
+        erasedGlb(this(tp1), this(tp2))
+    case OrType(tp1, tp2) =>
+      if isSymbol && sourceLanguage.isScala2 && ctx.settings.scalajs.value then
+        // In Scala2Unpickler we unpickle Scala.js pseudo-unions as if they were
+        // real unions, but we must still erase them as Scala 2 would to emit
+        // the correct signatures in SJSIR.
+        // We only do this when `isSymbol` is true since in other situations we
+        // cannot distinguish a Scala.js pseudo-union from a Scala 3 union that
+        // has been substituted into a Scala 2 type (e.g., via `asSeenFrom`),
+        // erasing these unions as if they were pseudo-unions could have an
+        // impact on overriding relationships so it's best to leave them
+        // alone (and this doesn't impact the SJSIR we generate).
+        JSDefinitions.jsdefn.PseudoUnionType
+      else
+        TypeComparer.orType(this(tp1), this(tp2), isErased = true)
+    case tp: MethodType =>
+      def paramErasure(tpToErase: Type) =
+        erasureFn(sourceLanguage, semiEraseVCs, isConstructor, isSymbol, wildcardOK)(tpToErase)
+      val (names, formals0) = if (tp.isErasedMethod) (Nil, Nil) else (tp.paramNames, tp.paramInfos)
+      val formals = formals0.mapConserve(paramErasure)
+      eraseResult(tp.resultType) match {
+        case rt: MethodType =>
+          tp.derivedLambdaType(names ++ rt.paramNames, formals ++ rt.paramInfos, rt.resultType)
+        case NoType =>
+          // Can happen if we smuggle in a Nothing in the qualifier. Normally we prevent that
+          // in Checking.checkMembersOK, but compiler-generated code can bypass this test.
+          // See i15377.scala for a test case.
+          NoType
+        case rt =>
+          tp.derivedLambdaType(names, formals, rt)
+      }
+    case tp: PolyType =>
+      this(tp.resultType)
+    case tp @ ClassInfo(pre, cls, parents, decls, _) =>
+      if (cls.is(Package)) tp
+      else {
+        def eraseParent(tp: Type) = tp.dealias match { // note: can't be opaque, since it's a class parent
+          case tp: AppliedType if tp.tycon.isRef(defn.PairClass) => defn.ObjectType
+          case _ => apply(tp)
+        }
+        val erasedParents: List[Type] =
+          if ((cls eq defn.ObjectClass) || cls.isPrimitiveValueClass) Nil
+          else parents.mapConserve(eraseParent) match {
+            case tr :: trs1 =>
+              assert(!tr.classSymbol.is(Trait), i"$cls has bad parents $parents%, %")
+              val tr1 = if (cls.is(Trait)) defn.ObjectType else tr
+              tr1 :: trs1.filterNot(_.isAnyRef)
+            case nil => nil
+          }
+        var erasedDecls = decls.filteredScope(sym => !sym.isType || sym.isClass).openForMutations
+        for dcl <- erasedDecls.iterator do
+          if dcl.lastKnownDenotation.unforcedAnnotation(defn.TargetNameAnnot).isDefined
+             && dcl.targetName != dcl.name
+          then
+            if erasedDecls eq decls then erasedDecls = erasedDecls.cloneScope
+            erasedDecls.unlink(dcl)
+            erasedDecls.enter(dcl.targetName, dcl)
+        val selfType1 = if cls.is(Module) then cls.sourceModule.termRef else NoType
+        tp.derivedClassInfo(NoPrefix, erasedParents, erasedDecls, selfType1)
+          // can't replace selftype by NoType because this would lose the sourceModule link
+      }
+    case _: ErrorType | JavaArrayType(_) =>
+      tp
+    case tp: WildcardType if wildcardOK =>
+      tp
+    case tp if (tp `eq` NoType) || (tp `eq` NoPrefix) =>
+      tp
+  }
+
+  /** Widen term ref, skipping any `()` parameter of an eventual getter. Used to erase a TermRef.
+   *  Since getters are introduced after erasure, one would think that erasing a TermRef
+   *  could just use `widen`. However, it's possible that the TermRef got read from a class
+   *  file after Getters (i.e. in the backend). In that case, the reference will not get
+   *  an earlier denotation even when time travelling forward to erasure. Hence, we
+   *  need to take the extra precaution of going from nullary method types to their resuls.
+   *  A test case where this is needed is pos/i15649.scala, which fails non-deterministically
+   *  if `underlyingOfTermRef` is replaced by `widen`.
+   */
+  private def underlyingOfTermRef(tp: TermRef)(using Context) = tp.widen match
+    case tpw @ MethodType(Nil) if tp.symbol.isGetter => tpw.resultType
+    case tpw => tpw
+
+  private def eraseArray(tp: Type)(using Context) = {
+    val defn.ArrayOf(elemtp) = tp: @unchecked
+    if (isGenericArrayElement(elemtp, isScala2 = sourceLanguage.isScala2)) defn.ObjectType
+    else
+      try JavaArrayType(erasureFn(sourceLanguage, semiEraseVCs = false, isConstructor, isSymbol, wildcardOK)(elemtp))
+      catch case ex: Throwable =>
+        handleRecursive("erase array type", tp.show, ex)
+  }
+
+  private def erasePair(tp: Type)(using Context): Type = {
+    // NOTE: `tupleArity` does not consider TypeRef(EmptyTuple$) equivalent to EmptyTuple.type,
+    // we fix this for printers, but type erasure should be preserved.
+    val arity = tp.tupleArity
+    if (arity < 0) defn.ProductClass.typeRef
+    else if (arity <= Definitions.MaxTupleArity) defn.TupleType(arity).nn
+    else defn.TupleXXLClass.typeRef
+  }
+
+  /** The erasure of a symbol's info. This is different from `apply` in the way `ExprType`s and
+   *  `PolyType`s are treated. `eraseInfo` maps them them to method types, whereas `apply` maps them
+   *  to the underlying type.
+   */
+  def eraseInfo(tp: Type, sym: Symbol)(using Context): Type =
+    val tp1 = tp match
+      case tp: MethodicType => integrateContextResults(tp, contextResultCount(sym))
+      case _ => tp
+    tp1 match
+      case ExprType(rt) =>
+        if sym.is(Param) then apply(tp1)
+            // Note that params with ExprTypes are eliminated by ElimByName,
+            // but potentially re-introduced by ResolveSuper, when we add
+            // forwarders to mixin methods.
+            // See doc comment for ElimByName for speculation how we could improve this.
+        else
+          MethodType(Nil, Nil,
+            eraseResult(rt.translateFromRepeated(toArray = sourceLanguage.isJava)))
+      case tp1: PolyType =>
+        eraseResult(tp1.resultType) match
+          case rt: MethodType => rt
+          case rt => MethodType(Nil, Nil, rt)
+      case tp1 => this(tp1)
+
+  private def eraseDerivedValueClass(tp: Type)(using Context): Type = {
+    val cls = tp.classSymbol.asClass
+    val unbox = valueClassUnbox(cls)
+    if unbox.exists then
+      val genericUnderlying = unbox.info.resultType
+      val underlying = tp.select(unbox).widen.resultType
+
+      // The underlying part of an ErasedValueType cannot be an ErasedValueType itself
+      val erase = erasureFn(sourceLanguage, semiEraseVCs = false, isConstructor, isSymbol, wildcardOK)
+      val erasedUnderlying = erase(underlying)
+
+      // Ideally, we would just use `erasedUnderlying` as the erasure of `tp`, but to
+      // be binary-compatible with Scala 2 we need two special cases for polymorphic
+      // value classes:
+      // - Given `class Foo[A](x: A) extends AnyVal`, `Foo[X]` should erase like
+      //   `X`, except if its a primitive in which case it erases to the boxed
+      //   version of this primitive.
+      // - Given `class Bar[A](x: Array[A]) extends AnyVal`, `Bar[X]` will be
+      //   erased like `Array[A]` as seen from its definition site, no matter
+      //   the `X` (same if `A` is bounded).
+      //
+      // The binary compatibility is checked by sbt-test/scala2-compat/i8001
+      val erasedValueClass =
+        if erasedUnderlying.isPrimitiveValueType && !genericUnderlying.isPrimitiveValueType then
+          defn.boxedType(erasedUnderlying)
+        else if genericUnderlying.derivesFrom(defn.ArrayClass) then
+          erasure(genericUnderlying)
+        else erasedUnderlying
+
+      if erasedValueClass.exists then ErasedValueType(cls.typeRef, erasedValueClass)
+      else
+        assert(ctx.reporter.errorsReported, i"no erasure for $underlying")
+        NoType
+    else NoType
+  }
+
+  private def eraseNormalClassRef(tref: TypeRef)(using Context): Type = {
+    val cls = tref.symbol.asClass
+    (if (cls.owner.is(Package)) normalizeClass(cls) else cls).typeRef
+  }
+
+  /** The erasure of a function result type. */
+  def eraseResult(tp: Type)(using Context): Type =
+    // For a value class V, "new V(x)" should have type V for type adaptation to work
+    // correctly (see SIP-15 and [[Erasure.Boxing.adaptToType]]), so the result type of a
+    // constructor method should not be semi-erased.
+    if semiEraseVCs && isConstructor && !tp.isInstanceOf[MethodOrPoly] then
+      erasureFn(sourceLanguage, semiEraseVCs = false, isConstructor, isSymbol, wildcardOK).eraseResult(tp)
+    else tp match
+      case tp: TypeRef =>
+        val sym = tp.symbol
+        if (sym eq defn.UnitClass) sym.typeRef
+        else this(tp)
+      case tp: AppliedType =>
+        val sym = tp.tycon.typeSymbol
+        if (sym.isClass && !erasureDependsOnArgs(sym)) eraseResult(tp.tycon)
+        else this(tp)
+      case _ =>
+        this(tp)
+
+  /** The name of the type as it is used in `Signature`s.
+   *  Need to ensure correspondence with erasure!
+   */
+  private def sigName(tp: Type)(using Context): TypeName = try
+    tp match {
+      case tp: TypeRef =>
+        if (!tp.denot.exists)
+          // println(i"missing: ${tp.toString} ${tp.denot} / ${tp.prefix.member(tp.name)}")
+          throw new MissingType(tp.prefix, tp.name)
+        val sym = tp.symbol
+        if (!sym.isClass) {
+          val info = tp.translucentSuperType
+          if (!info.exists) assert(false, i"undefined: $tp with symbol $sym")
+          return sigName(info)
+        }
+        if (semiEraseVCs && isDerivedValueClass(sym)) {
+          val erasedVCRef = eraseDerivedValueClass(tp)
+          if (erasedVCRef.exists) return sigName(erasedVCRef)
+        }
+        if (defn.isSyntheticFunctionClass(sym))
+          sigName(defn.functionTypeErasure(sym))
+        else
+          val cls = normalizeClass(sym.asClass)
+          val fullName =
+            if !ctx.erasedTypes then
+              // It's important to use the initial symbol to compute the full name
+              // because the current symbol might have a different name or owner
+              // and signatures are required to be stable before erasure.
+              cls.initial.fullName
+            else
+              cls.fullName
+          fullName.asTypeName
+      case tp: AppliedType =>
+        val sym = tp.tycon.typeSymbol
+        sigName( // todo: what about repeatedParam?
+          if (erasureDependsOnArgs(sym)) this(tp)
+          else if (sym.isClass) tp.underlying
+          else tp.translucentSuperType)
+      case ErasedValueType(_, underlying) =>
+        sigName(underlying)
+      case JavaArrayType(elem) =>
+        sigName(elem) ++ "[]"
+      case tp: TermRef =>
+        sigName(underlyingOfTermRef(tp))
+      case ExprType(rt) =>
+        sigName(defn.FunctionOf(Nil, rt))
+      case tp: TypeVar =>
+        val inst = tp.instanceOpt
+        if (inst.exists) sigName(inst) else tpnme.Uninstantiated
+      case tp @ RefinedType(parent, nme.apply, _) if parent.typeSymbol eq defn.PolyFunctionClass =>
+        // we need this case rather than falling through to the default
+        // because RefinedTypes <: TypeProxy and it would be caught by
+        // the case immediately below
+        sigName(this(tp))
+      case tp: TypeProxy =>
+        sigName(tp.underlying)
+      case tp: WildcardType =>
+        tpnme.Uninstantiated
+      case _: ErrorType | NoType =>
+        tpnme.ERROR
+      case _ =>
+        val erasedTp = this(tp)
+        assert(erasedTp ne tp, tp)
+        sigName(erasedTp)
+    }
+  catch {
+    case ex: AssertionError =>
+      println(s"no sig for $tp because of ${ex.printStackTrace()}")
+      throw ex
+  }
+}
diff --git a/tests/pos-with-compiler-cc/dotc/core/TypeErrors.scala b/tests/pos-with-compiler-cc/dotc/core/TypeErrors.scala
new file mode 100644
index 000000000000..4d8aae319d27
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/core/TypeErrors.scala
@@ -0,0 +1,170 @@
+package dotty.tools
+package dotc
+package core
+
+import Types._
+import Symbols._
+import Flags._
+import Names._
+import Contexts._
+import SymDenotations._
+import Denotations._
+import Decorators._
+import reporting._
+import ast.untpd
+import config.Printers.cyclicErrors
+import language.experimental.pureFunctions
+
+class TypeError(msg: String) extends Exception(msg) {
+  def this() = this("")
+  final def toMessage(using Context): Message =
+    withMode(Mode.Printing)(produceMessage)
+  def produceMessage(using Context): Message = super.getMessage.nn.toMessage
+  override def getMessage: String = super.getMessage.nn
+}
+
+class MalformedType(pre: Type, denot: Denotation, absMembers: Set[Name]) extends TypeError {
+  override def produceMessage(using Context): Message =
+    i"malformed type: $pre is not a legal prefix for $denot because it contains abstract type member${if (absMembers.size == 1) "" else "s"} ${absMembers.mkString(", ")}"
+      .toMessage
+}
+
+class MissingType(pre: Type, name: Name) extends TypeError {
+  private def otherReason(pre: Type)(using Context): String = pre match {
+    case pre: ThisType if pre.cls.givenSelfType.exists =>
+      i"\nor the self type of $pre might not contain all transitive dependencies"
+    case _ => ""
+  }
+
+  override def produceMessage(using Context): Message = {
+    if (ctx.debug) printStackTrace()
+    i"""cannot resolve reference to type $pre.$name
+       |the classfile defining the type might be missing from the classpath${otherReason(pre)}"""
+      .toMessage
+  }
+}
+
+class RecursionOverflow(val op: String, details: -> String, val previous: Throwable, val weight: Int)
+extends TypeError {
+
+  def explanation: String = s"$op $details"
+
+  private def recursions: List[RecursionOverflow] = {
+    import scala.collection.mutable.ListBuffer
+    val result = ListBuffer.empty[RecursionOverflow]
+    @annotation.tailrec def loop(throwable: Throwable): List[RecursionOverflow] = throwable match {
+      case ro: RecursionOverflow =>
+        result += ro
+        loop(ro.previous)
+      case _ => result.toList
+    }
+
+    loop(this)
+  }
+
+  def opsString(rs: List[RecursionOverflow])(using Context): String = {
+    val maxShown = 20
+    if (rs.lengthCompare(maxShown) > 0)
+      i"""${opsString(rs.take(maxShown / 2))}
+         |  ...
+         |${opsString(rs.takeRight(maxShown / 2))}"""
+    else
+      (rs.map(_.explanation): List[String]).mkString("\n  ", "\n|  ", "")
+  }
+
+  override def produceMessage(using Context): Message = NoExplanation {
+    val mostCommon = recursions.groupBy(_.op).toList.maxBy(_._2.map(_.weight).sum)._2.reverse
+    s"""Recursion limit exceeded.
+       |Maybe there is an illegal cyclic reference?
+       |If that's not the case, you could also try to increase the stacksize using the -Xss JVM option.
+       |For the unprocessed stack trace, compile with -Yno-decode-stacktraces.
+       |A recurring operation is (inner to outer):
+       |${opsString(mostCommon)}""".stripMargin
+  }
+
+  override def fillInStackTrace(): Throwable = this
+  override def getStackTrace(): Array[StackTraceElement] = previous.getStackTrace().asInstanceOf
+}
+
+/** Post-process exceptions that might result from StackOverflow to add
+  * tracing information while unwalking the stack.
+  */
+// Beware: Since this object is only used when handling a StackOverflow, this code
+// cannot consume significant amounts of stack.
+object handleRecursive {
+  def apply(op: String, details: -> String, exc: Throwable, weight: Int = 1)(using Context): Nothing =
+    if (ctx.settings.YnoDecodeStacktraces.value)
+      throw exc
+    else
+      exc match {
+        case _: RecursionOverflow =>
+          throw new RecursionOverflow(op, details, exc, weight)
+        case _ =>
+          var e: Throwable | Null = exc
+          while (e != null && !e.isInstanceOf[StackOverflowError]) e = e.getCause
+          if (e != null) throw new RecursionOverflow(op, details, e, weight)
+          else throw exc
+      }
+}
+
+/**
+ * This TypeError signals that completing denot encountered a cycle: it asked for denot.info (or similar),
+ * so it requires knowing denot already.
+ * @param denot
+ */
+class CyclicReference private (val denot: SymDenotation) extends TypeError {
+  var inImplicitSearch: Boolean = false
+
+  override def produceMessage(using Context): Message = {
+    val cycleSym = denot.symbol
+
+    // cycleSym.flags would try completing denot and would fail, but here we can use flagsUNSAFE to detect flags
+    // set by the parser.
+    val unsafeFlags = cycleSym.flagsUNSAFE
+    val isMethod = unsafeFlags.is(Method)
+    val isVal = !isMethod && cycleSym.isTerm
+
+    /* This CyclicReference might have arisen from asking for `m`'s type while trying to infer it.
+     * To try to diagnose this, walk the context chain searching for context in
+     * Mode.InferringReturnType for the innermost member without type
+     * annotations (!tree.tpt.typeOpt.exists).
+     */
+    def errorMsg(cx: Context): Message =
+      if (cx.mode is Mode.InferringReturnType)
+        cx.tree match {
+          case tree: untpd.ValOrDefDef if !tree.tpt.typeOpt.exists =>
+            if (inImplicitSearch)
+              TermMemberNeedsResultTypeForImplicitSearch(cycleSym)
+            else if (isMethod)
+              OverloadedOrRecursiveMethodNeedsResultType(cycleSym)
+            else if (isVal)
+              RecursiveValueNeedsResultType(cycleSym)
+            else
+              errorMsg(cx.outer)
+          case _ =>
+            errorMsg(cx.outer)
+        }
+
+      // Give up and give generic errors.
+      else if (cycleSym.isOneOf(GivenOrImplicitVal, butNot = Method) && cycleSym.owner.isTerm)
+        CyclicReferenceInvolvingImplicit(cycleSym)
+      else
+        CyclicReferenceInvolving(denot)
+
+    errorMsg(ctx)
+  }
+}
+
+object CyclicReference {
+  def apply(denot: SymDenotation)(using Context): CyclicReference = {
+    val ex = new CyclicReference(denot)
+    if (!(ctx.mode is Mode.CheckCyclic) || ctx.settings.Ydebug.value) {
+      cyclicErrors.println(s"Cyclic reference involving! $denot")
+      val sts = ex.getStackTrace.asInstanceOf[Array[StackTraceElement]]
+      for (elem <- sts take 200)
+        cyclicErrors.println(elem.toString)
+    }
+    ex
+  }
+}
+
diff --git a/tests/pos-with-compiler-cc/dotc/core/TypeEval.scala b/tests/pos-with-compiler-cc/dotc/core/TypeEval.scala
new file mode 100644
index 000000000000..7ec0f12db3b6
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/core/TypeEval.scala
@@ -0,0 +1,247 @@
+package dotty.tools
+package dotc
+package core
+
+import Types.*, Contexts.*, Symbols.*, Constants.*, Decorators.*
+import config.Printers.typr
+import reporting.trace
+import StdNames.tpnme
+
+object TypeEval:
+
+  def tryCompiletimeConstantFold(tp: AppliedType)(using Context): Type = tp.tycon match
+    case tycon: TypeRef if defn.isCompiletimeAppliedType(tycon.symbol) =>
+      extension (tp: Type) def fixForEvaluation: Type =
+        tp.normalized.dealias match
+          // enable operations for constant singleton terms. E.g.:
+          // ```
+          // final val one = 1
+          // type Two = one.type + one.type
+          // ```
+          case tp: TypeProxy =>
+            val tp1 = tp.superType
+            if tp1.isStable then tp1.fixForEvaluation else tp
+          case tp => tp
+
+      def constValue(tp: Type): Option[Any] = tp.fixForEvaluation match
+        case ConstantType(Constant(n)) => Some(n)
+        case _ => None
+
+      def boolValue(tp: Type): Option[Boolean] = tp.fixForEvaluation match
+        case ConstantType(Constant(n: Boolean)) => Some(n)
+        case _ => None
+
+      def intValue(tp: Type): Option[Int] = tp.fixForEvaluation match
+        case ConstantType(Constant(n: Int)) => Some(n)
+        case _ => None
+
+      def longValue(tp: Type): Option[Long] = tp.fixForEvaluation match
+        case ConstantType(Constant(n: Long)) => Some(n)
+        case _ => None
+
+      def floatValue(tp: Type): Option[Float] = tp.fixForEvaluation match
+        case ConstantType(Constant(n: Float)) => Some(n)
+        case _ => None
+
+      def doubleValue(tp: Type): Option[Double] = tp.fixForEvaluation match
+        case ConstantType(Constant(n: Double)) => Some(n)
+        case _ => None
+
+      def stringValue(tp: Type): Option[String] = tp.fixForEvaluation match
+        case ConstantType(Constant(n: String)) => Some(n)
+        case _ => None
+
+      // Returns Some(true) if the type is a constant.
+      // Returns Some(false) if the type is not a constant.
+      // Returns None if there is not enough information to determine if the type is a constant.
+      // The type is a constant if it is a constant type or a type operation composition of constant types.
+      // If we get a type reference for an argument, then the result is not yet known.
+      def isConst(tp: Type): Option[Boolean] = tp.dealias match
+        // known to be constant
+        case ConstantType(_) => Some(true)
+        // currently not a concrete known type
+        case TypeRef(NoPrefix,_) => None
+        // currently not a concrete known type
+        case _: TypeParamRef => None
+        // constant if the term is constant
+        case t: TermRef =>
+          if t.denot.symbol.flagsUNSAFE.is(Flags.Param) then
+            // might be substituted later
+            None
+          else
+            isConst(t.underlying)
+        // an operation type => recursively check all argument compositions
+        case applied: AppliedType if defn.isCompiletimeAppliedType(applied.typeSymbol) =>
+          val argsConst = applied.args.map(isConst)
+          if (argsConst.exists(_.isEmpty)) None
+          else Some(argsConst.forall(_.get))
+        // all other types are considered not to be constant
+        case _ => Some(false)
+
+      def expectArgsNum(expectedNum: Int): Unit =
+      // We can use assert instead of a compiler type error because this error should not
+      // occur since the type signature of the operation enforces the proper number of args.
+        assert(tp.args.length == expectedNum, s"Type operation expects $expectedNum arguments but found ${tp.args.length}")
+
+      def natValue(tp: Type): Option[Int] = intValue(tp).filter(n => n >= 0 && n < Int.MaxValue)
+
+      // Runs the op and returns the result as a constant type.
+      // If the op throws an exception, then this exception is converted into a type error.
+      def runConstantOp(op: => Any): Type =
+        val result =
+          try op
+          catch case e: Throwable =>
+            throw new TypeError(e.getMessage.nn)
+        ConstantType(Constant(result))
+
+      def constantFold1[T](extractor: Type => Option[T], op: T => Any): Option[Type] =
+        expectArgsNum(1)
+        extractor(tp.args.head).map(a => runConstantOp(op(a)))
+
+      def constantFold2[T](extractor: Type => Option[T], op: (T, T) => Any): Option[Type] =
+        constantFold2AB(extractor, extractor, op)
+
+      def constantFold2AB[TA, TB](extractorA: Type => Option[TA], extractorB: Type => Option[TB], op: (TA, TB) => Any): Option[Type] =
+        expectArgsNum(2)
+        for
+          a <- extractorA(tp.args(0))
+          b <- extractorB(tp.args(1))
+        yield runConstantOp(op(a, b))
+
+      def constantFold3[TA, TB, TC](
+        extractorA: Type => Option[TA],
+        extractorB: Type => Option[TB],
+        extractorC: Type => Option[TC],
+        op: (TA, TB, TC) => Any
+      ): Option[Type] =
+        expectArgsNum(3)
+        for
+          a <- extractorA(tp.args(0))
+          b <- extractorB(tp.args(1))
+          c <- extractorC(tp.args(2))
+        yield runConstantOp(op(a, b, c))
+
+      trace(i"compiletime constant fold $tp", typr, show = true) {
+        val name = tycon.symbol.name
+        val owner = tycon.symbol.owner
+        val constantType =
+          if defn.isCompiletime_S(tycon.symbol) then
+            constantFold1(natValue, _ + 1)
+          else if owner == defn.CompiletimeOpsAnyModuleClass then name match
+            case tpnme.Equals     => constantFold2(constValue, _ == _)
+            case tpnme.NotEquals  => constantFold2(constValue, _ != _)
+            case tpnme.ToString   => constantFold1(constValue, _.toString)
+            case tpnme.IsConst    => isConst(tp.args.head).map(b => ConstantType(Constant(b)))
+            case _ => None
+          else if owner == defn.CompiletimeOpsIntModuleClass then name match
+            case tpnme.Abs        => constantFold1(intValue, _.abs)
+            case tpnme.Negate     => constantFold1(intValue, x => -x)
+            // ToString is deprecated for ops.int, and moved to ops.any
+            case tpnme.ToString   => constantFold1(intValue, _.toString)
+            case tpnme.Plus       => constantFold2(intValue, _ + _)
+            case tpnme.Minus      => constantFold2(intValue, _ - _)
+            case tpnme.Times      => constantFold2(intValue, _ * _)
+            case tpnme.Div        => constantFold2(intValue, _ / _)
+            case tpnme.Mod        => constantFold2(intValue, _ % _)
+            case tpnme.Lt         => constantFold2(intValue, _ < _)
+            case tpnme.Gt         => constantFold2(intValue, _ > _)
+            case tpnme.Ge         => constantFold2(intValue, _ >= _)
+            case tpnme.Le         => constantFold2(intValue, _ <= _)
+            case tpnme.Xor        => constantFold2(intValue, _ ^ _)
+            case tpnme.BitwiseAnd => constantFold2(intValue, _ & _)
+            case tpnme.BitwiseOr  => constantFold2(intValue, _ | _)
+            case tpnme.ASR        => constantFold2(intValue, _ >> _)
+            case tpnme.LSL        => constantFold2(intValue, _ << _)
+            case tpnme.LSR        => constantFold2(intValue, _ >>> _)
+            case tpnme.Min        => constantFold2(intValue, _ min _)
+            case tpnme.Max        => constantFold2(intValue, _ max _)
+            case tpnme.NumberOfLeadingZeros => constantFold1(intValue, Integer.numberOfLeadingZeros(_))
+            case tpnme.ToLong     => constantFold1(intValue, _.toLong)
+            case tpnme.ToFloat    => constantFold1(intValue, _.toFloat)
+            case tpnme.ToDouble   => constantFold1(intValue, _.toDouble)
+            case _ => None
+          else if owner == defn.CompiletimeOpsLongModuleClass then name match
+            case tpnme.Abs        => constantFold1(longValue, _.abs)
+            case tpnme.Negate     => constantFold1(longValue, x => -x)
+            case tpnme.Plus       => constantFold2(longValue, _ + _)
+            case tpnme.Minus      => constantFold2(longValue, _ - _)
+            case tpnme.Times      => constantFold2(longValue, _ * _)
+            case tpnme.Div        => constantFold2(longValue, _ / _)
+            case tpnme.Mod        => constantFold2(longValue, _ % _)
+            case tpnme.Lt         => constantFold2(longValue, _ < _)
+            case tpnme.Gt         => constantFold2(longValue, _ > _)
+            case tpnme.Ge         => constantFold2(longValue, _ >= _)
+            case tpnme.Le         => constantFold2(longValue, _ <= _)
+            case tpnme.Xor        => constantFold2(longValue, _ ^ _)
+            case tpnme.BitwiseAnd => constantFold2(longValue, _ & _)
+            case tpnme.BitwiseOr  => constantFold2(longValue, _ | _)
+            case tpnme.ASR        => constantFold2(longValue, _ >> _)
+            case tpnme.LSL        => constantFold2(longValue, _ << _)
+            case tpnme.LSR        => constantFold2(longValue, _ >>> _)
+            case tpnme.Min        => constantFold2(longValue, _ min _)
+            case tpnme.Max        => constantFold2(longValue, _ max _)
+            case tpnme.NumberOfLeadingZeros =>
+              constantFold1(longValue, java.lang.Long.numberOfLeadingZeros(_))
+            case tpnme.ToInt      => constantFold1(longValue, _.toInt)
+            case tpnme.ToFloat    => constantFold1(longValue, _.toFloat)
+            case tpnme.ToDouble   => constantFold1(longValue, _.toDouble)
+            case _ => None
+          else if owner == defn.CompiletimeOpsFloatModuleClass then name match
+            case tpnme.Abs        => constantFold1(floatValue, _.abs)
+            case tpnme.Negate     => constantFold1(floatValue, x => -x)
+            case tpnme.Plus       => constantFold2(floatValue, _ + _)
+            case tpnme.Minus      => constantFold2(floatValue, _ - _)
+            case tpnme.Times      => constantFold2(floatValue, _ * _)
+            case tpnme.Div        => constantFold2(floatValue, _ / _)
+            case tpnme.Mod        => constantFold2(floatValue, _ % _)
+            case tpnme.Lt         => constantFold2(floatValue, _ < _)
+            case tpnme.Gt         => constantFold2(floatValue, _ > _)
+            case tpnme.Ge         => constantFold2(floatValue, _ >= _)
+            case tpnme.Le         => constantFold2(floatValue, _ <= _)
+            case tpnme.Min        => constantFold2(floatValue, _ min _)
+            case tpnme.Max        => constantFold2(floatValue, _ max _)
+            case tpnme.ToInt      => constantFold1(floatValue, _.toInt)
+            case tpnme.ToLong     => constantFold1(floatValue, _.toLong)
+            case tpnme.ToDouble   => constantFold1(floatValue, _.toDouble)
+            case _ => None
+          else if owner == defn.CompiletimeOpsDoubleModuleClass then name match
+            case tpnme.Abs        => constantFold1(doubleValue, _.abs)
+            case tpnme.Negate     => constantFold1(doubleValue, x => -x)
+            case tpnme.Plus       => constantFold2(doubleValue, _ + _)
+            case tpnme.Minus      => constantFold2(doubleValue, _ - _)
+            case tpnme.Times      => constantFold2(doubleValue, _ * _)
+            case tpnme.Div        => constantFold2(doubleValue, _ / _)
+            case tpnme.Mod        => constantFold2(doubleValue, _ % _)
+            case tpnme.Lt         => constantFold2(doubleValue, _ < _)
+            case tpnme.Gt         => constantFold2(doubleValue, _ > _)
+            case tpnme.Ge         => constantFold2(doubleValue, _ >= _)
+            case tpnme.Le         => constantFold2(doubleValue, _ <= _)
+            case tpnme.Min        => constantFold2(doubleValue, _ min _)
+            case tpnme.Max        => constantFold2(doubleValue, _ max _)
+            case tpnme.ToInt      => constantFold1(doubleValue, _.toInt)
+            case tpnme.ToLong     => constantFold1(doubleValue, _.toLong)
+            case tpnme.ToFloat    => constantFold1(doubleValue, _.toFloat)
+            case _ => None
+          else if owner == defn.CompiletimeOpsStringModuleClass then name match
+            case tpnme.Plus       => constantFold2(stringValue, _ + _)
+            case tpnme.Length     => constantFold1(stringValue, _.length)
+            case tpnme.Matches    => constantFold2(stringValue, _ matches _)
+            case tpnme.Substring  =>
+              constantFold3(stringValue, intValue, intValue, (s, b, e) => s.substring(b, e))
+            case tpnme.CharAt     =>
+              constantFold2AB(stringValue, intValue, _ charAt _)
+            case _ => None
+          else if owner == defn.CompiletimeOpsBooleanModuleClass then name match
+            case tpnme.Not        => constantFold1(boolValue, x => !x)
+            case tpnme.And        => constantFold2(boolValue, _ && _)
+            case tpnme.Or         => constantFold2(boolValue, _ || _)
+            case tpnme.Xor        => constantFold2(boolValue, _ ^ _)
+            case _ => None
+          else None
+
+        constantType.getOrElse(NoType)
+      }
+
+    case _ => NoType
+  end tryCompiletimeConstantFold
+end TypeEval
diff --git a/tests/pos-with-compiler-cc/dotc/core/TypeOps.scala b/tests/pos-with-compiler-cc/dotc/core/TypeOps.scala
new file mode 100644
index 000000000000..920a8d645278
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/core/TypeOps.scala
@@ -0,0 +1,968 @@
+package dotty.tools
+package dotc
+package core
+
+import Contexts._, Types._, Symbols._, Names._, Flags._
+import SymDenotations._
+import util.Spans._
+import util.Stats
+import Decorators._
+import StdNames._
+import collection.mutable
+import ast.tpd._
+import reporting.trace
+import config.Printers.typr
+import config.Feature
+import typer.ProtoTypes._
+import typer.ForceDegree
+import typer.Inferencing._
+import typer.IfBottom
+import reporting.TestingReporter
+import cc.{CapturingType, derivedCapturingType, CaptureSet, isBoxed, isBoxedCapturing}
+import CaptureSet.{CompareResult, IdempotentCaptRefMap, IdentityCaptRefMap}
+
+import scala.annotation.internal.sharable
+import scala.annotation.threadUnsafe
+import language.experimental.pureFunctions
+
+object TypeOps:
+
+  @sharable var track: Boolean = false // for debugging
+
+  /** The type `tp` as seen from prefix `pre` and owner `cls`. See the spec
+   *  for what this means.
+   */
+  final def asSeenFrom(tp: Type, pre: Type, cls: Symbol)(using Context): Type = {
+    pre match {
+      case pre: QualSkolemType =>
+        // When a selection has an unstable qualifier, the qualifier type gets
+        // wrapped in a `QualSkolemType` so that it may appear soundly as the
+        // prefix of a path in the selection type.
+        // However, we'd like to avoid referring to skolems when possible since
+        // they're an extra level of indirection we usually don't need, so we
+        // compute the type as seen from the widened prefix, and in the rare
+        // cases where this leads to an approximated type we recompute it with
+        // the skolemized prefix. See the i6199* tests for usecases.
+        val widenedAsf = new AsSeenFromMap(pre.info, cls)
+        val ret = widenedAsf.apply(tp)
+
+        if widenedAsf.approxCount == 0 then
+          return ret
+
+        Stats.record("asSeenFrom skolem prefix required")
+      case _ =>
+    }
+
+    new AsSeenFromMap(pre, cls).apply(tp)
+  }
+
+  /** The TypeMap handling the asSeenFrom */
+  class AsSeenFromMap(pre: Type, cls: Symbol)(using Context) extends ApproximatingTypeMap, IdempotentCaptRefMap {
+
+    /** The number of range approximations in invariant or contravariant positions
+     *  performed by this TypeMap.
+     *   - Incremented each time we produce a range.
+     *   - Decremented each time we drop a prefix range by forwarding to a type alias
+     *     or singleton type.
+     */
+    private[TypeOps] var approxCount: Int = 0
+
+    def apply(tp: Type): Type = {
+
+      /** Map a `C.this` type to the right prefix. If the prefix is unstable, and
+       *  the current variance is <= 0, return a range.
+       *  @param  pre     The prefix
+       *  @param  cls     The class in which the `C.this` type occurs
+       *  @param  thiscls The prefix `C` of the `C.this` type.
+       */
+      def toPrefix(pre: Type, cls: Symbol, thiscls: ClassSymbol): Type = /*>|>*/ trace.conditionally(track, s"toPrefix($pre, $cls, $thiscls)", show = true) /*<|<*/ {
+        if ((pre eq NoType) || (pre eq NoPrefix) || (cls is PackageClass))
+          tp
+        else pre match {
+          case pre: SuperType => toPrefix(pre.thistpe, cls, thiscls)
+          case _ =>
+            if (thiscls.derivesFrom(cls) && pre.baseType(thiscls).exists)
+              if (variance <= 0 && !isLegalPrefix(pre))
+                approxCount += 1
+                range(defn.NothingType, pre)
+              else pre
+            else if (pre.termSymbol.is(Package) && !thiscls.is(Package))
+              toPrefix(pre.select(nme.PACKAGE), cls, thiscls)
+            else
+              toPrefix(pre.baseType(cls).normalizedPrefix, cls.owner, thiscls)
+        }
+      }
+
+      trace.conditionally(track, s"asSeen ${tp.show} from (${pre.show}, ${cls.show})", show = true) { // !!! DEBUG
+        // All cases except for ThisType are the same as in Map. Inlined for performance
+        // TODO: generalize the inlining trick?
+        tp match {
+          case tp: NamedType =>
+            val sym = tp.symbol
+            if (sym.isStatic && !sym.maybeOwner.seesOpaques || (tp.prefix `eq` NoPrefix)) tp
+            else derivedSelect(tp, atVariance(variance max 0)(this(tp.prefix)))
+          case tp: LambdaType =>
+            mapOverLambda(tp) // special cased common case
+          case tp: ThisType =>
+            toPrefix(pre, cls, tp.cls)
+          case _: BoundType =>
+            tp
+          case _ =>
+            mapOver(tp)
+        }
+      }
+    }
+
+    override def reapply(tp: Type): Type =
+      // derived infos have already been subjected to asSeenFrom, hence to need to apply the map again.
+      tp
+
+    override protected def useAlternate(tp: Type): Type =
+      assert(approxCount > 0)
+      approxCount -= 1
+      tp
+  }
+
+  def isLegalPrefix(pre: Type)(using Context): Boolean =
+    pre.isStable || !ctx.phase.isTyper
+
+  /** Implementation of Types#simplified */
+  def simplify(tp: Type, theMap: SimplifyMap | Null)(using Context): Type = {
+    def mapOver = (if (theMap != null) theMap else new SimplifyMap).mapOver(tp)
+    tp match {
+      case tp: NamedType =>
+        if (tp.symbol.isStatic || (tp.prefix `eq` NoPrefix)) tp
+        else tp.derivedSelect(simplify(tp.prefix, theMap)) match {
+          case tp1: NamedType if tp1.denotationIsCurrent =>
+            val tp2 = tp1.reduceProjection
+            //if (tp2 ne tp1) println(i"simplified $tp1 -> $tp2")
+            tp2
+          case tp1 => tp1
+        }
+      case defn.MatchCase(pat, body) =>
+        defn.MatchCase(simplify(pat, theMap), body)
+      case tp: AppliedType =>
+        tp.tycon match
+          case tycon: TypeRef if tycon.info.isInstanceOf[MatchAlias] =>
+            isFullyDefined(tp, ForceDegree.all)
+          case _ =>
+        val normed = tp.tryNormalize
+        if normed.exists then normed else tp.map(simplify(_, theMap))
+      case tp: TypeParamRef =>
+        val tvar = ctx.typerState.constraint.typeVarOfParam(tp)
+        if tvar.exists then tvar else tp
+      case  _: ThisType | _: BoundType =>
+        tp
+      case tp: AliasingBounds =>
+        tp.derivedAlias(simplify(tp.alias, theMap))
+      case AndType(l, r) if !ctx.mode.is(Mode.Type) =>
+        simplify(l, theMap) & simplify(r, theMap)
+      case tp @ OrType(l, r)
+      if !ctx.mode.is(Mode.Type)
+         && (tp.isSoft || l.isBottomType || r.isBottomType) =>
+        // Normalize A | Null and Null | A to A even if the union is hard (i.e.
+        // explicitly declared), but not if -Yexplicit-nulls is set. The reason is
+        // that in this case the normal asSeenFrom machinery is not prepared to deal
+        // with Nulls (which have no base classes). Under -Yexplicit-nulls, we take
+        // corrective steps, so no widening is wanted.
+        simplify(l, theMap) | simplify(r, theMap)
+      case tp @ CapturingType(parent, refs) =>
+        if !ctx.mode.is(Mode.Type)
+            && refs.subCaptures(parent.captureSet, frozen = true).isOK
+            && (tp.isBoxed || !parent.isBoxedCapturing)
+              // fuse types with same boxed status and outer boxed with any type
+        then
+          simplify(parent, theMap)
+        else
+          mapOver
+      case tp @ AnnotatedType(parent, annot) =>
+        val parent1 = simplify(parent, theMap)
+        if annot.symbol == defn.UncheckedVarianceAnnot
+            && !ctx.mode.is(Mode.Type)
+            && !theMap.isInstanceOf[SimplifyKeepUnchecked]
+        then parent1
+        else tp.derivedAnnotatedType(parent1, annot)
+      case _: MatchType =>
+        val normed = tp.tryNormalize
+        if (normed.exists) normed else mapOver
+      case tp: MethodicType =>
+        // See documentation of `Types#simplified`
+        val addTypeVars = new TypeMap with IdempotentCaptRefMap:
+          val constraint = ctx.typerState.constraint
+          def apply(t: Type): Type = t match
+            case t: TypeParamRef => constraint.typeVarOfParam(t).orElse(t)
+            case _ => this.mapOver(t)
+        addTypeVars(tp)
+      case tp: SkolemType =>
+        // Mapping over a skolem creates a new skolem which by definition won't
+        // be =:= to the original one.
+        tp
+      case _ =>
+        mapOver
+    }
+  }
+
+  class SimplifyMap(using Context) extends IdentityCaptRefMap {
+    def apply(tp: Type): Type = simplify(tp, this)
+  }
+
+  class SimplifyKeepUnchecked(using Context) extends SimplifyMap
+
+  /** Approximate union type by intersection of its dominators.
+   *  That is, replace a union type Tn | ... | Tn
+   *  by the smallest intersection type of base-class instances of T1,...,Tn.
+   *  Example: Given
+   *
+   *      trait C[+T]
+   *      trait D
+   *      class A extends C[A] with D
+   *      class B extends C[B] with D with E
+   *
+   *  we approximate `A | B` by `C[A | B] with D`.
+   *
+   *  Before we do that, we try to find a common non-class supertype of T1 | ... | Tn
+   *  in a "best effort", ad-hoc way by selectively widening types in `T1, ..., Tn`
+   *  and stopping if the resulting union simplifies to a type that is not a disjunction.
+   */
+  def orDominator(tp: Type)(using Context): Type = {
+
+    /** a faster version of cs1 intersect cs2 that treats bottom types correctly */
+    def intersect(cs1: List[ClassSymbol], cs2: List[ClassSymbol]): List[ClassSymbol] =
+      if cs1.head == defn.NothingClass then cs2
+      else if cs2.head == defn.NothingClass then cs1
+      else if cs1.head == defn.NullClass && !ctx.explicitNulls && cs2.head.derivesFrom(defn.ObjectClass) then cs2
+      else if cs2.head == defn.NullClass && !ctx.explicitNulls && cs1.head.derivesFrom(defn.ObjectClass) then cs1
+      else
+        val cs2AsSet = new util.HashSet[ClassSymbol](128)
+        cs2.foreach(cs2AsSet += _)
+        cs1.filter(cs2AsSet.contains)
+
+    /** The minimal set of classes in `cs` which derive all other classes in `cs` */
+    def dominators(cs: List[ClassSymbol], accu: List[ClassSymbol]): List[ClassSymbol] = (cs: @unchecked) match {
+      case c :: rest =>
+        val accu1 = if (accu exists (_ derivesFrom c)) accu else c :: accu
+        if (cs == c.baseClasses) accu1 else dominators(rest, accu1)
+      case Nil => // this case can happen because after erasure we do not have a top class anymore
+        assert(ctx.erasedTypes || ctx.reporter.errorsReported)
+        defn.ObjectClass :: Nil
+    }
+
+    def mergeRefinedOrApplied(tp1: Type, tp2: Type): Type = {
+      def fail = throw new AssertionError(i"Failure to join alternatives $tp1 and $tp2")
+      def fallback = tp2 match
+        case AndType(tp21, tp22) =>
+          mergeRefinedOrApplied(tp1, tp21) & mergeRefinedOrApplied(tp1, tp22)
+        case _ =>
+          fail
+      tp1 match {
+        case tp1 @ RefinedType(parent1, name1, rinfo1) =>
+          tp2 match {
+            case RefinedType(parent2, `name1`, rinfo2) =>
+              tp1.derivedRefinedType(
+                mergeRefinedOrApplied(parent1, parent2), name1, rinfo1 | rinfo2)
+            case _ => fallback
+          }
+        case tp1 @ AppliedType(tycon1, args1) =>
+          tp2 match {
+            case AppliedType(tycon2, args2) =>
+              tp1.derivedAppliedType(
+                mergeRefinedOrApplied(tycon1, tycon2),
+                TypeComparer.lubArgs(args1, args2, tycon1.typeParams))
+            case _ => fallback
+          }
+        case tp1 @ TypeRef(pre1, _) =>
+          tp2 match {
+            case tp2 @ TypeRef(pre2, _) if tp1.name eq tp2.name =>
+              tp1.derivedSelect(pre1 | pre2)
+            case _ => fallback
+          }
+        case AndType(tp11, tp12) =>
+          mergeRefinedOrApplied(tp11, tp2) & mergeRefinedOrApplied(tp12, tp2)
+        case _ => fail
+      }
+    }
+
+    def approximateOr(tp1: Type, tp2: Type): Type = {
+      def isClassRef(tp: Type): Boolean = tp match {
+        case tp: TypeRef => tp.symbol.isClass
+        case tp: AppliedType => isClassRef(tp.tycon)
+        case tp: RefinedType => isClassRef(tp.parent)
+        case _ => false
+      }
+
+      // Step 1: Get RecTypes and ErrorTypes and CapturingTypes out of the way,
+      tp1 match {
+        case tp1: RecType =>
+          return tp1.rebind(approximateOr(tp1.parent, tp2))
+        case CapturingType(parent1, refs1) =>
+          return tp1.derivedCapturingType(approximateOr(parent1, tp2), refs1)
+        case err: ErrorType =>
+          return err
+        case _ =>
+      }
+      tp2 match {
+        case tp2: RecType =>
+          return tp2.rebind(approximateOr(tp1, tp2.parent))
+        case CapturingType(parent2, refs2) =>
+          return tp2.derivedCapturingType(approximateOr(tp1, parent2), refs2)
+        case err: ErrorType =>
+          return err
+        case _ =>
+      }
+
+      // Step 2: Try to widen either side. This is tricky and incomplete.
+      // An illustration is in test pos/padTo.scala: Here we need to compute the join of
+      //
+      //   `A | C` under the constraints `B >: A` and `C <: B`
+      //
+      // where `A, B, C` are type parameters.
+      // Widening `A` to its upper bound would give `Any | C`, i.e. `Any`.
+      // But widening `C` first would give `A | B` and then `B`.
+      // So we need to widen `C` first. But how to decide this in general?
+      // In the algorithm below, we try to widen both sides (once), and then proceed as follows:
+      //
+      //  2.0. If no widening succeeds, proceed with step 3.
+      //  2.1. If only one widening succeeds, continue with that one.
+      //  2.2. If the two widened types are in a subtype relationship, continue with the smaller one.
+      //  2.3. If exactly one of the two types is a singleton type, continue with the widened singleton type.
+      //  2.4. If the widened tp2 is a supertype of tp1, return widened tp2.
+      //  2.5. If the widened tp1 is a supertype of tp2, return widened tp1.
+      //  2.6. Otherwise, continue with widened tp1
+      //
+      // At steps 4-6 we lose possible solutions, since we have to make an
+      // arbitrary choice which side to widen. A better solution would look at
+      // the constituents of each operand (if the operand is an OrType again) and
+      // try to widen them selectively in turn. But this might lead to a combinatorial
+      // explosion of possibilities.
+      //
+      // Another approach could be to store information contained in lower bounds
+      // on both sides. So if `B >: A` we'd also record that `A <: B` and therefore
+      // widening `A` would yield `B` instead of `Any`, so we'd still be on the right track.
+      // This looks feasible if lower bounds are type parameters, but tricky if they
+      // are something else. We'd have to extract the strongest possible
+      // constraint over all type parameters that is implied by a lower bound.
+      // This looks related to an algorithmic problem arising in GADT matching.
+      //
+      // However, this alone is still not enough. There are other sources of incompleteness,
+      // for instance arising from mis-aligned refinements.
+      val tp1w = tp1 match {
+        case tp1: TypeProxy if !isClassRef(tp1) => tp1.superType.widenExpr
+        case _ => tp1
+      }
+      val tp2w = tp2 match {
+        case tp2: TypeProxy if !isClassRef(tp2) => tp2.superType.widenExpr
+        case _ => tp2
+      }
+      if ((tp1w ne tp1) || (tp2w ne tp2)) {
+        val isSingle1 = tp1.isInstanceOf[SingletonType]
+        val isSingle2 = tp2.isInstanceOf[SingletonType]
+        return {
+          if (tp2w eq tp2) orDominator(tp1w | tp2)                  // 2.1
+          else if (tp1w eq tp1) orDominator(tp1 | tp2w)             // 2.1
+          else if (tp1w frozen_<:< tp2w) orDominator(tp1w | tp2)    // 2.2
+          else if (tp2w frozen_<:< tp1w) orDominator(tp1 | tp2w)    // 2.2
+          else if (isSingle1 && !isSingle2) orDominator(tp1w | tp2) // 2.3
+          else if (isSingle2 && !isSingle1) orDominator(tp1 | tp2w) // 2.3
+          else if (tp1 frozen_<:< tp2w) tp2w                        // 2.4
+          else if (tp2 frozen_<:< tp1w) tp1w                        // 2.5
+          else orDominator(tp1w | tp2)                              // 2.6
+        }
+      }
+
+      // Step 3: Intersect base classes of both sides
+      val commonBaseClasses = tp.mapReduceOr(_.baseClasses)(intersect)
+      val doms = dominators(commonBaseClasses, Nil)
+      def baseTp(cls: ClassSymbol): Type =
+        tp.baseType(cls).mapReduceOr(identity)(mergeRefinedOrApplied)
+      doms.map(baseTp).reduceLeft(AndType.apply)
+    }
+
+    tp match {
+      case tp: OrType =>
+        (tp.tp1.dealias, tp.tp2.dealias) match
+          case (tp1 @ AppliedType(tycon1, args1), tp2 @ AppliedType(tycon2, args2))
+          if tycon1.typeSymbol == tycon2.typeSymbol && (tycon1 =:= tycon2) =>
+            mergeRefinedOrApplied(tp1, tp2)
+          case (tp1, tp2) =>
+            approximateOr(tp1, tp2)
+      case _ =>
+        tp
+    }
+  }
+
+  /** An abstraction of a class info, consisting of
+   *   - the intersection of its parents,
+   *   - refined by all non-private fields, methods, and type members,
+   *   - abstracted over all type parameters (into a type lambda)
+   *   - where all references to `this` of the class are closed over in a RecType.
+   */
+  def classBound(info: ClassInfo)(using Context): Type = {
+    val cls = info.cls
+    val parentType = info.parents.reduceLeft(TypeComparer.andType(_, _))
+    def isRefinable(sym: Symbol) =
+      !sym.is(Private) && !sym.isConstructor && !sym.isClass
+    val (refinableDecls, missingDecls) = info.decls.toList.partition(isRefinable)
+
+    def addRefinement(parent: Type, decl: Symbol) = {
+      val inherited =
+        parentType.findMember(decl.name, cls.thisType,
+          required = EmptyFlags, excluded = Private
+        ).suchThat(decl.matches(_))
+      val inheritedInfo = inherited.info
+      val isPolyFunctionApply = decl.name == nme.apply && (parent <:< defn.PolyFunctionType)
+      val needsRefinement =
+        isPolyFunctionApply
+        || {
+            if inheritedInfo.exists then
+              decl.info.widenExpr <:< inheritedInfo.widenExpr
+              && !(inheritedInfo.widenExpr <:< decl.info.widenExpr)
+            else
+              parent.derivesFrom(defn.SelectableClass)
+          }
+      if needsRefinement then
+        RefinedType(parent, decl.name, avoid(decl.info, missingDecls))
+      else parent
+    }
+
+    def close(tp: Type) = RecType.closeOver { rt =>
+      tp.subst(cls :: Nil, rt.recThis :: Nil).substThis(cls, rt.recThis)
+    }
+
+    val raw = refinableDecls.foldLeft(parentType)(addRefinement)
+    HKTypeLambda.fromParams(cls.typeParams, raw) match {
+      case tl: HKTypeLambda => tl.derivedLambdaType(resType = close(tl.resType))
+      case tp => close(tp)
+    }
+  }
+
+  /** An approximating map that drops NamedTypes matching `toAvoid` and wildcard types. */
+  abstract class AvoidMap(using Context) extends AvoidWildcardsMap, IdempotentCaptRefMap:
+    @threadUnsafe lazy val localParamRefs = util.HashSet[Type]()
+
+    def toAvoid(tp: NamedType): Boolean
+
+    /** True iff all NamedTypes on this prefix are static */
+    override def isStaticPrefix(pre: Type)(using Context): Boolean = pre match
+      case pre: NamedType =>
+        val sym = pre.currentSymbol
+        sym.is(Package) || sym.isStatic && isStaticPrefix(pre.prefix)
+      case _ => true
+
+    override def apply(tp: Type): Type =
+      try
+        tp match
+          case tp: TermRef if toAvoid(tp) =>
+            tp.info.widenExpr.dealias match {
+              case info: SingletonType => apply(info)
+              case info => range(defn.NothingType, apply(info))
+            }
+          case tp: TypeRef if toAvoid(tp) =>
+            tp.info match {
+              case info: AliasingBounds =>
+                apply(info.alias)
+              case TypeBounds(lo, hi) =>
+                range(atVariance(-variance)(apply(lo)), apply(hi))
+              case info: ClassInfo =>
+                range(defn.NothingType, apply(classBound(info)))
+              case _ =>
+                emptyRange // should happen only in error cases
+            }
+          case tp: ThisType =>
+            // ThisType is only used inside a class.
+            // Therefore, either they don't appear in the type to be avoided, or
+            // it must be a class that encloses the block whose type is to be avoided.
+            tp
+          case tp: LazyRef =>
+            if localParamRefs.contains(tp.ref) then tp
+            else if isExpandingBounds then emptyRange
+            else mapOver(tp)
+          case tl: HKTypeLambda =>
+            localParamRefs ++= tl.paramRefs
+            mapOver(tl)
+          case _ =>
+            super.apply(tp)
+      catch case ex: Throwable =>
+        handleRecursive("traversing for avoiding local references", s"${tp.show}" , ex)
+    end apply
+
+    /** Three deviations from standard derivedSelect:
+     *   1. We first try a widening conversion to the type's info with
+     *      the original prefix. Since the original prefix is known to
+     *      be a subtype of the returned prefix, this can improve results.
+     *   2. Then, if the approximation result is a singleton reference C#x.type, we
+     *      replace by the widened type, which is usually more natural.
+     *   3. Finally, we need to handle the case where the prefix type does not have a member
+     *      named `tp.name` anymmore. In that case, we need to fall back to Bot..Top.
+     */
+    override def derivedSelect(tp: NamedType, pre: Type) =
+      if (pre eq tp.prefix)
+        tp
+      else tryWiden(tp, tp.prefix).orElse {
+        if (tp.isTerm && variance > 0 && !pre.isSingleton)
+          apply(tp.info.widenExpr)
+        else if (upper(pre).member(tp.name).exists)
+          super.derivedSelect(tp, pre)
+        else
+          range(defn.NothingType, defn.AnyType)
+      }
+  end AvoidMap
+
+  /** An upper approximation of the given type `tp` that does not refer to any symbol in `symsToAvoid`
+   *  and does not contain any WildcardType.
+   *  We need to approximate with ranges:
+   *
+   *    term references to symbols in `symsToAvoid`,
+   *    term references that have a widened type of which some part refers
+   *    to a symbol in `symsToAvoid`,
+   *    type references to symbols in `symsToAvoid`,
+   *
+   *  Type variables that would be interpolated to a type that
+   *  needs to be widened are replaced by the widened interpolation instance.
+   *
+   *  TODO: Could we replace some or all usages of this method by
+   *  `LevelAvoidMap` instead? It would be good to investigate this in details
+   *  but when I tried it, avoidance for inlined trees broke because `TreeMap`
+   *  does not update `ctx.nestingLevel` when entering a block so I'm leaving
+   *  this as Future Work™.
+   */
+  def avoid(tp: Type, symsToAvoid: -> List[Symbol])(using Context): Type = {
+    val widenMap = new AvoidMap {
+      @threadUnsafe lazy val forbidden = symsToAvoid.toSet
+      def toAvoid(tp: NamedType) =
+        val sym = tp.symbol
+        forbidden.contains(sym)
+
+      /** We need to split the set into upper and lower approximations
+       *  only if it contains a local element. The idea here is that at the
+       *  time we perform an `avoid` all local elements are already accounted for
+       *  and no further elements will be added afterwards. So we can just keep
+       *  the set as it is. See comment by @linyxus on #16261.
+       */
+      override def needsRangeIfInvariant(refs: CaptureSet): Boolean =
+        refs.elems.exists {
+          case ref: TermRef => toAvoid(ref)
+          case _ => false
+        }
+
+      override def apply(tp: Type): Type = tp match
+        case tp: TypeVar if mapCtx.typerState.constraint.contains(tp) =>
+          val lo = TypeComparer.instanceType(
+            tp.origin,
+            fromBelow = variance > 0 || variance == 0 && tp.hasLowerBound,
+            widenUnions = tp.widenUnions)(using mapCtx)
+          val lo1 = apply(lo)
+          if (lo1 ne lo) lo1 else tp
+        case _ =>
+          super.apply(tp)
+      end apply
+    }
+
+    widenMap(tp)
+  }
+
+  /** If `tpe` is of the form `p.x` where `p` refers to a package
+   *  but `x` is not owned by a package, expand it to
+   *
+   *      p.package.x
+   */
+  def makePackageObjPrefixExplicit(tpe: NamedType)(using Context): Type = {
+    def tryInsert(pkgClass: SymDenotation): Type = pkgClass match {
+      case pkg: PackageClassDenotation =>
+        var sym = tpe.symbol
+        if !sym.exists && tpe.denot.isOverloaded then
+          // we know that all alternatives must come from the same package object, since
+          // otherwise we would get "is already defined" errors. So we can take the first
+          // symbol we see.
+          sym = tpe.denot.alternatives.head.symbol
+        val pobj = pkg.packageObjFor(sym)
+        if (pobj.exists) tpe.derivedSelect(pobj.termRef)
+        else tpe
+      case _ =>
+        tpe
+    }
+    if (tpe.symbol.isRoot)
+      tpe
+    else
+      tpe.prefix match {
+        case pre: ThisType if pre.cls.is(Package) => tryInsert(pre.cls)
+        case pre: TermRef if pre.symbol.is(Package) => tryInsert(pre.symbol.moduleClass)
+        case _ => tpe
+      }
+  }
+
+  /** An argument bounds violation is a triple consisting of
+   *   - the argument tree
+   *   - a string "upper" or "lower" indicating which bound is violated
+   *   - the violated bound
+   */
+  type BoundsViolation = (Tree, String, Type)
+
+  /** The list of violations where arguments are not within bounds.
+   *  @param  args          The arguments
+   *  @param  boundss       The list of type bounds
+   *  @param  instantiate   A function that maps a bound type and the list of argument types to a resulting type.
+   *                        Needed to handle bounds that refer to other bounds.
+   *  @param  app           The applied type whose arguments are checked, or NoType if
+   *                        arguments are for a TypeApply.
+   *
+   *  This is particularly difficult for F-bounds that also contain wildcard arguments (see below).
+   *  In fact the current treatment for this sitiuation can so far only be classified as "not obviously wrong",
+   *  (maybe it still needs to be revised).
+   */
+  def boundsViolations(
+      args: List[Tree],
+      boundss: List[TypeBounds],
+      instantiate: (Type, List[Type]) => Type,
+      app: Type)(
+      using Context): List[BoundsViolation] = withMode(Mode.CheckBoundsOrSelfType) {
+    val argTypes = args.tpes
+
+    /** Replace all wildcards in `tps` with `<app>#<tparam>` where `<tparam>` is the
+     *  type parameter corresponding to the wildcard.
+     */
+    def skolemizeWildcardArgs(tps: List[Type], app: Type) = app match {
+      case AppliedType(tycon: TypeRef, args)
+      if tycon.typeSymbol.isClass && !Feature.migrateTo3 =>
+        tps.zipWithConserve(tycon.typeSymbol.typeParams) {
+          (tp, tparam) => tp match {
+            case _: TypeBounds => app.select(tparam)
+            case _ => tp
+          }
+        }
+      case _ => tps
+    }
+
+    // Skolemized argument types are used to substitute in F-bounds.
+    val skolemizedArgTypes = skolemizeWildcardArgs(argTypes, app)
+    val violations = new mutable.ListBuffer[BoundsViolation]
+
+    def checkOverlapsBounds(lo: Type, hi: Type, arg: Tree, bounds: TypeBounds): Unit = {
+      //println(i" = ${instantiate(bounds.hi, argTypes)}")
+
+      var checkCtx = ctx  // the context to be used for bounds checking
+      if (argTypes ne skolemizedArgTypes) { // some of the arguments are wildcards
+
+        /** Is there a `LazyRef(TypeRef(_, sym))` reference in `tp`? */
+        def isLazyIn(sym: Symbol, tp: Type): Boolean = {
+          def isReference(tp: Type) = tp match {
+            case tp: LazyRef => tp.ref.isInstanceOf[TypeRef] && tp.ref.typeSymbol == sym
+            case _ => false
+          }
+          tp.existsPart(isReference, forceLazy = false)
+        }
+
+        /** The argument types of the form `TypeRef(_, sym)` which appear as a LazyRef in `bounds`.
+         *  This indicates that the application is used as an F-bound for the symbol referred to in the LazyRef.
+         */
+        val lazyRefs = skolemizedArgTypes collect {
+          case tp: TypeRef if isLazyIn(tp.symbol, bounds) => tp.symbol
+        }
+
+        for (sym <- lazyRefs) {
+
+          // If symbol `S` has an F-bound such as `C[?, S]` that contains wildcards,
+          // add a modifieed bound where wildcards are skolemized as a GADT bound for `S`.
+          // E.g. for `C[?, S]` we would add `C[C[?, S]#T0, S]` where `T0` is the first
+          // type parameter of `C`. The new bound is added as a GADT bound for `S` in
+          // `checkCtx`.
+          // This mirrors what we do for the bounds that are checked and allows us thus
+          // to bounds-check F-bounds with wildcards. A test case is pos/i6146.scala.
+
+          def massage(tp: Type): Type = tp match {
+            case tp @ AppliedType(tycon, args) =>
+              tp.derivedAppliedType(tycon, skolemizeWildcardArgs(args, tp))
+            case tp: AndOrType =>
+              tp.derivedAndOrType(massage(tp.tp1), massage(tp.tp2))
+            case _ => tp
+          }
+          def narrowBound(bound: Type, fromBelow: Boolean): Unit = {
+            val bound1 = massage(bound)
+            if (bound1 ne bound) {
+              if (checkCtx eq ctx) checkCtx = ctx.fresh.setFreshGADTBounds
+              if (!checkCtx.gadt.contains(sym)) checkCtx.gadt.addToConstraint(sym)
+              checkCtx.gadt.addBound(sym, bound1, fromBelow)
+              typr.println("install GADT bound $bound1 for when checking F-bounded $sym")
+            }
+          }
+          narrowBound(sym.info.loBound, fromBelow = true)
+          narrowBound(sym.info.hiBound, fromBelow = false)
+        }
+      }
+      val hiBound = instantiate(bounds.hi, skolemizedArgTypes)
+      val loBound = instantiate(bounds.lo, skolemizedArgTypes)
+
+      def check(using Context) = {
+        if (!(lo <:< hiBound)) violations += ((arg, "upper", hiBound))
+        if (!(loBound <:< hi)) violations += ((arg, "lower", loBound))
+      }
+      check(using checkCtx)
+    }
+
+    def loop(args: List[Tree], boundss: List[TypeBounds]): Unit = args match
+      case arg :: args1 => boundss match
+        case bounds :: boundss1 =>
+          arg.tpe match
+            case TypeBounds(lo, hi) => checkOverlapsBounds(lo, hi, arg, bounds)
+            case tp => checkOverlapsBounds(tp, tp, arg, bounds)
+          loop(args1, boundss1)
+        case _ =>
+      case _ =>
+
+    loop(args, boundss)
+    violations.toList
+  }
+
+  /** Refine child based on parent
+   *
+   *  In child class definition, we have:
+   *
+   *      class Child[Ts] extends path.Parent[Us] with Es
+   *      object Child extends path.Parent[Us] with Es
+   *      val child = new path.Parent[Us] with Es           // enum values
+   *
+   *  Given a parent type `parent` and a child symbol `child`, we infer the prefix
+   *  and type parameters for the child:
+   *
+   *      prefix.child[Vs] <:< parent
+   *
+   *  where `Vs` are fresh type variables and `prefix` is the symbol prefix with all
+   *  non-module and non-package `ThisType` replaced by fresh type variables.
+   *
+   *  If the subtyping is true, the instantiated type `p.child[Vs]` is
+   *  returned. Otherwise, `NoType` is returned.
+   */
+  def refineUsingParent(parent: Type, child: Symbol)(using Context): Type = {
+    // <local child> is a place holder from Scalac, it is hopeless to instantiate it.
+    //
+    // Quote from scalac (from nsc/symtab/classfile/Pickler.scala):
+    //
+    //     ...When a sealed class/trait has local subclasses, a single
+    //     <local child> class symbol is added as pickled child
+    //     (instead of a reference to the anonymous class; that was done
+    //     initially, but seems not to work, ...).
+    //
+    if (child.name == tpnme.LOCAL_CHILD) return child.typeRef
+
+    val childTp = if (child.isTerm) child.termRef else child.typeRef
+
+    inContext(ctx.fresh.setExploreTyperState().setFreshGADTBounds.addMode(Mode.GadtConstraintInference)) {
+      instantiateToSubType(childTp, parent).dealias
+    }
+  }
+
+  /** Instantiate type `tp1` to be a subtype of `tp2`
+   *
+   *  Return the instantiated type if type parameters in this type
+   *  in `tp1` can be instantiated such that `tp1 <:< tp2`.
+   *
+   *  Otherwise, return NoType.
+   */
+  private def instantiateToSubType(tp1: NamedType, tp2: Type)(using Context): Type = {
+    // In order for a child type S to qualify as a valid subtype of the parent
+    // T, we need to test whether it is possible S <: T.
+    //
+    // The check is different from subtype checking due to type parameters and
+    // `this`. We perform the following operations to approximate the parameters:
+    //
+    // 1. Replace type parameters in T with tvars
+    // 2. Replace `A.this.C` with `A#C` (see tests/patmat/i12681.scala)
+    // 3. Replace non-reducing MatchType with its bound
+    //
+    val approximateParent = new TypeMap {
+      val boundTypeParams = util.HashMap[TypeRef, TypeVar]()
+
+      def apply(tp: Type): Type = tp.dealias match {
+        case tp: MatchType =>
+          val reduced = tp.reduced
+          if reduced.exists then tp // break cycles
+          else mapOver(tp.bound) // if the match type doesn't statically reduce
+                                 // then to avoid it failing the <:<
+                                 // we'll approximate by widening to its bounds
+
+        case ThisType(tref: TypeRef) if !tref.symbol.isStaticOwner =>
+          tref
+
+        case tp: TypeRef if !tp.symbol.isClass =>
+          val lookup = boundTypeParams.lookup(tp)
+          if lookup != null then lookup
+          else
+            val TypeBounds(lo, hi) = tp.underlying.bounds
+            val tv = newTypeVar(TypeBounds(defn.NothingType, hi.topType))
+            boundTypeParams(tp) = tv
+            assert(tv <:< apply(hi))
+            apply(lo) <:< tv //  no assert, since bounds might conflict
+            tv
+
+        case tp @ AppliedType(tycon: TypeRef, _) if !tycon.dealias.typeSymbol.isClass && !tp.isMatchAlias =>
+
+          // In tests/patmat/i3645g.scala, we need to tell whether it's possible
+          // that K1 <: K[Foo]. If yes, we issue a warning; otherwise, no
+          // warnings.
+          //
+          // - K1 <: K[Foo] is possible <==>
+          // - K[Int] <: K[Foo] is possible <==>
+          // - Int <: Foo is possible <==>
+          // - Int <: Module.Foo.Type is possible
+          //
+          // If we remove this special case, we will encounter the case Int <:
+          // X[Y], where X and Y are tvars. The subtype checking will simply
+          // return false. But depending on the bounds of X and Y, the subtyping
+          // can be true.
+          //
+          // As a workaround, we approximate higher-kinded type parameters with
+          // the value types that can be instantiated from its bounds.
+          //
+          // Note that `HKTypeLambda.resType` may contain TypeParamRef that are
+          // bound in the HKTypeLambda. This is fine, as the TypeComparer will
+          // recurse on the bounds of `TypeParamRef`.
+          val bounds: TypeBounds = tycon.underlying match {
+            case TypeBounds(tl1: HKTypeLambda, tl2: HKTypeLambda) =>
+              TypeBounds(tl1.resType, tl2.resType)
+            case TypeBounds(tl1: HKTypeLambda, tp2) =>
+              TypeBounds(tl1.resType, tp2)
+            case TypeBounds(tp1, tl2: HKTypeLambda) =>
+              TypeBounds(tp1, tl2.resType)
+          }
+
+          newTypeVar(bounds)
+
+        case tp =>
+          mapOver(tp)
+      }
+    }
+
+    // Prefix inference, replace `p.C.this.Child` with `X.Child` where `X <: p.C`
+    // Note: we need to strip ThisType in `p` recursively.
+    //
+    // See tests/patmat/i3938.scala
+    class InferPrefixMap extends TypeMap {
+      var prefixTVar: Type | Null = null
+      def apply(tp: Type): Type = tp match {
+        case ThisType(tref: TypeRef) if !tref.symbol.isStaticOwner =>
+          if (tref.symbol.is(Module))
+            TermRef(this(tref.prefix), tref.symbol.sourceModule)
+          else if (prefixTVar != null)
+            this(tref)
+          else {
+            prefixTVar = WildcardType  // prevent recursive call from assigning it
+            val tref2 = this(tref.applyIfParameterized(tref.typeParams.map(_ => TypeBounds.empty)))
+            prefixTVar = newTypeVar(TypeBounds.upper(tref2))
+            prefixTVar.uncheckedNN
+          }
+        case tp => mapOver(tp)
+      }
+    }
+
+    val inferThisMap = new InferPrefixMap
+    val tvars = tp1.typeParams.map { tparam => newTypeVar(tparam.paramInfo.bounds) }
+    val protoTp1 = inferThisMap.apply(tp1).appliedTo(tvars)
+
+    val getAbstractSymbols = new TypeAccumulator[List[Symbol]]:
+      def apply(xs: List[Symbol], tp: Type) = tp.dealias match
+        case tp: TypeRef if tp.symbol.exists && !tp.symbol.isClass => foldOver(tp.symbol :: xs, tp)
+        case tp                                => foldOver(xs, tp)
+    val syms2 = getAbstractSymbols(Nil, tp2).reverse
+    if syms2.nonEmpty then ctx.gadt.addToConstraint(syms2)
+
+    // If parent contains a reference to an abstract type, then we should
+    // refine subtype checking to eliminate abstract types according to
+    // variance. As this logic is only needed in exhaustivity check,
+    // we manually patch subtyping check instead of changing TypeComparer.
+    // See tests/patmat/i3645b.scala
+    def parentQualify(tp1: Type, tp2: Type) = tp1.classSymbol.info.parents.exists { parent =>
+      parent.argInfos.nonEmpty && approximateParent(parent) <:< tp2
+    }
+
+    def instantiate(): Type = {
+      maximizeType(protoTp1, NoSpan)
+      wildApprox(protoTp1)
+    }
+
+    if (protoTp1 <:< tp2) instantiate()
+    else {
+      val approxTp2 = approximateParent(tp2)
+      if (protoTp1 <:< approxTp2 || parentQualify(protoTp1, approxTp2)) instantiate()
+      else NoType
+    }
+  }
+
+  def nestedPairs(ts: List[Type])(using Context): Type =
+    ts.foldRight(defn.EmptyTupleModule.termRef: Type)(defn.PairClass.typeRef.appliedTo(_, _))
+
+  class StripTypeVarsMap(using Context) extends TypeMap:
+    def apply(tp: Type) = mapOver(tp).stripTypeVar
+
+  /** Apply [[Type.stripTypeVar]] recursively. */
+  def stripTypeVars(tp: Type)(using Context): Type =
+    new StripTypeVarsMap().apply(tp)
+
+  /** computes a prefix for `child`, derived from its common prefix with `pre`
+   *  - `pre` is assumed to be the prefix of `parent` at a given callsite.
+   *  - `child` is assumed to be the sealed child of `parent`, and reachable according to `whyNotGenericSum`.
+   */
+  def childPrefix(pre: Type, parent: Symbol, child: Symbol)(using Context): Type =
+    // Example, given this class hierarchy, we can see how this should work
+    // when summoning a mirror for `wrapper.Color`:
+    //
+    // package example
+    // object Outer3:
+    //   class Wrapper:
+    //     sealed trait Color
+    //   val wrapper = new Wrapper
+    //   object Inner:
+    //     case object Red extends wrapper.Color
+    //     case object Green extends wrapper.Color
+    //     case object Blue extends wrapper.Color
+    //
+    //   summon[Mirror.SumOf[wrapper.Color]]
+    //                       ^^^^^^^^^^^^^
+    //       > pre = example.Outer3.wrapper.type
+    //       > parent = sealed trait example.Outer3.Wrapper.Color
+    //       > child = module val example.Outer3.Innner.Red
+    //       > parentOwners = [example, Outer3, Wrapper] // computed from definition
+    //       > childOwners = [example, Outer3, Inner] // computed from definition
+    //       > parentRest = [Wrapper] // strip common owners from `childOwners`
+    //       > childRest = [Inner] // strip common owners from `parentOwners`
+    //       > commonPrefix = example.Outer3.type // i.e. parentRest has only 1 element, use 1st subprefix of `pre`.
+    //       > childPrefix = example.Outer3.Inner.type // select all symbols in `childRest` from `commonPrefix`
+
+    /** unwind the prefix into a sequence of sub-prefixes, selecting the one at `limit`
+     *  @return `NoType` if there is an unrecognised prefix type.
+     */
+    def subPrefixAt(pre: Type, limit: Int): Type =
+      def go(pre: Type, limit: Int): Type =
+        if limit == 0 then pre // EXIT: No More prefix
+        else pre match
+          case pre: ThisType          => go(pre.tref.prefix, limit - 1)
+          case pre: TermRef           => go(pre.prefix, limit - 1)
+          case _:SuperType | NoPrefix => pre.ensuring(limit == 1) // EXIT: can't rewind further than this
+          case _                      => NoType // EXIT: unrecognized prefix
+      go(pre, limit)
+    end subPrefixAt
+
+    /** Successively select each symbol in the `suffix` from `pre`, such that they are reachable. */
+    def selectAll(pre: Type, suffix: Seq[Symbol]): Type =
+      suffix.foldLeft(pre)((pre, sym) =>
+        pre.select(
+          if sym.isType && sym.is(Module) then sym.sourceModule
+          else sym
+        )
+      )
+
+    def stripCommonPrefix(xs: List[Symbol], ys: List[Symbol]): (List[Symbol], List[Symbol]) = (xs, ys) match
+      case (x :: xs1, y :: ys1) if x eq y => stripCommonPrefix(xs1, ys1)
+      case _ => (xs, ys)
+
+    val (parentRest, childRest) = stripCommonPrefix(
+      parent.owner.ownersIterator.toList.reverse,
+      child.owner.ownersIterator.toList.reverse
+    )
+
+    val commonPrefix = subPrefixAt(pre, parentRest.size) // unwind parent owners up to common prefix
+
+    if commonPrefix.exists then selectAll(commonPrefix, childRest)
+    else NoType
+
+  end childPrefix
+
+end TypeOps
diff --git a/tests/pos-with-compiler-cc/dotc/core/TyperState.scala b/tests/pos-with-compiler-cc/dotc/core/TyperState.scala
new file mode 100644
index 000000000000..d2df2a2aebef
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/core/TyperState.scala
@@ -0,0 +1,306 @@
+package dotty.tools
+package dotc
+package core
+
+import Types._
+import Contexts._
+import util.SimpleIdentitySet
+import reporting._
+import config.Config
+import config.Printers.constr
+import collection.mutable
+import java.lang.ref.WeakReference
+import util.{Stats, SimpleIdentityMap}
+import Decorators._
+
+import scala.annotation.internal.sharable
+
+object TyperState {
+  @sharable private var nextId: Int = 0
+  def initialState() =
+    TyperState()
+      .init(null, OrderingConstraint.empty)
+      .setReporter(new ConsoleReporter())
+      .setCommittable(true)
+
+  type LevelMap = SimpleIdentityMap[TypeVar, Integer]
+
+  opaque type Snapshot = (Constraint, TypeVars, LevelMap)
+
+  extension (ts: TyperState)
+    def snapshot()(using Context): Snapshot =
+      (ts.constraint, ts.ownedVars, ts.upLevels)
+
+    def resetTo(state: Snapshot)(using Context): Unit =
+      val (constraint, ownedVars, upLevels) = state
+      for tv <- ownedVars do
+        if !ts.ownedVars.contains(tv) then // tv has been instantiated
+          tv.resetInst(ts)
+      ts.constraint = constraint
+      ts.ownedVars = ownedVars
+      ts.upLevels = upLevels
+}
+
+class TyperState() {
+  import TyperState.LevelMap
+
+  private var myId: Int = _
+  def id: Int = myId
+
+  private var previous: TyperState | Null = _
+
+  private var myReporter: Reporter = _
+
+  def reporter: Reporter = myReporter
+
+  /** A fresh type state with the same constraint as this one and the given reporter */
+  def setReporter(reporter: Reporter): this.type = { myReporter = reporter; this }
+
+  private var myConstraint: Constraint = _
+
+  def constraint: Constraint = myConstraint
+  def constraint_=(c: Constraint)(using Context): Unit = {
+    if (Config.debugCheckConstraintsClosed && isGlobalCommittable) c.checkClosed()
+    myConstraint = c
+    if Config.checkConsistentVars && !ctx.reporter.errorsReported then
+      c.checkConsistentVars()
+  }
+
+  private var previousConstraint: Constraint = _
+
+  private var myIsCommittable: Boolean = _
+
+  def isCommittable: Boolean = myIsCommittable
+
+  def setCommittable(committable: Boolean): this.type =
+    this.myIsCommittable = committable
+    this
+
+  def isGlobalCommittable: Boolean =
+    isCommittable && (previous == null || previous.uncheckedNN.isGlobalCommittable)
+
+  private var isCommitted: Boolean = _
+
+  /** The set of uninstantiated type variables which have this state as their owning state.
+   *
+   *  Invariant:
+   *   if `tstate.isCommittable` then
+   *     `tstate.ownedVars.contains(tvar)` iff `tvar.owningState.get eq tstate`
+   */
+  private var myOwnedVars: TypeVars = _
+  def ownedVars: TypeVars = myOwnedVars
+  def ownedVars_=(vs: TypeVars): Unit = myOwnedVars = vs
+
+  private var upLevels: LevelMap = _
+
+  /** Initializes all fields except reporter, isCommittable, which need to be
+   *  set separately.
+   */
+  private[core] def init(previous: TyperState | Null, constraint: Constraint): this.type =
+    this.myId = TyperState.nextId
+    TyperState.nextId += 1
+    this.previous = previous
+    this.myConstraint = constraint
+    this.previousConstraint = constraint
+    this.myOwnedVars = SimpleIdentitySet.empty
+    this.upLevels = SimpleIdentityMap.empty
+    this.isCommitted = false
+    this
+
+  /** A fresh typer state with the same constraint as this one. */
+  def fresh(reporter: Reporter = StoreReporter(this.reporter, fromTyperState = true),
+      committable: Boolean = this.isCommittable): TyperState =
+    util.Stats.record("TyperState.fresh")
+    val ts = TyperState().init(this, this.constraint)
+      .setReporter(reporter)
+      .setCommittable(committable)
+    ts.upLevels = upLevels
+    ts
+
+  /** The uninstantiated variables */
+  def uninstVars: collection.Seq[TypeVar] = constraint.uninstVars
+
+  /** The nestingLevel of `tv` in this typer state */
+  def nestingLevel(tv: TypeVar): Int =
+    val own = upLevels(tv)
+    if own == null then tv.initNestingLevel else own.intValue()
+
+  /** Set the nestingLevel of `tv` in this typer state
+   *  @pre this level must be smaller than `tv.initNestingLevel`
+  */
+  def setNestingLevel(tv: TypeVar, level: Int) =
+    assert(level < tv.initNestingLevel)
+    upLevels = upLevels.updated(tv, level)
+
+  /** The closest ancestor of this typer state (including possibly this typer state itself)
+   *  which is not yet committed, or which does not have a parent.
+   */
+  def uncommittedAncestor: TyperState =
+    if (isCommitted && previous != null) previous.uncheckedNN.uncommittedAncestor else this
+
+  /** Commit typer state so that its information is copied into current typer state
+   *  In addition (1) the owning state of undetermined or temporarily instantiated
+   *  type variables changes from this typer state to the current one. (2) Variables
+   *  that were temporarily instantiated in the current typer state are permanently
+   *  instantiated instead.
+   *
+   *  A note on merging: An interesting test case is isApplicableSafe.scala. It turns out that this
+   *  requires a context merge using the new `&' operator. Sequence of actions:
+   *  1) Typecheck argument in typerstate 1.
+   *  2) Cache argument.
+   *  3) Evolve same typer state (to typecheck other arguments, say)
+   *     leading to a different constraint.
+   *  4) Take typechecked argument in same state.
+   *
+   * It turns out that the merge is needed not just for
+   * isApplicableSafe but also for (e.g. erased-lubs.scala) as well as
+   * many parts of dotty itself.
+   */
+  def commit()(using Context): Unit = {
+    Stats.record("typerState.commit")
+    assert(isCommittable, s"$this is not committable")
+    assert(!isCommitted, s"$this is already committed")
+    val targetState = ctx.typerState
+
+    val nothingToCommit = (constraint eq targetState.constraint) && !reporter.hasUnreportedMessages
+    assert(!targetState.isCommitted || nothingToCommit ||
+       // Committing into an already committed TyperState usually doesn't make
+       // sense since it means the constraints and messages we're committing won't be propagated
+       // further, but it can happen if the targetState gets captured in a reported
+       // Message, because forcing that Message might involve creating and
+       // committing new TyperStates into the captured one after it's been committed.
+        targetState.reporter.hasErrors || targetState.reporter.hasWarnings,
+      s"Attempt to commit $this into already committed $targetState")
+
+    reporter.flush()
+    setCommittable(false)
+
+    if constraint ne targetState.constraint then
+      Stats.record("typerState.commit.new constraint")
+      constr.println(i"committing $this to $targetState, fromConstr = $constraint, toConstr = ${targetState.constraint}")
+      if targetState.constraint eq previousConstraint then
+        targetState.constraint = constraint
+        if !ownedVars.isEmpty then ownedVars.foreach(targetState.includeVar)
+      else
+        targetState.mergeConstraintWith(this)
+
+    upLevels.foreachBinding { (tv, level) =>
+      if level < targetState.nestingLevel(tv) then
+        targetState.setNestingLevel(tv, level)
+    }
+
+    targetState.gc()
+    isCommitted = true
+    ownedVars = SimpleIdentitySet.empty
+  }
+
+  /** Ensure that this constraint does not associate different TypeVars for the
+   *  same type lambda than the `other` constraint. Do this by renaming type lambdas
+   *  in this constraint and its predecessors where necessary.
+   */
+  def ensureNotConflicting(other: Constraint)(using Context): Unit =
+    val conflicting = constraint.domainLambdas.filter(constraint.hasConflictingTypeVarsFor(_, other))
+    for tl <- conflicting do
+      val tl1 = constraint.ensureFresh(tl)
+      for case (tvar: TypeVar, pref1) <- tl.paramRefs.map(constraint.typeVarOfParam).lazyZip(tl1.paramRefs) do
+        tvar.setOrigin(pref1)
+      var ts = this
+      while ts.constraint.domainLambdas.contains(tl) do
+        ts.constraint = ts.constraint.subst(tl, tl1)
+        ts = ts.previous.nn
+
+  /** Integrate the constraints from `that` into this TyperState.
+   *
+   *  @pre If `this` and `that` are committable, `that` must not contain any type variable which
+   *       does not exist in `this` (in other words, all its type variables must
+   *       be owned by a common parent of `this` and `that`).
+   */
+  def mergeConstraintWith(that: TyperState)(using Context): this.type =
+    if this eq that then return this
+
+    that.ensureNotConflicting(constraint)
+
+    val comparingCtx = ctx.withTyperState(this)
+
+    inContext(comparingCtx)(comparing(typeComparer =>
+      val other = that.constraint
+      val res = other.domainLambdas.forall(tl =>
+        // Integrate the type lambdas from `other`
+        constraint.contains(tl) || other.isRemovable(tl) || {
+          val tvars = tl.paramRefs.map(other.typeVarOfParam(_)).collect { case tv: TypeVar => tv }
+          if this.isCommittable then
+            tvars.foreach(tvar =>
+              if !tvar.inst.exists && !isOwnedAnywhere(this, tvar) then includeVar(tvar))
+          typeComparer.addToConstraint(tl, tvars)
+        }) &&
+        // Integrate the additional constraints on type variables from `other`
+        // and merge hardness markers
+        constraint.uninstVars.forall(tv =>
+          if other.isHard(tv) then constraint = constraint.withHard(tv)
+          val p = tv.origin
+          val otherLos = other.lower(p)
+          val otherHis = other.upper(p)
+          val otherEntry = other.entry(p)
+          (  (otherLos eq constraint.lower(p)) || otherLos.forall(_ <:< p)) &&
+          (  (otherHis eq constraint.upper(p)) || otherHis.forall(p <:< _)) &&
+          ((otherEntry eq constraint.entry(p)) || otherEntry.match
+            case NoType =>
+              true
+            case tp: TypeBounds =>
+              tp.contains(tv)
+            case tp =>
+              tv =:= tp
+          )
+        )
+      assert(res || ctx.reporter.errorsReported, i"cannot merge $constraint with $other.")
+    ))
+
+    for tl <- constraint.domainLambdas do
+      if constraint.isRemovable(tl) then constraint = constraint.remove(tl)
+    this
+  end mergeConstraintWith
+
+  /** Take ownership of `tvar`.
+   *
+   *  @pre `tvar` is not owned by a committable TyperState. This ensures
+   *       each tvar can only be instantiated by one TyperState.
+   */
+  private def includeVar(tvar: TypeVar)(using Context): Unit =
+    val oldState = tvar.owningState.nn.get
+    assert(oldState == null || !oldState.isCommittable,
+      i"$this attempted to take ownership of $tvar which is already owned by committable $oldState")
+    tvar.owningState = new WeakReference(this)
+    ownedVars += tvar
+
+  private def isOwnedAnywhere(ts: TyperState, tvar: TypeVar): Boolean =
+    ts.ownedVars.contains(tvar) || ts.previous != null && isOwnedAnywhere(ts.previous.uncheckedNN, tvar)
+
+  /** Make type variable instances permanent by assigning to `inst` field if
+   *  type variable instantiation cannot be retracted anymore. Then, remove
+   *  no-longer needed constraint entries.
+   */
+  def gc()(using Context): Unit =
+    if !ownedVars.isEmpty then
+      Stats.record("typerState.gc")
+      val toCollect = new mutable.ListBuffer[TypeLambda]
+      for tvar <- ownedVars do
+        val tvarState = tvar.owningState.nn.get
+        assert(tvarState eqn this, s"Inconsistent state in $this: it owns $tvar whose owningState is ${tvarState}")
+        assert(!tvar.inst.exists, s"Inconsistent state in $this: it owns $tvar which is already instantiated")
+        val inst = constraint.instType(tvar)
+        if inst.exists then
+          tvar.setInst(inst)
+          val tl = tvar.origin.binder
+          if constraint.isRemovable(tl) then toCollect += tl
+      for tl <- toCollect do
+        constraint = constraint.remove(tl)
+
+  override def toString: String = {
+    def ids(state: TyperState): List[String] =
+      s"${state.id}${if (state.isCommittable) "" else "X"}" ::
+        (if (state.previous == null) Nil else ids(state.previous.uncheckedNN))
+    s"TS[${ids(this).mkString(", ")}]"
+  }
+
+  def stateChainStr: String = s"$this${if (previous == null) "" else previous.uncheckedNN.stateChainStr}"
+}
diff --git a/tests/pos-with-compiler-cc/dotc/core/Types.scala b/tests/pos-with-compiler-cc/dotc/core/Types.scala
new file mode 100644
index 000000000000..967f4e2bc370
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/core/Types.scala
@@ -0,0 +1,6398 @@
+package dotty.tools
+package dotc
+package core
+
+import Symbols._
+import Flags._
+import Names._
+import StdNames._, NameOps._
+import NullOpsDecorator._
+import NameKinds.SkolemName
+import Scopes._
+import Constants._
+import Contexts._
+import Phases._
+import Annotations._
+import SymDenotations._
+import Decorators._
+import Denotations._
+import Periods._
+import CheckRealizable._
+import Variances.{Variance, setStructuralVariances, Invariant}
+import typer.Nullables
+import util.Stats._
+import util.SimpleIdentitySet
+import ast.tpd._
+import ast.TreeTypeMap
+import printing.Texts._
+import printing.Printer
+import Hashable._
+import Uniques._
+import collection.mutable
+import config.Config
+import annotation.{tailrec, constructorOnly}
+import scala.util.hashing.{ MurmurHash3 => hashing }
+import config.Printers.{core, typr, matchTypes}
+import reporting.{trace, Message}
+import java.lang.ref.WeakReference
+import compiletime.uninitialized
+import cc.{CapturingType, CaptureSet, derivedCapturingType, isBoxedCapturing, EventuallyCapturingType, boxedUnlessFun}
+import CaptureSet.{CompareResult, IdempotentCaptRefMap, IdentityCaptRefMap}
+
+import scala.annotation.internal.sharable
+import scala.annotation.threadUnsafe
+
+import dotty.tools.dotc.transform.SymUtils._
+import language.experimental.pureFunctions
+import annotation.retains
+
+object Types {
+
+  @sharable private var nextId = 0
+
+  implicit def eqType: CanEqual[Type, Type] = CanEqual.derived
+
+  /** Main class representing types.
+   *
+   *  The principal subclasses and sub-objects are as follows:
+   *
+   *  ```none
+   *  Type -+- ProxyType --+- NamedType ----+--- TypeRef
+   *        |              |                 \
+   *        |              +- SingletonType-+-+- TermRef
+   *        |              |                |
+   *        |              |                +--- ThisType
+   *        |              |                +--- SuperType
+   *        |              |                +--- ConstantType
+   *        |              |                +--- TermParamRef
+   *        |              |                +----RecThis
+   *        |              |                +--- SkolemType
+   *        |              +- TypeParamRef
+   *        |              +- RefinedOrRecType -+-- RefinedType
+   *        |              |                    +-- RecType
+   *        |              +- AppliedType
+   *        |              +- TypeBounds
+   *        |              +- ExprType
+   *        |              +- AnnotatedType
+   *        |              +- TypeVar
+   *        |              +- HKTypeLambda
+   *        |              +- MatchType
+   *        |
+   *        +- GroundType -+- AndType
+   *                       +- OrType
+   *                       +- MethodOrPoly ---+-- PolyType
+   *                       |                  +-- MethodType
+   *                       +- ClassInfo
+   *                       |
+   *                       +- NoType
+   *                       +- NoPrefix
+   *                       +- ErrorType
+   *                       +- WildcardType
+   *  ```
+   *
+   *  Note: please keep in sync with copy in `docs/docs/internals/type-system.md`.
+   */
+  abstract class Type extends Hashable, printing.Showable, caps.Pure {
+
+// ----- Tests -----------------------------------------------------
+
+//    // debug only: a unique identifier for a type
+//    val uniqId = {
+//      nextId = nextId + 1
+//      if (nextId == 19555)
+//        println("foo")
+//      nextId
+//    }
+
+    /** A cache indicating whether the type was still provisional, last time we checked */
+    @sharable private var mightBeProvisional = true
+
+    /** Is this type still provisional? This is the case if the type contains, or depends on,
+     *  uninstantiated type variables or type symbols that have the Provisional flag set.
+     *  This is an antimonotonic property - once a type is not provisional, it stays so forever.
+     */
+    def isProvisional(using Context): Boolean = mightBeProvisional && testProvisional
+
+    private def testProvisional(using Context): Boolean =
+      class ProAcc extends TypeAccumulator[Boolean]:
+        override def apply(x: Boolean, t: Type) = x || test(t, this)
+      def test(t: Type, theAcc: TypeAccumulator[Boolean] | Null): Boolean =
+        if t.mightBeProvisional then
+          t.mightBeProvisional = t match
+            case t: TypeRef =>
+              !t.currentSymbol.isStatic && {
+                (t: Type).mightBeProvisional = false // break cycles
+                t.symbol.isProvisional
+                || test(t.prefix, theAcc)
+                || t.denot.infoOrCompleter.match
+                    case info: LazyType => true
+                    case info: AliasingBounds => test(info.alias, theAcc)
+                    case TypeBounds(lo, hi) => test(lo, theAcc) || test(hi, theAcc)
+                    case _ => false
+              }
+            case t: TermRef =>
+              !t.currentSymbol.isStatic && test(t.prefix, theAcc)
+            case t: AppliedType =>
+              t.fold(false, (x, tp) => x || test(tp, theAcc))
+            case t: TypeVar =>
+              !t.inst.exists || test(t.inst, theAcc)
+            case t: LazyRef =>
+              !t.completed || test(t.ref, theAcc)
+            case _ =>
+              (if theAcc != null then theAcc else ProAcc()).foldOver(false, t)
+        end if
+        t.mightBeProvisional
+      end test
+      test(this, null)
+    end testProvisional
+
+    /** Is this type different from NoType? */
+    final def exists: Boolean = this.ne(NoType)
+
+    /** This type, if it exists, otherwise `that` type */
+    inline def orElse(inline that: Type): Type = if (exists) this else that
+
+    /** Is this type a value type? */
+    final def isValueType: Boolean = this.isInstanceOf[ValueType]
+
+    /** Is this a value type or a type lambda? */
+    final def isValueTypeOrLambda: Boolean = isValueType || this.isInstanceOf[TypeLambda]
+
+    /** Is this a value type or a wildcard? */
+    final def isValueTypeOrWildcard: Boolean = isValueType || this.isInstanceOf[WildcardType]
+
+    /** Does this type denote a stable reference (i.e. singleton type)?
+      *
+      * Like in isStableMember, "stability" means idempotence.
+      * Rationale: If an expression has a stable type, the expression must be idempotent, so stable types
+      * must be singleton types of stable expressions. */
+    final def isStable(using Context): Boolean = stripTypeVar match {
+      case tp: TermRef => tp.symbol.isStableMember && tp.prefix.isStable || tp.info.isStable
+      case _: SingletonType | NoPrefix => true
+      case tp: RefinedOrRecType => tp.parent.isStable
+      case tp: ExprType => tp.resultType.isStable
+      case tp: AnnotatedType =>
+        // NOTE UncheckedStableAnnot was originally meant to be put on fields,
+        // not on types. Allowing it on types is a Scala 3 extension. See:
+        // https://www.scala-lang.org/files/archive/spec/2.11/11-annotations.html#scala-compiler-annotations
+        tp.annot.symbol == defn.UncheckedStableAnnot || tp.parent.isStable
+      case tp: AndType =>
+        // TODO: fix And type check when tp contains type parames for explicit-nulls flow-typing
+        // see: tests/explicit-nulls/pos/flow-stable.scala.disabled
+        tp.tp1.isStable && (realizability(tp.tp2) eq Realizable) ||
+        tp.tp2.isStable && (realizability(tp.tp1) eq Realizable)
+      case tp: AppliedType => tp.cachedIsStable
+      case _ => false
+    }
+
+    /** Is this type a (possibly refined, applied, aliased or annotated) type reference
+     *  to the given type symbol?
+     *  @sym  The symbol to compare to. It must be a class symbol or abstract type.
+     *        It makes no sense for it to be an alias type because isRef would always
+     *        return false in that case.
+     */
+    def isRef(sym: Symbol, skipRefined: Boolean = true)(using Context): Boolean = this match {
+      case this1: TypeRef =>
+        this1.info match { // see comment in Namer#typeDefSig
+          case TypeAlias(tp) => tp.isRef(sym, skipRefined)
+          case _ => this1.symbol eq sym
+        }
+      case this1: RefinedOrRecType if skipRefined =>
+        this1.parent.isRef(sym, skipRefined)
+      case this1: AppliedType =>
+        val this2 = this1.dealias
+        if (this2 ne this1) this2.isRef(sym, skipRefined)
+        else this1.underlying.isRef(sym, skipRefined)
+      case this1: TypeVar =>
+        this1.instanceOpt.isRef(sym, skipRefined)
+      case this1: AnnotatedType =>
+        this1.parent.isRef(sym, skipRefined)
+      case _ => false
+    }
+
+    /** Is this type a (neither aliased nor applied nor annotated) reference to class `sym`? */
+    def isDirectRef(sym: Symbol)(using Context): Boolean = stripTypeVar match {
+      case this1: TypeRef =>
+        this1.name == sym.name && // avoid forcing info if names differ
+        (this1.symbol eq sym)
+      case _ =>
+        false
+    }
+
+    def isAny(using Context): Boolean     = isRef(defn.AnyClass, skipRefined = false)
+    def isAnyRef(using Context): Boolean  = isRef(defn.ObjectClass, skipRefined = false)
+    def isAnyKind(using Context): Boolean = isRef(defn.AnyKindClass, skipRefined = false)
+
+    def isTopType(using Context): Boolean = dealias match
+      case tp: TypeRef => defn.topClasses.contains(tp.symbol)
+      case _ => false
+
+    /** Is this type exactly Null (no vars, aliases, refinements etc allowed)? */
+    def isExactlyNull(using Context): Boolean = this match {
+      case tp: TypeRef =>
+        tp.name == tpnme.Null && (tp.symbol eq defn.NullClass)
+      case _ => false
+    }
+
+    /** Is this type exactly Nothing (no vars, aliases, refinements etc allowed)? */
+    def isExactlyNothing(using Context): Boolean = this match {
+      case tp: TypeRef =>
+        tp.name == tpnme.Nothing && (tp.symbol eq defn.NothingClass)
+      case _ => false
+    }
+
+    /** Is this type exactly Any (no vars, aliases, refinements etc allowed)? */
+    def isExactlyAny(using Context): Boolean = this match {
+      case tp: TypeRef =>
+        tp.name == tpnme.Any && (tp.symbol eq defn.AnyClass)
+      case _ => false
+    }
+
+    def isBottomType(using Context): Boolean =
+      if ctx.mode.is(Mode.SafeNulls) && !ctx.phase.erasedTypes then hasClassSymbol(defn.NothingClass)
+      else isBottomTypeAfterErasure
+
+    def isBottomTypeAfterErasure(using Context): Boolean =
+      val d = defn
+      hasClassSymbol(d.NothingClass) || hasClassSymbol(d.NullClass)
+
+    /** True if this type is an instance of the given `cls` or an instance of
+     *  a non-bottom subclass of `cls`.
+     */
+    final def derivesFrom(cls: Symbol)(using Context): Boolean = {
+      def isLowerBottomType(tp: Type) =
+        tp.isBottomType
+        && (tp.hasClassSymbol(defn.NothingClass)
+            || cls != defn.NothingClass && !cls.isValueClass)
+      def loop(tp: Type): Boolean = tp match {
+        case tp: TypeRef =>
+          val sym = tp.symbol
+          if (sym.isClass) sym.derivesFrom(cls) else loop(tp.superType)
+        case tp: AppliedType =>
+          tp.superType.derivesFrom(cls)
+        case tp: MatchType =>
+          tp.bound.derivesFrom(cls) || tp.reduced.derivesFrom(cls)
+        case tp: TypeProxy =>
+          loop(tp.underlying)
+        case tp: AndType =>
+          loop(tp.tp1) || loop(tp.tp2)
+        case tp: OrType =>
+          // If the type is `T | Null` or `T | Nothing`, the class is != Nothing,
+          // and `T` derivesFrom the class, then the OrType derivesFrom the class.
+          // Otherwise, we need to check both sides derivesFrom the class.
+          if isLowerBottomType(tp.tp1) then
+            loop(tp.tp2)
+          else if isLowerBottomType(tp.tp2) then
+            loop(tp.tp1)
+          else
+            loop(tp.tp1) && loop(tp.tp2)
+        case tp: JavaArrayType =>
+          cls == defn.ObjectClass
+        case _ =>
+          false
+      }
+      loop(this)
+    }
+
+    def isFromJavaObject(using Context): Boolean =
+      isRef(defn.ObjectClass) && (typeSymbol eq defn.FromJavaObjectSymbol)
+
+    def containsFromJavaObject(using Context): Boolean = this match
+      case tp: OrType => tp.tp1.containsFromJavaObject || tp.tp2.containsFromJavaObject
+      case tp: AndType => tp.tp1.containsFromJavaObject && tp.tp2.containsFromJavaObject
+      case _ => isFromJavaObject
+
+    /** True iff `symd` is a denotation of a class type parameter and the reference
+     *  `<pre> . <symd>` is an actual argument reference, i.e. `pre` is not the
+     *  ThisType of `symd`'s owner, or a reference to `symd`'s owner.'
+     */
+    def isArgPrefixOf(symd: SymDenotation)(using Context): Boolean =
+      symd.exists
+      && !symd.owner.is(Package) // Early exit if possible because the next check would force SymbolLoaders
+      && symd.isAllOf(ClassTypeParam)
+      && { this match
+          case tp: ThisType => tp.cls ne symd.owner
+          case tp: TypeRef => tp.symbol ne symd.owner
+          case _ => true
+      }
+
+    /** Is this type a (possibly aliased) singleton type? */
+    def isSingleton(using Context): Boolean = dealias.isInstanceOf[SingletonType]
+
+    /** Is this type of kind `AnyKind`? */
+    def hasAnyKind(using Context): Boolean = {
+      @tailrec def loop(tp: Type): Boolean = tp match {
+        case tp: TypeRef =>
+          val sym = tp.symbol
+          if (sym.isClass) sym == defn.AnyKindClass else loop(tp.translucentSuperType)
+        case tp: TypeProxy =>
+          loop(tp.underlying) // underlying OK here since an AnyKinded type cannot be a type argument of another type
+        case _ =>
+          false
+      }
+      loop(this)
+    }
+
+    /** Is this type guaranteed not to have `null` as a value? */
+    final def isNotNull(using Context): Boolean = this match {
+      case tp: ConstantType => tp.value.value != null
+      case tp: ClassInfo => !tp.cls.isNullableClass && tp.cls != defn.NothingClass
+      case tp: AppliedType => tp.superType.isNotNull
+      case tp: TypeBounds => tp.lo.isNotNull
+      case tp: TypeProxy => tp.underlying.isNotNull
+      case AndType(tp1, tp2) => tp1.isNotNull || tp2.isNotNull
+      case OrType(tp1, tp2) => tp1.isNotNull && tp2.isNotNull
+      case _ => false
+    }
+
+    /** Is this type produced as a repair for an error? */
+    final def isError(using Context): Boolean = stripTypeVar.isInstanceOf[ErrorType]
+
+    /** Is some part of the widened version of this type produced as a repair for an error?
+     *
+     */
+    def isErroneous(using Context): Boolean =
+      try widen.existsPart(_.isError, forceLazy = false)
+      catch case ex: TypeError => true
+
+    /** Is this type unusable for implicit search or overloading resolution
+     *  since it has embedded errors that can match anything? This is weaker and more
+     *  ad-hoc than isErroneous. The main differences are that we always consider aliases
+     *  (since these are relevant for inference or resolution) but never consider prefixes
+     *  (since these often do not constrain the search space anyway).
+     */
+    def unusableForInference(using Context): Boolean = widenDealias match
+      case AppliedType(tycon, args) => tycon.unusableForInference || args.exists(_.unusableForInference)
+      case RefinedType(parent, _, rinfo) => parent.unusableForInference || rinfo.unusableForInference
+      case TypeBounds(lo, hi) => lo.unusableForInference || hi.unusableForInference
+      case tp: AndOrType => tp.tp1.unusableForInference || tp.tp2.unusableForInference
+      case tp: LambdaType => tp.resultType.unusableForInference || tp.paramInfos.exists(_.unusableForInference)
+      case WildcardType(optBounds) => optBounds.unusableForInference
+      case CapturingType(parent, refs) => parent.unusableForInference || refs.elems.exists(_.unusableForInference)
+      case _: ErrorType => true
+      case _ => false
+
+    /** Does the type carry an annotation that is an instance of `cls`? */
+    @tailrec final def hasAnnotation(cls: ClassSymbol)(using Context): Boolean = stripTypeVar match {
+      case AnnotatedType(tp, annot) => (annot matches cls) || (tp hasAnnotation cls)
+      case _ => false
+    }
+
+    /** Does this type have a supertype with an annotation satisfying given predicate `p`? */
+    def derivesAnnotWith(p: Annotation => Boolean)(using Context): Boolean = this match {
+      case tp: AnnotatedType => p(tp.annot) || tp.parent.derivesAnnotWith(p)
+      case tp: TypeProxy => tp.superType.derivesAnnotWith(p)
+      case AndType(l, r) => l.derivesAnnotWith(p) || r.derivesAnnotWith(p)
+      case OrType(l, r) => l.derivesAnnotWith(p) && r.derivesAnnotWith(p)
+      case _ => false
+    }
+
+    /** Does this type occur as a part of type `that`? */
+    def occursIn(that: Type)(using Context): Boolean =
+      that.existsPart(this == _)
+
+    /** Does this type not refer to TypeParamRefs or uninstantiated TypeVars? */
+    final def isGround(using Context): Boolean =
+      (new isGroundAccumulator).apply(true, this)
+
+    /** Is this a type of a repeated parameter? */
+    def isRepeatedParam(using Context): Boolean =
+      typeSymbol eq defn.RepeatedParamClass
+
+    /** Is this the type of a method that has a repeated parameter type as
+     *  last parameter type?
+     */
+    def isVarArgsMethod(using Context): Boolean = stripPoly match {
+      case mt: MethodType => mt.paramInfos.nonEmpty && mt.paramInfos.last.isRepeatedParam
+      case _ => false
+    }
+
+    /** Is this the type of a method with a leading empty parameter list?
+     */
+    def isNullaryMethod(using Context): Boolean = stripPoly match {
+      case MethodType(Nil) => true
+      case _ => false
+    }
+
+    /** Is this an alias TypeBounds? */
+    final def isTypeAlias: Boolean = this.isInstanceOf[TypeAlias]
+
+    /** Is this a Method or PolyType which has implicit or contextual parameters? */
+    def isImplicitMethod: Boolean = false
+
+    /** Is this a Method or PolyType which has contextual parameters as first value parameter list? */
+    def isContextualMethod: Boolean = false
+
+    /** Is this a MethodType for which the parameters will not be used? */
+    def isErasedMethod: Boolean = false
+
+    /** Is this a match type or a higher-kinded abstraction of one?
+     */
+    def isMatch(using Context): Boolean = underlyingMatchType.exists
+
+    def underlyingMatchType(using Context): Type = stripped match {
+      case tp: MatchType => tp
+      case tp: HKTypeLambda => tp.resType.underlyingMatchType
+      case tp: AppliedType if tp.isMatchAlias => tp.superType.underlyingMatchType
+      case _ => NoType
+    }
+
+    /** Is this a higher-kinded type lambda with given parameter variances? */
+    def isDeclaredVarianceLambda: Boolean = false
+
+    /** Does this type contain wildcard types? */
+    final def containsWildcardTypes(using Context) =
+      existsPart(_.isInstanceOf[WildcardType], StopAt.Static, forceLazy = false)
+
+// ----- Higher-order combinators -----------------------------------
+
+    /** Returns true if there is a part of this type that satisfies predicate `p`.
+     */
+    final def existsPart(p: Type => Boolean, stopAt: StopAt = StopAt.None, forceLazy: Boolean = true)(using Context): Boolean =
+      new ExistsAccumulator(p, stopAt, forceLazy).apply(false, this)
+
+    /** Returns true if all parts of this type satisfy predicate `p`.
+     */
+    final def forallParts(p: Type => Boolean)(using Context): Boolean =
+      !existsPart(!p(_))
+
+    /** Performs operation on all parts of this type */
+    final def foreachPart(p: Type => Unit, stopAt: StopAt = StopAt.None)(using Context): Unit =
+      new ForeachAccumulator(p, stopAt).apply((), this)
+
+    /** The parts of this type which are type or term refs and which
+     *  satisfy predicate `p`.
+     *
+     *  @param p                   The predicate to satisfy
+     */
+    def namedPartsWith(p: NamedType => Boolean)(using Context): List[NamedType] =
+      new NamedPartsAccumulator(p).apply(Nil, this)
+
+    /** Map function `f` over elements of an AndType, rebuilding with function `g` */
+    def mapReduceAnd[T](f: Type => T)(g: (T, T) => T)(using Context): T = stripTypeVar match {
+      case AndType(tp1, tp2) => g(tp1.mapReduceAnd(f)(g), tp2.mapReduceAnd(f)(g))
+      case _ => f(this)
+    }
+
+    /** Map function `f` over elements of an OrType, rebuilding with function `g` */
+    final def mapReduceOr[T](f: Type => T)(g: (T, T) => T)(using Context): T = stripTypeVar match {
+      case OrType(tp1, tp2) => g(tp1.mapReduceOr(f)(g), tp2.mapReduceOr(f)(g))
+      case _ => f(this)
+    }
+
+// ----- Associated symbols ----------------------------------------------
+
+    /** The type symbol associated with the type */
+    @tailrec final def typeSymbol(using Context): Symbol = this match {
+      case tp: TypeRef => tp.symbol
+      case tp: TypeProxy => tp.underlying.typeSymbol
+      case tp: ClassInfo => tp.cls
+      case  _: JavaArrayType => defn.ArrayClass
+      case _ => NoSymbol
+    }
+
+    /** The least class or trait of which this type is a subtype or parameterized
+     *  instance, or NoSymbol if none exists (either because this type is not a
+     *  value type, or because superclasses are ambiguous).
+     */
+    final def classSymbol(using Context): Symbol = this match
+      case tp: TypeRef =>
+        val sym = tp.symbol
+        if (sym.isClass) sym else tp.superType.classSymbol
+      case tp: TypeProxy =>
+        tp.superType.classSymbol
+      case tp: ClassInfo =>
+        tp.cls
+      case AndType(l, r) =>
+        val lsym = l.classSymbol
+        val rsym = r.classSymbol
+        if (lsym isSubClass rsym) lsym
+        else if (rsym isSubClass lsym) rsym
+        else NoSymbol
+      case tp: OrType =>
+        if tp.tp1.hasClassSymbol(defn.NothingClass) then
+          tp.tp2.classSymbol
+        else if tp.tp2.hasClassSymbol(defn.NothingClass) then
+          tp.tp1.classSymbol
+        else
+          def tp1Null = tp.tp1.hasClassSymbol(defn.NullClass)
+          def tp2Null = tp.tp2.hasClassSymbol(defn.NullClass)
+          if ctx.erasedTypes && (tp1Null || tp2Null) then
+            val otherSide = if tp1Null then tp.tp2.classSymbol else tp.tp1.classSymbol
+            if otherSide.isValueClass then defn.AnyClass else otherSide
+          else
+            tp.join.classSymbol
+      case _: JavaArrayType =>
+        defn.ArrayClass
+      case _ =>
+        NoSymbol
+
+    /** The least (wrt <:<) set of symbols satisfying the `include` predicate of which this type is a subtype
+     */
+    final def parentSymbols(include: Symbol => Boolean)(using Context): List[Symbol] = this match {
+      case tp: TypeRef =>
+        val sym = tp.symbol
+        if (include(sym)) sym :: Nil else tp.superType.parentSymbols(include)
+      case tp: TypeProxy =>
+        tp.superType.parentSymbols(include)
+      case tp: ClassInfo =>
+        tp.cls :: Nil
+      case AndType(l, r) =>
+        l.parentSymbols(include) | r.parentSymbols(include)
+      case OrType(l, r) =>
+        l.parentSymbols(include) intersect r.parentSymbols(include) // TODO does not conform to spec
+      case _ =>
+        Nil
+    }
+
+    /** The least (wrt <:<) set of class symbols of which this type is a subtype
+     */
+    final def classSymbols(using Context): List[ClassSymbol] =
+      parentSymbols(_.isClass).asInstanceOf
+
+    /** Same as `this.classSymbols.contains(cls)` but more efficient */
+    final def hasClassSymbol(cls: Symbol)(using Context): Boolean = this match
+      case tp: TypeRef   =>
+        val sym = tp.symbol
+        sym == cls || !sym.isClass && tp.superType.hasClassSymbol(cls)
+      case tp: TypeProxy =>
+        tp.superType.hasClassSymbol(cls)
+      case tp: ClassInfo =>
+        tp.cls == cls
+      case AndType(l, r) =>
+        l.hasClassSymbol(cls) || r.hasClassSymbol(cls)
+      case OrType(l, r) =>
+        l.hasClassSymbol(cls) && r.hasClassSymbol(cls)
+      case _ =>
+        false
+
+    /** Same as hasClassSmbol(MatchableClass), except that we also follow the constraint
+     *  bounds of type variables in the constraint.
+     */
+    def isMatchableBound(using Context): Boolean = dealias match
+      case tp: TypeRef =>
+        val sym = tp.symbol
+        sym == defn.MatchableClass || !sym.isClass && tp.superType.isMatchableBound
+      case tp: TypeParamRef =>
+        ctx.typerState.constraint.entry(tp) match
+          case bounds: TypeBounds => bounds.hi.isMatchableBound
+          case _ => false
+      case tp: TypeProxy => tp.superType.isMatchableBound
+      case tp: AndType => tp.tp1.isMatchableBound || tp.tp2.isMatchableBound
+      case tp: OrType => tp.tp1.isMatchableBound && tp.tp2.isMatchableBound
+      case _ => false
+
+    /** The term symbol associated with the type */
+    @tailrec final def termSymbol(using Context): Symbol = this match {
+      case tp: TermRef => tp.symbol
+      case tp: TypeProxy => tp.underlying.termSymbol
+      case _ => NoSymbol
+    }
+
+    /** The base classes of this type as determined by ClassDenotation
+     *  in linearization order, with the class itself as first element.
+     *  Inherited by all type proxies. Overridden for And and Or types.
+     *  `Nil` for all other types.
+     */
+    def baseClasses(using Context): List[ClassSymbol] =
+      record("baseClasses")
+      try
+        this match
+          case tp: TypeProxy =>
+            tp.superType.baseClasses
+          case tp: ClassInfo =>
+            tp.cls.classDenot.baseClasses
+          case _ => Nil
+      catch case ex: Throwable =>
+        handleRecursive("base classes of", this.show, ex)
+
+// ----- Member access -------------------------------------------------
+
+    /** The scope of all declarations of this type.
+     *  Defined by ClassInfo, inherited by type proxies.
+     *  Empty scope for all other types.
+     */
+    @tailrec final def decls(using Context): Scope = this match {
+      case tp: ClassInfo =>
+        tp.decls
+      case tp: TypeProxy =>
+        tp.superType.decls
+      case _ =>
+        EmptyScope
+    }
+
+    /** A denotation containing the declaration(s) in this type with the given name.
+     *  The result is either a SymDenotation or a MultiDenotation of SymDenotations.
+     *  The info(s) are the original symbol infos, no translation takes place.
+     */
+    final def decl(name: Name)(using Context): Denotation = {
+      record("decl")
+      findDecl(name, EmptyFlags)
+    }
+
+    /** A denotation containing the non-private declaration(s) in this type with the given name */
+    final def nonPrivateDecl(name: Name)(using Context): Denotation =
+      findDecl(name, Private)
+
+    /** A denotation containing the declaration(s) in this type with the given
+     *  name, as seen from prefix type `pre`. Declarations that have a flag
+     *  in `excluded` are omitted.
+     */
+    @tailrec final def findDecl(name: Name, excluded: FlagSet)(using Context): Denotation = this match {
+      case tp: ClassInfo =>
+        tp.decls.denotsNamed(name).filterWithFlags(EmptyFlags, excluded).toDenot(NoPrefix)
+      case tp: TypeProxy =>
+        tp.superType.findDecl(name, excluded)
+      case err: ErrorType =>
+        newErrorSymbol(classSymbol orElse defn.RootClass, name, err.msg)
+      case _ =>
+        NoDenotation
+    }
+
+    /** The member of this type with the given name  */
+    final def member(name: Name)(using Context): Denotation = {
+      record("member")
+      memberBasedOnFlags(name, required = EmptyFlags, excluded = EmptyFlags)
+    }
+
+    /** The non-private member of this type with the given name. */
+    final def nonPrivateMember(name: Name)(using Context): Denotation = {
+      record("nonPrivateMember")
+      memberBasedOnFlags(name, required = EmptyFlags, excluded = Flags.Private)
+    }
+
+    /** The member with given `name` and required and/or excluded flags */
+    final def memberBasedOnFlags(name: Name, required: FlagSet = EmptyFlags, excluded: FlagSet = EmptyFlags)(using Context): Denotation = {
+      // We need a valid prefix for `asSeenFrom`
+      val pre = this match {
+        case tp: ClassInfo => tp.appliedRef
+        case _ => widenIfUnstable
+      }
+      findMember(name, pre, required, excluded)
+    }
+
+    /** Find member of this type with given `name`, all `required`
+     *  flags and no `excluded` flag and produce a denotation that contains
+     *  the type of the member as seen from given prefix `pre`.
+     */
+    final def findMember(name: Name, pre: Type, required: FlagSet = EmptyFlags, excluded: FlagSet = EmptyFlags)(using Context): Denotation = {
+      @tailrec def go(tp: Type): Denotation = tp match {
+        case tp: TermRef =>
+          go (tp.underlying match {
+            case mt: MethodType
+            if mt.paramInfos.isEmpty && tp.symbol.is(StableRealizable) => mt.resultType
+            case tp1 => tp1
+          })
+        case tp: TypeRef =>
+          tp.denot match {
+            case d: ClassDenotation => d.findMember(name, pre, required, excluded)
+            case d => go(d.info)
+          }
+        case tp: AppliedType =>
+          tp.tycon match {
+            case tc: TypeRef =>
+              if (tc.symbol.isClass) go(tc)
+              else {
+                val normed = tp.tryNormalize
+                go(if (normed.exists) normed else tp.superType)
+              }
+            case tc: HKTypeLambda =>
+              goApplied(tp, tc)
+            case _ =>
+              go(tp.superType)
+          }
+        case tp: ThisType => // ??? inline
+          goThis(tp)
+        case tp: RefinedType =>
+          if (name eq tp.refinedName) goRefined(tp) else go(tp.parent)
+        case tp: RecType =>
+          goRec(tp)
+        case tp: TypeParamRef =>
+          goParam(tp)
+        case tp: SuperType =>
+          goSuper(tp)
+        case tp: MatchType =>
+          val normed = tp.tryNormalize
+          go(if (normed.exists) normed else tp.underlying)
+        case tp: TypeProxy =>
+          go(tp.underlying)
+        case tp: ClassInfo =>
+          tp.cls.findMember(name, pre, required, excluded)
+        case AndType(l, r) =>
+          goAnd(l, r)
+        case tp: OrType =>
+          goOr(tp)
+        case tp: JavaArrayType =>
+          defn.ObjectType.findMember(name, pre, required, excluded)
+        case err: ErrorType =>
+          newErrorSymbol(pre.classSymbol orElse defn.RootClass, name, err.msg)
+        case _ =>
+          NoDenotation
+      }
+      def goRec(tp: RecType) =
+        // TODO: change tp.parent to nullable or other values
+        if ((tp.parent: Type | Null) == null) NoDenotation
+        else if (tp eq pre) go(tp.parent)
+        else {
+          //println(s"find member $pre . $name in $tp")
+
+          // We have to be careful because we might open the same (wrt eq) recursive type
+          // twice during findMember which risks picking the wrong prefix in the `substRecThis(rt, pre)`
+          // call below. To avoid this problem we do a defensive copy of the recursive
+          // type first. But if we do this always we risk being inefficient and we ran into
+          // stackoverflows when compiling pos/hk.scala under the refinement encoding
+          // of hk-types. So we only do a copy if the type
+          // is visited again in a recursive call to `findMember`, as tracked by `tp.opened`.
+          // Furthermore, if this happens we mark the original recursive type with `openedTwice`
+          // which means that we always defensively copy the type in the future. This second
+          // measure is necessary because findMember calls might be cached, so do not
+          // necessarily appear in nested order.
+          // Without the defensive copy, Typer.scala fails to compile at the line
+          //
+          //      untpd.rename(lhsCore, setterName).withType(setterType), WildcardType)
+          //
+          // because the subtype check
+          //
+          //      ThisTree[Untyped]#ThisTree[Typed] <: Tree[Typed]
+          //
+          // fails (in fact it thinks the underlying type of the LHS is `Tree[Untyped]`.)
+          //
+          // Without the `openedTwice` trick, Typer.scala fails to Ycheck
+          // at phase resolveSuper.
+          val rt =
+            if (tp.opened) { // defensive copy
+              tp.openedTwice = true
+              RecType(rt => tp.parent.substRecThis(tp, rt.recThis))
+            }
+            else tp
+          rt.opened = true
+          try go(rt.parent).mapInfo(_.substRecThis(rt, pre))
+          finally
+            if (!rt.openedTwice) rt.opened = false
+        }
+
+      def goRefined(tp: RefinedType) = {
+        val pdenot = go(tp.parent)
+        val pinfo = pdenot.info
+        val rinfo = tp.refinedInfo
+        if (name.isTypeName && !pinfo.isInstanceOf[ClassInfo]) { // simplified case that runs more efficiently
+          val jointInfo =
+            if rinfo.isInstanceOf[TypeAlias] && !ctx.mode.is(Mode.CheckBoundsOrSelfType) then
+              // In normal situations, the only way to "improve" on rinfo is to return an empty type bounds
+              // So, we do not lose anything essential in "widening" to rinfo.
+              // We need to compute the precise info only when checking for empty bounds
+              // which is communicated by the CheckBoundsOrSelfType mode.
+              rinfo
+            else if ctx.base.pendingMemberSearches.contains(name) then
+              pinfo safe_& rinfo
+            else
+              pinfo recoverable_& rinfo
+          pdenot.asSingleDenotation.derivedSingleDenotation(pdenot.symbol, jointInfo)
+        }
+        else
+          val isRefinedMethod = rinfo.isInstanceOf[MethodOrPoly]
+          val joint = pdenot.meet(
+            new JointRefDenotation(NoSymbol, rinfo, Period.allInRun(ctx.runId), pre, isRefinedMethod),
+            pre,
+            safeIntersection = ctx.base.pendingMemberSearches.contains(name))
+          joint match
+            case joint: SingleDenotation
+            if isRefinedMethod && rinfo <:< joint.info =>
+              // use `rinfo` to keep the right parameter names for named args. See i8516.scala.
+              joint.derivedSingleDenotation(joint.symbol, rinfo, pre, isRefinedMethod)
+            case _ =>
+              joint
+      }
+
+      def goApplied(tp: AppliedType, tycon: HKTypeLambda) =
+        go(tycon.resType).mapInfo(info =>
+          tycon.derivedLambdaAbstraction(tycon.paramNames, tycon.paramInfos, info).appliedTo(tp.args))
+
+      def goThis(tp: ThisType) =
+        val underlying = tp.underlying
+        val d = go(underlying)
+        if d.exists then
+          if underlying.isInstanceOf[AndType] then
+            // The underlying type of `this` is specified in a self type clause.
+            // In this case we need to exclude all private members from `d` which are
+            // not defined in the class of the `this` type. We could do this test
+            // always, but the restriction to test only if `underlying` is an AndType
+            // is made to save execution time in the common case. See i9844.scala for test cases.
+            def qualifies(sd: SingleDenotation) =
+              !sd.symbol.is(Private) || sd.symbol.owner == tp.cls
+            d match
+              case d: SingleDenotation => if qualifies(d) then d else NoDenotation
+              case d => d.filterWithPredicate(qualifies)
+          else d
+        else
+          // There is a special case to handle:
+          //   trait Super { this: Sub => private class Inner {} println(this.Inner) }
+          //   class Sub extends Super
+          // When resolving Super.this.Inner, the normal logic goes to the self type and
+          // looks for Inner from there. But this fails because Inner is private.
+          // We fix the problem by having the following fallback case, which links up the
+          // member in Super instead of Sub.
+          // As an example of this in the wild, see
+          // loadClassWithPrivateInnerAndSubSelf in ShowClassTests
+          go(tp.cls.typeRef) orElse d
+
+      def goParam(tp: TypeParamRef) = {
+        val next = tp.underlying
+        ctx.typerState.constraint.entry(tp) match {
+          case bounds: TypeBounds if bounds ne next =>
+            go(bounds.hi)
+          case _ =>
+            go(next)
+        }
+      }
+
+      def goSuper(tp: SuperType) = go(tp.underlying) match {
+        case d: JointRefDenotation =>
+          typr.println(i"redirecting super.$name from $tp to ${d.symbol.showLocated}")
+          new UniqueRefDenotation(d.symbol, tp.memberInfo(d.symbol), d.validFor, pre)
+        case d => d
+      }
+
+      def goAnd(l: Type, r: Type) =
+        go(l).meet(go(r), pre, safeIntersection = ctx.base.pendingMemberSearches.contains(name))
+
+      def goOr(tp: OrType) =
+        inline def searchAfterJoin =
+          // we need to keep the invariant that `pre <: tp`. Branch `union-types-narrow-prefix`
+          // achieved that by narrowing `pre` to each alternative, but it led to merge errors in
+          // lots of places. The present strategy is instead of widen `tp` using `join` to be a
+          // supertype of `pre`.
+          go(tp.join)
+
+        if Nullables.unsafeNullsEnabled then tp match
+          case OrNull(tp1) if tp1 <:< defn.ObjectType  =>
+            // Selecting `name` from a type `T | Null` is like selecting `name` from `T`, if
+            // unsafeNulls is enabled and T is a subtype of AnyRef.
+            // This can throw at runtime, but we trade soundness for usability.
+            tp1.findMember(name, pre.stripNull, required, excluded)
+          case _ =>
+            searchAfterJoin
+        else searchAfterJoin
+
+      val recCount = ctx.base.findMemberCount
+      if (recCount >= Config.LogPendingFindMemberThreshold)
+        ctx.base.pendingMemberSearches = name :: ctx.base.pendingMemberSearches
+      ctx.base.findMemberCount = recCount + 1
+      try go(this)
+      catch {
+        case ex: Throwable =>
+          core.println(s"findMember exception for $this member $name, pre = $pre, recCount = $recCount")
+
+          def showPrefixSafely(pre: Type)(using Context): String = pre.stripTypeVar match {
+            case pre: TermRef => i"${pre.symbol.name}."
+            case pre: TypeRef => i"${pre.symbol.name}#"
+            case pre: TypeProxy => showPrefixSafely(pre.superType)
+            case _ => if (pre.typeSymbol.exists) i"${pre.typeSymbol.name}#" else "."
+          }
+
+          handleRecursive("find-member", i"${showPrefixSafely(pre)}$name", ex)
+      }
+      finally {
+        if (recCount >= Config.LogPendingFindMemberThreshold)
+          ctx.base.pendingMemberSearches = ctx.base.pendingMemberSearches.tail
+        ctx.base.findMemberCount = recCount
+      }
+    }
+
+    /** The set of names of members of this type that pass the given name filter
+     *  when seen as members of `pre`. More precisely, these are all
+     *  of members `name` such that `keepOnly(pre, name)` is `true`.
+     *  @note: OK to use a Set[Name] here because Name hashcodes are replayable,
+     *         hence the Set will always give the same names in the same order.
+     */
+    final def memberNames(keepOnly: NameFilter, pre: Type = this)(using Context): Set[Name] = this match {
+      case tp: ClassInfo =>
+        val names = tp.cls.classDenot.memberNames(keepOnly)
+        if keepOnly.isStable then names else names.filter(keepOnly(pre, _))
+      case tp: RefinedType =>
+        val ns = tp.parent.memberNames(keepOnly, pre)
+        if (keepOnly(pre, tp.refinedName)) ns + tp.refinedName else ns
+      case tp: TypeProxy =>
+        tp.superType.memberNames(keepOnly, pre)
+      case tp: AndType =>
+        tp.tp1.memberNames(keepOnly, pre) | tp.tp2.memberNames(keepOnly, pre)
+      case tp: OrType =>
+        tp.tp1.memberNames(keepOnly, pre) & tp.tp2.memberNames(keepOnly, pre)
+      case _ =>
+        Set()
+    }
+
+    def memberDenots(keepOnly: NameFilter, f: (Name, mutable.Buffer[SingleDenotation]) => Unit)(using Context): Seq[SingleDenotation] = {
+      val buf = mutable.ListBuffer[SingleDenotation]()
+      for (name <- memberNames(keepOnly)) f(name, buf)
+      buf.toList
+    }
+
+    /** The set of abstract term members of this type. */
+    final def abstractTermMembers(using Context): Seq[SingleDenotation] = {
+      record("abstractTermMembers")
+      memberDenots(abstractTermNameFilter,
+          (name, buf) => buf ++= nonPrivateMember(name).altsWith(_.is(Deferred)))
+    }
+
+    /**
+     * Returns the set of methods that are abstract and do not overlap with any of
+     * [[java.lang.Object]] methods.
+     *
+     * Conceptually, a SAM (functional interface) has exactly one abstract method.
+     * If an interface declares an abstract method overriding one of the public
+     * methods of [[java.lang.Object]], that also does not count toward the interface's
+     * abstract method count.
+     *
+     * @see https://docs.oracle.com/javase/8/docs/api/java/lang/FunctionalInterface.html
+     *
+     * @return the set of methods that are abstract and do not match any of [[java.lang.Object]]
+     *
+     */
+    final def possibleSamMethods(using Context): Seq[SingleDenotation] = {
+      record("possibleSamMethods")
+      atPhaseNoLater(erasurePhase) {
+        abstractTermMembers.toList.filterConserve { m =>
+          !m.symbol.matchingMember(defn.ObjectType).exists
+          && !m.symbol.isSuperAccessor
+          && !m.symbol.isInlineMethod
+        }
+      }.map(_.current)
+    }
+
+    /** The set of abstract type members of this type. */
+    final def abstractTypeMembers(using Context): Seq[SingleDenotation] = {
+      record("abstractTypeMembers")
+      memberDenots(abstractTypeNameFilter,
+          (name, buf) => buf += nonPrivateMember(name).asSingleDenotation)
+    }
+
+    /** The set of abstract type members of this type. */
+    final def nonClassTypeMembers(using Context): Seq[SingleDenotation] = {
+      record("nonClassTypeMembers")
+      memberDenots(nonClassTypeNameFilter,
+          (name, buf) => buf += member(name).asSingleDenotation)
+    }
+
+    /** The set of type alias members of this type */
+    final def typeAliasMembers(using Context): Seq[SingleDenotation] = {
+      record("typeAliasMembers")
+      memberDenots(typeAliasNameFilter,
+          (name, buf) => buf += member(name).asSingleDenotation)
+    }
+
+    /** The set of type members of this type */
+    final def typeMembers(using Context): Seq[SingleDenotation] = {
+      record("typeMembers")
+      memberDenots(typeNameFilter,
+          (name, buf) => buf += member(name).asSingleDenotation)
+    }
+
+    /** The set of implicit term members of this type */
+    final def implicitMembers(using Context): List[TermRef] = {
+      record("implicitMembers")
+      memberDenots(implicitFilter,
+          (name, buf) => buf ++= member(name).altsWith(_.isOneOf(GivenOrImplicitVal)))
+        .toList.map(d => TermRef(this, d.symbol.asTerm))
+    }
+
+    /** The set of member classes of this type */
+    final def memberClasses(using Context): Seq[SingleDenotation] = {
+      record("memberClasses")
+      memberDenots(typeNameFilter,
+        (name, buf) => buf ++= member(name).altsWith(x => x.isClass))
+    }
+
+    final def fields(using Context): Seq[SingleDenotation] = {
+      record("fields")
+      memberDenots(fieldFilter,
+        (name, buf) => buf ++= member(name).altsWith(x => !x.is(Method)))
+    }
+
+    /** The set of members of this type that have all of `required` flags but none of `excluded` flags set. */
+    final def membersBasedOnFlags(required: FlagSet, excluded: FlagSet)(using Context): Seq[SingleDenotation] = {
+      record("membersBasedOnFlags")
+      memberDenots(takeAllFilter,
+        (name, buf) => buf ++= memberBasedOnFlags(name, required, excluded).alternatives)
+    }
+
+    /** All members of this type. Warning: this can be expensive to compute! */
+    final def allMembers(using Context): Seq[SingleDenotation] = {
+      record("allMembers")
+      memberDenots(takeAllFilter, (name, buf) => buf ++= member(name).alternatives)
+    }
+
+    /** The info of `sym`, seen as a member of this type. */
+    final def memberInfo(sym: Symbol)(using Context): Type =
+      sym.info.asSeenFrom(this, sym.owner)
+
+    /** This type seen as if it were the type of a member of prefix type `pre`
+     *  declared in class `cls`.
+     */
+    final def asSeenFrom(pre: Type, cls: Symbol)(using Context): Type = {
+      record("asSeenFrom")
+      if (!cls.membersNeedAsSeenFrom(pre)) this
+      else TypeOps.asSeenFrom(this, pre, cls)
+    }
+
+// ----- Subtype-related --------------------------------------------
+
+    /** Is this type a subtype of that type? */
+    final def <:<(that: Type)(using Context): Boolean = {
+      record("<:<")
+      TypeComparer.topLevelSubType(this, that)
+    }
+
+    /** Is this type a subtype of that type? */
+    final def frozen_<:<(that: Type)(using Context): Boolean = {
+      record("frozen_<:<")
+      TypeComparer.isSubTypeWhenFrozen(this, that)
+    }
+
+    /** Is this type the same as that type?
+     *  This is the case iff `this <:< that` and `that <:< this`.
+     */
+    final def =:=(that: Type)(using Context): Boolean = {
+      record("=:=")
+      TypeComparer.isSameType(this, that)
+    }
+
+    final def frozen_=:=(that: Type)(using Context): Boolean =
+      TypeComparer.isSameTypeWhenFrozen(this, that)
+
+    /** Is this type a primitive value type which can be widened to the primitive value type `that`? */
+    def isValueSubType(that: Type)(using Context): Boolean = widenDealias match
+      case self: TypeRef if self.symbol.isPrimitiveValueClass =>
+        that.widenExpr.dealias match
+          case that: TypeRef if that.symbol.isPrimitiveValueClass =>
+            defn.isValueSubClass(self.symbol, that.symbol)
+          case _ =>
+            false
+      case _ =>
+        false
+
+    def relaxed_<:<(that: Type)(using Context): Boolean =
+      (this <:< that) || (this isValueSubType that)
+
+    /** Is this type a legal type for member `sym1` that overrides another
+     *  member `sym2` of type `that`? This is the same as `<:<`, except that
+     *  @param relaxedCheck   if true type `Null` becomes a subtype of non-primitive value types in TypeComparer.
+     *  @param matchLoosely   if true the types `=> T` and `()T` are seen as overriding each other.
+     *  @param checkClassInfo if true we check that ClassInfos are within bounds of abstract types
+     */
+    final def overrides(that: Type, relaxedCheck: Boolean, matchLoosely: => Boolean, checkClassInfo: Boolean = true)(using Context): Boolean = {
+      val overrideCtx = if relaxedCheck then ctx.relaxedOverrideContext else ctx
+      inContext(overrideCtx) {
+        !checkClassInfo && this.isInstanceOf[ClassInfo]
+        || (this.widenExpr frozen_<:< that.widenExpr)
+        || matchLoosely && {
+            val this1 = this.widenNullaryMethod
+            val that1 = that.widenNullaryMethod
+            ((this1 `ne` this) || (that1 `ne` that)) && this1.overrides(that1, relaxedCheck, false, checkClassInfo)
+          }
+      }
+    }
+
+    /** Is this type close enough to that type so that members
+     *  with the two types would override each other?
+     *  This means:
+     *    - Either both types are polytypes with the same number of
+     *      type parameters and their result types match after renaming
+     *      corresponding type parameters
+     *    - Or both types are method types with =:=-equivalent(*) parameter types
+     *      and matching result types after renaming corresponding parameter types
+     *      if the method types are dependent.
+     *    - Or both types are =:=-equivalent
+     *    - Or phase.erasedTypes is false, and neither type takes
+     *      term or type parameters.
+     *
+     *  (*) when matching with a Java method, we also regard Any and Object as equivalent
+     *      parameter types.
+     *
+     *  Under explicit nulls, this function will always use unsafe-nulls semamtics to
+     *  check the types. This is because we are using a relaxed rule (ignoring `Null` types)
+     *  to check overriding Java methods.
+     */
+    def matches(that: Type)(using Context): Boolean = {
+      record("matches")
+      val overrideCtx = if ctx.explicitNulls then ctx.relaxedOverrideContext else ctx
+      TypeComparer.matchesType(this, that, relaxed = !ctx.phase.erasedTypes)(using overrideCtx)
+    }
+
+    /** This is the same as `matches` except that it also matches => T with T and
+     *  vice versa.
+     */
+    def matchesLoosely(that: Type)(using Context): Boolean =
+      (this matches that) || {
+        val thisResult = this.widenExpr
+        val thatResult = that.widenExpr
+        (this eq thisResult) != (that eq thatResult) && (thisResult matchesLoosely thatResult)
+      }
+
+    /** The basetype of this type with given class symbol, NoType if `base` is not a class. */
+    final def baseType(base: Symbol)(using Context): Type = {
+      record("baseType")
+      base.denot match {
+        case classd: ClassDenotation => classd.baseTypeOf(this)
+        case _ => NoType
+      }
+    }
+
+    def & (that: Type)(using Context): Type = {
+      record("&")
+      TypeComparer.glb(this, that)
+    }
+
+    /** Safer version of `&`.
+     *
+     *  This version does not simplify the bounds of the intersection of
+     *  two TypeBounds. The simplification done by `&` requires subtyping checks
+     *  which may end up calling `&` again, in most cases this should be safe
+     *  but because of F-bounded types, this can result in an infinite loop
+     *  (which will be masked unless `-Yno-deep-subtypes` is enabled).
+     *  pos/i536 demonstrates that the infinite loop can also involve lower bounds.
+     */
+    def safe_& (that: Type)(using Context): Type = (this, that) match {
+      case (TypeBounds(lo1, hi1), TypeBounds(lo2, hi2)) =>
+        TypeBounds(
+          OrType.makeHk(lo1.stripLazyRef, lo2.stripLazyRef),
+          AndType.makeHk(hi1.stripLazyRef, hi2.stripLazyRef))
+      case _ =>
+        this & that
+    }
+
+    /** `this & that`, but handle CyclicReferences by falling back to `safe_&`.
+     */
+    def recoverable_&(that: Type)(using Context): Type =
+      try this & that
+      catch {
+        case ex: CyclicReference => this safe_& that
+          // A test case where this happens is tests/pos/i536.scala.
+          // The & causes a subtype check which calls baseTypeRef again with the same
+          // superclass.
+      }
+
+    def | (that: Type)(using Context): Type = {
+      record("|")
+      TypeComparer.lub(this, that)
+    }
+
+// ----- Unwrapping types -----------------------------------------------
+
+    /** Map a TypeVar to either its instance if it is instantiated, or its origin,
+     *  if not, until the result is no longer a TypeVar. Identity on all other types.
+     */
+    def stripTypeVar(using Context): Type = this
+
+    /** Remove all AnnotatedTypes wrapping this type.
+     */
+    def stripAnnots(using Context): Type = this
+
+    /** Strip TypeVars and Annotation and CapturingType wrappers */
+    def stripped(using Context): Type = this
+
+    def strippedDealias(using Context): Type =
+      val tp1 = stripped.dealias
+      if tp1 ne this then tp1.strippedDealias else this
+
+    def rewrapAnnots(tp: Type)(using Context): Type = tp.stripTypeVar match {
+      case AnnotatedType(tp1, annot) => AnnotatedType(rewrapAnnots(tp1), annot)
+      case _ => this
+    }
+
+    /** Strip PolyType prefixes */
+    def stripPoly(using Context): Type = this match {
+      case tp: PolyType => tp.resType.stripPoly
+      case _ => this
+    }
+
+    /** Strip LazyRef wrappers */
+    def stripLazyRef(using Context): Type = this match
+      case lzy: LazyRef => lzy.ref.stripLazyRef
+      case _ => this
+
+    /** Widen from singleton type to its underlying non-singleton
+     *  base type by applying one or more `underlying` dereferences,
+     *  Also go from => T to T.
+     *  Identity for all other types. Example:
+     *
+     *  class Outer { class C ; val x: C }
+     *  def o: Outer
+     *  <o.x.type>.widen = o.C
+     */
+    final def widen(using Context): Type = this match
+      case _: TypeRef | _: MethodOrPoly => this // fast path for most frequent cases
+      case tp: TermRef => // fast path for next most frequent case
+        if tp.isOverloaded then tp else tp.underlying.widen
+      case tp: SingletonType => tp.underlying.widen
+      case tp: ExprType => tp.resultType.widen
+      case tp =>
+        val tp1 = tp.stripped
+        if tp1 eq tp then tp
+        else
+          val tp2 = tp1.widen
+          if tp2 ne tp1 then tp2 else tp
+
+    /** Widen from singleton type to its underlying non-singleton
+     *  base type by applying one or more `underlying` dereferences.
+     */
+    final def widenSingleton(using Context): Type = stripped match {
+      case tp: SingletonType if !tp.isOverloaded => tp.underlying.widenSingleton
+      case _ => this
+    }
+
+    /** Widen from TermRef to its underlying non-termref
+     *  base type, while also skipping Expr types.
+     */
+    final def widenTermRefExpr(using Context): Type = stripTypeVar match {
+      case tp: TermRef if !tp.isOverloaded => tp.underlying.widenExpr.widenTermRefExpr
+      case _ => this
+    }
+
+    /** Widen from ExprType type to its result type.
+     *  (Note: no stripTypeVar needed because TypeVar's can't refer to ExprTypes.)
+     */
+    final def widenExpr: Type = this match {
+      case tp: ExprType => tp.resType
+      case _ => this
+    }
+
+    /** Widen type if it is unstable (i.e. an ExprType, or TermRef to unstable symbol */
+    final def widenIfUnstable(using Context): Type = stripTypeVar match {
+      case tp: ExprType => tp.resultType.widenIfUnstable
+      case tp: TermRef if tp.symbol.exists && !tp.symbol.isStableMember => tp.underlying.widenIfUnstable
+      case _ => this
+    }
+
+    /** If this is a skolem, its underlying type, otherwise the type itself */
+    final def widenSkolem(using Context): Type = this match {
+      case tp: SkolemType => tp.underlying
+      case _ => this
+    }
+
+    /** Widen this type and if the result contains embedded soft union types, replace
+     *  them by their joins.
+     *  "Embedded" means: inside type lambdas, intersections or recursive types,
+     *  in prefixes of refined types, or in hard union types.
+     *  If an embedded soft union is found, we first try to simplify or eliminate it by
+     *  re-lubbing it while allowing type parameters to be constrained further.
+     *  Any remaining union types are replaced by their joins.
+     *
+     *  For instance, if `A` is an unconstrained type variable, then
+     *
+     * 	      ArrayBuffer[Int] | ArrayBuffer[A]
+     *
+     *  is approximated by constraining `A` to be =:= to `Int` and returning `ArrayBuffer[Int]`
+     *  instead of `ArrayBuffer[? >: Int | A <: Int & A]`
+     *
+     *  Exception (if `-YexplicitNulls` is set): if this type is a nullable union (i.e. of the form `T | Null`),
+     *  then the top-level union isn't widened. This is needed so that type inference can infer nullable types.
+     */
+    def widenUnion(using Context): Type = widen match
+      case tp @ OrNull(tp1): OrType =>
+        // Don't widen `T|Null`, since otherwise we wouldn't be able to infer nullable unions.
+        val tp1Widen = tp1.widenUnionWithoutNull
+        if (tp1Widen.isRef(defn.AnyClass)) tp1Widen
+        else tp.derivedOrType(tp1Widen, defn.NullType)
+      case tp =>
+        tp.widenUnionWithoutNull
+
+    /** Overridden in OrType */
+    def widenUnionWithoutNull(using Context): Type = widen match
+      case tp: AndType =>
+        tp.derivedAndType(tp.tp1.widenUnionWithoutNull, tp.tp2.widenUnionWithoutNull)
+      case tp: RefinedType =>
+        tp.derivedRefinedType(tp.parent.widenUnion, tp.refinedName, tp.refinedInfo)
+      case tp: RecType =>
+        tp.rebind(tp.parent.widenUnion)
+      case tp: HKTypeLambda =>
+        tp.derivedLambdaType(resType = tp.resType.widenUnion)
+      case tp =>
+        tp
+
+    /** Widen all top-level singletons reachable by dealiasing
+     *  and going to the operands of & and |.
+     *  Overridden and cached in OrType.
+     */
+    def widenSingletons(using Context): Type = dealias match {
+      case tp: SingletonType =>
+        tp.widen
+      case tp: OrType =>
+        val tp1w = tp.widenSingletons
+        if (tp1w eq tp) this else tp1w
+      case tp: AndType =>
+        val tp1w = tp.tp1.widenSingletons
+        val tp2w = tp.tp2.widenSingletons
+        if ((tp.tp1 eq tp1w) && (tp.tp2 eq tp2w)) this else tp1w & tp2w
+      case _ =>
+        this
+    }
+
+    /** If this is a nullary method type, its result type */
+    def widenNullaryMethod(using Context): Type = this match
+      case tp @ MethodType(Nil) => tp.resType
+      case _ => this
+
+    /** The singleton types that must or may be in this type. @see Atoms.
+     *  Overridden and cached in OrType.
+     */
+    def atoms(using Context): Atoms =
+      def normalize(tp: Type): Type = tp match
+        case tp: SingletonType =>
+          tp.underlying.dealias match
+            case tp1: SingletonType => normalize(tp1)
+            case _ =>
+              tp match
+                case tp: TermRef => tp.derivedSelect(normalize(tp.prefix))
+                case _ => tp
+        case _ => tp
+
+      def single(tp: Type): Atoms =
+        if tp.isStable then
+          val set = Set.empty + normalize(tp)
+          Atoms.Range(set, set)
+        else Atoms.Unknown
+
+      dealias match
+        case tp: SingletonType =>
+          tp.underlying.atoms match
+            case as @ Atoms.Range(lo, hi) =>
+              if hi.size == 1 then as // if there's just one atom, there's no uncertainty which one it is
+              else Atoms.Range(Set.empty, hi)
+            case Atoms.Unknown =>
+              single(tp)
+        case tp: ExprType => tp.resType.atoms
+        case tp: OrType => tp.atoms // `atoms` overridden in OrType
+        case tp: AndType => tp.tp1.atoms & tp.tp2.atoms
+        case tp: TypeRef if tp.symbol.is(ModuleClass) =>
+          // The atom of a module class is the module itself,
+          // this corresponds to the special case in TypeComparer
+          // which ensures that `X$ <:< X.type` returns true.
+          single(tp.symbol.companionModule.termRef.asSeenFrom(tp.prefix, tp.symbol.owner))
+        case tp: TypeProxy =>
+          tp.superType.atoms match
+            case Atoms.Range(_, hi) => Atoms.Range(Set.empty, hi)
+            case Atoms.Unknown => Atoms.Unknown
+        case _ => Atoms.Unknown
+
+    private def dealias1(keep: AnnotatedType => Context ?=> Boolean, keepOpaques: Boolean)(using Context): Type = this match {
+      case tp: TypeRef =>
+        if (tp.symbol.isClass) tp
+        else tp.info match {
+          case TypeAlias(alias) if !(keepOpaques && tp.symbol.is(Opaque)) =>
+            alias.dealias1(keep, keepOpaques)
+          case _ => tp
+        }
+      case app @ AppliedType(tycon, _) =>
+        val tycon1 = tycon.dealias1(keep, keepOpaques)
+        if (tycon1 ne tycon) app.superType.dealias1(keep, keepOpaques)
+        else this
+      case tp: TypeVar =>
+        val tp1 = tp.instanceOpt
+        if (tp1.exists) tp1.dealias1(keep, keepOpaques) else tp
+      case tp: AnnotatedType =>
+        val parent1 = tp.parent.dealias1(keep, keepOpaques)
+        tp match
+          case tp @ CapturingType(parent, refs) =>
+            tp.derivedCapturingType(parent1, refs)
+          case _ =>
+            if keep(tp) then tp.derivedAnnotatedType(parent1, tp.annot)
+            else parent1
+      case tp: LazyRef =>
+        tp.ref.dealias1(keep, keepOpaques)
+      case _ => this
+    }
+
+    /** Follow aliases and dereferences LazyRefs, annotated types and instantiated
+     *  TypeVars until type is no longer alias type, annotated type, LazyRef,
+     *  or instantiated type variable.
+     */
+    final def dealias(using Context): Type = dealias1(keepNever, keepOpaques = false)
+
+    /** Follow aliases and dereferences LazyRefs and instantiated TypeVars until type
+     *  is no longer alias type, LazyRef, or instantiated type variable.
+     *  Goes through annotated types and rewraps annotations on the result.
+     */
+    final def dealiasKeepAnnots(using Context): Type = dealias1(keepAlways, keepOpaques = false)
+
+    /** Like `dealiasKeepAnnots`, but keeps only refining annotations */
+    final def dealiasKeepRefiningAnnots(using Context): Type = dealias1(keepIfRefining, keepOpaques = false)
+
+    /** Follow non-opaque aliases and dereferences LazyRefs, annotated types and instantiated
+     *  TypeVars until type is no longer alias type, annotated type, LazyRef,
+     *  or instantiated type variable.
+     */
+    final def dealiasKeepOpaques(using Context): Type = dealias1(keepNever, keepOpaques = true)
+
+    /** Approximate this type with a type that does not contain skolem types. */
+    final def deskolemized(using Context): Type =
+      val deskolemizer = new ApproximatingTypeMap {
+        def apply(tp: Type) = /*trace(i"deskolemize($tp) at $variance", show = true)*/
+          tp match {
+            case tp: SkolemType => range(defn.NothingType, atVariance(1)(apply(tp.info)))
+            case _ => mapOver(tp)
+          }
+      }
+      deskolemizer(this)
+
+    /** The result of normalization using `tryNormalize`, or the type itself if
+     *  tryNormlize yields NoType
+     */
+    final def normalized(using Context): Type = {
+      val normed = tryNormalize
+      if (normed.exists) normed else this
+    }
+
+    /** If this type can be normalized at the top-level by rewriting match types
+     *  of S[n] types, the result after applying all toplevel normalizations,
+     *  otherwise NoType
+     */
+    def tryNormalize(using Context): Type = NoType
+
+    private def widenDealias1(keep: AnnotatedType => Context ?=> Boolean)(using Context): Type = {
+      val res = this.widen.dealias1(keep, keepOpaques = false)
+      if (res eq this) res else res.widenDealias1(keep)
+    }
+
+    /** Perform successive widenings and dealiasings until none can be applied anymore */
+    final def widenDealias(using Context): Type = widenDealias1(keepNever)
+
+    /** Perform successive widenings and dealiasings while rewrapping annotations, until none can be applied anymore */
+    final def widenDealiasKeepAnnots(using Context): Type = widenDealias1(keepAlways)
+
+    /** Perform successive widenings and dealiasings while rewrapping refining annotations, until none can be applied anymore */
+    final def widenDealiasKeepRefiningAnnots(using Context): Type = widenDealias1(keepIfRefining)
+
+    /** Widen from constant type to its underlying non-constant
+     *  base type.
+     */
+    final def deconst(using Context): Type = stripTypeVar match {
+      case tp: ConstantType => tp.value.tpe
+      case _ => this
+    }
+
+    /** Dealias, and if result is a dependent function type, drop the `apply` refinement. */
+    final def dropDependentRefinement(using Context): Type = dealias match {
+      case RefinedType(parent, nme.apply, _) => parent
+      case tp => tp
+    }
+
+    /** The type constructor of an applied type, otherwise the type itself */
+    final def typeConstructor(using Context): Type = this match {
+      case AppliedType(tycon, _) => tycon
+      case _ => this
+    }
+
+    /** If this is a (possibly aliased, annotated, and/or parameterized) reference to
+     *  a class, the class type ref, otherwise NoType.
+     *  @param  refinementOK   If `true` we also skip refinements.
+     */
+    def underlyingClassRef(refinementOK: Boolean)(using Context): Type = dealias match {
+      case tp: TypeRef =>
+        if (tp.symbol.isClass) tp
+        else if (tp.symbol.isAliasType) tp.underlying.underlyingClassRef(refinementOK)
+        else NoType
+      case tp: AppliedType =>
+        if (tp.tycon.isLambdaSub) NoType
+        else tp.superType.underlyingClassRef(refinementOK)
+      case tp: AnnotatedType =>
+        tp.parent.underlyingClassRef(refinementOK)
+      case tp: RefinedType =>
+        if (refinementOK) tp.underlying.underlyingClassRef(refinementOK) else NoType
+      case tp: RecType =>
+        tp.underlying.underlyingClassRef(refinementOK)
+      case _ =>
+        NoType
+    }
+
+    /** The iterator of underlying types as long as type is a TypeProxy.
+     *  Useful for diagnostics
+     */
+    def underlyingIterator(using Context): Iterator[Type] = new Iterator[Type] {
+      var current = Type.this
+      var hasNext = true
+      def next = {
+        val res = current
+        hasNext = current.isInstanceOf[TypeProxy]
+        if (hasNext) current = current.asInstanceOf[TypeProxy].underlying
+        res
+      }
+    }
+
+    /** A prefix-less refined this or a termRef to a new skolem symbol
+     *  that has the given type as info.
+     */
+    def narrow(using Context): TermRef =
+      TermRef(NoPrefix, newSkolem(this))
+
+    /** Useful for diagnostics: The underlying type if this type is a type proxy,
+     *  otherwise NoType
+     */
+    def underlyingIfProxy(using Context): Type = this match {
+      case this1: TypeProxy => this1.underlying
+      case _ => NoType
+    }
+
+    /** If this is a repeated type, its element type, otherwise the type itself */
+    def repeatedToSingle(using Context): Type = this match {
+      case tp @ ExprType(tp1) => tp.derivedExprType(tp1.repeatedToSingle)
+      case _                  => if (isRepeatedParam) this.argTypesHi.head else this
+    }
+
+    /** The capture set of this type. Overridden and cached in CaptureRef */
+    def captureSet(using Context): CaptureSet = CaptureSet.ofType(this)
+
+    // ----- Normalizing typerefs over refined types ----------------------------
+
+    /** If this normalizes* to a refinement type that has a refinement for `name` (which might be followed
+     *  by other refinements), and the refined info is a type alias, return the alias,
+     *  otherwise return NoType. Used to reduce types of the form
+     *
+     *    P { ... type T = / += / -= U ... } # T
+     *
+     *  to just U. Does not perform the reduction if the resulting type would contain
+     *  a reference to the "this" of the current refined type, except in the following situation
+     *
+     *  (1) The "this" reference can be avoided by following an alias. Example:
+     *
+     *      P { type T = String, type R = P{...}.T } # R  -->  String
+     *
+     *  (*) normalizes means: follow instantiated typevars and aliases.
+     */
+    def lookupRefined(name: Name)(using Context): Type = {
+      @tailrec def loop(pre: Type): Type = pre.stripTypeVar match {
+        case pre: RefinedType =>
+          pre.refinedInfo match {
+            case tp: AliasingBounds =>
+              if (pre.refinedName ne name) loop(pre.parent) else tp.alias
+            case _ =>
+              loop(pre.parent)
+          }
+        case pre: RecType =>
+          val candidate = pre.parent.lookupRefined(name)
+          if (candidate.exists && !pre.isReferredToBy(candidate))
+            //println(s"lookupRefined ${this.toString} . $name, pre: $pre ---> $candidate / ${candidate.toString}")
+            candidate
+          else NoType
+        case SkolemType(tp) =>
+          loop(tp)
+        case pre: WildcardType =>
+          WildcardType
+        case pre: TypeRef =>
+          pre.info match {
+            case TypeAlias(alias) => loop(alias)
+            case _ => NoType
+          }
+        case _ =>
+          NoType
+      }
+
+      loop(this)
+    }
+
+    /** The type <this . name> , reduced if possible */
+    def select(name: Name)(using Context): Type =
+      NamedType(this, name, member(name)).reduceProjection
+
+    /** The type <this . name> with given denotation, reduced if possible. */
+    def select(name: Name, denot: Denotation)(using Context): Type =
+      NamedType(this, name, denot).reduceProjection
+
+    /** The type <this . sym>, reduced if possible */
+    def select(sym: Symbol)(using Context): Type =
+      NamedType(this, sym).reduceProjection
+
+    def select(name: TermName)(using Context): TermRef =
+      TermRef(this, name, member(name))
+
+    def select(name: TermName, sig: Signature, target: Name)(using Context): TermRef =
+      TermRef(this, name, member(name).atSignature(sig, target, relaxed = !ctx.erasedTypes))
+
+// ----- Access to parts --------------------------------------------
+
+    /** The normalized prefix of this type is:
+     *  For an alias type, the normalized prefix of its alias
+     *  For all other named type and class infos: the prefix.
+     *  Inherited by all other type proxies.
+     *  `NoType` for all other types.
+     */
+    @tailrec final def normalizedPrefix(using Context): Type = this match {
+      case tp: NamedType =>
+        if (tp.symbol.info.isTypeAlias) tp.info.normalizedPrefix else tp.prefix
+      case tp: ClassInfo =>
+        tp.prefix
+      case tp: TypeProxy =>
+        tp.superType.normalizedPrefix
+      case _ =>
+        NoType
+    }
+
+    /** The full parent types, including all type arguments */
+    def parents(using Context): List[Type] = this match {
+      case tp @ AppliedType(tycon, args) if tycon.typeSymbol.isClass =>
+        tycon.parents.map(_.subst(tycon.typeSymbol.typeParams, args))
+      case tp: TypeRef =>
+        if (tp.info.isInstanceOf[TempClassInfo])
+          tp.recomputeDenot()
+            // We usually should have `!tp.info.isInstanceOf[TempClassInfo]` here, but
+            // this can be falsified for code with illegal cyclic references. See neg/i7107.scala.
+        tp.info.parents
+      case tp: TypeProxy =>
+        tp.superType.parents
+      case _ => Nil
+    }
+
+    /** The first parent of this type, AnyRef if list of parents is empty */
+    def firstParent(using Context): Type = parents match {
+      case p :: _ => p
+      case _ => defn.AnyType
+    }
+
+    /** The parameter types of a PolyType or MethodType, Empty list for others */
+    final def paramInfoss(using Context): List[List[Type]] = stripPoly match {
+      case mt: MethodType => mt.paramInfos :: mt.resultType.paramInfoss
+      case _ => Nil
+    }
+
+    /** The parameter names of a PolyType or MethodType, Empty list for others */
+    final def paramNamess(using Context): List[List[TermName]] = stripPoly match {
+      case mt: MethodType => mt.paramNames :: mt.resultType.paramNamess
+      case _ => Nil
+    }
+
+    /** The parameter types in the first parameter section of a generic type or MethodType, Empty list for others */
+    final def firstParamTypes(using Context): List[Type] = stripPoly match {
+      case mt: MethodType => mt.paramInfos
+      case _ => Nil
+    }
+
+    /** The parameter names in the first parameter section of a generic type or MethodType, Empty list for others */
+    final def firstParamNames(using Context): List[TermName] = stripPoly match {
+      case mt: MethodType => mt.paramNames
+      case _ => Nil
+    }
+
+    /** Is this either not a method at all, or a parameterless method? */
+    final def isParameterless(using Context): Boolean = stripPoly match {
+      case mt: MethodType => false
+      case _ => true
+    }
+
+    /** Is this (an alias of) the `scala.Null` type? */
+    final def isNullType(using Context) = isRef(defn.NullClass)
+
+    /** Is this (an alias of) the `scala.Nothing` type? */
+    final def isNothingType(using Context) = isRef(defn.NothingClass)
+
+    /** The resultType of a LambdaType, or ExprType, the type itself for others */
+    def resultType(using Context): Type = this
+
+    /** The final result type of a PolyType, MethodType, or ExprType, after skipping
+     *  all parameter sections, the type itself for all others.
+     */
+    def finalResultType(using Context): Type = resultType.stripPoly match {
+      case mt: MethodType => mt.resultType.finalResultType
+      case _ => resultType
+    }
+
+    /** Determine the expected function type from the prototype.
+     *  If no function type is found, NoType is returned. If multiple
+     *  function types are found in an intersection, their intersection
+     *  is returned. This works since `&` invokes `TypeComparer.distributeAnd`, which
+     *  ensures that `(A1 => B1) & (A2 => B2)` simplifies to `(A1 | A2) => (B1 & B2)`,
+     *  so the result is again a function type. An analogous distribution mechanism
+     *  does not exist for `|`. Therefore, a union of function types also yields `NoType`,
+     *  since we cannot determine a single expected function type.
+     */
+    def findFunctionType(using Context): Type = dealias match
+      case tp: AndType =>
+        tp.tp1.findFunctionType & tp.tp2.findFunctionType
+      case tp: OrType =>
+        val tf1 = tp.tp1.findFunctionType
+        val tf2 = tp.tp2.findFunctionType
+        if !tf1.exists then tf2
+        else if !tf2.exists then tf1
+        else NoType
+      case t if defn.isNonRefinedFunction(t) =>
+        t
+      case t @ SAMType(_) =>
+        t
+      case _ =>
+        NoType
+
+    /** This type seen as a TypeBounds */
+    final def bounds(using Context): TypeBounds = this match {
+      case tp: TypeBounds => tp
+      case ci: ClassInfo => TypeAlias(ci.appliedRef)
+      case wc: WildcardType =>
+        wc.optBounds match {
+          case bounds: TypeBounds => bounds
+          case NoType => TypeBounds.empty
+        }
+      case _ => TypeAlias(this)
+    }
+
+    /** The lower bound of a TypeBounds type, the type itself otherwise */
+    def loBound: Type = this match {
+      case tp: TypeBounds => tp.lo
+      case _ => this
+    }
+
+    /** The upper bound of a TypeBounds type, the type itself otherwise */
+    def hiBound: Type = this match {
+      case tp: TypeBounds => tp.hi
+      case _ => this
+    }
+
+    /** The type parameter with given `name`. This tries first `decls`
+     *  in order not to provoke a cycle by forcing the info. If that yields
+     *  no symbol it tries `member` as an alternative.
+     */
+    def typeParamNamed(name: TypeName)(using Context): Symbol =
+      classSymbol.unforcedDecls.lookup(name) orElse member(name).symbol
+
+    /** If this is a prototype with some ignored component, reveal one more
+     *  layer of it. Otherwise the type itself.
+     */
+    def deepenProto(using Context): Type = this
+
+    /** If this is a prototype with some ignored component, reveal it, and
+     *  deepen the result transitively. Otherwise the type itself.
+     */
+    def deepenProtoTrans(using Context): Type = this
+
+    /** If this is an ignored proto type, its underlying type, otherwise the type itself */
+    def revealIgnored: Type = this
+
+    /** If this is a proto type, WildcardType, otherwise the type itself */
+    def dropIfProto: Type = this
+
+    /** If this is an AndType, the number of factors, 1 for all other types */
+    def andFactorCount: Int = 1
+
+    /** If this is a OrType, the number of factors if that match `soft`,
+     *  1 for all other types.
+     */
+    def orFactorCount(soft: Boolean): Int = 1
+
+// ----- Substitutions -----------------------------------------------------
+
+    /** Substitute all types that refer in their symbol attribute to
+     *  one of the symbols in `from` by the corresponding types in `to`.
+     */
+    final def subst(from: List[Symbol], to: List[Type])(using Context): Type =
+      if (from.isEmpty) this
+      else {
+        val from1 = from.tail
+        if (from1.isEmpty) Substituters.subst1(this, from.head, to.head, null)
+        else {
+          val from2 = from1.tail
+          if (from2.isEmpty) Substituters.subst2(this, from.head, to.head, from1.head, to.tail.head, null)
+          else Substituters.subst(this, from, to, null)
+        }
+      }
+
+    /** Substitute all types of the form `TypeParamRef(from, N)` by
+     *  `TypeParamRef(to, N)`.
+     */
+    final def subst(from: BindingType, to: BindingType)(using Context): Type =
+      Substituters.subst(this, from, to, null)
+
+    /** Substitute all occurrences of `This(cls)` by `tp` */
+    final def substThis(cls: ClassSymbol, tp: Type)(using Context): Type =
+      Substituters.substThis(this, cls, tp, null)
+
+    /** As substThis, but only is class is a static owner (i.e. a globally accessible object) */
+    final def substThisUnlessStatic(cls: ClassSymbol, tp: Type)(using Context): Type =
+      if (cls.isStaticOwner) this else Substituters.substThis(this, cls, tp, null)
+
+    /** Substitute all occurrences of `RecThis(binder)` by `tp` */
+    final def substRecThis(binder: RecType, tp: Type)(using Context): Type =
+      Substituters.substRecThis(this, binder, tp, null)
+
+    /** Substitute a bound type by some other type */
+    final def substParam(from: ParamRef, to: Type)(using Context): Type =
+      Substituters.substParam(this, from, to, null)
+
+    /** Substitute bound types by some other types */
+    final def substParams(from: BindingType, to: List[Type])(using Context): Type =
+      Substituters.substParams(this, from, to, null)
+
+    /** Substitute all occurrences of symbols in `from` by references to corresponding symbols in `to`
+     */
+    final def substSym(from: List[Symbol], to: List[Symbol])(using Context): Type =
+      Substituters.substSym(this, from, to, null)
+
+    /** Substitute all occurrences of symbols in `from` by corresponding types in `to`.
+     *  Unlike for `subst`, the `to` types can be type bounds. A TypeBounds target
+     *  will be replaced by range that gets absorbed in an approximating type map.
+     */
+    final def substApprox(from: List[Symbol], to: List[Type])(using Context): Type =
+      new Substituters.SubstApproxMap(from, to).apply(this)
+
+// ----- misc -----------------------------------------------------------
+
+    /** Turn type into a function type.
+     *  @pre this is a method type without parameter dependencies.
+     *  @param dropLast        the number of trailing parameters that should be dropped
+     *                         when forming the function type.
+     *  @param alwaysDependent if true, always create a dependent function type.
+     */
+    def toFunctionType(isJava: Boolean, dropLast: Int = 0, alwaysDependent: Boolean = false)(using Context): Type = this match {
+      case mt: MethodType if !mt.isParamDependent =>
+        val formals1 = if (dropLast == 0) mt.paramInfos else mt.paramInfos dropRight dropLast
+        val isContextual = mt.isContextualMethod && !ctx.erasedTypes
+        val isErased = mt.isErasedMethod && !ctx.erasedTypes
+        val result1 = mt.nonDependentResultApprox match {
+          case res: MethodType => res.toFunctionType(isJava)
+          case res => res
+        }
+        val funType = defn.FunctionOf(
+          formals1 mapConserve (_.translateFromRepeated(toArray = isJava)),
+          result1, isContextual, isErased)
+        if alwaysDependent || mt.isResultDependent then RefinedType(funType, nme.apply, mt)
+        else funType
+    }
+
+    /** The signature of this type. This is by default NotAMethod,
+     *  but is overridden for PolyTypes, MethodTypes, and TermRef types.
+     *  (the reason why we deviate from the "final-method-with-pattern-match-in-base-class"
+     *   pattern is that method signatures use caching, so encapsulation
+     *   is improved using an OO scheme).
+     */
+    def signature(using Context): Signature = Signature.NotAMethod
+
+    /** Drop annotation of given `cls` from this type */
+    def dropAnnot(cls: Symbol)(using Context): Type = stripTypeVar match {
+      case self @ AnnotatedType(pre, annot) =>
+        if (annot.symbol eq cls) pre
+        else self.derivedAnnotatedType(pre.dropAnnot(cls), annot)
+      case _ =>
+        this
+    }
+
+    def dropRepeatedAnnot(using Context): Type = dropAnnot(defn.RepeatedAnnot)
+
+    def annotatedToRepeated(using Context): Type = this match {
+      case tp @ ExprType(tp1) =>
+        tp.derivedExprType(tp1.annotatedToRepeated)
+      case self @ AnnotatedType(tp, annot) if annot matches defn.RetainsByNameAnnot =>
+        self.derivedAnnotatedType(tp.annotatedToRepeated, annot)
+      case AnnotatedType(tp, annot) if annot matches defn.RepeatedAnnot =>
+        val typeSym = tp.typeSymbol.asClass
+        assert(typeSym == defn.SeqClass || typeSym == defn.ArrayClass)
+        tp.translateParameterized(typeSym, defn.RepeatedParamClass)
+      case _ => this
+    }
+
+    /** A type capturing `ref` */
+    def capturing(ref: CaptureRef)(using Context): Type =
+      if captureSet.accountsFor(ref) then this
+      else CapturingType(this, ref.singletonCaptureSet)
+
+    /** A type capturing the capture set `cs`. If this type is already a capturing type
+     *  the two capture sets are combined.
+     */
+    def capturing(cs: CaptureSet)(using Context): Type =
+      if cs.isConst && cs.subCaptures(captureSet, frozen = true).isOK then this
+      else this match
+        case CapturingType(parent, cs1) => parent.capturing(cs1 ++ cs)
+        case _ => CapturingType(this, cs)
+
+    /** The set of distinct symbols referred to by this type, after all aliases are expanded */
+    def coveringSet(using Context): Set[Symbol] =
+      (new CoveringSetAccumulator).apply(Set.empty[Symbol], this)
+
+    /** The number of applications and refinements in this type, after all aliases are expanded */
+    def typeSize(using Context): Int =
+      (new TypeSizeAccumulator).apply(0, this)
+
+    /** Convert to text */
+    def toText(printer: Printer): Text = printer.toText(this)
+
+    /** Utility method to show the underlying type of a TypeProxy chain together
+     *  with the proxy type itself.
+     */
+    def showWithUnderlying(n: Int = 1)(using Context): String = this match {
+      case tp: TypeProxy if n > 0 => s"$show with underlying ${tp.underlying.showWithUnderlying(n - 1)}"
+      case _ => show
+    }
+
+    /** A simplified version of this type which is equivalent wrt =:= to this type.
+     *  This applies a typemap to the type which (as all typemaps) follows type
+     *  variable instances and reduces typerefs over refined types. It also
+     *
+     *   - re-evaluates all occurrences of And/OrType with &/| because
+     *     what was a union or intersection of type variables might be a simpler type
+     *     after the type variables are instantiated.
+     *   - maps poly params in the current constraint set back to their type vars.
+     *   - forces match types to be fully defined and tries to normalize them.
+     *
+     *  NOTE: Simplifying an intersection type might change its erasure (for
+     *  example, the Java erasure of `Object & Serializable` is `Object`,
+     *  but its simplification is `Serializable`). This means that simplification
+     *  should never be used in a `MethodicType`, because that could
+     *  lead to a different `signature`. Since this isn't very useful anyway,
+     *  this method handles this by never simplifying inside a `MethodicType`,
+     *  except for replacing type parameters with associated type variables.
+     */
+    def simplified(using Context): Type = TypeOps.simplify(this, null)
+
+    /** Compare `this == that`, assuming corresponding binders in `bs` are equal.
+     *  The normal `equals` should be equivalent to `equals(that, null`)`.
+     *  We usually override `equals` when we override `iso` except if the
+     *  `equals` comes from a case class, so it already has the right definition anyway.
+     */
+    final def equals(that: Any, bs: BinderPairs): Boolean =
+      (this `eq` that.asInstanceOf[AnyRef]) || this.iso(that, bs)
+
+    /** Is `this` isomorphic to `that`, assuming pairs of matching binders `bs`?
+     *  It is assumed that `this.ne(that)`.
+     */
+    protected def iso(that: Any, bs: BinderPairs): Boolean = this.equals(that)
+
+    /** Equality used for hash-consing; uses `eq` on all recursive invocations,
+     *  except where a BindingType is involved. The latter demand a deep isomorphism check.
+     */
+    def eql(that: Type): Boolean = this.equals(that)
+
+    /** customized hash code of this type.
+     *  NotCached for uncached types. Cached types
+     *  compute hash and use it as the type's hashCode.
+     */
+    def hash: Int
+
+    /** Compute hashcode relative to enclosing binders `bs` */
+    def computeHash(bs: Binders): Int
+
+    /** Is the `hash` of this type the same for all possible sequences of enclosing binders? */
+    def hashIsStable: Boolean = true
+  }
+
+  // end Type
+
+// ----- Type categories ----------------------------------------------
+
+  /** A marker trait for cached types */
+  trait CachedType extends Type
+
+  /** A marker trait for type proxies.
+   *  Each implementation is expected to redefine the `underlying` method.
+   */
+  abstract class TypeProxy extends Type {
+
+    /** The type to which this proxy forwards operations. */
+    def underlying(using Context): Type
+
+    /** The closest supertype of this type. This is the same as `underlying`,
+     *  except that
+     *    - instead of a TyperBounds type it returns its upper bound, and
+     *    - for applied types it returns the upper bound of the constructor re-applied to the arguments.
+     */
+    def superType(using Context): Type = underlying match {
+      case TypeBounds(_, hi) => hi
+      case st => st
+    }
+
+    def superTypeNormalized(using Context): Type = superType.normalized
+
+    /** Same as superType, except for two differences:
+     *   - opaque types are treated as transparent aliases
+     *   - applied type are matchtype-reduced if possible
+     *
+     *  Note: the reason to reduce match type aliases here and not in `superType`
+     *  is that `superType` is context-independent and cached, whereas matchtype
+     *  reduction depends on context and should not be cached (at least not without
+     *  the very specific cache invalidation condition for matchtypes).
+     */
+    def translucentSuperType(using Context): Type = superType
+  }
+
+  // Every type has to inherit one of the following four abstract type classes.,
+  // which determine whether the type is cached, and whether
+  // it is a proxy of some other type. The duplication in their methods
+  // is for efficiency.
+
+  /**  Instances of this class are cached and are not proxies. */
+  abstract class CachedGroundType extends Type with CachedType {
+    private var myHash = HashUnknown
+    final def hash: Int = {
+      if (myHash == HashUnknown) {
+        myHash = computeHash(null)
+        assert(myHash != HashUnknown)
+      }
+      myHash
+    }
+    override final def hashCode: Int =
+      if (hash == NotCached) System.identityHashCode(this) else hash
+  }
+
+  /**  Instances of this class are cached and are proxies. */
+  abstract class CachedProxyType extends TypeProxy with CachedType {
+    protected var myHash: Int = HashUnknown
+    final def hash: Int = {
+      if (myHash == HashUnknown) {
+        myHash = computeHash(null)
+        assert(myHash != HashUnknown)
+      }
+      myHash
+    }
+    override final def hashCode: Int =
+      if (hash == NotCached) System.identityHashCode(this) else hash
+  }
+
+  /**  Instances of this class are uncached and are not proxies. */
+  abstract class UncachedGroundType extends Type {
+    final def hash: Int = NotCached
+    final def computeHash(bs: Binders): Int = NotCached
+    if (monitored) {
+      record(s"uncachable")
+      record(s"uncachable: $getClass")
+    }
+  }
+
+  /**  Instances of this class are uncached and are proxies. */
+  abstract class UncachedProxyType extends TypeProxy {
+    final def hash: Int = NotCached
+    final def computeHash(bs: Binders): Int = NotCached
+    if (monitored) {
+      record(s"uncachable")
+      record(s"uncachable: $getClass")
+    }
+  }
+
+  /** A marker trait for types that apply only to type symbols */
+  trait TypeType extends Type
+
+  /** A marker trait for types that apply only to term symbols or that
+   *  represent higher-kinded types.
+   */
+  trait TermType extends Type
+
+  /** A marker trait for types that can be types of values or prototypes of value types */
+  trait ValueTypeOrProto extends TermType
+
+  /** A marker trait for types that can be types of values or that are higher-kinded  */
+  trait ValueType extends ValueTypeOrProto
+
+  /** A marker trait for types that are guaranteed to contain only a
+   *  single non-null value (they might contain null in addition).
+   */
+  trait SingletonType extends TypeProxy with ValueType {
+    def isOverloaded(using Context): Boolean = false
+  }
+
+  /** A trait for references in CaptureSets. These can be NamedTypes, ThisTypes or ParamRefs */
+  trait CaptureRef extends SingletonType:
+    private var myCaptureSet: CaptureSet | Null = _
+    private var myCaptureSetRunId: Int = NoRunId
+    private var mySingletonCaptureSet: CaptureSet.Const | Null = null
+
+    /** Can the reference be tracked? This is true for all ThisTypes or ParamRefs
+     *  but only for some NamedTypes.
+     */
+    def canBeTracked(using Context): Boolean
+
+    /** Is the reference tracked? This is true if it can be tracked and the capture
+     *  set of the underlying type is not always empty.
+     */
+    final def isTracked(using Context): Boolean = canBeTracked && !captureSetOfInfo.isAlwaysEmpty
+
+    /** Is this reference the root capability `*` ? */
+    def isRootCapability(using Context): Boolean = false
+
+    /** Normalize reference so that it can be compared with `eq` for equality */
+    def normalizedRef(using Context): CaptureRef = this
+
+    /** The capture set consisting of exactly this reference */
+    def singletonCaptureSet(using Context): CaptureSet.Const =
+      if mySingletonCaptureSet == null then
+        mySingletonCaptureSet = CaptureSet(this.normalizedRef)
+      mySingletonCaptureSet.uncheckedNN
+
+    /** The capture set of the type underlying this reference */
+    def captureSetOfInfo(using Context): CaptureSet =
+      if ctx.runId == myCaptureSetRunId then myCaptureSet.nn
+      else if myCaptureSet.asInstanceOf[AnyRef] eq CaptureSet.Pending then CaptureSet.empty
+      else
+        myCaptureSet = CaptureSet.Pending
+        val computed = CaptureSet.ofInfo(this)
+        if ctx.phase != Phases.checkCapturesPhase || underlying.isProvisional then
+          myCaptureSet = null
+        else
+          myCaptureSet = computed
+          myCaptureSetRunId = ctx.runId
+        computed
+
+    def invalidateCaches() =
+      myCaptureSetRunId = NoRunId
+
+    override def captureSet(using Context): CaptureSet =
+      val cs = captureSetOfInfo
+      if canBeTracked && !cs.isAlwaysEmpty then singletonCaptureSet else cs
+  end CaptureRef
+
+  /** A trait for types that bind other types that refer to them.
+   *  Instances are: LambdaType, RecType.
+   */
+  trait BindingType extends Type {
+
+    /** If this type is in `bs`, a hashcode based on its position in `bs`.
+     *  Otherise the standard identity hash.
+     */
+    override def identityHash(bs: Binders): Int = {
+      def recur(n: Int, tp: BindingType, rest: Binders): Int =
+        if (this `eq` tp) finishHash(hashing.mix(hashSeed, n), 1)
+        else if (rest == null) System.identityHashCode(this)
+        else recur(n + 1, rest.tp, rest.next)
+      avoidSpecialHashes(
+        if (bs == null) System.identityHashCode(this)
+        else recur(1, bs.tp, bs.next))
+    }
+
+    def equalBinder(that: BindingType, bs: BinderPairs): Boolean =
+      (this `eq` that) || bs != null && bs.matches(this, that)
+  }
+
+  /** A trait for proto-types, used as expected types in typer */
+  trait ProtoType extends Type {
+    def isMatchedBy(tp: Type, keepConstraint: Boolean = false)(using Context): Boolean
+    def fold[T](x: T, ta: TypeAccumulator[T] @retains(caps.*))(using Context): T
+    def map(tm: TypeMap)(using Context): ProtoType
+
+    /** If this prototype captures a context, the same prototype except that the result
+     *  captures the given context `ctx`.
+     */
+    def withContext(ctx: Context): ProtoType = this
+
+    override def dropIfProto = WildcardType
+  }
+
+  /** Implementations of this trait cache the results of `narrow`. */
+  trait NarrowCached extends Type {
+    private var myNarrow: TermRef | Null = null
+    override def narrow(using Context): TermRef = {
+      if (myNarrow == null) myNarrow = super.narrow
+      myNarrow.nn
+    }
+  }
+
+// --- NamedTypes ------------------------------------------------------------------
+
+  abstract class NamedType extends CachedProxyType, ValueType { self =>
+
+    type ThisType >: this.type <: NamedType
+    type ThisName <: Name
+
+    val prefix: Type
+    def designator: Designator
+    protected def designator_=(d: Designator): Unit
+
+    assert(prefix.isValueType || (prefix eq NoPrefix), s"invalid prefix $prefix")
+
+    private var myName: Name | Null = null
+    private var lastDenotation: Denotation | Null = null
+    private var lastSymbol: Symbol | Null = null
+    private var checkedPeriod: Period = Nowhere
+    private var myStableHash: Byte = 0
+    private var mySignature: Signature = _
+    private var mySignatureRunId: Int = NoRunId
+
+    // Invariants:
+    // (1) checkedPeriod != Nowhere     =>  lastDenotation != null
+    // (2) lastDenotation != null       =>  lastSymbol != null
+    // (3) mySignatureRunId != NoRunId  =>  mySignature != null
+
+    def isType: Boolean = isInstanceOf[TypeRef]
+    def isTerm: Boolean = isInstanceOf[TermRef]
+
+    /** If designator is a name, this name. Otherwise, the original name
+     *  of the designator symbol.
+     */
+    final def name(using Context): ThisName = {
+      if (myName == null) myName = computeName
+      myName.asInstanceOf[ThisName]
+    }
+
+    private def computeName: Name = designator match {
+      case name: Name => name
+      case sym: Symbol => sym.originDenotation.name
+    }
+
+    final override def signature(using Context): Signature =
+      /** The signature computed from the last known denotation with `sigFromDenot`,
+       *  or if there is none, the signature of the symbol. Signatures are always
+       *  computed before erasure, since some symbols change their signature at erasure.
+       */
+      def computeSignature(using Context): Signature =
+        val lastd = lastDenotation
+        if lastd != null then sigFromDenot(lastd)
+        else if ctx.erasedTypes then atPhase(erasurePhase)(computeSignature)
+        else symbol.asSeenFrom(prefix).signature
+
+      if ctx.runId != mySignatureRunId then
+        mySignature = computeSignature
+        if !mySignature.isUnderDefined then mySignatureRunId = ctx.runId
+      mySignature
+    end signature
+
+    /** The signature computed from the current denotation with `sigFromDenot` if it is
+     *  known without forcing.
+     *  Otherwise the signature of the current symbol if it is known without forcing.
+     *  Otherwise NotAMethod. Signatures are always computed before erasure, since
+     *  some symbols change their signature at erasure.
+     */
+    private def currentSignature(using Context): Signature =
+      if ctx.runId == mySignatureRunId then mySignature
+      else
+        val lastd = lastDenotation
+        if lastd != null then sigFromDenot(lastd)
+        else if ctx.erasedTypes then atPhase(erasurePhase)(currentSignature)
+        else
+          val sym = currentSymbol
+          if sym.exists then sym.asSeenFrom(prefix).signature
+          else Signature.NotAMethod
+
+    /** The signature of a pre-erasure version of denotation `lastd`. */
+    private def sigFromDenot(lastd: Denotation)(using Context) =
+      if lastd.validFor.firstPhaseId <= erasurePhase.id then lastd.signature
+      else lastd match
+        case lastd: SingleDenotation => lastd.initial.signature
+        case _ => Signature.OverloadedSignature
+
+    final def symbol(using Context): Symbol =
+      // We can rely on checkedPeriod (unlike in the definition of `denot` below)
+      // because SymDenotation#installAfter never changes the symbol
+      if (checkedPeriod == ctx.period) lastSymbol.nn else computeSymbol
+
+    private def computeSymbol(using Context): Symbol =
+      designator match {
+        case sym: Symbol =>
+          if (sym.isValidInCurrentRun) sym else denot.symbol
+        case name =>
+          (if (denotationIsCurrent) lastDenotation.nn else denot).symbol
+      }
+
+    /** There is a denotation computed which is valid (somewhere in) the
+     *  current run.
+     */
+    def denotationIsCurrent(using Context): Boolean =
+      lastDenotation != null && lastDenotation.uncheckedNN.validFor.runId == ctx.runId
+
+    /** If the reference is symbolic or the denotation is current, its symbol, otherwise NoDenotation.
+     *
+     *  Note: This operation does not force the denotation, and is therefore
+     *  timing dependent. It should only be used if the outcome of the
+     *  essential computation does not depend on the symbol being present or not.
+     *  It's currently used to take an optimized path in substituters and
+     *  type accumulators, as well as to be safe in diagnostic printing.
+     *  Normally, it's better to use `symbol`, not `currentSymbol`.
+     */
+    final def currentSymbol(using Context): Symbol = designator match {
+      case sym: Symbol => sym
+      case _ => if (denotationIsCurrent) lastDenotation.nn.symbol else NoSymbol
+    }
+
+    /** Retrieves currently valid symbol without necessarily updating denotation.
+     *  Assumes that symbols do not change between periods in the same run.
+     *  Used to get the class underlying a ThisType.
+     */
+    private[Types] def stableInRunSymbol(using Context): Symbol =
+      if (checkedPeriod.runId == ctx.runId) lastSymbol.nn
+      else symbol
+
+    def info(using Context): Type = denot.info
+
+    /** The denotation currently denoted by this type */
+    final def denot(using Context): Denotation = {
+      util.Stats.record("NamedType.denot")
+      val now = ctx.period
+      // Even if checkedPeriod == now we still need to recheck lastDenotation.validFor
+      // as it may have been mutated by SymDenotation#installAfter
+      if (checkedPeriod != Nowhere && lastDenotation.nn.validFor.contains(now)) {
+        checkedPeriod = now
+        lastDenotation.nn
+      }
+      else computeDenot
+    }
+
+    private def computeDenot(using Context): Denotation = {
+      util.Stats.record("NamedType.computeDenot")
+
+      def finish(d: Denotation) = {
+        if (d.exists)
+          // Avoid storing NoDenotations in the cache - we will not be able to recover from
+          // them. The situation might arise that a type has NoDenotation in some later
+          // phase but a defined denotation earlier (e.g. a TypeRef to an abstract type
+          // is undefined after erasure.) We need to be able to do time travel back and
+          // forth also in these cases.
+          setDenot(d)
+        d
+      }
+
+      def fromDesignator = designator match {
+        case name: Name =>
+          val sym = lastSymbol
+          val allowPrivate = sym == null || (sym == NoSymbol) || sym.lastKnownDenotation.flagsUNSAFE.is(Private)
+          finish(memberDenot(name, allowPrivate))
+        case sym: Symbol =>
+          val symd = sym.lastKnownDenotation
+          if (symd.validFor.runId != ctx.runId && !stillValid(symd))
+            finish(memberDenot(symd.initial.name, allowPrivate = false))
+          else if (prefix.isArgPrefixOf(symd))
+            finish(argDenot(sym.asType))
+          else if (infoDependsOnPrefix(symd, prefix))
+            finish(memberDenot(symd.initial.name, allowPrivate = symd.is(Private)))
+          else
+            finish(symd.current)
+      }
+
+      lastDenotation match {
+        case lastd0: SingleDenotation =>
+          val lastd = lastd0.skipRemoved
+          if lastd.validFor.runId == ctx.runId && checkedPeriod != Nowhere then
+            finish(lastd.current)
+          else lastd match {
+            case lastd: SymDenotation =>
+              if (stillValid(lastd) && (checkedPeriod != Nowhere)) finish(lastd.current)
+              else finish(memberDenot(lastd.initial.name, allowPrivate = false))
+            case _ =>
+              fromDesignator
+          }
+        case _ => fromDesignator
+      }
+    }
+
+    private def disambiguate(d: Denotation)(using Context): Denotation =
+      disambiguate(d, currentSignature, currentSymbol.targetName)
+
+    private def disambiguate(d: Denotation, sig: Signature | Null, target: Name)(using Context): Denotation =
+      if (sig != null)
+        d.atSignature(sig, target, relaxed = !ctx.erasedTypes) match {
+          case d1: SingleDenotation => d1
+          case d1 =>
+            d1.atSignature(sig, target, relaxed = false) match {
+              case d2: SingleDenotation => d2
+              case d2 => d2.suchThat(currentSymbol.eq).orElse(d2)
+            }
+        }
+      else d
+
+    private def memberDenot(name: Name, allowPrivate: Boolean)(using Context): Denotation = {
+      var d = memberDenot(prefix, name, allowPrivate)
+      if (!d.exists && !allowPrivate && ctx.mode.is(Mode.Interactive))
+        // In the IDE we might change a public symbol to private, and would still expect to find it.
+        d = memberDenot(prefix, name, true)
+      if (!d.exists && ctx.isAfterTyper && lastDenotation.isInstanceOf[SymDenotation])
+        // name has changed; try load in earlier phase and make current
+        d = atPhase(ctx.phaseId - 1)(memberDenot(name, allowPrivate)).current
+      if (d.isOverloaded)
+        d = disambiguate(d)
+      d
+    }
+
+    private def memberDenot(prefix: Type, name: Name, allowPrivate: Boolean)(using Context): Denotation =
+      if (allowPrivate) prefix.member(name) else prefix.nonPrivateMember(name)
+
+    private def argDenot(param: TypeSymbol)(using Context): Denotation = {
+      val cls = param.owner
+      val args = prefix.baseType(cls).argInfos
+      val typeParams = cls.typeParams
+
+      def concretize(arg: Type, tparam: TypeSymbol) = arg match {
+        case arg: TypeBounds => TypeRef(prefix, tparam)
+        case arg => arg
+      }
+      val concretized = args.zipWithConserve(typeParams)(concretize)
+
+      def rebase(arg: Type) = arg.subst(typeParams, concretized)
+
+      val idx = typeParams.indexOf(param)
+
+      if (0 <= idx && idx < args.length) {
+        val argInfo = args(idx) match {
+          case arg: TypeBounds =>
+            val v = param.paramVarianceSign
+            val pbounds = param.paramInfo
+            if (v > 0 && pbounds.loBound.dealiasKeepAnnots.isExactlyNothing) TypeAlias(arg.hiBound & rebase(pbounds.hiBound))
+            else if (v < 0 && pbounds.hiBound.dealiasKeepAnnots.isExactlyAny) TypeAlias(arg.loBound | rebase(pbounds.loBound))
+            else arg recoverable_& rebase(pbounds)
+          case arg => TypeAlias(arg)
+        }
+        param.derivedSingleDenotation(param, argInfo)
+      }
+      else {
+        if (!ctx.reporter.errorsReported)
+          throw new TypeError(
+            i"""bad parameter reference $this at ${ctx.phase}
+               |the parameter is ${param.showLocated} but the prefix $prefix
+               |does not define any corresponding arguments.
+               |idx = $idx, args = $args%, %,
+               |constraint = ${ctx.typerState.constraint}""")
+        NoDenotation
+      }
+    }
+
+    /** Reload denotation by computing the member with the reference's name as seen
+     *  from the reference's prefix.
+     */
+    def recomputeDenot()(using Context): Unit =
+      setDenot(memberDenot(name, allowPrivate = !symbol.exists || symbol.is(Private)))
+
+    private def setDenot(denot: Denotation)(using Context): Unit = {
+      if (Config.checkNoDoubleBindings)
+        if (ctx.settings.YnoDoubleBindings.value)
+          checkSymAssign(denot.symbol)
+
+      lastDenotation = denot
+      lastSymbol = denot.symbol
+      checkedPeriod = if (prefix.isProvisional) Nowhere else ctx.period
+      designator match {
+        case sym: Symbol if designator ne lastSymbol.nn =>
+          designator = lastSymbol.asInstanceOf[Designator{ type ThisName = self.ThisName }]
+        case _ =>
+      }
+      checkDenot()
+    }
+
+    private def checkDenot()(using Context) = {}
+
+    private def checkSymAssign(sym: Symbol)(using Context) = {
+      def selfTypeOf(sym: Symbol) =
+        if (sym.isClass) sym.asClass.givenSelfType else NoType
+      val lastSym = lastSymbol
+      assert(
+        (lastSym == null)
+        ||
+        (lastSym eq sym)
+        ||
+        !denotationIsCurrent
+        ||
+        lastSym.infoOrCompleter.isInstanceOf[ErrorType]
+        ||
+        !sym.exists
+        ||
+        !lastSym.exists
+        ||
+        sym.isPackageObject // package objects can be visited before we get around to index them
+        ||
+        sym.owner != lastSym.owner &&
+          (sym.owner.derivesFrom(lastSym.owner)
+           ||
+           selfTypeOf(sym).derivesFrom(lastSym.owner)
+           ||
+           selfTypeOf(lastSym).derivesFrom(sym.owner)
+          )
+        ||
+        sym == defn.AnyClass.primaryConstructor, {
+          if lastSym == null then
+            s"""data race? overwriting $lastSym with $sym in type $this,
+             |period = ${ctx.phase} at run ${ctx.runId}"""
+          else
+            s"""data race? overwriting $lastSym with $sym in type $this,
+             |last sym id = ${lastSym.id}, new sym id = ${sym.id},
+             |last owner = ${lastSym.owner}, new owner = ${sym.owner},
+             |period = ${ctx.phase} at run ${ctx.runId}""" })
+    }
+
+    /** A reference with the initial symbol in `symd` has an info that
+     *  might depend on the given prefix.
+     */
+    private def infoDependsOnPrefix(symd: SymDenotation, prefix: Type)(using Context): Boolean =
+      symd.maybeOwner.membersNeedAsSeenFrom(prefix) && !symd.is(NonMember)
+      || prefix.isInstanceOf[Types.ThisType] && symd.is(Opaque) // see pos/i11277.scala for a test where this matters
+
+    /** Is this a reference to a class or object member with an info that might depend
+     *  on the prefix?
+     */
+    def isPrefixDependentMemberRef(using Context): Boolean = designator match {
+      case sym: Symbol => infoDependsOnPrefix(sym, prefix)
+      case _ => true
+    }
+
+    /** (1) Reduce a type-ref `W # X` or `W { ... } # U`, where `W` is a wildcard type
+     *  to an (unbounded) wildcard type.
+     *
+     *  (2) Reduce a type-ref `T { X = U; ... } # X`  to   `U`
+     *  provided `U` does not refer with a RecThis to the
+     *  refinement type `T { X = U; ... }`
+     */
+    def reduceProjection(using Context): Type =
+      if (isType) {
+        val reduced = prefix.lookupRefined(name)
+        if (reduced.exists) reduced else this
+      }
+      else this
+
+    /** Guard against cycles that can arise if given `op`
+     *  follows info. The problematic cases are a type alias to itself or
+     *  bounded by itself or a val typed as itself:
+     *
+     *  type T <: T
+     *  val x: x.type
+     *
+     *  These are errors but we have to make sure that operations do
+     *  not loop before the error is detected.
+     */
+    final def controlled[T](op: => T)(using Context): T = try {
+      ctx.base.underlyingRecursions += 1
+      if (ctx.base.underlyingRecursions < Config.LogPendingUnderlyingThreshold)
+        op
+      else if (ctx.pendingUnderlying contains this)
+        throw CyclicReference(symbol)
+      else
+        try {
+          ctx.pendingUnderlying += this
+          op
+        }
+        finally
+          ctx.pendingUnderlying -= this
+    }
+    finally
+      ctx.base.underlyingRecursions -= 1
+
+    /** The argument corresponding to class type parameter `tparam` as seen from
+     *  prefix `pre`. Can produce a TypeBounds type if `widenAbstract` is true,
+     *  or prefix is an & or | type and parameter is non-variant.
+     *  Otherwise, a typebounds argument is dropped and the original type parameter
+     *  reference is returned.
+     */
+    def argForParam(pre: Type, widenAbstract: Boolean = false)(using Context): Type = {
+      val tparam = symbol
+      val cls = tparam.owner
+      val base = pre.baseType(cls)
+      base.stripped match {
+        case AppliedType(tycon, allArgs) =>
+          var tparams = cls.typeParams
+          var args = allArgs
+          var idx = 0
+          while (tparams.nonEmpty && args.nonEmpty) {
+            if (tparams.head.eq(tparam))
+              return args.head match {
+                case _: TypeBounds if !widenAbstract => TypeRef(pre, tparam)
+                case arg => arg.boxedUnlessFun(tycon)
+              }
+            tparams = tparams.tail
+            args = args.tail
+            idx += 1
+          }
+          NoType
+        case base: AndOrType =>
+          var tp1 = argForParam(base.tp1)
+          var tp2 = argForParam(base.tp2)
+          val variance = tparam.paramVarianceSign
+          if (isBounds(tp1) || isBounds(tp2) || variance == 0) {
+            // compute argument as a type bounds instead of a point type
+            tp1 = tp1.bounds
+            tp2 = tp2.bounds
+          }
+          if (base.isAnd == variance >= 0) tp1 & tp2 else tp1 | tp2
+        case _ =>
+          if (pre.termSymbol.is(Package)) argForParam(pre.select(nme.PACKAGE))
+          else if (pre.isExactlyNothing) pre
+          else NoType
+      }
+    }
+
+    /** A selection of the same kind, but with potentially a different prefix.
+     *  The following normalizations are performed for type selections T#A:
+     *
+     *     T#A --> B                if A is bound to an alias `= B` in T
+     *
+     *  If Config.splitProjections is set:
+     *
+     *     (S & T)#A --> S#A        if T does not have a member named A
+     *               --> T#A        if S does not have a member named A
+     *               --> S#A & T#A  otherwise
+     *     (S | T)#A --> S#A | T#A
+     */
+    def derivedSelect(prefix: Type)(using Context): Type =
+      if (prefix eq this.prefix) this
+      else if (prefix.isExactlyNothing) prefix
+      else {
+        if (isType) {
+          val res =
+            if (currentSymbol.isAllOf(ClassTypeParam)) argForParam(prefix)
+            else prefix.lookupRefined(name)
+          if (res.exists) return res
+          if (Config.splitProjections)
+            prefix match {
+              case prefix: AndType =>
+                def isMissing(tp: Type) = tp match {
+                  case tp: TypeRef => !tp.info.exists
+                  case _ => false
+                }
+                val derived1 = derivedSelect(prefix.tp1)
+                val derived2 = derivedSelect(prefix.tp2)
+                return (
+                  if (isMissing(derived1)) derived2
+                  else if (isMissing(derived2)) derived1
+                  else prefix.derivedAndType(derived1, derived2))
+              case prefix: OrType =>
+                val derived1 = derivedSelect(prefix.tp1)
+                val derived2 = derivedSelect(prefix.tp2)
+                return prefix.derivedOrType(derived1, derived2)
+              case _ =>
+            }
+        }
+        if (prefix.isInstanceOf[WildcardType]) WildcardType
+        else withPrefix(prefix)
+      }
+
+    /** A reference like this one, but with the given symbol, if it exists */
+    final def withSym(sym: Symbol)(using Context): ThisType =
+      if ((designator ne sym) && sym.exists) NamedType(prefix, sym).asInstanceOf[ThisType]
+      else this
+
+    /** A reference like this one, but with the given denotation, if it exists.
+     *  Returns a new named type with the denotation's symbol if that symbol exists, and
+     *  one of the following alternatives applies:
+     *   1. The current designator is a symbol and the symbols differ, or
+     *   2. The current designator is a name and the new symbolic named type
+     *      does not have a currently known denotation.
+     *   3. The current designator is a name and the new symbolic named type
+     *      has the same info as the current info
+     *  Otherwise the current denotation is overwritten with the given one.
+     *
+     *  Note: (2) and (3) are a "lock in mechanism" where a reference with a name as
+     *  designator can turn into a symbolic reference.
+     *
+     *  Note: This is a subtle dance to keep the balance between going to symbolic
+     *  references as much as we can (since otherwise we'd risk getting cycles)
+     *  and to still not lose any type info in the denotation (since symbolic
+     *  references often recompute their info directly from the symbol's info).
+     *  A test case is neg/opaque-self-encoding.scala.
+     */
+    final def withDenot(denot: Denotation)(using Context): ThisType =
+      if denot.exists then
+        val adapted = withSym(denot.symbol)
+        val result =
+          if (adapted.eq(this)
+              || designator.isInstanceOf[Symbol]
+              || !adapted.denotationIsCurrent
+              || adapted.info.eq(denot.info))
+            adapted
+          else this
+        val lastDenot = result.lastDenotation
+        denot match
+          case denot: SymDenotation
+          if denot.validFor.firstPhaseId < ctx.phase.id
+            && lastDenot != null
+            && lastDenot.validFor.lastPhaseId > denot.validFor.firstPhaseId
+            && !lastDenot.isInstanceOf[SymDenotation] =>
+            // In this case the new SymDenotation might be valid for all phases, which means
+            // we would not recompute the denotation when travelling to an earlier phase, maybe
+            // in the next run. We fix that problem by creating a UniqueRefDenotation instead.
+            core.println(i"overwrite ${result.toString} / ${result.lastDenotation}, ${result.lastDenotation.getClass} with $denot at ${ctx.phaseId}")
+            result.setDenot(
+              UniqueRefDenotation(
+                denot.symbol, denot.info,
+                Period(ctx.runId, ctx.phaseId, denot.validFor.lastPhaseId),
+                this.prefix))
+          case _ =>
+            result.setDenot(denot)
+        result.asInstanceOf[ThisType]
+      else // don't assign NoDenotation, we might need to recover later. Test case is pos/avoid.scala.
+        this
+
+    /** A reference like this one, but with the given prefix. */
+    final def withPrefix(prefix: Type)(using Context): NamedType = {
+      def reload(): NamedType = {
+        val lastSym = lastSymbol.nn
+        val allowPrivate = !lastSym.exists || lastSym.is(Private)
+        var d = memberDenot(prefix, name, allowPrivate)
+        if (d.isOverloaded && lastSym.exists)
+          d = disambiguate(d,
+                if (lastSym.signature == Signature.NotAMethod) Signature.NotAMethod
+                else lastSym.asSeenFrom(prefix).signature,
+                lastSym.targetName)
+        NamedType(prefix, name, d)
+      }
+      if (prefix eq this.prefix) this
+      else if (lastDenotation == null) NamedType(prefix, designator)
+      else designator match {
+        case sym: Symbol =>
+          if (infoDependsOnPrefix(sym, prefix) && !prefix.isArgPrefixOf(sym)) {
+            val candidate = reload()
+            val falseOverride = sym.isClass && candidate.symbol.exists && candidate.symbol != symbol
+              // A false override happens if we rebind an inner class to another type with the same name
+              // in an outer subclass. This is wrong, since classes do not override. We need to
+              // return a type with the existing class info as seen from the new prefix instead.
+            if (falseOverride) NamedType(prefix, sym.name, denot.asSeenFrom(prefix))
+            else candidate
+          }
+          else NamedType(prefix, sym)
+        case name: Name => reload()
+      }
+    }
+
+    override def equals(that: Any): Boolean = equals(that, null)
+
+    override def iso(that: Any, bs: BinderPairs): Boolean = that match {
+      case that: NamedType =>
+        designator.equals(that.designator) &&
+        prefix.equals(that.prefix, bs)
+      case _ =>
+        false
+    }
+
+    override def computeHash(bs: Binders): Int = doHash(bs, designator, prefix)
+
+    override def hashIsStable: Boolean = {
+      if (myStableHash == 0) myStableHash = if (prefix.hashIsStable) 1 else -1
+      myStableHash > 0
+    }
+
+    override def eql(that: Type): Boolean = this eq that // safe because named types are hash-consed separately
+  }
+
+  /** A reference to an implicit definition. This can be either a TermRef or a
+   *  Implicits.RenamedImplicitRef.
+   */
+  trait ImplicitRef {
+    def implicitName(using Context): TermName
+    def underlyingRef: TermRef
+  }
+
+  /** The singleton type for path prefix#myDesignator.
+   */
+  abstract case class TermRef(override val prefix: Type,
+                              private var myDesignator: Designator)
+    extends NamedType, ImplicitRef, CaptureRef {
+
+    type ThisType = TermRef
+    type ThisName = TermName
+
+    override def designator: Designator = myDesignator
+    override protected def designator_=(d: Designator): Unit = myDesignator = d
+
+    //assert(name.toString != "<local Coder>")
+    override def underlying(using Context): Type = {
+      val d = denot
+      if (d.isOverloaded) NoType else d.info
+    }
+
+    override def isOverloaded(using Context): Boolean = denot.isOverloaded
+
+    def alternatives(using Context): List[TermRef] =
+      denot.alternatives.map(withDenot(_))
+
+    def altsWith(p: Symbol => Boolean)(using Context): List[TermRef] =
+      denot.altsWith(p).map(withDenot(_))
+
+    def implicitName(using Context): TermName = name
+    def underlyingRef: TermRef = this
+
+    /** A term reference can be tracked if it is a local term ref to a value
+     *  or a method term parameter. References to term parameters of classes
+     *  cannot be tracked individually.
+     *  They are subsumed in the capture sets of the enclosing class.
+     *  TODO: ^^^ What about call-by-name?
+     */
+    def canBeTracked(using Context) =
+      ((prefix eq NoPrefix)
+      || symbol.is(ParamAccessor) && (prefix eq symbol.owner.thisType)
+      || isRootCapability
+      ) && !symbol.isOneOf(UnstableValueFlags)
+
+    override def isRootCapability(using Context): Boolean =
+      name == nme.CAPTURE_ROOT && symbol == defn.captureRoot
+
+    override def normalizedRef(using Context): CaptureRef =
+      if canBeTracked then symbol.termRef else this
+  }
+
+  abstract case class TypeRef(override val prefix: Type,
+                              private var myDesignator: Designator)
+    extends NamedType {
+
+    type ThisType = TypeRef
+    type ThisName = TypeName
+
+    private var myCanDropAliasPeriod: Period = Nowhere
+    private var myCanDropAlias: Boolean = _
+
+    /** Given an alias type `type A = B` where a recursive comparison with `B` yields
+     *  `false`, can we conclude that the comparison is definitely false?
+     *  This could not be the case if `A` overrides some abstract type. Example:
+     *
+     *    class C { type A }
+     *    class D { type A = Int }
+     *    val c: C
+     *    val d: D & c.type
+     *    c.A <:< d.A   ?
+     *
+     *  The test should return true, by performing the logic in the bottom half of
+     *  firstTry (where we check the names of types). But just following the alias
+     *  from d.A to Int reduces the problem to `c.A <:< Int`, which returns `false`.
+     *  So we can't drop the alias here, we need to do the backtracking to the name-
+     *  based tests.
+     */
+    def canDropAlias(using Context) =
+      if myCanDropAliasPeriod != ctx.period then
+        myCanDropAlias =
+          !symbol.canMatchInheritedSymbols
+          || !prefix.baseClasses.exists(_.info.decls.lookup(name).is(Deferred))
+        myCanDropAliasPeriod = ctx.period
+      myCanDropAlias
+
+    override def designator: Designator = myDesignator
+    override protected def designator_=(d: Designator): Unit = myDesignator = d
+
+    override def underlying(using Context): Type = info
+
+    override def translucentSuperType(using Context) = info match {
+      case TypeAlias(aliased) => aliased
+      case TypeBounds(_, hi) =>
+        if (symbol.isOpaqueAlias)
+          symbol.opaqueAlias.asSeenFrom(prefix, symbol.owner).orElse(hi) // orElse can happen for malformed input
+        else hi
+      case _ => underlying
+    }
+
+    /** Hook that can be called from creation methods in TermRef and TypeRef */
+    def validated(using Context): this.type =
+      this
+  }
+
+  final class CachedTermRef(prefix: Type, designator: Designator, hc: Int) extends TermRef(prefix, designator) {
+    assert((prefix ne NoPrefix) || designator.isInstanceOf[Symbol])
+    myHash = hc
+  }
+
+  final class CachedTypeRef(prefix: Type, designator: Designator, hc: Int) extends TypeRef(prefix, designator) {
+    assert((prefix ne NoPrefix) || designator.isInstanceOf[Symbol])
+    myHash = hc
+  }
+
+  /** Assert current phase does not have erasure semantics */
+  private def assertUnerased()(using Context) =
+    if (Config.checkUnerased) assert(!ctx.phase.erasedTypes)
+
+  /** The designator to be used for a named type creation with given prefix, name, and denotation.
+   *  This is the denotation's symbol, if it exists and the prefix is not the this type
+   *  of the class owning the symbol. The reason for the latter qualification is that
+   *  when re-computing the denotation of a `this.<symbol>` reference we read the
+   *  type directly off the symbol. But the given denotation might contain a more precise
+   *  type than what can be computed from the symbol's info. We have to create in this case
+   *  a reference with a name as designator so that the denotation will be correctly updated in
+   *  the future. See also NamedType#withDenot. Test case is neg/opaque-self-encoding.scala.
+   */
+  private def designatorFor(prefix: Type, name: Name, denot: Denotation)(using Context): Designator = {
+    def ownerIsPrefix(owner: Symbol) = prefix match
+      case prefix: ThisType => prefix.sameThis(owner.thisType)
+      case _ => false
+    val sym = denot.symbol
+    if (sym.exists && (prefix.eq(NoPrefix) || !ownerIsPrefix(sym.owner)))
+      sym
+    else
+      name
+  }
+
+  object NamedType {
+    def isType(desig: Designator)(using Context): Boolean = desig match {
+      case sym: Symbol => sym.isType
+      case name: Name => name.isTypeName
+    }
+    def apply(prefix: Type, designator: Designator)(using Context): NamedType =
+      if (isType(designator)) TypeRef.apply(prefix, designator)
+      else TermRef.apply(prefix, designator)
+    def apply(prefix: Type, designator: Name, denot: Denotation)(using Context): NamedType =
+      if (designator.isTermName) TermRef.apply(prefix, designator.asTermName, denot)
+      else TypeRef.apply(prefix, designator.asTypeName, denot)
+  }
+
+  object TermRef {
+
+    /** Create a term ref with given designator */
+    def apply(prefix: Type, desig: Designator)(using Context): TermRef =
+      ctx.uniqueNamedTypes.enterIfNew(prefix, desig, isTerm = true).asInstanceOf[TermRef]
+
+    /** Create a term ref with given initial denotation. The name of the reference is taken
+     *  from the denotation's symbol if the latter exists, or else it is the given name.
+     */
+    def apply(prefix: Type, name: TermName, denot: Denotation)(using Context): TermRef =
+      apply(prefix, designatorFor(prefix, name, denot)).withDenot(denot)
+  }
+
+  object TypeRef {
+
+    /** Create a type ref with given prefix and name */
+    def apply(prefix: Type, desig: Designator)(using Context): TypeRef =
+      ctx.uniqueNamedTypes.enterIfNew(prefix, desig, isTerm = false).asInstanceOf[TypeRef]
+
+    /** Create a type ref with given initial denotation. The name of the reference is taken
+     *  from the denotation's symbol if the latter exists, or else it is the given name.
+     */
+    def apply(prefix: Type, name: TypeName, denot: Denotation)(using Context): TypeRef =
+      apply(prefix, designatorFor(prefix, name, denot)).withDenot(denot)
+  }
+
+  // --- Other SingletonTypes: ThisType/SuperType/ConstantType ---------------------------
+
+  /** The type cls.this
+   *  @param tref    A type ref which indicates the class `cls`.
+   *  Note: we do not pass a class symbol directly, because symbols
+   *  do not survive runs whereas typerefs do.
+   */
+  abstract case class ThisType(tref: TypeRef) extends CachedProxyType, CaptureRef {
+    def cls(using Context): ClassSymbol = tref.stableInRunSymbol match {
+      case cls: ClassSymbol => cls
+      case _ if ctx.mode.is(Mode.Interactive) => defn.AnyClass // was observed to happen in IDE mode
+    }
+
+    override def underlying(using Context): Type =
+      if (ctx.erasedTypes) tref
+      else cls.info match {
+        case cinfo: ClassInfo => cinfo.selfType
+        case _: ErrorType | NoType if ctx.mode.is(Mode.Interactive) => cls.info
+          // can happen in IDE if `cls` is stale
+      }
+
+    def canBeTracked(using Context) = true
+
+    override def computeHash(bs: Binders): Int = doHash(bs, tref)
+
+    override def eql(that: Type): Boolean = that match {
+      case that: ThisType => tref.eq(that.tref)
+      case _ => false
+    }
+
+    /** Check that the rhs is a ThisType that refers to the same class.
+     */
+    def sameThis(that: Type)(using Context): Boolean = (that eq this) || that.match
+      case that: ThisType => this.cls eq that.cls
+      case _ => false
+  }
+
+  final class CachedThisType(tref: TypeRef) extends ThisType(tref)
+
+  object ThisType {
+    /** Normally one should use ClassSymbol#thisType instead */
+    def raw(tref: TypeRef)(using Context): CachedThisType =
+      unique(new CachedThisType(tref))
+  }
+
+  /** The type of a super reference cls.super where
+   *  `thistpe` is cls.this and `supertpe` is the type of the value referenced
+   *  by `super`.
+   */
+  abstract case class SuperType(thistpe: Type, supertpe: Type) extends CachedProxyType with SingletonType {
+    override def underlying(using Context): Type = supertpe
+    override def superType(using Context): Type =
+      thistpe.baseType(supertpe.typeSymbol)
+    def derivedSuperType(thistpe: Type, supertpe: Type)(using Context): Type =
+      if ((thistpe eq this.thistpe) && (supertpe eq this.supertpe)) this
+      else SuperType(thistpe, supertpe)
+
+    override def computeHash(bs: Binders): Int = doHash(bs, thistpe, supertpe)
+
+    override def eql(that: Type): Boolean = that match {
+      case that: SuperType => thistpe.eq(that.thistpe) && supertpe.eq(that.supertpe)
+      case _ => false
+    }
+  }
+
+  final class CachedSuperType(thistpe: Type, supertpe: Type) extends SuperType(thistpe, supertpe)
+
+  object SuperType {
+    def apply(thistpe: Type, supertpe: Type)(using Context): SuperType = {
+      assert(thistpe != NoPrefix)
+      unique(new CachedSuperType(thistpe, supertpe))
+    }
+  }
+
+  /** A constant type with single `value`. */
+  abstract case class ConstantType(value: Constant) extends CachedProxyType with SingletonType {
+    override def underlying(using Context): Type = value.tpe
+
+    override def computeHash(bs: Binders): Int = doHash(value)
+  }
+
+  final class CachedConstantType(value: Constant) extends ConstantType(value)
+
+  object ConstantType {
+    def apply(value: Constant)(using Context): ConstantType = {
+      assertUnerased()
+      unique(new CachedConstantType(value))
+    }
+  }
+
+  // `refFn` can be null only if `computed` is true.
+  case class LazyRef(private var refFn: (Context -> (Type | Null)) | Null) extends UncachedProxyType with ValueType {
+    private var myRef: Type | Null = null
+    private var computed = false
+
+    override def tryNormalize(using Context): Type = ref.tryNormalize
+
+    def ref(using Context): Type =
+      if computed then
+        if myRef == null then
+          // if errors were reported previously handle this by throwing a CyclicReference
+          // instead of crashing immediately. A test case is neg/i6057.scala.
+          assert(ctx.mode.is(Mode.CheckCyclic)
+              || ctx.mode.is(Mode.Printing)
+              || ctx.reporter.errorsReported)
+          throw CyclicReference(NoDenotation)
+      else
+        computed = true
+        val result = refFn.nn(ctx)
+        refFn = null
+        if result != null then myRef = result
+        else assert(myRef != null)  // must have been `update`d
+      myRef.nn
+
+    /** Update the value of the lazyref, discarding the compute function `refFn`
+     *  Can be called only as long as the ref is still undefined.
+     */
+    def update(tp: Type)(using Context) =
+      assert(myRef == null || ctx.reporter.errorsReported)
+      myRef = tp
+      computed = true
+      refFn = null
+
+    def evaluating: Boolean = computed && myRef == null
+    def completed: Boolean = myRef != null
+    override def underlying(using Context): Type = ref
+    override def toString: String = s"LazyRef(${if (computed) myRef else "..."})"
+    override def equals(other: Any): Boolean = this.eq(other.asInstanceOf[AnyRef])
+    override def hashCode: Int = System.identityHashCode(this)
+  }
+  object LazyRef:
+    def of(refFn: Context ?-> (Type | Null)): LazyRef = LazyRef(refFn(using _))
+
+  // --- Refined Type and RecType ------------------------------------------------
+
+  abstract class RefinedOrRecType extends CachedProxyType with ValueType {
+    def parent: Type
+  }
+
+  /** A refined type parent { refinement }
+   *  @param parent      The type being refined
+   *  @param refinedName The name of the refinement declaration
+   *  @param refinedInfo The info of the refinement declaration
+   */
+  abstract case class RefinedType(parent: Type, refinedName: Name, refinedInfo: Type) extends RefinedOrRecType {
+
+    if (refinedName.isTermName) assert(refinedInfo.isInstanceOf[TermType])
+    else assert(refinedInfo.isInstanceOf[TypeType], this)
+    assert(!refinedName.is(NameKinds.ExpandedName), this)
+
+    override def underlying(using Context): Type = parent
+
+    private def badInst =
+      throw new AssertionError(s"bad instantiation: $this")
+
+    def checkInst(using Context): this.type = this // debug hook
+
+    def derivedRefinedType(parent: Type, refinedName: Name, refinedInfo: Type)(using Context): Type =
+      if ((parent eq this.parent) && (refinedName eq this.refinedName) && (refinedInfo eq this.refinedInfo)) this
+      else RefinedType(parent, refinedName, refinedInfo)
+
+    /** Add this refinement to `parent`, provided `refinedName` is a member of `parent`. */
+    def wrapIfMember(parent: Type)(using Context): Type =
+      if (parent.member(refinedName).exists) derivedRefinedType(parent, refinedName, refinedInfo)
+      else parent
+
+    override def computeHash(bs: Binders): Int = doHash(bs, refinedName, refinedInfo, parent)
+    override def hashIsStable: Boolean = refinedInfo.hashIsStable && parent.hashIsStable
+
+    override def eql(that: Type): Boolean = that match {
+      case that: RefinedType =>
+        refinedName.eq(that.refinedName) &&
+        refinedInfo.eq(that.refinedInfo) &&
+        parent.eq(that.parent)
+      case _ => false
+    }
+
+    // equals comes from case class; no matching override is needed
+
+    override def iso(that: Any, bs: BinderPairs): Boolean = that match {
+      case that: RefinedType =>
+        refinedName.eq(that.refinedName) &&
+        refinedInfo.equals(that.refinedInfo, bs) &&
+        parent.equals(that.parent, bs)
+      case _ => false
+    }
+  }
+
+  class CachedRefinedType(parent: Type, refinedName: Name, refinedInfo: Type)
+  extends RefinedType(parent, refinedName, refinedInfo)
+
+  object RefinedType {
+    @tailrec def make(parent: Type, names: List[Name], infos: List[Type])(using Context): Type =
+      if (names.isEmpty) parent
+      else make(RefinedType(parent, names.head, infos.head), names.tail, infos.tail)
+
+    def apply(parent: Type, name: Name, info: Type)(using Context): RefinedType = {
+      assert(!ctx.erasedTypes)
+      unique(new CachedRefinedType(parent, name, info)).checkInst
+    }
+  }
+
+  /** A recursive type. Instances should be constructed via the companion object.
+   *
+   *  @param parentExp A function that, given a recursive type R, produces a type
+   *                   that can refer to R via a `RecThis(R)` node. This is used to
+   *                   "tie the knot".
+   *
+   *  For example, in
+   *    class C { type T1; type T2 }
+   *    type C2 = C { type T1; type T2 = T1  }
+   *
+   *  The type of `C2` is a recursive type `{(x) => C{T1; T2 = x.T1}}`, written as
+   *
+   *    RecType(
+   *      RefinedType(
+   *        RefinedType(
+   *         TypeRef(...,class C),
+   *         T1,
+   *         TypeBounds(...)),
+   *        T2,
+   *        TypeBounds(
+   *          TypeRef(RecThis(...),T1),
+   *          TypeRef(RecThis(...),T1))))
+   *
+   *  Where `RecThis(...)` points back to the enclosing `RecType`.
+   */
+  class RecType(@constructorOnly parentExp: RecType => Type) extends RefinedOrRecType with BindingType {
+
+    // See discussion in findMember#goRec why these vars are needed
+    private[Types] var opened: Boolean = false
+    private[Types] var openedTwice: Boolean = false
+
+    val parent: Type = parentExp(this: @unchecked)
+
+    private var myRecThis: RecThis | Null = null
+
+    def recThis: RecThis = {
+      if (myRecThis == null) myRecThis = new RecThisImpl(this)
+      myRecThis.nn
+    }
+
+    override def underlying(using Context): Type = parent
+
+    def derivedRecType(parent: Type)(using Context): RecType =
+      if (parent eq this.parent) this
+      else RecType(rt => parent.substRecThis(this, rt.recThis))
+
+    def rebind(parent: Type)(using Context): Type =
+      if (parent eq this.parent) this
+      else RecType.closeOver(rt => parent.substRecThis(this, rt.recThis))
+
+    def isReferredToBy(tp: Type)(using Context): Boolean = {
+      val refacc = new TypeAccumulator[Boolean] {
+        override def apply(x: Boolean, tp: Type) = x || {
+          tp match {
+            case tp: TypeRef => apply(x, tp.prefix)
+            case tp: RecThis => RecType.this eq tp.binder
+            case tp: LazyRef => this(x, tp.ref)
+            case _ => foldOver(x, tp)
+          }
+        }
+      }
+      refacc.apply(false, tp)
+    }
+
+    override def computeHash(bs: Binders): Int = doHash(new SomeBinders(this, bs), parent)
+
+    override def hashIsStable: Boolean = false
+      // this is a conservative observation. By construction RecTypes contain at least
+      // one RecThis occurrence. Since `stableHash` does not keep track of enclosing
+      // bound types, it will return "unstable" for this occurrence and this would propagate.
+
+    // No definition of `eql` --> fall back on equals, which calls iso
+
+    override def equals(that: Any): Boolean = equals(that, null)
+
+    override def iso(that: Any, bs: BinderPairs): Boolean = that match {
+      case that: RecType =>
+        parent.equals(that.parent, new SomeBinderPairs(this, that, bs))
+      case _ => false
+    }
+
+    override def toString: String = s"RecType($parent | $hashCode)"
+
+    private def checkInst(using Context): this.type = this // debug hook
+  }
+
+  object RecType {
+
+    /** Create a RecType, normalizing its contents. This means:
+     *
+     *   1. Nested Rec types on the type's spine are merged with the outer one.
+     *   2. Any refinement of the form `type T = z.T` on the spine of the type
+     *      where `z` refers to the created rec-type is replaced by
+     *      `type T`. This avoids infinite recursions later when we
+     *      try to follow these references.
+     *   TODO: Figure out how to guarantee absence of cycles
+     *         of length > 1
+     */
+    def apply(parentExp: RecType => Type)(using Context): RecType = {
+      val rt = new RecType(parentExp)
+      def normalize(tp: Type): Type = tp.stripTypeVar match {
+        case tp: RecType =>
+          normalize(tp.parent.substRecThis(tp, rt.recThis))
+        case tp @ RefinedType(parent, rname, rinfo) =>
+          val rinfo1 = rinfo match {
+            case TypeAlias(ref @ TypeRef(RecThis(`rt`), _)) if ref.name == rname => TypeBounds.empty
+            case _ => rinfo
+          }
+          tp.derivedRefinedType(normalize(parent), rname, rinfo1)
+        case tp =>
+          tp
+      }
+      unique(rt.derivedRecType(normalize(rt.parent))).checkInst
+    }
+
+    /** Create a `RecType`, but only if the type generated by `parentExp` is indeed recursive. */
+    def closeOver(parentExp: RecType => Type)(using Context): Type = {
+      val rt = this(parentExp)
+      if (rt.isReferredToBy(rt.parent)) rt else rt.parent
+    }
+  }
+
+  // --- AndType/OrType ---------------------------------------------------------------
+
+  abstract class AndOrType extends CachedGroundType with ValueType {
+    def isAnd: Boolean
+    def tp1: Type
+    def tp2: Type
+
+    def derivedAndOrType(tp1: Type, tp2: Type)(using Context) =
+      if ((tp1 eq this.tp1) && (tp2 eq this.tp2)) this
+      else this match
+        case tp: OrType => OrType.make(tp1, tp2, tp.isSoft)
+        case tp: AndType => AndType.make(tp1, tp2, checkValid = true)
+  }
+
+  abstract case class AndType(tp1: Type, tp2: Type) extends AndOrType {
+    def isAnd: Boolean = true
+    private var myBaseClassesPeriod: Period = Nowhere
+    private var myBaseClasses: List[ClassSymbol] = _
+    /** Base classes of are the merge of the operand base classes. */
+    override final def baseClasses(using Context): List[ClassSymbol] = {
+      if (myBaseClassesPeriod != ctx.period) {
+        val bcs1 = tp1.baseClasses
+        val bcs1set = BaseClassSet(bcs1)
+        def recur(bcs2: List[ClassSymbol]): List[ClassSymbol] = bcs2 match {
+          case bc2 :: bcs2rest =>
+            if (bcs1set contains bc2)
+              if (bc2.is(Trait)) recur(bcs2rest)
+              else bcs1 // common class, therefore rest is the same in both sequences
+            else bc2 :: recur(bcs2rest)
+          case nil => bcs1
+        }
+        myBaseClasses = recur(tp2.baseClasses)
+        myBaseClassesPeriod = ctx.period
+      }
+      myBaseClasses
+    }
+
+    private var myFactorCount = 0
+    override def andFactorCount =
+      if myFactorCount == 0 then
+      	myFactorCount = tp1.andFactorCount + tp2.andFactorCount
+      myFactorCount
+
+    def derivedAndType(tp1: Type, tp2: Type)(using Context): Type =
+      if ((tp1 eq this.tp1) && (tp2 eq this.tp2)) this
+      else AndType.make(tp1, tp2, checkValid = true)
+
+    def derived_& (tp1: Type, tp2: Type)(using Context): Type =
+      if ((tp1 eq this.tp1) && (tp2 eq this.tp2)) this
+      else tp1 & tp2
+
+    override def computeHash(bs: Binders): Int = doHash(bs, tp1, tp2)
+
+    override def eql(that: Type): Boolean = that match {
+      case that: AndType => tp1.eq(that.tp1) && tp2.eq(that.tp2)
+      case _ => false
+    }
+  }
+
+  final class CachedAndType(tp1: Type, tp2: Type) extends AndType(tp1, tp2)
+
+  object AndType {
+    def apply(tp1: Type, tp2: Type)(using Context): AndType = {
+      assert(tp1.isValueTypeOrWildcard &&
+             tp2.isValueTypeOrWildcard, i"$tp1 & $tp2 / " + s"$tp1 & $tp2")
+      unchecked(tp1, tp2)
+    }
+
+    def balanced(tp1: Type, tp2: Type)(using Context): AndType =
+      tp1 match
+        case AndType(tp11, tp12) if tp1.andFactorCount > tp2.andFactorCount * 2 =>
+          if tp11.andFactorCount < tp12.andFactorCount then
+            return apply(tp12, balanced(tp11, tp2))
+          else
+            return apply(tp11, balanced(tp12, tp2))
+        case _ =>
+      tp2 match
+        case AndType(tp21, tp22) if tp2.andFactorCount > tp1.andFactorCount * 2 =>
+          if tp22.andFactorCount < tp21.andFactorCount then
+            return apply(balanced(tp1, tp22), tp21)
+          else
+            return apply(balanced(tp1, tp21), tp22)
+        case _ =>
+      apply(tp1, tp2)
+
+    def unchecked(tp1: Type, tp2: Type)(using Context): AndType = {
+      assertUnerased()
+      unique(new CachedAndType(tp1, tp2))
+    }
+
+    /** Make an AndType using `op` unless clearly unnecessary (i.e. without
+     *  going through `&`).
+     */
+    def make(tp1: Type, tp2: Type, checkValid: Boolean = false)(using Context): Type =
+      if ((tp1 eq tp2) || (tp2 eq defn.AnyType))
+        tp1
+      else if (tp1 eq defn.AnyType)
+        tp2
+      else
+        if (checkValid) apply(tp1, tp2) else unchecked(tp1, tp2)
+
+    /** Like `make`, but also supports higher-kinded types as argument */
+    def makeHk(tp1: Type, tp2: Type)(using Context): Type =
+      TypeComparer.liftIfHK(tp1, tp2, AndType.make(_, _, checkValid = false), makeHk, _ | _)
+  }
+
+  abstract case class OrType(tp1: Type, tp2: Type) extends AndOrType {
+    def isAnd: Boolean = false
+    def isSoft: Boolean
+    private var myBaseClassesPeriod: Period = Nowhere
+    private var myBaseClasses: List[ClassSymbol] = _
+    /** Base classes of are the intersection of the operand base classes. */
+    override final def baseClasses(using Context): List[ClassSymbol] = {
+      if (myBaseClassesPeriod != ctx.period) {
+        val bcs1 = tp1.baseClasses
+        val bcs1set = BaseClassSet(bcs1)
+        def recur(bcs2: List[ClassSymbol]): List[ClassSymbol] = bcs2 match {
+          case bc2 :: bcs2rest =>
+            if (bcs1set contains bc2)
+              if (bc2.is(Trait)) bc2 :: recur(bcs2rest)
+              else bcs2
+            else recur(bcs2rest)
+          case nil =>
+            bcs2
+        }
+        myBaseClasses = recur(tp2.baseClasses)
+        myBaseClassesPeriod = ctx.period
+      }
+      myBaseClasses
+    }
+
+    private var myFactorCount = 0
+    override def orFactorCount(soft: Boolean) =
+      if this.isSoft == soft then
+        if myFactorCount == 0 then
+          myFactorCount = tp1.orFactorCount(soft) + tp2.orFactorCount(soft)
+        myFactorCount
+      else 1
+
+    assert(tp1.isValueTypeOrWildcard &&
+           tp2.isValueTypeOrWildcard, s"$tp1 $tp2")
+
+    private var myJoin: Type = _
+    private var myJoinPeriod: Period = Nowhere
+
+    /** Replace or type by the closest non-or type above it */
+    def join(using Context): Type = {
+      if (myJoinPeriod != ctx.period) {
+        myJoin = TypeOps.orDominator(this)
+        core.println(i"join of $this == $myJoin")
+        assert(myJoin != this)
+        myJoinPeriod = ctx.period
+      }
+      myJoin
+    }
+
+    private var myUnion: Type = _
+    private var myUnionPeriod: Period = Nowhere
+
+    override def widenUnionWithoutNull(using Context): Type =
+      if myUnionPeriod != ctx.period then
+        myUnion =
+          if isSoft then
+            TypeComparer.lub(tp1.widenUnionWithoutNull, tp2.widenUnionWithoutNull, canConstrain = true, isSoft = isSoft) match
+              case union: OrType => union.join
+              case res => res
+          else derivedOrType(tp1.widenUnionWithoutNull, tp2.widenUnionWithoutNull, soft = isSoft)
+        if !isProvisional then myUnionPeriod = ctx.period
+      myUnion
+
+    private var atomsRunId: RunId = NoRunId
+    private var myAtoms: Atoms = _
+    private var myWidened: Type = _
+
+    private def ensureAtomsComputed()(using Context): Unit =
+      if atomsRunId != ctx.runId then
+        myAtoms =
+          if tp1.hasClassSymbol(defn.NothingClass) then tp2.atoms
+          else if tp2.hasClassSymbol(defn.NothingClass) then tp1.atoms
+          else tp1.atoms | tp2.atoms
+        val tp1w = tp1.widenSingletons
+        val tp2w = tp2.widenSingletons
+        myWidened = if ((tp1 eq tp1w) && (tp2 eq tp2w)) this else TypeComparer.lub(tp1w, tp2w, isSoft = isSoft)
+        atomsRunId = ctx.runId
+
+    override def atoms(using Context): Atoms =
+      ensureAtomsComputed()
+      myAtoms
+
+    override def widenSingletons(using Context): Type = {
+      ensureAtomsComputed()
+      myWidened
+    }
+
+    def derivedOrType(tp1: Type, tp2: Type, soft: Boolean = isSoft)(using Context): Type =
+      if ((tp1 eq this.tp1) && (tp2 eq this.tp2) && soft == isSoft) this
+      else OrType.make(tp1, tp2, soft)
+
+    override def computeHash(bs: Binders): Int =
+      doHash(bs, if isSoft then 0 else 1, tp1, tp2)
+
+    override def eql(that: Type): Boolean = that match {
+      case that: OrType => tp1.eq(that.tp1) && tp2.eq(that.tp2) && isSoft == that.isSoft
+      case _ => false
+    }
+  }
+
+  final class CachedOrType(tp1: Type, tp2: Type, override val isSoft: Boolean) extends OrType(tp1, tp2)
+
+  object OrType {
+
+    def apply(tp1: Type, tp2: Type, soft: Boolean)(using Context): OrType = {
+      assertUnerased()
+      unique(new CachedOrType(tp1, tp2, soft))
+    }
+
+    def balanced(tp1: Type, tp2: Type, soft: Boolean)(using Context): OrType =
+      tp1 match
+        case OrType(tp11, tp12) if tp1.orFactorCount(soft) > tp2.orFactorCount(soft) * 2 =>
+          if tp11.orFactorCount(soft) < tp12.orFactorCount(soft) then
+            return apply(tp12, balanced(tp11, tp2, soft), soft)
+          else
+            return apply(tp11, balanced(tp12, tp2, soft), soft)
+        case _ =>
+      tp2 match
+        case OrType(tp21, tp22) if tp2.orFactorCount(soft) > tp1.orFactorCount(soft) * 2 =>
+          if tp22.orFactorCount(soft) < tp21.orFactorCount(soft) then
+            return apply(balanced(tp1, tp22, soft), tp21, soft)
+          else
+            return apply(balanced(tp1, tp21, soft), tp22, soft)
+        case _ =>
+      apply(tp1, tp2, soft)
+
+    def make(tp1: Type, tp2: Type, soft: Boolean)(using Context): Type =
+      if (tp1 eq tp2) tp1
+      else apply(tp1, tp2, soft)
+
+    /** Like `make`, but also supports higher-kinded types as argument */
+    def makeHk(tp1: Type, tp2: Type)(using Context): Type =
+      TypeComparer.liftIfHK(tp1, tp2, OrType(_, _, soft = true), makeHk, _ & _)
+  }
+
+  /** An extractor object to pattern match against a nullable union.
+   *  e.g.
+   *
+   *  (tp: Type) match
+   *    case OrNull(tp1) => // tp had the form `tp1 | Null`
+   *    case _ => // tp was not a nullable union
+   */
+  object OrNull {
+    def apply(tp: Type)(using Context) =
+      if tp.isNullType then tp else OrType(tp, defn.NullType, soft = false)
+    def unapply(tp: Type)(using Context): Option[Type] =
+      val tp1 = tp.stripNull
+      if tp1 ne tp then Some(tp1) else None
+  }
+
+  // ----- ExprType and LambdaTypes -----------------------------------
+
+  // Note: method types are cached whereas poly types are not. The reason
+  // is that most poly types are cyclic via poly params,
+  // and therefore two different poly types would never be equal.
+
+  trait MethodicType extends TermType
+
+  /** A by-name parameter type of the form `=> T`, or the type of a method with no parameter list. */
+  abstract case class ExprType(resType: Type)
+  extends CachedProxyType with MethodicType {
+    override def resultType(using Context): Type = resType
+    override def underlying(using Context): Type = resType
+
+    override def signature(using Context): Signature = Signature.NotAMethod
+
+    def derivedExprType(resType: Type)(using Context): ExprType =
+      if (resType eq this.resType) this else ExprType(resType)
+
+    override def computeHash(bs: Binders): Int = doHash(bs, resType)
+    override def hashIsStable: Boolean = resType.hashIsStable
+
+    override def eql(that: Type): Boolean = that match {
+      case that: ExprType => resType.eq(that.resType)
+      case _ => false
+    }
+
+    // equals comes from case class; no matching override is needed
+
+    override def iso(that: Any, bs: BinderPairs): Boolean = that match {
+      case that: ExprType => resType.equals(that.resType, bs)
+      case _ => false
+    }
+  }
+
+  final class CachedExprType(resultType: Type) extends ExprType(resultType)
+
+  object ExprType {
+    def apply(resultType: Type)(using Context): ExprType = {
+      assertUnerased()
+      unique(new CachedExprType(resultType))
+    }
+  }
+
+  /** The lambda type square:
+   *
+   *    LambdaType   |   TermLambda      |   TypeLambda
+   *    -------------+-------------------+------------------
+   *    HKLambda     |   HKTermLambda    |   HKTypeLambda
+   *    MethodOrPoly |   MethodType	     |   PolyType
+   */
+  trait LambdaType extends BindingType with TermType { self =>
+    type ThisName <: Name
+    type PInfo <: Type
+    type This <: LambdaType{type PInfo = self.PInfo}
+    type ParamRefType <: ParamRef
+
+    def paramNames: List[ThisName]
+    def paramInfos: List[PInfo]
+    def resType: Type
+    protected def newParamRef(n: Int): ParamRefType
+
+    override def resultType(using Context): Type = resType
+
+    def isResultDependent(using Context): Boolean
+    def isParamDependent(using Context): Boolean
+
+    final def isTermLambda: Boolean = isInstanceOf[TermLambda]
+    final def isTypeLambda: Boolean = isInstanceOf[TypeLambda]
+    final def isHigherKinded: Boolean = isInstanceOf[TypeProxy]
+
+    private var myParamRefs: List[ParamRefType] | Null = null
+
+    def paramRefs: List[ParamRefType] = {
+      if myParamRefs == null then
+        def recur(paramNames: List[ThisName], i: Int): List[ParamRefType] =
+          paramNames match
+            case _ :: rest => newParamRef(i) :: recur(rest, i + 1)
+            case _ => Nil
+        myParamRefs = recur(paramNames, 0)
+      myParamRefs.nn
+    }
+
+    /** Like `paramInfos` but substitute parameter references with the given arguments */
+    final def instantiateParamInfos(argTypes: => List[Type])(using Context): List[Type] =
+      if (isParamDependent) paramInfos.mapConserve(_.substParams(this, argTypes))
+      else paramInfos
+
+    /** Like `resultType` but substitute parameter references with the given arguments */
+    final def instantiate(argTypes: => List[Type])(using Context): Type =
+      if (isResultDependent) resultType.substParams(this, argTypes)
+      else resultType
+
+    def companion: LambdaTypeCompanion[ThisName, PInfo, This]
+
+    /** The type `[tparams := paramRefs] tp`, where `tparams` can be
+     *  either a list of type parameter symbols or a list of lambda parameters
+     *
+     *  @pre If `tparams` is a list of lambda parameters, then it must be the
+     *       full, in-order list of type parameters of some type constructor, as
+     *       can be obtained using `TypeApplications#typeParams`.
+     */
+    def integrate(tparams: List[ParamInfo], tp: Type)(using Context): Type =
+      (tparams: @unchecked) match {
+        case LambdaParam(lam, _) :: _ => tp.subst(lam, this) // This is where the precondition is necessary.
+        case params: List[Symbol @unchecked] => tp.subst(params, paramRefs)
+      }
+
+    final def derivedLambdaType(paramNames: List[ThisName] = this.paramNames,
+                          paramInfos: List[PInfo] = this.paramInfos,
+                          resType: Type = this.resType)(using Context): LambdaType =
+      if ((paramNames eq this.paramNames) && (paramInfos eq this.paramInfos) && (resType eq this.resType)) this
+      else newLikeThis(paramNames, paramInfos, resType)
+
+    def newLikeThis(paramNames: List[ThisName], paramInfos: List[PInfo], resType: Type)(using Context): This =
+      def substParams(pinfos: List[PInfo], to: This): List[PInfo] = pinfos match
+        case pinfos @ (pinfo :: rest) =>
+          pinfos.derivedCons(pinfo.subst(this, to).asInstanceOf[PInfo], substParams(rest, to))
+        case nil =>
+          nil
+      companion(paramNames)(
+          x => substParams(paramInfos, x),
+          x => resType.subst(this, x))
+
+    protected def prefixString: String
+    override def toString: String = s"$prefixString($paramNames, $paramInfos, $resType)"
+  }
+
+  abstract class HKLambda extends CachedProxyType with LambdaType {
+    final override def underlying(using Context): Type = resType
+    final override def hashIsStable: Boolean = resType.hashIsStable && paramInfos.hashIsStable
+    final override def equals(that: Any): Boolean = equals(that, null)
+  }
+
+  /** The superclass of MethodType and PolyType. */
+  sealed abstract class MethodOrPoly extends UncachedGroundType with LambdaType with MethodicType {
+
+    // Invariants:
+    // (1) mySignatureRunId != NoRunId      =>  mySignature != null
+    // (2) myJavaSignatureRunId != NoRunId  =>  myJavaSignature != null
+
+    private var mySignature: Signature = _
+    private var mySignatureRunId: Int = NoRunId
+    private var myJavaSignature: Signature = _
+    private var myJavaSignatureRunId: Int = NoRunId
+    private var myScala2Signature: Signature = _
+    private var myScala2SignatureRunId: Int = NoRunId
+
+    /** If `isJava` is false, the Scala signature of this method. Otherwise, its Java signature.
+     *
+     *  This distinction is needed because the same method type
+     *  might be part of both a Java and Scala class and each language has
+     *  different type erasure rules.
+     *
+     *  Invariants:
+     *  - Two distinct method overloads defined in the same _Scala_ class will
+     *    have distinct _Scala_ signatures.
+     *  - Two distinct methods overloads defined in the same _Java_ class will
+     *    have distinct _Java_ signatures.
+     *
+     *  @see SingleDenotation#signature
+     */
+    def signature(sourceLanguage: SourceLanguage)(using Context): Signature =
+      def computeSignature(using Context): Signature =
+        val resultSignature = resultType match
+          case tp: MethodOrPoly => tp.signature(sourceLanguage)
+          case tp: ExprType => tp.signature
+          case tp =>
+            if tp.isRef(defn.UnitClass) then Signature(Nil, defn.UnitClass.fullName.asTypeName)
+            else Signature(tp, sourceLanguage)
+        this match
+          case tp: MethodType =>
+            val params = if (isErasedMethod) Nil else tp.paramInfos
+            resultSignature.prependTermParams(params, sourceLanguage)
+          case tp: PolyType =>
+            resultSignature.prependTypeParams(tp.paramNames.length)
+
+      sourceLanguage match
+        case SourceLanguage.Java =>
+          if ctx.runId != myJavaSignatureRunId then
+            myJavaSignature = computeSignature
+            if !myJavaSignature.isUnderDefined then myJavaSignatureRunId = ctx.runId
+          myJavaSignature
+        case SourceLanguage.Scala2 =>
+          if ctx.runId != myScala2SignatureRunId then
+            myScala2Signature = computeSignature
+            if !myScala2Signature.isUnderDefined then myScala2SignatureRunId = ctx.runId
+          myScala2Signature
+        case SourceLanguage.Scala3 =>
+          if ctx.runId != mySignatureRunId then
+            mySignature = computeSignature
+            if !mySignature.isUnderDefined then mySignatureRunId = ctx.runId
+          mySignature
+    end signature
+
+    /** The Scala signature of this method. Note that two distinct Java method
+     *  overloads may have the same Scala signature, the other overload of
+     *  `signature` can be used to avoid ambiguity if necessary.
+     */
+    final override def signature(using Context): Signature =
+      signature(sourceLanguage = SourceLanguage.Scala3)
+
+    final override def hashCode: Int = System.identityHashCode(this)
+
+    final override def equals(that: Any): Boolean = equals(that, null)
+
+    // No definition of `eql` --> fall back on equals, which is `eq`
+
+    final override def iso(that: Any, bs: BinderPairs): Boolean = that match {
+      case that: MethodOrPoly =>
+        paramNames.eqElements(that.paramNames) &&
+        companion.eq(that.companion) && {
+          val bs1 = new SomeBinderPairs(this, that, bs)
+          paramInfos.equalElements(that.paramInfos, bs1) &&
+          resType.equals(that.resType, bs1)
+        }
+      case _ =>
+        false
+    }
+  }
+
+  trait TermLambda extends LambdaType { thisLambdaType =>
+    import DepStatus._
+    type ThisName = TermName
+    type PInfo = Type
+    type This <: TermLambda
+    type ParamRefType = TermParamRef
+
+    override def resultType(using Context): Type =
+      if (dependencyStatus == FalseDeps) { // dealias all false dependencies
+        val dealiasMap = new TypeMap with IdentityCaptRefMap {
+          def apply(tp: Type) = tp match {
+            case tp @ TypeRef(pre, _) =>
+              tp.info match {
+                case TypeAlias(alias) if depStatus(NoDeps, pre) == TrueDeps => apply(alias)
+                case _ => mapOver(tp)
+              }
+            case _ =>
+              mapOver(tp)
+          }
+        }
+        dealiasMap(resType)
+      }
+      else resType
+
+    private var myDependencyStatus: DependencyStatus = Unknown
+    private var myParamDependencyStatus: DependencyStatus = Unknown
+
+    private def depStatus(initial: DependencyStatus, tp: Type)(using Context): DependencyStatus =
+      class DepAcc extends TypeAccumulator[DependencyStatus]:
+        def apply(status: DependencyStatus, tp: Type) = compute(status, tp, this)
+      def combine(x: DependencyStatus, y: DependencyStatus) =
+        val status = (x & StatusMask) max (y & StatusMask)
+        val provisional = (x | y) & Provisional
+        (if status == TrueDeps then status else status | provisional).toByte
+      def compute(status: DependencyStatus, tp: Type, theAcc: TypeAccumulator[DependencyStatus] | Null): DependencyStatus =
+        def applyPrefix(tp: NamedType) =
+          if tp.isInstanceOf[SingletonType] && tp.currentSymbol.isStatic
+          then status // Note: a type ref with static symbol can still be dependent since the symbol might be refined in the enclosing type. See pos/15331.scala.
+          else compute(status, tp.prefix, theAcc)
+        if status == TrueDeps then status
+        else tp match
+          case tp: TypeRef =>
+            val status1 = applyPrefix(tp)
+            tp.info match { // follow type alias to avoid dependency
+              case TypeAlias(alias) if status1 == TrueDeps =>
+                combine(compute(status, alias, theAcc), FalseDeps)
+              case _ =>
+                status1
+            }
+          case tp: TermRef => applyPrefix(tp)
+          case tp: AppliedType => tp.fold(status, compute(_, _, theAcc))
+          case tp: TypeVar if !tp.isInstantiated => combine(status, Provisional)
+          case tp: TermParamRef if tp.binder eq thisLambdaType => TrueDeps
+          case tp: AnnotatedType =>
+            tp match
+              case CapturingType(parent, refs) =>
+                (compute(status, parent, theAcc) /: refs.elems) {
+                  (s, ref) => ref match
+                    case tp: TermParamRef if tp.binder eq thisLambdaType => combine(s, CaptureDeps)
+                    case _ => s
+                }
+              case _ =>
+                if tp.annot.refersToParamOf(thisLambdaType) then TrueDeps
+                else compute(status, tp.parent, theAcc)
+          case _: ThisType | _: BoundType | NoPrefix => status
+          case t: LazyRef =>
+            if t.completed then compute(status, t.ref, theAcc)
+            else Unknown
+          case _ =>
+            (if theAcc != null then theAcc else DepAcc()).foldOver(status, tp)
+      compute(initial, tp, null)
+    end depStatus
+
+    /** The dependency status of this method. Some examples:
+     *
+     *    class C extends { type S; type T = String }
+     *    def f(x: C)(y: Boolean)   // dependencyStatus = NoDeps
+     *    def f(x: C)(y: x.S)       // dependencyStatus = TrueDeps
+     *    def f(x: C)(y: x.T)       // dependencyStatus = FalseDeps, i.e.
+     *                              // dependency can be eliminated by dealiasing.
+     */
+    private def dependencyStatus(using Context): DependencyStatus =
+      if (myDependencyStatus != Unknown) myDependencyStatus
+      else {
+        val result = depStatus(NoDeps, resType)
+        if ((result & Provisional) == 0) myDependencyStatus = result
+        (result & StatusMask).toByte
+      }
+
+    /** The parameter dependency status of this method. Analogous to `dependencyStatus`,
+     *  but tracking dependencies in same parameter list.
+     */
+    private def paramDependencyStatus(using Context): DependencyStatus =
+      if (myParamDependencyStatus != Unknown) myParamDependencyStatus
+      else {
+        val result =
+          if (paramInfos.isEmpty) NoDeps
+          else paramInfos.tail.foldLeft(NoDeps)(depStatus(_, _))
+        if ((result & Provisional) == 0) myParamDependencyStatus = result
+        (result & StatusMask).toByte
+      }
+
+    /** Does result type contain references to parameters of this method type,
+     *  which cannot be eliminated by de-aliasing?
+     */
+    def isResultDependent(using Context): Boolean =
+      dependencyStatus == TrueDeps || dependencyStatus == CaptureDeps
+
+    /** Does one of the parameter types contain references to earlier parameters
+     *  of this method type which cannot be eliminated by de-aliasing?
+     */
+    def isParamDependent(using Context): Boolean = paramDependencyStatus == TrueDeps
+
+    /** Is there a dependency involving a reference in a capture set, but
+     *  otherwise no true result dependency?
+     */
+    def isCaptureDependent(using Context) = dependencyStatus == CaptureDeps
+
+    def newParamRef(n: Int): TermParamRef = new TermParamRefImpl(this, n)
+
+    /** The least supertype of `resultType` that does not contain parameter dependencies */
+    def nonDependentResultApprox(using Context): Type =
+      if isResultDependent then
+        val dropDependencies = new ApproximatingTypeMap with IdempotentCaptRefMap {
+          def apply(tp: Type) = tp match {
+            case tp @ TermParamRef(`thisLambdaType`, _) =>
+              range(defn.NothingType, atVariance(1)(apply(tp.underlying)))
+            case CapturingType(_, _) =>
+              mapOver(tp)
+            case AnnotatedType(parent, ann) if ann.refersToParamOf(thisLambdaType) =>
+              val parent1 = mapOver(parent)
+              if ann.symbol == defn.RetainsAnnot || ann.symbol == defn.RetainsByNameAnnot then
+                range(
+                  AnnotatedType(parent1, CaptureSet.empty.toRegularAnnotation(ann.symbol)),
+                  AnnotatedType(parent1, CaptureSet.universal.toRegularAnnotation(ann.symbol)))
+              else
+                parent1
+            case _ => mapOver(tp)
+          }
+        }
+        dropDependencies(resultType)
+      else resultType
+  }
+
+  abstract case class MethodType(paramNames: List[TermName])(
+      @constructorOnly paramInfosExp: MethodType => List[Type],
+      @constructorOnly resultTypeExp: MethodType => Type)
+    extends MethodOrPoly with TermLambda with NarrowCached { thisMethodType =>
+
+    type This = MethodType
+
+    val paramInfos: List[Type] = paramInfosExp(this: @unchecked)
+    val resType: Type = resultTypeExp(this: @unchecked)
+    assert(resType.exists)
+
+    def companion: MethodTypeCompanion
+
+    final override def isImplicitMethod: Boolean =
+      companion.eq(ImplicitMethodType) ||
+      companion.eq(ErasedImplicitMethodType) ||
+      isContextualMethod
+    final override def isErasedMethod: Boolean =
+      companion.eq(ErasedMethodType) ||
+      companion.eq(ErasedImplicitMethodType) ||
+      companion.eq(ErasedContextualMethodType)
+    final override def isContextualMethod: Boolean =
+      companion.eq(ContextualMethodType) ||
+      companion.eq(ErasedContextualMethodType)
+
+    protected def prefixString: String = companion.prefixString
+  }
+
+  final class CachedMethodType(paramNames: List[TermName])(
+      @constructorOnly paramInfosExp: MethodType => List[Type],
+      @constructorOnly resultTypeExp: MethodType => Type,
+      val companion: MethodTypeCompanion)
+    extends MethodType(paramNames)(paramInfosExp, resultTypeExp)
+
+  abstract class LambdaTypeCompanion[N <: Name, PInfo <: Type, LT <: LambdaType] {
+    def syntheticParamName(n: Int): N
+
+    @sharable private val memoizedNames = util.HashMap[Int, List[N]]()
+    def syntheticParamNames(n: Int): List[N] = synchronized {
+      memoizedNames.getOrElseUpdate(n, (0 until n).map(syntheticParamName).toList)
+    }
+
+    def apply(paramNames: List[N])(paramInfosExp: LT => List[PInfo], resultTypeExp: LT => Type)(using Context): LT
+    def apply(paramNames: List[N], paramInfos: List[PInfo], resultType: Type)(using Context): LT =
+      apply(paramNames)(_ => paramInfos, _ => resultType)
+    def apply(paramInfos: List[PInfo])(resultTypeExp: LT => Type)(using Context): LT =
+      apply(syntheticParamNames(paramInfos.length))(_ => paramInfos, resultTypeExp)
+    def apply(paramInfos: List[PInfo], resultType: Type)(using Context): LT =
+      apply(syntheticParamNames(paramInfos.length), paramInfos, resultType)
+
+    protected def toPInfo(tp: Type)(using Context): PInfo
+
+    def fromParams[PI <: ParamInfo.Of[N]](params: List[PI], resultType: Type)(using Context): Type =
+      if (params.isEmpty) resultType
+      else apply(params.map(_.paramName))(
+        tl => params.map(param => toPInfo(tl.integrate(params, param.paramInfo))),
+        tl => tl.integrate(params, resultType))
+  }
+
+  abstract class TermLambdaCompanion[LT <: TermLambda]
+  extends LambdaTypeCompanion[TermName, Type, LT] {
+    def toPInfo(tp: Type)(using Context): Type = tp
+    def syntheticParamName(n: Int): TermName = nme.syntheticParamName(n)
+  }
+
+  abstract class TypeLambdaCompanion[LT <: TypeLambda]
+  extends LambdaTypeCompanion[TypeName, TypeBounds, LT] {
+    def toPInfo(tp: Type)(using Context): TypeBounds = (tp: @unchecked) match {
+      case tp: TypeBounds => tp
+      case tp: ErrorType => TypeAlias(tp)
+    }
+    def syntheticParamName(n: Int): TypeName = tpnme.syntheticTypeParamName(n)
+  }
+
+  abstract class MethodTypeCompanion(val prefixString: String) extends TermLambdaCompanion[MethodType] { self =>
+
+    /** Produce method type from parameter symbols, with special mappings for repeated
+     *  and inline parameters:
+     *   - replace @repeated annotations on Seq or Array types by <repeated> types
+     *   - add @inlineParam to inline parameters
+     */
+    def fromSymbols(params: List[Symbol], resultType: Type)(using Context): MethodType = {
+      def translateInline(tp: Type): Type = tp match {
+        case ExprType(resType) => ExprType(AnnotatedType(resType, Annotation(defn.InlineParamAnnot)))
+        case _ => AnnotatedType(tp, Annotation(defn.InlineParamAnnot))
+      }
+      def translateErased(tp: Type): Type = tp match {
+        case ExprType(resType) => ExprType(AnnotatedType(resType, Annotation(defn.ErasedParamAnnot)))
+        case _ => AnnotatedType(tp, Annotation(defn.ErasedParamAnnot))
+      }
+      def paramInfo(param: Symbol) = {
+        var paramType = param.info.annotatedToRepeated
+        if (param.is(Inline)) paramType = translateInline(paramType)
+        if (param.is(Erased)) paramType = translateErased(paramType)
+        paramType
+      }
+
+      apply(params.map(_.name.asTermName))(
+         tl => params.map(p => tl.integrate(params, paramInfo(p))),
+         tl => tl.integrate(params, resultType))
+    }
+
+    final def apply(paramNames: List[TermName])(paramInfosExp: MethodType => List[Type], resultTypeExp: MethodType => Type)(using Context): MethodType =
+      checkValid(unique(new CachedMethodType(paramNames)(paramInfosExp, resultTypeExp, self)))
+
+    def checkValid(mt: MethodType)(using Context): mt.type = {
+      if (Config.checkMethodTypes)
+        for ((paramInfo, idx) <- mt.paramInfos.zipWithIndex)
+          paramInfo.foreachPart {
+            case TermParamRef(`mt`, j) => assert(j < idx, mt)
+            case _ =>
+          }
+      mt
+    }
+  }
+
+  object MethodType extends MethodTypeCompanion("MethodType") {
+    def companion(isContextual: Boolean = false, isImplicit: Boolean = false, isErased: Boolean = false): MethodTypeCompanion =
+      if (isContextual)
+        if (isErased) ErasedContextualMethodType else ContextualMethodType
+      else if (isImplicit)
+        if (isErased) ErasedImplicitMethodType else ImplicitMethodType
+      else
+        if (isErased) ErasedMethodType else MethodType
+  }
+  object ErasedMethodType extends MethodTypeCompanion("ErasedMethodType")
+  object ContextualMethodType extends MethodTypeCompanion("ContextualMethodType")
+  object ErasedContextualMethodType extends MethodTypeCompanion("ErasedContextualMethodType")
+  object ImplicitMethodType extends MethodTypeCompanion("ImplicitMethodType")
+  object ErasedImplicitMethodType extends MethodTypeCompanion("ErasedImplicitMethodType")
+
+  /** A ternary extractor for MethodType */
+  object MethodTpe {
+    def unapply(mt: MethodType)(using Context): Some[(List[TermName], List[Type], Type)] =
+      Some((mt.paramNames, mt.paramInfos, mt.resultType))
+  }
+
+  trait TypeLambda extends LambdaType {
+    type ThisName = TypeName
+    type PInfo = TypeBounds
+    type This <: TypeLambda
+    type ParamRefType = TypeParamRef
+
+    def isResultDependent(using Context): Boolean = true
+    def isParamDependent(using Context): Boolean = true
+
+    def newParamRef(n: Int): TypeParamRef = new TypeParamRefImpl(this, n)
+
+    @threadUnsafe lazy val typeParams: List[LambdaParam] =
+      paramNames.indices.toList.map(new LambdaParam(this, _))
+
+    def derivedLambdaAbstraction(paramNames: List[TypeName], paramInfos: List[TypeBounds], resType: Type)(using Context): Type =
+      resType match {
+        case resType: AliasingBounds =>
+          resType.derivedAlias(newLikeThis(paramNames, paramInfos, resType.alias))
+        case resType @ TypeBounds(lo, hi) =>
+          resType.derivedTypeBounds(
+            if (lo.isRef(defn.NothingClass)) lo else newLikeThis(paramNames, paramInfos, lo),
+            newLikeThis(paramNames, paramInfos, hi))
+        case _ =>
+          derivedLambdaType(paramNames, paramInfos, resType)
+      }
+  }
+
+  /** A type lambda of the form `[X_0 B_0, ..., X_n B_n] => T`
+   *
+   *  @param  paramNames      The names `X_0`, ..., `X_n`
+   *  @param  paramInfosExp  A function that, given the polytype itself, returns the
+   *                          parameter bounds `B_1`, ..., `B_n`
+   *  @param  resultTypeExp   A function that, given the polytype itself, returns the
+   *                          result type `T`.
+   *  @param  variances       The variances of the type parameters, if the type lambda
+   *                          carries variances, i.e. it is a bound of an abstract type
+   *                          or the rhs of a match alias or opaque alias. The parameter
+   *                          is Nil for all other lambdas.
+   *
+   *  Variances are stored in the `typeParams` list of the lambda.
+   */
+  class HKTypeLambda(val paramNames: List[TypeName], @constructorOnly variances: List[Variance])(
+      @constructorOnly paramInfosExp: HKTypeLambda => List[TypeBounds],
+      @constructorOnly resultTypeExp: HKTypeLambda => Type)
+  extends HKLambda with TypeLambda {
+    type This = HKTypeLambda
+    def companion: HKTypeLambda.type = HKTypeLambda
+
+    val paramInfos: List[TypeBounds] = paramInfosExp(this: @unchecked)
+    val resType: Type = resultTypeExp(this: @unchecked)
+
+    private def setVariances(tparams: List[LambdaParam], vs: List[Variance]): Unit =
+      if tparams.nonEmpty then
+        tparams.head.declaredVariance = vs.head
+        setVariances(tparams.tail, vs.tail)
+
+    override val isDeclaredVarianceLambda = variances.nonEmpty
+    if isDeclaredVarianceLambda then setVariances(typeParams, variances)
+
+    def declaredVariances =
+      if isDeclaredVarianceLambda then typeParams.map(_.declaredVariance)
+      else Nil
+
+    override def computeHash(bs: Binders): Int =
+      doHash(new SomeBinders(this, bs), declaredVariances ::: paramNames, resType, paramInfos)
+
+    // No definition of `eql` --> fall back on equals, which calls iso
+
+    final override def iso(that: Any, bs: BinderPairs): Boolean = that match {
+      case that: HKTypeLambda =>
+        paramNames.eqElements(that.paramNames)
+        && isDeclaredVarianceLambda == that.isDeclaredVarianceLambda
+        && (!isDeclaredVarianceLambda
+            || typeParams.corresponds(that.typeParams)((x, y) =>
+                  x.declaredVariance == y.declaredVariance))
+        && {
+          val bs1 = new SomeBinderPairs(this, that, bs)
+          // `paramInfos` and `resType` might still be uninstantiated at this point
+          (paramInfos: List[TypeBounds] | Null) != null && (resType: Type | Null) != null &&
+          paramInfos.equalElements(that.paramInfos, bs1) &&
+          resType.equals(that.resType, bs1)
+        }
+      case _ =>
+        false
+    }
+
+    override def newLikeThis(paramNames: List[ThisName], paramInfos: List[PInfo], resType: Type)(using Context): This =
+      newLikeThis(paramNames, declaredVariances, paramInfos, resType)
+
+    def newLikeThis(paramNames: List[ThisName], variances: List[Variance], paramInfos: List[PInfo], resType: Type)(using Context): This =
+      HKTypeLambda(paramNames, variances)(
+          x => paramInfos.mapConserve(_.subst(this, x).asInstanceOf[PInfo]),
+          x => resType.subst(this, x))
+
+    def withVariances(variances: List[Variance])(using Context): This =
+      newLikeThis(paramNames, variances, paramInfos, resType)
+
+    protected def prefixString: String = "HKTypeLambda"
+    final override def toString: String =
+      if isDeclaredVarianceLambda then
+        s"HKTypeLambda($paramNames, $paramInfos, $resType, ${declaredVariances.map(_.flagsString)})"
+      else super.toString
+
+    assert(resType.isInstanceOf[TermType], this)
+    assert(paramNames.nonEmpty)
+  }
+
+  /** The type of a polymorphic method. It has the same form as HKTypeLambda,
+   *  except it applies to terms and parameters do not have variances.
+   */
+  class PolyType(val paramNames: List[TypeName])(
+      @constructorOnly paramInfosExp: PolyType => List[TypeBounds],
+      @constructorOnly resultTypeExp: PolyType => Type)
+  extends MethodOrPoly with TypeLambda {
+
+    type This = PolyType
+    def companion: PolyType.type = PolyType
+
+    val paramInfos: List[TypeBounds] = paramInfosExp(this: @unchecked)
+    val resType: Type = resultTypeExp(this: @unchecked)
+
+    assert(resType.isInstanceOf[TermType], this)
+    assert(paramNames.nonEmpty)
+
+    override def isContextualMethod = resType.isContextualMethod
+    override def isImplicitMethod = resType.isImplicitMethod
+
+    /** Merge nested polytypes into one polytype. nested polytypes are normally not supported
+     *  but can arise as temporary data structures.
+     */
+    def flatten(using Context): PolyType = resType match {
+      case that: PolyType =>
+        val shiftedSubst = (x: PolyType) => new TypeMap {
+          def apply(t: Type) = t match {
+            case TypeParamRef(`that`, n) => x.paramRefs(n + paramNames.length)
+            case t => mapOver(t)
+          }
+        }
+        PolyType(paramNames ++ that.paramNames)(
+          x => this.paramInfos.mapConserve(_.subst(this, x).bounds) ++
+               that.paramInfos.mapConserve(shiftedSubst(x)(_).bounds),
+          x => shiftedSubst(x)(that.resultType).subst(this, x))
+      case _ => this
+    }
+
+    protected def prefixString: String = "PolyType"
+  }
+
+  object HKTypeLambda extends TypeLambdaCompanion[HKTypeLambda] {
+    def apply(paramNames: List[TypeName])(
+        paramInfosExp: HKTypeLambda => List[TypeBounds],
+        resultTypeExp: HKTypeLambda => Type)(using Context): HKTypeLambda =
+      apply(paramNames, Nil)(paramInfosExp, resultTypeExp)
+
+    def apply(paramNames: List[TypeName], variances: List[Variance])(
+        paramInfosExp: HKTypeLambda => List[TypeBounds],
+        resultTypeExp: HKTypeLambda => Type)(using Context): HKTypeLambda =
+      unique(new HKTypeLambda(paramNames, variances)(paramInfosExp, resultTypeExp))
+
+    def unapply(tl: HKTypeLambda): Some[(List[LambdaParam], Type)] =
+      Some((tl.typeParams, tl.resType))
+
+    def any(n: Int)(using Context): HKTypeLambda =
+      apply(syntheticParamNames(n))(
+        pt => List.fill(n)(TypeBounds.empty), pt => defn.AnyType)
+
+    override def fromParams[PI <: ParamInfo.Of[TypeName]](params: List[PI], resultType: Type)(using Context): Type =
+      resultType match
+        case bounds: TypeBounds => boundsFromParams(params, bounds)
+        case _ => super.fromParams(params, resultType)
+
+    /** Distributes Lambda inside type bounds. Examples:
+     *
+     *      type T[X] = U        becomes    type T = [X] -> U
+     *      type T[X] <: U       becomes    type T >: Nothing <: ([X] -> U)
+     *      type T[X] >: L <: U  becomes    type T >: ([X] -> L) <: ([X] -> U)
+     *
+     *  The variances of regular TypeBounds types, as well as of match aliases
+     *  and of opaque aliases are always determined from the given parameters
+     *  `params`. The variances of other type aliases are determined from
+     *  the given parameters only if one of these parameters carries a `+`
+     *  or `-` variance annotation. Type aliases without variance annotation
+     *  are treated structurally. That is, their parameter variances are
+     *  determined by how the parameter(s) appear in the result type.
+     *
+     *  Examples:
+     *
+     *    type T[X] >: A              // X is invariant
+     *    type T[X] <: List[X]        // X is invariant
+     *    type T[X] = List[X]         // X is covariant (determined structurally)
+     *    opaque type T[X] = List[X]  // X is invariant
+     *    opaque type T[+X] = List[X] // X is covariant
+     *    type T[A, B] = A => B       // A is contravariant, B is covariant (determined structurally)
+     *    type T[A, +B] = A => B      // A is invariant, B is covariant
+     */
+    def boundsFromParams[PI <: ParamInfo.Of[TypeName]](params: List[PI], bounds: TypeBounds)(using Context): TypeBounds = {
+      def expand(tp: Type, useVariances: Boolean) =
+        if params.nonEmpty && useVariances then
+          apply(params.map(_.paramName), params.map(_.paramVariance))(
+            tl => params.map(param => toPInfo(tl.integrate(params, param.paramInfo))),
+            tl => tl.integrate(params, tp))
+        else
+          super.fromParams(params, tp)
+      def isOpaqueAlias = params match
+        case (param: Symbol) :: _ => param.owner.is(Opaque)
+        case _ => false
+      bounds match {
+        case bounds: MatchAlias =>
+          bounds.derivedAlias(expand(bounds.alias, true))
+        case bounds: TypeAlias =>
+          bounds.derivedAlias(expand(bounds.alias,
+            isOpaqueAlias || params.exists(!_.paramVariance.isEmpty)))
+        case TypeBounds(lo, hi) =>
+          bounds.derivedTypeBounds(
+            if lo.isRef(defn.NothingClass) then lo else expand(lo, true),
+            expand(hi, true))
+      }
+    }
+  }
+
+  object PolyType extends TypeLambdaCompanion[PolyType] {
+    def apply(paramNames: List[TypeName])(
+        paramInfosExp: PolyType => List[TypeBounds],
+        resultTypeExp: PolyType => Type)(using Context): PolyType =
+      unique(new PolyType(paramNames)(paramInfosExp, resultTypeExp))
+
+    def unapply(tl: PolyType): Some[(List[LambdaParam], Type)] =
+      Some((tl.typeParams, tl.resType))
+  }
+
+  private object DepStatus {
+    type DependencyStatus = Byte
+    final val Unknown: DependencyStatus = 0      // not yet computed
+    final val NoDeps: DependencyStatus = 1       // no dependent parameters found
+    final val FalseDeps: DependencyStatus = 2    // all dependent parameters are prefixes of non-depended alias types
+    final val CaptureDeps: DependencyStatus = 3  // dependencies in capture sets under captureChecking, otherwise only false dependencoes
+    final val TrueDeps: DependencyStatus = 4     // some truly dependent parameters exist
+    final val StatusMask: DependencyStatus = 7   // the bits indicating actual dependency status
+    final val Provisional: DependencyStatus = 8  // set if dependency status can still change due to type variable instantiations
+  }
+
+  // ----- Type application: LambdaParam, AppliedType ---------------------
+
+  /** The parameter of a type lambda */
+  case class LambdaParam(tl: TypeLambda, n: Int) extends ParamInfo, printing.Showable {
+    type ThisName = TypeName
+
+    def isTypeParam(using Context): Boolean = tl.paramNames.head.isTypeName
+    def paramName(using Context): tl.ThisName = tl.paramNames(n)
+    def paramInfo(using Context): tl.PInfo = tl.paramInfos(n)
+    def paramInfoAsSeenFrom(pre: Type)(using Context): tl.PInfo = paramInfo
+    def paramInfoOrCompleter(using Context): Type = paramInfo
+    def paramRef(using Context): Type = tl.paramRefs(n)
+
+    private var myVariance: FlagSet = UndefinedFlags
+
+    /** Low level setter, only called from Variances.setStructuralVariances */
+    def storedVariance_= (v: Variance): Unit =
+      myVariance = v
+
+    /** Low level getter, only called from Variances.setStructuralVariances */
+    def storedVariance: Variance =
+      myVariance
+
+    /** Set the declared variance of this parameter.
+     *  @pre the containing lambda is a isDeclaredVarianceLambda
+     */
+    def declaredVariance_=(v: Variance): Unit =
+      assert(tl.isDeclaredVarianceLambda)
+      assert(myVariance == UndefinedFlags)
+      myVariance = v
+
+    /** The declared variance of this parameter.
+     *  @pre the containing lambda is a isDeclaredVarianceLambda
+     */
+    def declaredVariance: Variance =
+      assert(tl.isDeclaredVarianceLambda)
+      assert(myVariance != UndefinedFlags)
+      myVariance
+
+    /** The declared or structural variance of this parameter. */
+    def paramVariance(using Context): Variance =
+      if myVariance == UndefinedFlags then
+        tl match
+          case tl: HKTypeLambda =>
+            setStructuralVariances(tl)
+          case _ =>
+            myVariance = Invariant
+      myVariance
+
+    def toText(printer: Printer): Text = printer.toText(this)
+  }
+
+  /** A type application `C[T_1, ..., T_n]` */
+  abstract case class AppliedType(tycon: Type, args: List[Type])
+  extends CachedProxyType with ValueType {
+
+    private var validSuper: Period = Nowhere
+    private var cachedSuper: Type = uninitialized
+
+    // Boolean caches: 0 = uninitialized, -1 = false, 1 = true
+    private var myStableHash: Byte = 0
+    private var myGround: Byte = 0
+
+    private var myisStableRunId: RunId = NoRunId
+    private var myIsStable: Boolean = uninitialized
+
+    private var myEvalRunId: RunId = NoRunId
+    private var myEvalued: Type = uninitialized
+
+    def isGround(acc: TypeAccumulator[Boolean])(using Context): Boolean =
+      if myGround == 0 then myGround = if acc.foldOver(true, this) then 1 else -1
+      myGround > 0
+
+    private[Types] def cachedIsStable(using Context): Boolean =
+      // We need to invalidate the cache when the run changes because the case
+      // `TermRef` of `Type#isStable` reads denotations, which depend on the
+      // run. See docs/_docs/internals/periods.md for more information. We do
+      // not need to check the phase because once a type is not provisional, its
+      // stability should not change anymore.
+      if myisStableRunId != ctx.runId then
+        val res: Boolean = computeIsStable
+        // We don't cache if the type is provisional because `Type#isStable`
+        // calls `Type#stripTypeVar` which might return different results later.
+        if !isProvisional then
+          myisStableRunId = ctx.runId
+          myIsStable = res
+        res
+      else
+        myIsStable
+
+    private def computeIsStable(using Context): Boolean = tycon match
+      case tycon: TypeRef if defn.isCompiletimeAppliedType(tycon.symbol) && args.forall(_.isStable) => true
+      case _ => false
+
+    override def underlying(using Context): Type = tycon
+
+    override def superType(using Context): Type =
+      if ctx.period != validSuper then
+        validSuper = if (tycon.isProvisional) Nowhere else ctx.period
+        cachedSuper = tycon match
+          case tycon: HKTypeLambda => defn.AnyType
+          case tycon: TypeRef if tycon.symbol.isClass => tycon
+          case tycon: TypeProxy => tycon.superType.applyIfParameterized(args)
+          case _ => defn.AnyType
+      cachedSuper
+
+    override def translucentSuperType(using Context): Type = tycon match {
+      case tycon: TypeRef if tycon.symbol.isOpaqueAlias =>
+        tycon.translucentSuperType.applyIfParameterized(args)
+      case _ =>
+        tryNormalize.orElse(superType)
+    }
+
+    inline def map(inline op: Type => Type)(using Context) =
+      def mapArgs(args: List[Type]): List[Type] = args match
+        case args @ (arg :: rest) => args.derivedCons(op(arg), mapArgs(rest))
+        case nil => nil
+      derivedAppliedType(op(tycon), mapArgs(args))
+
+    inline def fold[T](x: T, inline op: (T, Type) => T)(using Context): T =
+      def foldArgs(x: T, args: List[Type]): T = args match
+        case arg :: rest => foldArgs(op(x, arg), rest)
+        case nil => x
+      foldArgs(op(x, tycon), args)
+
+    override def tryNormalize(using Context): Type = tycon.stripTypeVar match {
+      case tycon: TypeRef =>
+        def tryMatchAlias = tycon.info match {
+          case MatchAlias(alias) =>
+            trace(i"normalize $this", typr, show = true) {
+              MatchTypeTrace.recurseWith(this) {
+                alias.applyIfParameterized(args.map(_.normalized)).tryNormalize
+              }
+            }
+          case _ =>
+            NoType
+        }
+        tryCompiletimeConstantFold.orElse(tryMatchAlias)
+      case _ =>
+        NoType
+    }
+
+    /** Does this application expand to a match type? */
+    def isMatchAlias(using Context): Boolean = tycon.stripTypeVar match
+      case tycon: TypeRef =>
+        tycon.info match
+          case _: MatchAlias => true
+          case _ => false
+      case _ => false
+
+    /** Is this an unreducible application to wildcard arguments?
+     *  This is the case if tycon is higher-kinded. This means
+     *  it is a subtype of a hk-lambda, but not a match alias.
+     *  (normal parameterized aliases are removed in `appliedTo`).
+     *  Applications of higher-kinded type constructors to wildcard arguments
+     *  are equivalent to existential types, which are not supported.
+     */
+    def isUnreducibleWild(using Context): Boolean =
+      tycon.isLambdaSub && hasWildcardArg && !isMatchAlias
+
+    def tryCompiletimeConstantFold(using Context): Type =
+      if myEvalRunId == ctx.runId then myEvalued
+      else
+        val res = TypeEval.tryCompiletimeConstantFold(this)
+        if !isProvisional then
+          myEvalRunId = ctx.runId
+          myEvalued = res
+        res
+
+    def lowerBound(using Context): Type = tycon.stripTypeVar match {
+      case tycon: TypeRef =>
+        tycon.info match {
+          case TypeBounds(lo, hi) =>
+            if (lo eq hi) superType // optimization, can profit from caching in this case
+            else lo.applyIfParameterized(args)
+          case _ => NoType
+        }
+      case tycon: AppliedType =>
+        tycon.lowerBound.applyIfParameterized(args)
+      case _ =>
+        NoType
+    }
+
+    def tyconTypeParams(using Context): List[ParamInfo] = {
+      val tparams = tycon.typeParams
+      if (tparams.isEmpty) HKTypeLambda.any(args.length).typeParams else tparams
+    }
+
+    def hasWildcardArg(using Context): Boolean = args.exists(isBounds)
+
+    def derivedAppliedType(tycon: Type, args: List[Type])(using Context): Type =
+      if ((tycon eq this.tycon) && (args eq this.args)) this
+      else tycon.appliedTo(args)
+
+    override def computeHash(bs: Binders): Int = doHash(bs, tycon, args)
+
+    override def hashIsStable: Boolean = {
+      if (myStableHash == 0) myStableHash = if (tycon.hashIsStable && args.hashIsStable) 1 else -1
+      myStableHash > 0
+    }
+
+    override def eql(that: Type): Boolean = this `eq` that // safe because applied types are hash-consed separately
+
+    // equals comes from case class; no matching override is needed
+
+    final override def iso(that: Any, bs: BinderPairs): Boolean = that match {
+      case that: AppliedType => tycon.equals(that.tycon, bs) && args.equalElements(that.args, bs)
+      case _ => false
+    }
+  }
+
+  final class CachedAppliedType(tycon: Type, args: List[Type], hc: Int) extends AppliedType(tycon, args) {
+    myHash = hc
+  }
+
+  object AppliedType {
+    def apply(tycon: Type, args: List[Type])(using Context): AppliedType = {
+      assertUnerased()
+      ctx.base.uniqueAppliedTypes.enterIfNew(tycon, args)
+    }
+  }
+
+  // ----- BoundTypes: ParamRef, RecThis ----------------------------------------
+
+  abstract class BoundType extends CachedProxyType with ValueType {
+    type BT <: Type
+    val binder: BT
+    def copyBoundType(bt: BT): Type
+    override def hashIsStable: Boolean = false
+  }
+
+  abstract class ParamRef extends BoundType {
+    type BT <: LambdaType
+    def paramNum: Int
+    def paramName: binder.ThisName = binder.paramNames(paramNum)
+
+    override def underlying(using Context): Type = {
+      // TODO: update paramInfos's type to nullable
+      val infos: List[Type] | Null = binder.paramInfos
+      if (infos == null) NoType // this can happen if the referenced generic type is not initialized yet
+      else infos(paramNum)
+    }
+
+    override def computeHash(bs: Binders): Int = doHash(paramNum, binder.identityHash(bs))
+
+    override def equals(that: Any): Boolean = equals(that, null)
+
+    override def iso(that: Any, bs: BinderPairs): Boolean = that match {
+      case that: ParamRef => paramNum == that.paramNum && binder.equalBinder(that.binder, bs)
+      case _ => false
+    }
+
+    protected def kindString: String
+
+    override def toString: String =
+      try s"${kindString}ParamRef($paramName)"
+      catch {
+        case ex: IndexOutOfBoundsException => s"ParamRef(<bad index: $paramNum>)"
+      }
+  }
+
+  /** Only created in `binder.paramRefs`. Use `binder.paramRefs(paramNum)` to
+   *  refer to `TermParamRef(binder, paramNum)`.
+   */
+  abstract case class TermParamRef(binder: TermLambda, paramNum: Int) extends ParamRef, CaptureRef {
+    type BT = TermLambda
+    def canBeTracked(using Context) = true
+    def kindString: String = "Term"
+    def copyBoundType(bt: BT): Type = bt.paramRefs(paramNum)
+  }
+
+  private final class TermParamRefImpl(binder: TermLambda, paramNum: Int) extends TermParamRef(binder, paramNum)
+
+  /** Only created in `binder.paramRefs`. Use `binder.paramRefs(paramNum)` to
+   *  refer to `TypeParamRef(binder, paramNum)`.
+   */
+  abstract case class TypeParamRef(binder: TypeLambda, paramNum: Int) extends ParamRef {
+    type BT = TypeLambda
+    def kindString: String = "Type"
+    def copyBoundType(bt: BT): Type = bt.paramRefs(paramNum)
+
+    /** Optimized version of occursIn, avoid quadratic blowup when solving
+     *  constraints over large ground types.
+     */
+    override def occursIn(that: Type)(using Context): Boolean = !that.isGround && super.occursIn(that)
+
+    /** Looking only at the structure of `bound`, is one of the following true?
+     *     - fromBelow and param <:< bound
+     *     - !fromBelow and param >:> bound
+     */
+    def occursIn(bound: Type, fromBelow: Boolean)(using Context): Boolean = bound.stripTypeVar match {
+      case bound: ParamRef => bound == this
+      case bound: AndType  => occursIn(bound.tp1, fromBelow) && occursIn(bound.tp2, fromBelow)
+      case bound: OrType   => occursIn(bound.tp1, fromBelow) || occursIn(bound.tp2, fromBelow)
+      case _ => false
+    }
+  }
+
+  private final class TypeParamRefImpl(binder: TypeLambda, paramNum: Int) extends TypeParamRef(binder, paramNum)
+
+  /** a self-reference to an enclosing recursive type. The only creation method is
+   *  `binder.recThis`, returning `RecThis(binder)`.
+   */
+  abstract case class RecThis(binder: RecType) extends BoundType with SingletonType {
+    type BT = RecType
+    override def underlying(using Context): RecType = binder
+    def copyBoundType(bt: BT): RecThis = bt.recThis
+
+    // need to customize hashCode and equals to prevent infinite recursion
+    // between RecTypes and RecRefs.
+    override def computeHash(bs: Binders): Int = addDelta(binder.identityHash(bs), 41)
+
+    override def equals(that: Any): Boolean = equals(that, null)
+
+    override def iso(that: Any, bs: BinderPairs): Boolean = that match {
+      case that: RecThis => binder.equalBinder(that.binder, bs)
+      case _ => false
+    }
+
+    override def toString: String =
+      try s"RecThis(${binder.hashCode})"
+      catch {
+        case ex: NullPointerException => s"RecThis(<under construction>)"
+      }
+  }
+
+  private final class RecThisImpl(binder: RecType) extends RecThis(binder)
+
+  // @sharable private var skid: Int = 0
+
+  // ----- Skolem types -----------------------------------------------
+
+  /** A skolem type reference with underlying type `info`.
+   *
+   * For Dotty, a skolem type is a singleton type of some unknown value of type `info`.
+   * Note that care is needed when creating them, since not all types need to be inhabited.
+   * A skolem is equal to itself and no other type.
+   */
+  case class SkolemType(info: Type) extends CachedProxyType with ValueType with SingletonType {
+    override def underlying(using Context): Type = info
+    def derivedSkolemType(info: Type)(using Context): SkolemType =
+      if (info eq this.info) this else SkolemType(info)
+
+    override def computeHash(bs: Binders): Int = identityHash(bs)
+    override def equals(that: Any): Boolean = this.eq(that.asInstanceOf[AnyRef])
+
+    def withName(name: Name): this.type = { myRepr = name; this }
+
+    //skid += 1
+    //val id = skid
+    //assert(id != 10)
+
+    private var myRepr: Name | Null = null
+    def repr(using Context): Name = {
+      if (myRepr == null) myRepr = SkolemName.fresh()
+      myRepr.nn
+    }
+
+    override def toString: String = s"SkolemType($hashCode)"
+  }
+
+  /** A skolem type used to wrap the type of the qualifier of a selection.
+   *
+   *  When typing a selection `e.f`, if `e` is unstable then we unconditionally
+   *  skolemize it. We use a subclass of `SkolemType` for this so that
+   *  [[TypeOps#asSeenFrom]] may treat it specially for optimization purposes,
+   *  see its implementation for more details.
+   */
+  class QualSkolemType(info: Type) extends SkolemType(info) {
+    override def derivedSkolemType(info: Type)(using Context): SkolemType =
+      if (info eq this.info) this else QualSkolemType(info)
+  }
+  object QualSkolemType {
+    def apply(info: Type): QualSkolemType = new QualSkolemType(info)
+  }
+
+  // ------------ Type variables ----------------------------------------
+
+  /** In a TypeApply tree, a TypeVar is created for each argument type to be inferred.
+   *  Every type variable is referred to by exactly one inferred type parameter of some
+   *  TypeApply tree.
+   *
+   *  A type variable is essentially a switch that models some part of a substitution.
+   *  It is first linked to `origin`, a poly param that's in the current constraint set.
+   *  It can then be (once) instantiated to some other type. The instantiation is
+   *  recorded in the type variable itself, or else, if the current type state
+   *  is different from the variable's creation state (meaning unrolls are possible)
+   *  in the current typer state.
+   *
+   *  @param  origin           the parameter that's tracked by the type variable.
+   *  @param  creatorState     the typer state in which the variable was created.
+   *  @param  initNestingLevel the initial nesting level of the type variable. (c.f. nestingLevel)
+   */
+  final class TypeVar private(initOrigin: TypeParamRef, creatorState: TyperState | Null, val initNestingLevel: Int) extends CachedProxyType with ValueType {
+    private var currentOrigin = initOrigin
+
+    def origin: TypeParamRef = currentOrigin
+
+    /** Set origin to new parameter. Called if we merge two conflicting constraints.
+     *  See OrderingConstraint#merge, OrderingConstraint#rename
+     */
+    def setOrigin(p: TypeParamRef) = currentOrigin = p
+
+    /** The permanent instance type of the variable, or NoType is none is given yet */
+    private var myInst: Type = NoType
+
+    private[core] def inst: Type = myInst
+    private[core] def setInst(tp: Type): Unit =
+      myInst = tp
+      if tp.exists && owningState != null then
+        val owningState1 = owningState.uncheckedNN.get
+        if owningState1 != null then
+          owningState1.ownedVars -= this
+          owningState = null // no longer needed; null out to avoid a memory leak
+
+    private[core] def resetInst(ts: TyperState): Unit =
+      assert(myInst.exists)
+      myInst = NoType
+      owningState = new WeakReference(ts)
+
+    /** The state owning the variable. This is at first `creatorState`, but it can
+     *  be changed to an enclosing state on a commit.
+     */
+    private[core] var owningState: WeakReference[TyperState] | Null =
+      if (creatorState == null) null else new WeakReference(creatorState)
+
+    /** The nesting level of this type variable in the current typer state. This is usually
+     *  the same as `initNestingLevel`, but can be decremented by calling `TyperState#setNestingLevel`.
+     *  Symbols with a nestingLevel strictly greater than this level will not appear in the
+     *  instantiation of this type variable. This is enforced in `ConstraintHandling`,
+     *  dependig on the Config flags setting `checkLevelsOnConstraints` and `checkLevelsOnInstantiation`.
+     *
+     *  Under `checkLevelsOnConstraints` we maintain the invariant that
+     *  the `nonParamBounds` of a type variable never refer to a type with a
+     *  greater `nestingLevel` (see `legalBound` for the reason why this
+     *  cannot be delayed until instantiation). Then, on instantiation,
+     *  we replace any param in the param bound with a level greater than
+     *  nestingLevel (see `fullLowerBound`).
+     *
+     *  Under `checkLevelsOnInstantiation`, we avoid incorrect levels only
+     *  when a type variable is instantiated, see `ConstraintHandling$fixLevels`.
+     *  Under this mode, the `nestingLevel` of a type variable can be made
+     *  smaller when fixing the levels for some other type variable instance.
+     */
+    def nestingLevel(using Context): Int = ctx.typerState.nestingLevel(this)
+
+    /** The instance type of this variable, or NoType if the variable is currently
+     *  uninstantiated
+     */
+    def instanceOpt(using Context): Type =
+      if (inst.exists) inst else ctx.typerState.constraint.instType(this)
+
+    /** Is the variable already instantiated? */
+    def isInstantiated(using Context): Boolean = instanceOpt.exists
+
+    /** Instantiate variable with given type */
+    def instantiateWith(tp: Type)(using Context): Type = {
+      assert(tp ne this, i"self instantiation of $origin, constraint = ${ctx.typerState.constraint}")
+      assert(!myInst.exists, i"$origin is already instantiated to $myInst but we attempted to instantiate it to $tp")
+      typr.println(i"instantiating $this with $tp")
+
+      if Config.checkConstraintsSatisfiable then
+        assert(currentEntry.bounds.contains(tp),
+          i"$origin is constrained to be $currentEntry but attempted to instantiate it to $tp")
+
+      if ((ctx.typerState eq owningState.nn.get.uncheckedNN) && !TypeComparer.subtypeCheckInProgress)
+        setInst(tp)
+      ctx.typerState.constraint = ctx.typerState.constraint.replace(origin, tp)
+      tp
+    }
+
+    /** Instantiate variable from the constraints over its `origin`.
+     *  If `fromBelow` is true, the variable is instantiated to the lub
+     *  of its lower bounds in the current constraint; otherwise it is
+     *  instantiated to the glb of its upper bounds. However, a lower bound
+     *  instantiation can be a singleton type only if the upper bound
+     *  is also a singleton type.
+     */
+    def instantiate(fromBelow: Boolean)(using Context): Type =
+      val tp = TypeComparer.instanceType(origin, fromBelow, widenUnions, nestingLevel)
+      if myInst.exists then // The line above might have triggered instantiation of the current type variable
+        myInst
+      else
+        instantiateWith(tp)
+
+    /** Widen unions when instantiating this variable in the current context? */
+    def widenUnions(using Context): Boolean = !ctx.typerState.constraint.isHard(this)
+
+    /** For uninstantiated type variables: the entry in the constraint (either bounds or
+     *  provisional instance value)
+     */
+    private def currentEntry(using Context): Type = ctx.typerState.constraint.entry(origin)
+
+    /** For uninstantiated type variables: Is the lower bound different from Nothing? */
+    def hasLowerBound(using Context): Boolean = !currentEntry.loBound.isExactlyNothing
+
+    /** For uninstantiated type variables: Is the upper bound different from Any? */
+    def hasUpperBound(using Context): Boolean = !currentEntry.hiBound.isRef(defn.AnyClass)
+
+    /** Unwrap to instance (if instantiated) or origin (if not), until result
+     *  is no longer a TypeVar
+     */
+    override def stripTypeVar(using Context): Type = {
+      val inst = instanceOpt
+      if (inst.exists) inst.stripTypeVar else origin
+    }
+
+    override def stripped(using Context): Type = stripTypeVar.stripped
+
+    /** If the variable is instantiated, its instance, otherwise its origin */
+    override def underlying(using Context): Type = {
+      val inst = instanceOpt
+      if (inst.exists) inst else origin
+    }
+
+    override def computeHash(bs: Binders): Int = identityHash(bs)
+    override def equals(that: Any): Boolean = this.eq(that.asInstanceOf[AnyRef])
+
+    override def toString: String = {
+      def instStr = if (inst.exists) s" -> $inst" else ""
+      s"TypeVar($origin$instStr)"
+    }
+  }
+  object TypeVar:
+    def apply(using Context)(initOrigin: TypeParamRef, creatorState: TyperState | Null, nestingLevel: Int = ctx.nestingLevel) =
+      new TypeVar(initOrigin, creatorState, nestingLevel)
+
+  type TypeVars = SimpleIdentitySet[TypeVar]
+
+  // ------ MatchType ---------------------------------------------------------------
+
+  /**    scrutinee match { case_1 ... case_n }
+   *
+   *  where
+   *
+   *     case_i  =   [X1, ..., Xn] patternType => resultType
+   *
+   *  and `X_1,...X_n` are the type variables bound in `patternType`
+   */
+  abstract case class MatchType(bound: Type, scrutinee: Type, cases: List[Type]) extends CachedProxyType with ValueType {
+    def derivedMatchType(bound: Type, scrutinee: Type, cases: List[Type])(using Context): MatchType =
+      if (bound.eq(this.bound) && scrutinee.eq(this.scrutinee) && cases.eqElements(this.cases)) this
+      else MatchType(bound, scrutinee, cases)
+
+    def caseType(tp: Type)(using Context): Type = tp match {
+      case tp: HKTypeLambda => caseType(tp.resType)
+      case defn.MatchCase(_, body) => body
+    }
+
+    def alternatives(using Context): List[Type] = cases.map(caseType)
+    def underlying(using Context): Type = bound
+
+    private var myReduced: Type | Null = null
+    private var reductionContext: util.MutableMap[Type, Type] = _
+
+    override def tryNormalize(using Context): Type =
+      try
+        reduced.normalized
+      catch
+        case ex: Throwable =>
+          handleRecursive("normalizing", s"${scrutinee.show} match ..." , ex)
+
+    def reduced(using Context): Type = {
+
+      def contextInfo(tp: Type): Type = tp match {
+        case tp: TypeParamRef =>
+          val constraint = ctx.typerState.constraint
+          if (constraint.entry(tp).exists) TypeComparer.fullBounds(tp)
+          else NoType
+        case tp: TypeRef =>
+          val bounds = ctx.gadt.fullBounds(tp.symbol)
+          if (bounds == null) NoType else bounds
+        case tp: TypeVar =>
+          tp.underlying
+      }
+
+      def updateReductionContext(footprint: collection.Set[Type]): Unit =
+        reductionContext = util.HashMap()
+        for (tp <- footprint)
+          reductionContext(tp) = contextInfo(tp)
+        typr.println(i"footprint for $this $hashCode: ${footprint.toList.map(x => (x, contextInfo(x)))}%, %")
+
+      def isUpToDate: Boolean =
+        reductionContext.keysIterator.forall { tp =>
+          reductionContext(tp) `eq` contextInfo(tp)
+        }
+
+      record("MatchType.reduce called")
+      if !Config.cacheMatchReduced
+          || myReduced == null
+          || !isUpToDate
+          || MatchTypeTrace.isRecording
+      then
+        record("MatchType.reduce computed")
+        if (myReduced != null) record("MatchType.reduce cache miss")
+        myReduced =
+          trace(i"reduce match type $this $hashCode", matchTypes, show = true) {
+            def matchCases(cmp: TrackingTypeComparer): Type =
+              val saved = ctx.typerState.snapshot()
+              try cmp.matchCases(scrutinee.normalized, cases)
+              catch case ex: Throwable =>
+                handleRecursive("reduce type ", i"$scrutinee match ...", ex)
+              finally
+                updateReductionContext(cmp.footprint)
+                ctx.typerState.resetTo(saved)
+                  // this drops caseLambdas in constraint and undoes any typevar
+                  // instantiations during matchtype reduction
+
+            TypeComparer.tracked(matchCases)
+          }
+      myReduced.nn
+    }
+
+    /** True if the reduction uses GADT constraints. */
+    def reducesUsingGadt(using Context): Boolean =
+      (reductionContext ne null) && reductionContext.keysIterator.exists {
+        case tp: TypeRef => reductionContext(tp).exists
+        case _           => false
+      }
+
+    override def computeHash(bs: Binders): Int = doHash(bs, scrutinee, bound :: cases)
+
+    override def eql(that: Type): Boolean = that match {
+      case that: MatchType =>
+        bound.eq(that.bound) && scrutinee.eq(that.scrutinee) && cases.eqElements(that.cases)
+      case _ => false
+    }
+  }
+
+  class CachedMatchType(bound: Type, scrutinee: Type, cases: List[Type]) extends MatchType(bound, scrutinee, cases)
+
+  object MatchType {
+    def apply(bound: Type, scrutinee: Type, cases: List[Type])(using Context): MatchType =
+      unique(new CachedMatchType(bound, scrutinee, cases))
+
+    def thatReducesUsingGadt(tp: Type)(using Context): Boolean = tp match
+      case MatchType.InDisguise(mt) => mt.reducesUsingGadt
+      case mt: MatchType            => mt.reducesUsingGadt
+      case _                        => false
+
+    /** Extractor for match types hidden behind an AppliedType/MatchAlias. */
+    object InDisguise:
+      def unapply(tp: AppliedType)(using Context): Option[MatchType] = tp match
+        case AppliedType(tycon: TypeRef, args) => tycon.info match
+          case MatchAlias(alias) => alias.applyIfParameterized(args) match
+            case mt: MatchType => Some(mt)
+            case _ => None
+          case _ => None
+        case _ => None
+  }
+
+  // ------ ClassInfo, Type Bounds --------------------------------------------------
+
+  type TypeOrSymbol = Type | Symbol
+
+  /** Roughly: the info of a class during a period.
+   *  @param prefix           The prefix on which parents, decls, and selfType need to be rebased.
+   *  @param cls              The class symbol.
+   *  @param declaredParents  The parent types of this class.
+   *                          These are all normalized to be TypeRefs by moving any refinements
+   *                          to be member definitions of the class itself.
+   *                          Unlike `parents`, the types are not seen as seen from `prefix`.
+   *  @param decls            The symbols defined directly in this class.
+   *  @param selfInfo         The type of `this` in this class, if explicitly given,
+   *                          NoType otherwise. If class is compiled from source, can also
+   *                          be a reference to the self symbol containing the type.
+   */
+  abstract case class ClassInfo(
+      prefix: Type,
+      cls: ClassSymbol,
+      declaredParents: List[Type],
+      decls: Scope,
+      selfInfo: TypeOrSymbol) extends CachedGroundType with TypeType {
+
+    private var selfTypeCache: Type | Null = null
+    private var appliedRefCache: Type | Null = null
+
+    /** The self type of a class is the conjunction of
+     *   - the explicit self type if given (or the info of a given self symbol), and
+     *   - the fully applied reference to the class itself.
+     */
+    def selfType(using Context): Type = {
+      val clsd = cls.classDenot
+      if (selfTypeCache == null)
+        selfTypeCache = {
+          val givenSelf = clsd.givenSelfType
+          if (!givenSelf.isValueType) appliedRef
+          else if (clsd.is(Module)) givenSelf
+          else if (ctx.erasedTypes) appliedRef
+          else givenSelf match
+            case givenSelf @ EventuallyCapturingType(tp, _) =>
+              givenSelf.derivedAnnotatedType(tp & appliedRef, givenSelf.annot)
+            case _ =>
+              AndType(givenSelf, appliedRef)
+        }
+      selfTypeCache.nn
+    }
+
+    def appliedRef(using Context): Type = {
+      if (appliedRefCache == null)
+        appliedRefCache =
+          TypeRef(prefix, cls).appliedTo(cls.classDenot.typeParams.map(_.typeRef))
+      appliedRefCache.nn
+    }
+
+    // cached because baseType needs parents
+    private var parentsCache: List[Type] | Null = null
+
+    override def parents(using Context): List[Type] = {
+      if (parentsCache == null)
+        parentsCache = declaredParents.mapConserve(_.asSeenFrom(prefix, cls.owner))
+      parentsCache.nn
+    }
+
+    protected def newLikeThis(prefix: Type, declaredParents: List[Type], decls: Scope, selfInfo: TypeOrSymbol)(using Context): ClassInfo =
+      ClassInfo(prefix, cls, declaredParents, decls, selfInfo)
+
+    def derivedClassInfo(prefix: Type)(using Context): ClassInfo =
+      if (prefix eq this.prefix) this
+      else newLikeThis(prefix, declaredParents, decls, selfInfo)
+
+    def derivedClassInfo(prefix: Type = this.prefix, declaredParents: List[Type] = this.declaredParents, decls: Scope = this.decls, selfInfo: TypeOrSymbol = this.selfInfo)(using Context): ClassInfo =
+      if ((prefix eq this.prefix) && (declaredParents eq this.declaredParents) && (decls eq this.decls) && (selfInfo eq this.selfInfo)) this
+      else newLikeThis(prefix, declaredParents, decls, selfInfo)
+
+    /** If this class has opaque type alias members, a new class info
+     *  with their aliases added as refinements to the self type of the class.
+     *  Otherwise, this classInfo.
+     *  If there are opaque alias members, updates `cls` to have `Opaque` flag as a side effect.
+     */
+    def integrateOpaqueMembers(using Context): ClassInfo =
+      decls.toList.foldLeft(this) { (cinfo, sym) =>
+        if sym.isOpaqueAlias then
+          cls.setFlag(Opaque)
+          def force(using Context) =
+            if sym.isOpaqueAlias then // could have been reset because of a syntax error
+              sym.infoOrCompleter match
+                case completer: LazyType =>
+                  completer.complete(sym) // will update the LazyRef
+                  null                    // tells the LazyRef to use the updated value
+                case info => // can occur under cyclic references, e.g. i6225.scala
+                  defn.AnyType
+            else defn.AnyType         // dummy type in case of errors
+          def refineSelfType(selfType: Type) =
+            RefinedType(selfType, sym.name,
+              TypeAlias(
+                withMode(Mode.CheckCyclic)(
+                  LazyRef.of(force))))
+          cinfo.selfInfo match
+            case self: Type =>
+              cinfo.derivedClassInfo(
+                selfInfo = refineSelfType(self.orElse(defn.AnyType)))
+            case self: Symbol =>
+              self.info = refineSelfType(self.info)
+              cinfo
+        else cinfo
+      }
+
+    override def computeHash(bs: Binders  | Null): Int = doHash(bs, cls, prefix)
+    override def hashIsStable: Boolean = prefix.hashIsStable && declaredParents.hashIsStable
+
+    override def eql(that: Type): Boolean = that match {
+      case that: ClassInfo =>
+        prefix.eq(that.prefix) &&
+        cls.eq(that.cls) &&
+        declaredParents.eqElements(that.declaredParents) &&
+        decls.eq(that.decls) &&
+        selfInfo.eq(that.selfInfo)
+      case _ => false
+    }
+
+    override def equals(that: Any): Boolean = equals(that, null)
+
+    override def iso(that: Any, bs: BinderPairs): Boolean = that match {
+      case that: ClassInfo =>
+        prefix.equals(that.prefix, bs) &&
+        cls.eq(that.cls) &&
+        declaredParents.equalElements(that.declaredParents, bs) &&
+        decls.eq(that.decls) &&
+        selfInfo.eq(that.selfInfo)
+      case _ => false
+    }
+
+    override def toString: String = s"ClassInfo($prefix, $cls, $declaredParents)"
+  }
+
+  class CachedClassInfo(prefix: Type, cls: ClassSymbol, declaredParents: List[Type], decls: Scope, selfInfo: TypeOrSymbol)
+    extends ClassInfo(prefix, cls, declaredParents, decls, selfInfo)
+
+  /** A class for temporary class infos where `parents` are not yet known */
+  final class TempClassInfo(prefix: Type, cls: ClassSymbol, decls: Scope, selfInfo: TypeOrSymbol)
+  extends CachedClassInfo(prefix, cls, Nil, decls, selfInfo) {
+
+    /** Convert to classinfo with known parents */
+    def finalized(parents: List[Type])(using Context): ClassInfo =
+      ClassInfo(prefix, cls, parents, decls, selfInfo)
+
+    override def newLikeThis(prefix: Type, declaredParents: List[Type], decls: Scope, selfInfo: TypeOrSymbol)(using Context): ClassInfo =
+      TempClassInfo(prefix, cls, decls, selfInfo)
+
+    override def toString: String = s"TempClassInfo($prefix, $cls)"
+  }
+
+  object ClassInfo {
+    def apply(prefix: Type, cls: ClassSymbol, declaredParents: List[Type], decls: Scope, selfInfo: TypeOrSymbol = NoType)(using Context): ClassInfo =
+      unique(new CachedClassInfo(prefix, cls, declaredParents, decls, selfInfo))
+  }
+
+  /** Type bounds >: lo <: hi */
+  abstract case class TypeBounds(lo: Type, hi: Type) extends CachedProxyType with TypeType {
+
+    assert(lo.isInstanceOf[TermType], lo)
+    assert(hi.isInstanceOf[TermType], hi)
+
+    override def underlying(using Context): Type = hi
+
+    /** The non-alias type bounds type with given bounds */
+    def derivedTypeBounds(lo: Type, hi: Type)(using Context): TypeBounds =
+      if ((lo eq this.lo) && (hi eq this.hi)) this
+      else TypeBounds(lo, hi)
+
+    def contains(tp: Type)(using Context): Boolean = tp match {
+      case tp: TypeBounds => lo <:< tp.lo && tp.hi <:< hi
+      case tp: ClassInfo =>
+        val cls = tp.cls
+        // Note: Taking a normal typeRef does not work here. A normal ref might contain
+        // also other information about the named type (e.g. bounds).
+        contains(
+          TypeRef(tp.prefix, cls)
+            .withDenot(new UniqueRefDenotation(cls, tp, cls.validFor, tp.prefix)))
+      case _ =>
+        lo <:< tp && tp <:< hi
+    }
+
+    def & (that: TypeBounds)(using Context): TypeBounds =
+      // This will try to preserve the FromJavaObjects type in upper bounds.
+      // For example, (? <: FromJavaObjects | Null) & (? <: Any),
+      // we want to get (? <: FromJavaObjects | Null) intead of (? <: Any),
+      // because we may check the result <:< (? <: Object | Null) later.
+      if this.hi.containsFromJavaObject
+        && (this.hi frozen_<:< that.hi)
+        && (that.lo frozen_<:< this.lo) then
+        // FromJavaObject in tp1.hi guarantees tp2.hi <:< tp1.hi
+        // prefer tp1 if FromJavaObject is in its hi
+        this
+      else if that.hi.containsFromJavaObject
+        && (that.hi frozen_<:< this.hi)
+        && (this.lo frozen_<:< that.lo) then
+        // Similarly, prefer tp2 if FromJavaObject is in its hi
+        that
+      else if (this.lo frozen_<:< that.lo) && (that.hi frozen_<:< this.hi) then that
+      else if (that.lo frozen_<:< this.lo) && (this.hi frozen_<:< that.hi) then this
+      else TypeBounds(this.lo | that.lo, this.hi & that.hi)
+
+    def | (that: TypeBounds)(using Context): TypeBounds =
+      if ((this.lo frozen_<:< that.lo) && (that.hi frozen_<:< this.hi)) this
+      else if ((that.lo frozen_<:< this.lo) && (this.hi frozen_<:< that.hi)) that
+      else TypeBounds(this.lo & that.lo, this.hi | that.hi)
+
+    override def & (that: Type)(using Context): Type = that match {
+      case that: TypeBounds => this & that
+      case _ => super.& (that)
+    }
+
+    override def | (that: Type)(using Context): Type = that match {
+      case that: TypeBounds => this | that
+      case _ => super.| (that)
+    }
+
+    override def computeHash(bs: Binders): Int = doHash(bs, lo, hi)
+    override def hashIsStable: Boolean = lo.hashIsStable && hi.hashIsStable
+
+    override def equals(that: Any): Boolean = equals(that, null)
+
+    override def iso(that: Any, bs: BinderPairs): Boolean = that match {
+      case that: AliasingBounds => false
+      case that: TypeBounds => lo.equals(that.lo, bs) && hi.equals(that.hi, bs)
+      case _ => false
+    }
+
+    override def eql(that: Type): Boolean = that match {
+      case that: AliasingBounds => false
+      case that: TypeBounds => lo.eq(that.lo) && hi.eq(that.hi)
+      case _ => false
+    }
+  }
+
+  class RealTypeBounds(lo: Type, hi: Type) extends TypeBounds(lo, hi)
+
+  /** Common supertype of `TypeAlias` and `MatchAlias` */
+  abstract class AliasingBounds(val alias: Type) extends TypeBounds(alias, alias) {
+
+    def derivedAlias(alias: Type)(using Context): AliasingBounds
+
+    override def computeHash(bs: Binders): Int = doHash(bs, alias)
+    override def hashIsStable: Boolean = alias.hashIsStable
+
+    override def iso(that: Any, bs: BinderPairs): Boolean = that match {
+      case that: AliasingBounds => this.isTypeAlias == that.isTypeAlias && alias.equals(that.alias, bs)
+      case _ => false
+    }
+
+    // equals comes from case class; no matching override is needed
+
+    override def eql(that: Type): Boolean = that match {
+      case that: AliasingBounds => this.isTypeAlias == that.isTypeAlias && alias.eq(that.alias)
+      case _ => false
+    }
+  }
+
+  /**    = T
+   */
+  class TypeAlias(alias: Type) extends AliasingBounds(alias) {
+    def derivedAlias(alias: Type)(using Context): AliasingBounds =
+      if (alias eq this.alias) this else TypeAlias(alias)
+  }
+
+  /**    = T     where `T` is a `MatchType`
+   *
+   *  Match aliases are treated differently from type aliases. Their sides are mutually
+   *  subtypes of each other but one side is not generally substitutable for the other.
+   *  If we assumed full substitutivity, we would have to reject all recursive match
+   *  aliases (or else take the jump and allow full recursive types).
+   */
+  class MatchAlias(alias: Type) extends AliasingBounds(alias) {
+    def derivedAlias(alias: Type)(using Context): AliasingBounds =
+      if (alias eq this.alias) this else MatchAlias(alias)
+  }
+
+  object TypeBounds {
+    def apply(lo: Type, hi: Type)(using Context): TypeBounds =
+      unique(new RealTypeBounds(lo, hi))
+    def empty(using Context): TypeBounds =
+      val result = ctx.base.emptyTypeBounds
+      if result == null then
+        ctx.base.emptyTypeBounds = apply(defn.NothingType, defn.AnyType)
+        empty
+      else
+        result
+    def emptyPolyKind(using Context): TypeBounds = apply(defn.NothingType, defn.AnyKindType)
+    def upper(hi: Type)(using Context): TypeBounds = apply(defn.NothingType, hi)
+    def lower(lo: Type)(using Context): TypeBounds = apply(lo, defn.AnyType)
+  }
+
+  object TypeAlias {
+    def apply(alias: Type)(using Context): TypeAlias = unique(new TypeAlias(alias))
+    def unapply(tp: TypeAlias): Option[Type] = Some(tp.alias)
+  }
+
+  object MatchAlias {
+    def apply(alias: Type)(using Context): MatchAlias = unique(new MatchAlias(alias))
+    def unapply(tp: MatchAlias): Option[Type] = Some(tp.alias)
+  }
+
+  // ----- Annotated and Import types -----------------------------------------------
+
+  /** An annotated type tpe @ annot */
+  abstract case class AnnotatedType(parent: Type, annot: Annotation) extends CachedProxyType, ValueType {
+
+    override def underlying(using Context): Type = parent
+
+    def derivedAnnotatedType(parent: Type, annot: Annotation)(using Context): AnnotatedType =
+      if ((parent eq this.parent) && (annot eq this.annot)) this
+      else AnnotatedType(parent, annot)
+
+    override def stripTypeVar(using Context): Type =
+      derivedAnnotatedType(parent.stripTypeVar, annot)
+
+    override def stripAnnots(using Context): Type = parent.stripAnnots
+
+    override def stripped(using Context): Type = parent.stripped
+
+    private var isRefiningKnown = false
+    private var isRefiningCache: Boolean = _
+
+    def isRefining(using Context): Boolean = {
+      if (!isRefiningKnown) {
+        isRefiningCache = annot.symbol.derivesFrom(defn.RefiningAnnotationClass)
+        isRefiningKnown = true
+      }
+      isRefiningCache
+    }
+
+    // equals comes from case class; no matching override is needed
+
+    override def computeHash(bs: Binders): Int =
+      doHash(bs, annot.hash, parent)
+    override def hashIsStable: Boolean =
+      parent.hashIsStable
+
+    override def eql(that: Type): Boolean = that match
+      case that: AnnotatedType => (parent eq that.parent) && (annot eql that.annot)
+      case _ => false
+
+    override def iso(that: Any, bs: BinderPairs): Boolean = that match
+      case that: AnnotatedType => parent.equals(that.parent, bs) && (annot eql that.annot)
+      case _ => false
+  }
+
+  class CachedAnnotatedType(parent: Type, annot: Annotation) extends AnnotatedType(parent, annot)
+
+  object AnnotatedType:
+    def make(underlying: Type, annots: List[Annotation])(using Context): Type =
+      annots.foldLeft(underlying)(apply(_, _))
+    def apply(parent: Type, annot: Annotation)(using Context): AnnotatedType =
+      unique(CachedAnnotatedType(parent, annot))
+  end AnnotatedType
+
+  // Special type objects and classes -----------------------------------------------------
+
+  /** The type of an erased array */
+  abstract case class JavaArrayType(elemType: Type) extends CachedGroundType with ValueType {
+    def derivedJavaArrayType(elemtp: Type)(using Context): JavaArrayType =
+      if (elemtp eq this.elemType) this else JavaArrayType(elemtp)
+
+    override def computeHash(bs: Binders): Int = doHash(bs, elemType)
+    override def hashIsStable: Boolean = elemType.hashIsStable
+
+    override def eql(that: Type): Boolean = that match {
+      case that: JavaArrayType => elemType.eq(that.elemType)
+      case _ => false
+    }
+  }
+  final class CachedJavaArrayType(elemType: Type) extends JavaArrayType(elemType)
+  object JavaArrayType {
+    def apply(elemType: Type)(using Context): JavaArrayType = unique(new CachedJavaArrayType(elemType))
+  }
+
+  /** The type of an import clause tree */
+  case class ImportType(expr: Tree) extends UncachedGroundType
+
+  /** Sentinel for "missing type" */
+  @sharable case object NoType extends CachedGroundType {
+    override def computeHash(bs: Binders): Int = hashSeed
+  }
+
+  /** Missing prefix */
+  @sharable case object NoPrefix extends CachedGroundType {
+    override def computeHash(bs: Binders): Int = hashSeed
+  }
+
+  /** A common superclass of `ErrorType` and `TryDynamicCallSite`. Instances of this
+   *  class are at the same time subtypes and supertypes of every other type.
+   */
+  abstract class FlexType extends UncachedGroundType with ValueType
+
+  abstract class ErrorType extends FlexType {
+    def msg(using Context): Message
+  }
+
+  object ErrorType:
+    def apply(m: Message)(using Context): ErrorType =
+      val et = new PreviousErrorType
+      ctx.base.errorTypeMsg(et) = m
+      et
+    def apply(s: -> String)(using Context): ErrorType =
+      apply(s.toMessage)
+  end ErrorType
+
+  class PreviousErrorType extends ErrorType:
+    def msg(using Context): Message =
+      ctx.base.errorTypeMsg.get(this) match
+        case Some(m) => m
+        case None => "error message from previous run no longer available".toMessage
+
+  object UnspecifiedErrorType extends ErrorType {
+    override def msg(using Context): Message = "unspecified error".toMessage
+  }
+
+  /* Type used to track Select nodes that could not resolve a member and their qualifier is a scala.Dynamic. */
+  object TryDynamicCallType extends FlexType
+
+  /** Wildcard type, possibly with bounds */
+  abstract case class WildcardType(optBounds: Type) extends CachedGroundType with TermType {
+
+    def effectiveBounds(using Context): TypeBounds = optBounds match
+      case bounds: TypeBounds => bounds
+      case _ => TypeBounds.empty
+
+    def derivedWildcardType(optBounds: Type)(using Context): WildcardType =
+      if (optBounds eq this.optBounds) this
+      else if (!optBounds.exists) WildcardType
+      else WildcardType(optBounds.asInstanceOf[TypeBounds])
+
+    override def computeHash(bs: Binders): Int = doHash(bs, optBounds)
+    override def hashIsStable: Boolean = optBounds.hashIsStable
+
+    override def eql(that: Type): Boolean = that match {
+      case that: WildcardType => optBounds.eq(that.optBounds)
+      case _ => false
+    }
+
+    // equals comes from case class; no matching override is needed
+
+    override def iso(that: Any, bs: BinderPairs): Boolean = that match {
+      case that: WildcardType => optBounds.equals(that.optBounds, bs)
+      case _ => false
+    }
+  }
+
+  final class CachedWildcardType(optBounds: Type) extends WildcardType(optBounds)
+
+  @sharable object WildcardType extends WildcardType(NoType) {
+    def apply(bounds: TypeBounds)(using Context): WildcardType =
+      if bounds eq TypeBounds.empty then
+        val result = ctx.base.emptyWildcardBounds
+        if result == null then
+          ctx.base.emptyWildcardBounds = unique(CachedWildcardType(bounds))
+          apply(bounds)
+        else
+          result
+      else unique(CachedWildcardType(bounds))
+  }
+
+  /** An extractor for single abstract method types.
+   *  A type is a SAM type if it is a reference to a class or trait, which
+   *
+   *   - has a single abstract method with a method type (ExprType
+   *     and PolyType not allowed!) whose result type is not an implicit function type
+   *     and which is not marked inline.
+   *   - can be instantiated without arguments or with just () as argument.
+   *
+   *  The pattern `SAMType(sam)` matches a SAM type, where `sam` is the
+   *  type of the single abstract method.
+   */
+  object SAMType {
+    def zeroParamClass(tp: Type)(using Context): Type = tp match {
+      case tp: ClassInfo =>
+        def zeroParams(tp: Type): Boolean = tp.stripPoly match {
+          case mt: MethodType => mt.paramInfos.isEmpty && !mt.resultType.isInstanceOf[MethodType]
+          case et: ExprType => true
+          case _ => false
+        }
+        // `ContextFunctionN` does not have constructors
+        val ctor = tp.cls.primaryConstructor
+        if (!ctor.exists || zeroParams(ctor.info)) tp
+        else NoType
+      case tp: AppliedType =>
+        zeroParamClass(tp.superType)
+      case tp: TypeRef =>
+        zeroParamClass(tp.underlying)
+      case tp: RefinedType =>
+        zeroParamClass(tp.underlying)
+      case tp: TypeBounds =>
+        zeroParamClass(tp.underlying)
+      case tp: TypeVar =>
+        zeroParamClass(tp.underlying)
+      case tp: AnnotatedType =>
+        zeroParamClass(tp.underlying)
+      case _ =>
+        NoType
+    }
+    def isInstantiatable(tp: Type)(using Context): Boolean = zeroParamClass(tp) match {
+      case cinfo: ClassInfo if !cinfo.cls.isOneOf(FinalOrSealed) =>
+        val selfType = cinfo.selfType.asSeenFrom(tp, cinfo.cls)
+        tp <:< selfType
+      case _ =>
+        false
+    }
+    def unapply(tp: Type)(using Context): Option[MethodType] =
+      if (isInstantiatable(tp)) {
+        val absMems = tp.possibleSamMethods
+        if (absMems.size == 1)
+          absMems.head.info match {
+            case mt: MethodType if !mt.isParamDependent &&
+                !defn.isContextFunctionType(mt.resultType) =>
+              val cls = tp.classSymbol
+
+              // Given a SAM type such as:
+              //
+              //     import java.util.function.Function
+              //     Function[? >: String, ? <: Int]
+              //
+              // the single abstract method will have type:
+              //
+              //     (x: Function[? >: String, ? <: Int]#T): Function[? >: String, ? <: Int]#R
+              //
+              // which is not implementable outside of the scope of Function.
+              //
+              // To avoid this kind of issue, we approximate references to
+              // parameters of the SAM type by their bounds, this way in the
+              // above example we get:
+              //
+              //    (x: String): Int
+              val approxParams = new ApproximatingTypeMap {
+                def apply(tp: Type): Type = tp match {
+                  case tp: TypeRef if tp.symbol.isAllOf(ClassTypeParam) && tp.symbol.owner == cls =>
+                    tp.info match {
+                      case info: AliasingBounds =>
+                        mapOver(info.alias)
+                      case TypeBounds(lo, hi) =>
+                        range(atVariance(-variance)(apply(lo)), apply(hi))
+                      case _ =>
+                        range(defn.NothingType, defn.AnyType) // should happen only in error cases
+                    }
+                  case _ =>
+                    mapOver(tp)
+                }
+              }
+              val approx =
+                if ctx.owner.isContainedIn(cls) then mt
+                else approxParams(mt).asInstanceOf[MethodType]
+              Some(approx)
+            case _ =>
+              None
+          }
+        else if (tp isRef defn.PartialFunctionClass)
+          // To maintain compatibility with 2.x, we treat PartialFunction specially,
+          // pretending it is a SAM type. In the future it would be better to merge
+          // Function and PartialFunction, have Function1 contain a isDefinedAt method
+          //     def isDefinedAt(x: T) = true
+          // and overwrite that method whenever the function body is a sequence of
+          // case clauses.
+          absMems.find(_.symbol.name == nme.apply).map(_.info.asInstanceOf[MethodType])
+        else None
+      }
+      else None
+  }
+
+  // ----- TypeMaps --------------------------------------------------------------------
+
+  /** Where a traversal should stop */
+  enum StopAt:
+    case None    // traverse everything
+    case Package // stop at package references
+    case Static  // stop at static references
+
+  /** Common base class of TypeMap and TypeAccumulator */
+  abstract class VariantTraversal:
+    protected[dotc] var variance: Int = 1
+
+    inline protected def atVariance[T](v: Int)(op: => T): T = {
+      val saved = variance
+      variance = v
+      val res = op
+      variance = saved
+      res
+    }
+
+    protected def stopAt: StopAt = StopAt.Static
+
+    /** Can the prefix of this static reference be omitted if the reference
+     *  itself can be omitted? Overridden in TypeOps#avoid.
+     */
+    protected def isStaticPrefix(pre: Type)(using Context): Boolean = true
+
+    protected def stopBecauseStaticOrLocal(tp: NamedType)(using Context): Boolean =
+      (tp.prefix eq NoPrefix)
+      || {
+        val stop = stopAt
+        stop == StopAt.Static && tp.currentSymbol.isStatic && isStaticPrefix(tp.prefix)
+        || stop == StopAt.Package && tp.currentSymbol.is(Package)
+      }
+  end VariantTraversal
+
+  /** A supertrait for some typemaps that are bijections. Used for capture checking.
+   *  BiTypeMaps should map capture references to capture references.
+   */
+  trait BiTypeMap extends TypeMap:
+    thisMap =>
+
+    /** The inverse of the type map as a function */
+    def inverse(tp: Type): Type
+
+    /** The inverse of the type map as a BiTypeMap map, which
+     *  has the original type map as its own inverse.
+     */
+    def inverseTypeMap(using Context) = new BiTypeMap:
+      def apply(tp: Type) = thisMap.inverse(tp)
+      def inverse(tp: Type) = thisMap.apply(tp)
+
+    /** A restriction of this map to a function on tracked CaptureRefs */
+    def forward(ref: CaptureRef): CaptureRef = this(ref) match
+      case result: CaptureRef if result.canBeTracked => result
+
+    /** A restriction of the inverse to a function on tracked CaptureRefs */
+    def backward(ref: CaptureRef): CaptureRef = inverse(ref) match
+      case result: CaptureRef if result.canBeTracked => result
+  end BiTypeMap
+
+  abstract class TypeMap(implicit protected var mapCtx: Context)
+  extends VariantTraversal with (Type -> Type) { thisMap: TypeMap =>
+
+    def apply(tp: Type): Type
+
+    protected def derivedSelect(tp: NamedType, pre: Type): Type =
+      tp.derivedSelect(pre)
+    protected def derivedRefinedType(tp: RefinedType, parent: Type, info: Type): Type =
+      tp.derivedRefinedType(parent, tp.refinedName, info)
+    protected def derivedRecType(tp: RecType, parent: Type): Type =
+      tp.rebind(parent)
+    protected def derivedAlias(tp: AliasingBounds, alias: Type): Type =
+      tp.derivedAlias(alias)
+    protected def derivedTypeBounds(tp: TypeBounds, lo: Type, hi: Type): Type =
+      tp.derivedTypeBounds(lo, hi)
+    protected def derivedSuperType(tp: SuperType, thistp: Type, supertp: Type): Type =
+      tp.derivedSuperType(thistp, supertp)
+    protected def derivedAppliedType(tp: AppliedType, tycon: Type, args: List[Type]): Type =
+      tp.derivedAppliedType(tycon, args)
+    protected def derivedAndType(tp: AndType, tp1: Type, tp2: Type): Type =
+      tp.derivedAndType(tp1, tp2)
+    protected def derivedOrType(tp: OrType, tp1: Type, tp2: Type): Type =
+      tp.derivedOrType(tp1, tp2)
+    protected def derivedMatchType(tp: MatchType, bound: Type, scrutinee: Type, cases: List[Type]): Type =
+      tp.derivedMatchType(bound, scrutinee, cases)
+    protected def derivedAnnotatedType(tp: AnnotatedType, underlying: Type, annot: Annotation): Type =
+      tp.derivedAnnotatedType(underlying, annot)
+    protected def derivedCapturingType(tp: Type, parent: Type, refs: CaptureSet): Type =
+      tp.derivedCapturingType(parent, refs)
+    protected def derivedWildcardType(tp: WildcardType, bounds: Type): Type =
+      tp.derivedWildcardType(bounds)
+    protected def derivedSkolemType(tp: SkolemType, info: Type): Type =
+      tp.derivedSkolemType(info)
+    protected def derivedClassInfo(tp: ClassInfo, pre: Type): Type =
+      tp.derivedClassInfo(pre)
+    protected def derivedJavaArrayType(tp: JavaArrayType, elemtp: Type): Type =
+      tp.derivedJavaArrayType(elemtp)
+    protected def derivedExprType(tp: ExprType, restpe: Type): Type =
+      tp.derivedExprType(restpe)
+    // note: currying needed  because Scala2 does not support param-dependencies
+    protected def derivedLambdaType(tp: LambdaType)(formals: List[tp.PInfo], restpe: Type): Type =
+      tp.derivedLambdaType(tp.paramNames, formals, restpe)
+
+    protected def mapArgs(args: List[Type], tparams: List[ParamInfo]): List[Type] = args match
+      case arg :: otherArgs if tparams.nonEmpty =>
+        val arg1 = arg match
+          case arg: TypeBounds => this(arg)
+          case arg => atVariance(variance * tparams.head.paramVarianceSign)(this(arg))
+        val otherArgs1 = mapArgs(otherArgs, tparams.tail)
+        if ((arg1 eq arg) && (otherArgs1 eq otherArgs)) args
+        else arg1 :: otherArgs1
+      case nil =>
+        nil
+
+    protected def mapOverLambda(tp: LambdaType) =
+      val restpe = tp.resultType
+      val saved = variance
+      variance = if (defn.MatchCase.isInstance(restpe)) 0 else -variance
+      val ptypes1 = tp.paramInfos.mapConserve(this).asInstanceOf[List[tp.PInfo]]
+      variance = saved
+      derivedLambdaType(tp)(ptypes1, this(restpe))
+
+    def isRange(tp: Type): Boolean = tp.isInstanceOf[Range]
+
+    protected def mapCapturingType(tp: Type, parent: Type, refs: CaptureSet, v: Int): Type =
+      val saved = variance
+      variance = v
+      try derivedCapturingType(tp, this(parent), refs.map(this))
+      finally variance = saved
+
+    /** Map this function over given type */
+    def mapOver(tp: Type): Type = {
+      record(s"TypeMap mapOver ${getClass}")
+      record("TypeMap mapOver total")
+      val ctx = this.mapCtx // optimization for performance
+      given Context = ctx
+      tp match {
+        case tp: NamedType =>
+          if stopBecauseStaticOrLocal(tp) then tp
+          else
+            val prefix1 = atVariance(variance max 0)(this(tp.prefix))
+              // A prefix is never contravariant. Even if say `p.A` is used in a contravariant
+              // context, we cannot assume contravariance for `p` because `p`'s lower
+              // bound might not have a binding for `A` (e.g. the lower bound could be `Nothing`).
+              // By contrast, covariance does translate to the prefix, since we have that
+              // if `p <: q` then `p.A <: q.A`, and well-formedness requires that `A` is a member
+              // of `p`'s upper bound.
+            derivedSelect(tp, prefix1)
+
+        case tp: AppliedType =>
+          derivedAppliedType(tp, this(tp.tycon), mapArgs(tp.args, tp.tyconTypeParams))
+
+        case tp: LambdaType =>
+          mapOverLambda(tp)
+
+        case tp: AliasingBounds =>
+          derivedAlias(tp, atVariance(0)(this(tp.alias)))
+
+        case tp: TypeBounds =>
+          variance = -variance
+          val lo1 = this(tp.lo)
+          variance = -variance
+          derivedTypeBounds(tp, lo1, this(tp.hi))
+
+        case tp: TypeVar =>
+          val inst = tp.instanceOpt
+          if (inst.exists) apply(inst) else tp
+
+        case tp: ExprType =>
+          derivedExprType(tp, this(tp.resultType))
+
+        case CapturingType(parent, refs) =>
+          mapCapturingType(tp, parent, refs, variance)
+
+        case tp @ AnnotatedType(underlying, annot) =>
+          val underlying1 = this(underlying)
+          val annot1 = annot.mapWith(this)
+          if annot1 eq EmptyAnnotation then underlying1
+          else derivedAnnotatedType(tp, underlying1, annot1)
+
+        case _: ThisType
+          | _: BoundType
+          | NoPrefix =>
+          tp
+
+        case tp: ProtoType =>
+          tp.map(this)
+
+        case tp: RefinedType =>
+          derivedRefinedType(tp, this(tp.parent), this(tp.refinedInfo))
+
+        case tp: RecType =>
+          record("TypeMap.RecType")
+          derivedRecType(tp, this(tp.parent))
+
+        case tp @ SuperType(thistp, supertp) =>
+          derivedSuperType(tp, this(thistp), this(supertp))
+
+        case tp: LazyRef =>
+          LazyRef { refCtx =>
+            given Context = refCtx
+            val ref1 = tp.ref
+            if refCtx.runId == mapCtx.runId then this(ref1)
+            else // splice in new run into map context
+              val saved = mapCtx
+              mapCtx = mapCtx.fresh
+                .setPeriod(Period(refCtx.runId, mapCtx.phaseId))
+                .setRun(refCtx.run)
+              try this(ref1) finally mapCtx = saved
+          }
+
+        case tp: ClassInfo =>
+          mapClassInfo(tp)
+
+        case tp: AndType =>
+          derivedAndType(tp, this(tp.tp1), this(tp.tp2))
+
+        case tp: OrType =>
+          derivedOrType(tp, this(tp.tp1), this(tp.tp2))
+
+        case tp: MatchType =>
+          val bound1 = this(tp.bound)
+          val scrut1 = atVariance(0)(this(tp.scrutinee))
+          derivedMatchType(tp, bound1, scrut1, tp.cases.mapConserve(this))
+
+        case tp: SkolemType =>
+          derivedSkolemType(tp, this(tp.info))
+
+        case tp: WildcardType =>
+          derivedWildcardType(tp, mapOver(tp.optBounds))
+
+        case tp: JavaArrayType =>
+          derivedJavaArrayType(tp, this(tp.elemType))
+
+        case _ =>
+          tp
+      }
+    }
+
+    private def treeTypeMap = new TreeTypeMap(typeMap = this)
+
+    def mapOver(syms: List[Symbol]): List[Symbol] = mapSymbols(syms, treeTypeMap)
+
+    def mapOver(scope: Scope): Scope = {
+      val elems = scope.toList
+      val elems1 = mapOver(elems)
+      if (elems1 eq elems) scope
+      else newScopeWith(elems1: _*)
+    }
+
+    def mapOver(tree: Tree): Tree = treeTypeMap(tree)
+
+    /** Can be overridden. By default, only the prefix is mapped. */
+    protected def mapClassInfo(tp: ClassInfo): Type =
+      derivedClassInfo(tp, this(tp.prefix))
+
+    def andThen(f: Type -> Type): TypeMap = new TypeMap {
+      override def stopAt = thisMap.stopAt
+      def apply(tp: Type) = f(thisMap(tp))
+    }
+  }
+
+  /** A type map that maps also parents and self type of a ClassInfo */
+  abstract class DeepTypeMap(using Context) extends TypeMap {
+    override def mapClassInfo(tp: ClassInfo): ClassInfo = {
+      val prefix1 = this(tp.prefix)
+      val parents1 = tp.declaredParents mapConserve this
+      val selfInfo1: TypeOrSymbol = tp.selfInfo match {
+        case selfInfo: Type => this(selfInfo)
+        case selfInfo => selfInfo
+      }
+      tp.derivedClassInfo(prefix1, parents1, tp.decls, selfInfo1)
+    }
+  }
+
+  @sharable object IdentityTypeMap extends TypeMap()(NoContext) {
+    def apply(tp: Type): Type = tp
+  }
+
+  /** A type map that approximates TypeBounds types depending on
+   *  variance.
+   *
+   *  if variance > 0 : approximate by upper bound
+   *     variance < 0 : approximate by lower bound
+   *     variance = 0 : propagate bounds to next outer level
+   */
+  abstract class ApproximatingTypeMap(using Context) extends TypeMap { thisMap =>
+
+    protected def range(lo: Type, hi: Type): Type =
+      if (variance > 0) hi
+      else if (variance < 0) lo
+      else if (lo `eq` hi) lo
+      else Range(lower(lo), upper(hi))
+
+    protected def emptyRange = range(defn.NothingType, defn.AnyType)
+
+    protected def lower(tp: Type): Type = tp match {
+      case tp: Range => tp.lo
+      case _ => tp
+    }
+
+    protected def upper(tp: Type): Type = tp match {
+      case tp: Range => tp.hi
+      case _ => tp
+    }
+
+    protected def rangeToBounds(tp: Type): Type = tp match {
+      case Range(lo, hi) => TypeBounds(lo, hi)
+      case _ => tp
+    }
+
+    private var expandingBounds: Boolean = false
+
+    /** Use an alterate type `tp` that replaces a range. This can happen if the
+     *  prefix of a Select is a range and the selected symbol is an alias type
+     *  or a value with a singleton type. In both cases we can forget the prefix
+     *  and use the symbol's type.
+     */
+    protected def useAlternate(tp: Type): Type = reapply(tp)
+
+    /** Whether it is currently expanding bounds
+     *
+     *  It is used to avoid following LazyRef in F-Bounds
+     */
+    def isExpandingBounds: Boolean = expandingBounds
+
+    protected def expandBounds(tp: TypeBounds): Type =
+      val saved = expandingBounds
+      expandingBounds = true
+      val res = range(atVariance(-variance)(reapply(tp.lo)), reapply(tp.hi))
+      expandingBounds = saved
+      res
+
+    /** Try to widen a named type to its info relative to given prefix `pre`, where possible.
+     *  The possible cases are listed inline in the code.
+     */
+    def tryWiden(tp: NamedType, pre: Type): Type = pre.member(tp.name) match {
+      case d: SingleDenotation =>
+        val tp1 = d.info.dealiasKeepAnnots
+        tp1.stripAnnots match {
+          case TypeAlias(alias) =>
+            // if H#T = U, then for any x in L..H, x.T =:= U,
+            // hence we can replace with U under all variances
+            useAlternate(alias.rewrapAnnots(tp1))
+          case bounds: TypeBounds =>
+            // If H#T = ? >: S <: U, then for any x in L..H, S <: x.T <: U,
+            // hence we can replace with S..U under all variances
+            expandBounds(bounds)
+          case info: SingletonType =>
+            // if H#x: y.type, then for any x in L..H, x.type =:= y.type,
+            // hence we can replace with y.type under all variances
+            useAlternate(info)
+          case _ =>
+            NoType
+        }
+      case _ => NoType
+    }
+
+    /** Expand parameter reference corresponding to prefix `pre`;
+     *  If the expansion is a wildcard parameter reference, convert its
+     *  underlying bounds to a range, otherwise return the expansion.
+     */
+    def expandParam(tp: NamedType, pre: Type): Type =
+      tp.argForParam(pre) match {
+        case arg @ TypeRef(pre, _) if pre.isArgPrefixOf(arg.symbol) =>
+          arg.info match {
+            case argInfo: TypeBounds => expandBounds(argInfo)
+            case argInfo => useAlternate(arg)
+          }
+        case arg: TypeBounds => expandBounds(arg)
+        case arg => useAlternate(arg)
+      }
+
+    /** Derived selection.
+     *  @pre   the (upper bound of) prefix `pre` has a member named `tp.name`.
+     */
+    override protected def derivedSelect(tp: NamedType, pre: Type): Type =
+      if (pre eq tp.prefix) tp
+      else pre match {
+        case Range(preLo, preHi) =>
+          val forwarded =
+            if (tp.symbol.isAllOf(ClassTypeParam)) expandParam(tp, preHi)
+            else tryWiden(tp, preHi)
+          forwarded.orElse(
+            range(super.derivedSelect(tp, preLo).loBound, super.derivedSelect(tp, preHi).hiBound))
+        case _ =>
+          super.derivedSelect(tp, pre) match {
+            case TypeBounds(lo, hi) => range(lo, hi)
+            case tp => tp
+          }
+      }
+
+    override protected def derivedRefinedType(tp: RefinedType, parent: Type, info: Type): Type =
+      if ((parent eq tp.parent) && (info eq tp.refinedInfo)) tp
+      else parent match {
+        case Range(parentLo, parentHi) =>
+          range(derivedRefinedType(tp, parentLo, info), derivedRefinedType(tp, parentHi, info))
+        case _ =>
+          def propagate(lo: Type, hi: Type) =
+            range(derivedRefinedType(tp, parent, lo), derivedRefinedType(tp, parent, hi))
+          if (parent.isExactlyNothing) parent
+          else info match {
+            case Range(infoLo: TypeBounds, infoHi: TypeBounds) =>
+              assert(variance == 0)
+              if (!infoLo.isTypeAlias && !infoHi.isTypeAlias) propagate(infoLo, infoHi)
+              else range(defn.NothingType, parent)
+            case Range(infoLo, infoHi) =>
+              propagate(infoLo, infoHi)
+            case _ =>
+              tp.derivedRefinedType(parent, tp.refinedName, info)
+          }
+      }
+
+    override protected def derivedRecType(tp: RecType, parent: Type): Type =
+      if (parent eq tp.parent) tp
+      else parent match {
+        case Range(lo, hi) => range(tp.rebind(lo), tp.rebind(hi))
+        case _ => tp.rebind(parent)
+      }
+
+    override protected def derivedAlias(tp: AliasingBounds, alias: Type): Type =
+      if (alias eq tp.alias) tp
+      else alias match {
+        case Range(lo, hi) =>
+          if (variance > 0) TypeBounds(lo, hi)
+          else range(tp.derivedAlias(lo), tp.derivedAlias(hi))
+        case _ => tp.derivedAlias(alias)
+      }
+
+    override protected def derivedTypeBounds(tp: TypeBounds, lo: Type, hi: Type): Type =
+      if ((lo eq tp.lo) && (hi eq tp.hi)) tp
+      else if (isRange(lo) || isRange(hi))
+        if (variance > 0) TypeBounds(lower(lo), upper(hi))
+        else range(TypeBounds(upper(lo), lower(hi)), TypeBounds(lower(lo), upper(hi)))
+      else tp.derivedTypeBounds(lo, hi)
+
+    override protected def derivedSuperType(tp: SuperType, thistp: Type, supertp: Type): Type =
+      if (isRange(thistp) || isRange(supertp)) emptyRange
+      else tp.derivedSuperType(thistp, supertp)
+
+    override protected def derivedAppliedType(tp: AppliedType, tycon: Type, args: List[Type]): Type =
+      tycon match {
+        case Range(tyconLo, tyconHi) =>
+          range(derivedAppliedType(tp, tyconLo, args), derivedAppliedType(tp, tyconHi, args))
+        case _ =>
+          if args.exists(isRange) then
+            if variance > 0 then
+              tp.derivedAppliedType(tycon, args.map(rangeToBounds)) match
+                case tp1: AppliedType if tp1.isUnreducibleWild && ctx.phase != checkCapturesPhase =>
+                  // don't infer a type that would trigger an error later in
+                  // Checking.checkAppliedType; fall through to default handling instead
+                case tp1 =>
+                  return tp1
+            end if
+            val loBuf, hiBuf = new mutable.ListBuffer[Type]
+            // Given `C[A1, ..., An]` where some A's are ranges, try to find
+            // non-range arguments L1, ..., Ln and H1, ..., Hn such that
+            // C[L1, ..., Ln] <: C[H1, ..., Hn] by taking the right limits of
+            // ranges that appear in as co- or contravariant arguments.
+            // Fail for non-variant argument ranges (see use-site else branch below).
+            // If successful, the L-arguments are in loBut, the H-arguments in hiBuf.
+            // @return  operation succeeded for all arguments.
+            def distributeArgs(args: List[Type], tparams: List[ParamInfo]): Boolean = args match {
+              case Range(lo, hi) :: args1 =>
+                val v = tparams.head.paramVarianceSign
+                if (v == 0) false
+                else {
+                  if (v > 0) { loBuf += lo; hiBuf += hi }
+                  else { loBuf += hi; hiBuf += lo }
+                  distributeArgs(args1, tparams.tail)
+                }
+              case arg :: args1 =>
+                loBuf += arg; hiBuf += arg
+                distributeArgs(args1, tparams.tail)
+              case nil =>
+                true
+            }
+            if (distributeArgs(args, tp.tyconTypeParams))
+              range(tp.derivedAppliedType(tycon, loBuf.toList),
+                    tp.derivedAppliedType(tycon, hiBuf.toList))
+            else if tycon.isLambdaSub || args.exists(isRangeOfNonTermTypes) then
+              range(defn.NothingType, defn.AnyType)
+            else
+              // See lampepfl/dotty#14152
+              range(defn.NothingType, tp.derivedAppliedType(tycon, args.map(rangeToBounds)))
+          else tp.derivedAppliedType(tycon, args)
+      }
+
+    private def isRangeOfNonTermTypes(tp: Type): Boolean = tp match
+      case Range(lo, hi) => !lo.isInstanceOf[TermType] || !hi.isInstanceOf[TermType]
+      case _             => false
+
+    override protected def derivedAndType(tp: AndType, tp1: Type, tp2: Type): Type =
+      if (isRange(tp1) || isRange(tp2)) range(lower(tp1) & lower(tp2), upper(tp1) & upper(tp2))
+      else tp.derivedAndType(tp1, tp2)
+
+    override protected def derivedOrType(tp: OrType, tp1: Type, tp2: Type): Type =
+      if (isRange(tp1) || isRange(tp2)) range(lower(tp1) | lower(tp2), upper(tp1) | upper(tp2))
+      else tp.derivedOrType(tp1, tp2)
+
+    override protected def derivedAnnotatedType(tp: AnnotatedType, underlying: Type, annot: Annotation): Type =
+      underlying match {
+        case Range(lo, hi) =>
+          range(tp.derivedAnnotatedType(lo, annot), tp.derivedAnnotatedType(hi, annot))
+        case _ =>
+          if (underlying.isExactlyNothing) underlying
+          else tp.derivedAnnotatedType(underlying, annot)
+      }
+    override protected def derivedCapturingType(tp: Type, parent: Type, refs: CaptureSet): Type =
+      parent match // TODO ^^^ handle ranges in capture sets as well
+        case Range(lo, hi) =>
+          range(derivedCapturingType(tp, lo, refs), derivedCapturingType(tp, hi, refs))
+        case _ =>
+          tp.derivedCapturingType(parent, refs)
+
+    override protected def derivedWildcardType(tp: WildcardType, bounds: Type): WildcardType =
+      tp.derivedWildcardType(rangeToBounds(bounds))
+
+    override protected def derivedMatchType(tp: MatchType, bound: Type, scrutinee: Type, cases: List[Type]): Type =
+      bound match
+        case Range(lo, hi) =>
+          range(derivedMatchType(tp, lo, scrutinee, cases), derivedMatchType(tp, hi, scrutinee, cases))
+        case _ =>
+          scrutinee match
+            case Range(lo, hi) => range(bound.bounds.lo, bound.bounds.hi)
+            case _ =>
+              if cases.exists(isRange) then
+                Range(
+                  tp.derivedMatchType(bound, scrutinee, cases.map(lower)),
+                  tp.derivedMatchType(bound, scrutinee, cases.map(upper)))
+              else
+                tp.derivedMatchType(bound, scrutinee, cases)
+
+    override protected def derivedSkolemType(tp: SkolemType, info: Type): Type =
+      if info eq tp.info then tp
+      // By definition, a skolem is neither a subtype nor a supertype of a
+      // different skolem. So, regardless of `variance`, we cannot return a
+      // fresh skolem when approximating an existing skolem, we can only return
+      // a range.
+      else range(defn.NothingType, info)
+
+    override protected def derivedClassInfo(tp: ClassInfo, pre: Type): Type = {
+      assert(!isRange(pre))
+        // we don't know what to do here; this case has to be handled in subclasses
+        // (typically by handling ClassInfo's specially, in case they can be encountered).
+      tp.derivedClassInfo(pre)
+    }
+
+    override protected def derivedLambdaType(tp: LambdaType)(formals: List[tp.PInfo], restpe: Type): Type =
+      restpe match {
+        case Range(lo, hi) =>
+          range(derivedLambdaType(tp)(formals, lo), derivedLambdaType(tp)(formals, hi))
+        case _ =>
+          if formals.exists(isRange) then
+            range(
+              derivedLambdaType(tp)(formals.map(upper(_).asInstanceOf[tp.PInfo]), restpe),
+              derivedLambdaType(tp)(formals.map(lower(_).asInstanceOf[tp.PInfo]), restpe))
+          else
+            tp.derivedLambdaType(tp.paramNames, formals, restpe)
+      }
+
+    /** Overridden in TypeOps.avoid */
+    protected def needsRangeIfInvariant(refs: CaptureSet): Boolean = true
+
+    override def mapCapturingType(tp: Type, parent: Type, refs: CaptureSet, v: Int): Type =
+      if v == 0 && needsRangeIfInvariant(refs) then
+        range(mapCapturingType(tp, parent, refs, -1), mapCapturingType(tp, parent, refs, 1))
+      else
+        super.mapCapturingType(tp, parent, refs, v)
+
+    protected def reapply(tp: Type): Type = apply(tp)
+  }
+
+  /** A range of possible types between lower bound `lo` and upper bound `hi`.
+   *  Only used internally in `ApproximatingTypeMap`.
+   */
+  case class Range(lo: Type, hi: Type) extends UncachedGroundType:
+    assert(!lo.isInstanceOf[Range])
+    assert(!hi.isInstanceOf[Range])
+
+  /** Approximate wildcards by their bounds */
+  class AvoidWildcardsMap(using Context) extends ApproximatingTypeMap:
+    protected def mapWild(t: WildcardType) =
+      val bounds = t.effectiveBounds
+      range(atVariance(-variance)(apply(bounds.lo)), apply(bounds.hi))
+    def apply(t: Type): Type = t match
+      case t: WildcardType => mapWild(t)
+      case _ => mapOver(t)
+
+  // ----- TypeAccumulators ----------------------------------------------------
+
+  abstract class TypeAccumulator[T](implicit protected val accCtx: Context)
+  extends VariantTraversal with ((T, Type) => T) {
+    this: TypeAccumulator[T] @annotation.retains(caps.*) =>
+
+    def apply(x: T, tp: Type): T
+
+    protected def applyToAnnot(x: T, annot: Annotation): T = x // don't go into annotations
+
+    protected final def applyToPrefix(x: T, tp: NamedType): T =
+      atVariance(variance max 0)(this(x, tp.prefix)) // see remark on NamedType case in TypeMap
+
+    def foldOver(x: T, tp: Type): T = {
+      record(s"foldOver $getClass")
+      record(s"foldOver total")
+      tp match {
+      case tp: TypeRef =>
+        if stopBecauseStaticOrLocal(tp) then x
+        else
+          val tp1 = tp.prefix.lookupRefined(tp.name)
+          if (tp1.exists) this(x, tp1) else applyToPrefix(x, tp)
+
+      case tp @ AppliedType(tycon, args) =>
+        @tailrec def foldArgs(x: T, tparams: List[ParamInfo], args: List[Type]): T =
+          if (args.isEmpty || tparams.isEmpty) x
+          else {
+            val tparam = tparams.head
+            val acc = args.head match {
+              case arg: TypeBounds => this(x, arg)
+              case arg => atVariance(variance * tparam.paramVarianceSign)(this(x, arg))
+            }
+            foldArgs(acc, tparams.tail, args.tail)
+          }
+        foldArgs(this(x, tycon), tp.tyconTypeParams, args)
+
+      case _: BoundType | _: ThisType => x
+
+      case tp: LambdaType =>
+        val restpe = tp.resultType
+        val saved = variance
+        variance = if (defn.MatchCase.isInstance(restpe)) 0 else -variance
+        val y = foldOver(x, tp.paramInfos)
+        variance = saved
+        this(y, restpe)
+
+      case tp: TermRef =>
+        if stopBecauseStaticOrLocal(tp) then x else applyToPrefix(x, tp)
+
+      case tp: TypeVar =>
+        this(x, tp.underlying)
+
+      case ExprType(restpe) =>
+        this(x, restpe)
+
+      case bounds @ TypeBounds(lo, hi) =>
+        if (lo eq hi) atVariance(0)(this(x, lo))
+        else {
+          variance = -variance
+          val y = this(x, lo)
+          variance = -variance
+          this(y, hi)
+        }
+
+      case tp: AndType =>
+        this(this(x, tp.tp1), tp.tp2)
+
+      case tp: OrType =>
+        this(this(x, tp.tp1), tp.tp2)
+
+      case tp: MatchType =>
+        val x1 = this(x, tp.bound)
+        val x2 = atVariance(0)(this(x1, tp.scrutinee))
+        foldOver(x2, tp.cases)
+
+      case CapturingType(parent, refs) =>
+        (this(x, parent) /: refs.elems)(apply) // !cc! does not work under apply := this
+
+      case AnnotatedType(underlying, annot) =>
+        this(applyToAnnot(x, annot), underlying)
+
+      case tp: ProtoType =>
+        tp.fold(x, this)
+
+      case tp: RefinedType =>
+        this(this(x, tp.parent), tp.refinedInfo)
+
+      case tp: WildcardType =>
+        this(x, tp.optBounds)
+
+      case tp @ ClassInfo(prefix, _, _, _, _) =>
+        this(x, prefix)
+
+      case tp: JavaArrayType =>
+        this(x, tp.elemType)
+
+      case tp: SkolemType =>
+        this(x, tp.info)
+
+      case SuperType(thistp, supertp) =>
+        this(this(x, thistp), supertp)
+
+      case tp: LazyRef =>
+        this(x, tp.ref)
+
+      case tp: RecType =>
+        this(x, tp.parent)
+
+      case _ => x
+    }}
+
+    @tailrec final def foldOver(x: T, ts: List[Type]): T = ts match {
+      case t :: ts1 => foldOver(apply(x, t), ts1)
+      case nil => x
+    }
+  }
+
+  abstract class TypeTraverser(using Context) extends TypeAccumulator[Unit] {
+    def traverse(tp: Type): Unit
+    def apply(x: Unit, tp: Type): Unit = traverse(tp)
+    protected def traverseChildren(tp: Type): Unit = foldOver((), tp)
+  }
+
+  class ExistsAccumulator(
+      p: Type => Boolean,
+      override val stopAt: StopAt,
+      forceLazy: Boolean)(using Context) extends TypeAccumulator[Boolean]:
+    def apply(x: Boolean, tp: Type): Boolean =
+      x || p(tp) || (forceLazy || !tp.isInstanceOf[LazyRef]) && foldOver(x, tp)
+
+  class ForeachAccumulator(p: Type => Unit, override val stopAt: StopAt)(using Context) extends TypeAccumulator[Unit] {
+    def apply(x: Unit, tp: Type): Unit = foldOver(p(tp), tp)
+  }
+
+  class NamedPartsAccumulator(p: NamedType => Boolean)(using Context)
+  extends TypeAccumulator[List[NamedType]]:
+    def maybeAdd(xs: List[NamedType], tp: NamedType): List[NamedType] = if p(tp) then tp :: xs else xs
+    val seen = util.HashSet[Type]()
+    def apply(xs: List[NamedType], tp: Type): List[NamedType] =
+      if seen contains tp then xs
+      else
+        seen += tp
+        tp match
+          case tp: TypeRef =>
+            foldOver(maybeAdd(xs, tp), tp)
+          case tp: ThisType =>
+            apply(xs, tp.tref)
+          case NoPrefix =>
+            foldOver(xs, tp)
+          case tp: TermRef =>
+            apply(foldOver(maybeAdd(xs, tp), tp), tp.underlying)
+          case tp: AppliedType =>
+            foldOver(xs, tp)
+          case TypeBounds(lo, hi) =>
+            apply(apply(xs, lo), hi)
+          case tp: ParamRef =>
+            apply(xs, tp.underlying)
+          case tp: ConstantType =>
+            apply(xs, tp.underlying)
+          case _ =>
+            foldOver(xs, tp)
+  end NamedPartsAccumulator
+
+  class isGroundAccumulator(using Context) extends TypeAccumulator[Boolean] {
+    def apply(x: Boolean, tp: Type): Boolean = x && {
+      tp match {
+        case _: TypeParamRef => false
+        case tp: TypeVar => apply(x, tp.underlying)
+        case tp: AppliedType => tp.isGround(this)
+        case _ => foldOver(x, tp)
+      }
+    }
+  }
+
+  class TypeSizeAccumulator(using Context) extends TypeAccumulator[Int] {
+    var seen = util.HashSet[Type](initialCapacity = 8)
+    def apply(n: Int, tp: Type): Int =
+      if seen.contains(tp) then n
+      else {
+        seen += tp
+        tp match {
+          case tp: AppliedType =>
+            foldOver(n + 1, tp)
+          case tp: RefinedType =>
+            foldOver(n + 1, tp)
+          case tp: TypeRef if tp.info.isTypeAlias =>
+            apply(n, tp.superType)
+          case tp: TypeParamRef =>
+            apply(n, TypeComparer.bounds(tp))
+          case _ =>
+            foldOver(n, tp)
+        }
+      }
+  }
+
+  class CoveringSetAccumulator(using Context) extends TypeAccumulator[Set[Symbol]] {
+    var seen = util.HashSet[Type](initialCapacity = 8)
+    def apply(cs: Set[Symbol], tp: Type): Set[Symbol] =
+      if seen.contains(tp) then cs
+      else {
+        seen += tp
+        tp match {
+          case tp if tp.isExactlyAny || tp.isExactlyNothing =>
+            cs
+          case tp: AppliedType =>
+            foldOver(cs + tp.typeSymbol, tp)
+          case tp: RefinedType =>
+            foldOver(cs + tp.typeSymbol, tp)
+          case tp: TypeRef if tp.info.isTypeAlias =>
+            apply(cs, tp.superType)
+          case tp: TypeRef if tp.symbol.isClass =>
+            foldOver(cs + tp.typeSymbol, tp)
+          case tp: TermRef =>
+            val tsym = if (tp.termSymbol.is(Param)) tp.underlying.typeSymbol else tp.termSymbol
+            foldOver(cs + tsym, tp)
+          case tp: TypeParamRef =>
+            apply(cs, TypeComparer.bounds(tp))
+          case other =>
+            foldOver(cs, tp)
+        }
+      }
+  }
+
+  //   ----- Name Filters --------------------------------------------------
+
+  /** A name filter selects or discards a member name of a type `pre`.
+   *  To enable efficient caching, name filters have to satisfy the
+   *  following invariant: If `keep` is a name filter, and `pre` has
+   *  class `C` as a base class, then
+   *
+   *    keep(pre, name)  implies  keep(C.this, name)
+   */
+  abstract class NameFilter {
+    def apply(pre: Type, name: Name)(using Context): Boolean
+
+    /** Filter does not need to be rechecked with full prefix, if it
+     *  has been already checked for the class denotation of the prefix
+     */
+    def isStable: Boolean
+  }
+
+  /** A filter for names of abstract types of a given type */
+  object abstractTypeNameFilter extends NameFilter {
+    def apply(pre: Type, name: Name)(using Context): Boolean =
+      name.isTypeName && {
+        val mbr = pre.nonPrivateMember(name)
+        mbr.symbol.is(Deferred) && mbr.info.isInstanceOf[RealTypeBounds]
+      }
+    def isStable = false
+  }
+
+  /** A filter for names of abstract types of a given type */
+  object nonClassTypeNameFilter extends NameFilter {
+    def apply(pre: Type, name: Name)(using Context): Boolean =
+      name.isTypeName && {
+        val mbr = pre.member(name)
+        mbr.symbol.isType && !mbr.symbol.isClass
+      }
+    def isStable = false
+  }
+
+  /** A filter for names of deferred term definitions of a given type */
+  object abstractTermNameFilter extends NameFilter {
+    def apply(pre: Type, name: Name)(using Context): Boolean =
+      name.isTermName && pre.nonPrivateMember(name).hasAltWith(_.symbol.is(Deferred))
+    def isStable = false
+  }
+
+  /** A filter for names of type aliases of a given type */
+  object typeAliasNameFilter extends NameFilter {
+    def apply(pre: Type, name: Name)(using Context): Boolean =
+      name.isTypeName && {
+        val mbr = pre.nonPrivateMember(name)
+        mbr.symbol.isAliasType
+      }
+    def isStable = false
+  }
+
+  object typeNameFilter extends NameFilter {
+    def apply(pre: Type, name: Name)(using Context): Boolean = name.isTypeName
+    def isStable = true
+  }
+
+  object fieldFilter extends NameFilter {
+    def apply(pre: Type, name: Name)(using Context): Boolean =
+      name.isTermName && (pre member name).hasAltWith(!_.symbol.is(Method))
+    def isStable = true
+  }
+
+  object takeAllFilter extends NameFilter {
+    def apply(pre: Type, name: Name)(using Context): Boolean = name != nme.CONSTRUCTOR
+    def isStable = true
+  }
+
+  object implicitFilter extends NameFilter {
+    /** A dummy filter method.
+     *  Implicit filtering is handled specially in computeMemberNames, so
+     *  no post-filtering is needed.
+     */
+    def apply(pre: Type, name: Name)(using Context): Boolean = true
+    def isStable = true
+  }
+
+  // ----- Debug ---------------------------------------------------------
+
+  @sharable var debugTrace: Boolean = false
+
+  val watchList: List[TypeName] = List[String](
+  ) map (_.toTypeName)
+
+  def isWatched(tp: Type)(using Context): Boolean = tp match {
+    case ref: TypeRef => watchList contains ref.name
+    case _ => false
+  }
+
+  // ----- Helpers and Decorator implicits --------------------------------------
+
+  implicit def decorateTypeApplications(tpe: Type): TypeApplications = new TypeApplications(tpe)
+
+  extension (tps1: List[Type]) {
+    @tailrec def hashIsStable: Boolean =
+      tps1.isEmpty || tps1.head.hashIsStable && tps1.tail.hashIsStable
+    @tailrec def equalElements(tps2: List[Type], bs: BinderPairs): Boolean =
+      (tps1 `eq` tps2) || {
+        if (tps1.isEmpty) tps2.isEmpty
+        else tps2.nonEmpty && tps1.head.equals(tps2.head, bs) && tps1.tail.equalElements(tps2.tail, bs)
+      }
+  }
+
+  private val keepAlways: AnnotatedType => Context ?=> Boolean = _ => true
+  private val keepNever: AnnotatedType => Context ?=> Boolean = _ => false
+  private val keepIfRefining: AnnotatedType => Context ?=> Boolean = _.isRefining
+
+  val isBounds: Type => Boolean = _.isInstanceOf[TypeBounds]
+}
diff --git a/tests/pos-with-compiler-cc/dotc/core/Uniques.scala b/tests/pos-with-compiler-cc/dotc/core/Uniques.scala
new file mode 100644
index 000000000000..4078a2b1051a
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/core/Uniques.scala
@@ -0,0 +1,92 @@
+package dotty.tools.dotc
+package core
+
+import Types._, Contexts._, util.Stats._, Hashable._, Names._
+import config.Config
+import Decorators._
+import util.{WeakHashSet, Stats}
+import WeakHashSet.Entry
+import scala.annotation.tailrec
+
+class Uniques extends WeakHashSet[Type](Config.initialUniquesCapacity):
+  override def hash(x: Type): Int = x.hash
+  override def isEqual(x: Type, y: Type) = x.eql(y)
+
+/** Defines operation `unique` for hash-consing types.
+ *  Also defines specialized hash sets for hash consing uniques of a specific type.
+ *  All sets offer a `enterIfNew` method which checks whether a type
+ *  with the given parts exists already and creates a new one if not.
+ */
+object Uniques:
+
+  private inline def recordCaching(tp: Type): Unit = recordCaching(tp.hash, tp.getClass)
+  private inline def recordCaching(h: Int, clazz: Class[?]): Unit =
+    if monitored then
+      if h == NotCached then
+        record("uncached-types")
+        record(s"uncached: $clazz")
+      else
+        record("cached-types")
+        record(s"cached: $clazz")
+
+  def unique[T <: Type](tp: T)(using Context): T =
+    recordCaching(tp)
+    if tp.hash == NotCached then tp
+    else ctx.uniques.put(tp).asInstanceOf[T]
+
+  final class NamedTypeUniques extends WeakHashSet[NamedType](Config.initialUniquesCapacity * 4) with Hashable:
+    override def hash(x: NamedType): Int = x.hash
+
+    def enterIfNew(prefix: Type, designator: Designator, isTerm: Boolean)(using Context): NamedType =
+      val h = doHash(null, designator, prefix)
+      if monitored then recordCaching(h, classOf[NamedType])
+      def newType =
+        if (isTerm) new CachedTermRef(prefix, designator, h)
+        else new CachedTypeRef(prefix, designator, h)
+      if h == NotCached then newType
+      else
+        // Inlined from WeakHashSet#put
+        Stats.record(statsItem("put"))
+        removeStaleEntries()
+        val bucket = index(h)
+        val oldHead = table(bucket)
+
+        @tailrec
+        def linkedListLoop(entry: Entry[NamedType] | Null): NamedType = entry match
+          case null                    => addEntryAt(bucket, newType, h, oldHead)
+          case _                       =>
+            val e = entry.get
+            if e != null && (e.prefix eq prefix) && (e.designator eq designator) && (e.isTerm == isTerm) then e
+            else linkedListLoop(entry.tail)
+
+        linkedListLoop(oldHead)
+      end if
+  end NamedTypeUniques
+
+  final class AppliedUniques extends WeakHashSet[AppliedType](Config.initialUniquesCapacity * 2) with Hashable:
+    override def hash(x: AppliedType): Int = x.hash
+
+    def enterIfNew(tycon: Type, args: List[Type]): AppliedType =
+      val h = doHash(null, tycon, args)
+      def newType = new CachedAppliedType(tycon, args, h)
+      if monitored then recordCaching(h, classOf[CachedAppliedType])
+      if h == NotCached then newType
+      else
+        // Inlined from WeakHashSet#put
+        Stats.record(statsItem("put"))
+        removeStaleEntries()
+        val bucket = index(h)
+        val oldHead = table(bucket)
+
+        @tailrec
+        def linkedListLoop(entry: Entry[AppliedType] | Null): AppliedType = entry match
+          case null                    => addEntryAt(bucket, newType, h, oldHead)
+          case _                       =>
+            val e = entry.get
+            if e != null && (e.tycon eq tycon) && e.args.eqElements(args) then e
+            else linkedListLoop(entry.tail)
+
+        linkedListLoop(oldHead)
+      end if
+  end AppliedUniques
+end Uniques
diff --git a/tests/pos-with-compiler-cc/dotc/core/Variances.scala b/tests/pos-with-compiler-cc/dotc/core/Variances.scala
new file mode 100644
index 000000000000..2401b43c8e17
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/core/Variances.scala
@@ -0,0 +1,82 @@
+package dotty.tools.dotc
+package core
+
+import Types._, Contexts._, Flags._, Symbols._, Annotations._
+import TypeApplications.TypeParamInfo
+import Decorators._
+
+object Variances {
+
+  type Variance = FlagSet
+  val Bivariant: Variance = VarianceFlags
+  val Invariant: Variance = EmptyFlags
+
+  def varianceFromInt(v: Int): Variance =
+    if v < 0 then Contravariant
+    else if v > 0 then Covariant
+    else Invariant
+
+  def varianceToInt(v: Variance): Int =
+    if v.is(Covariant) then 1
+    else if v.is(Contravariant) then -1
+    else 0
+
+  /** Flip between covariant and contravariant */
+  def flip(v: Variance): Variance =
+    if (v == Covariant) Contravariant
+    else if (v == Contravariant) Covariant
+    else v
+
+  def setStructuralVariances(lam: HKTypeLambda)(using Context): Unit =
+    assert(!lam.isDeclaredVarianceLambda)
+    for param <- lam.typeParams do param.storedVariance = Bivariant
+    object narrowVariances extends TypeTraverser {
+      def traverse(t: Type): Unit = t match
+        case t: TypeParamRef if t.binder eq lam =>
+          lam.typeParams(t.paramNum).storedVariance &= varianceFromInt(variance)
+        case _ =>
+          traverseChildren(t)
+    }
+    // Note: Normally, we'd need to repeat `traverse` until a fixpoint is reached.
+    // But since recursive lambdas can only appear in bounds, and bounds never have
+    // structural variances, a single traversal is enough.
+    narrowVariances.traverse(lam.resType)
+
+  /** Does variance `v1` conform to variance `v2`?
+   *  This is the case if the variances are the same or `sym` is nonvariant.
+   */
+  def varianceConforms(v1: Int, v2: Int): Boolean =
+    v1 == v2 || v2 == 0
+
+  /** Does the variance of type parameter `tparam1` conform to the variance of type parameter `tparam2`?
+   */
+  def varianceConforms(tparam1: TypeParamInfo, tparam2: TypeParamInfo)(using Context): Boolean =
+    tparam1.paramVariance.isAllOf(tparam2.paramVariance)
+
+  /** Do the variances of type parameters `tparams1` conform to the variances
+   *  of corresponding type parameters `tparams2`?
+   *  This is only the case if `tparams1` and `tparams2` have the same length.
+   */
+  def variancesConform(tparams1: List[TypeParamInfo], tparams2: List[TypeParamInfo])(using Context): Boolean =
+    val needsDetailedCheck = tparams2 match
+      case (_: Symbol) :: _ => true
+      case LambdaParam(tl: HKTypeLambda, _) :: _ => tl.isDeclaredVarianceLambda
+      case _ => false
+    if needsDetailedCheck then tparams1.corresponds(tparams2)(varianceConforms)
+    else tparams1.hasSameLengthAs(tparams2)
+
+  def varianceSign(v: Variance): String = varianceSign(varianceToInt(v))
+  def varianceLabel(v: Variance): String = varianceLabel(varianceToInt(v))
+
+  def varianceSign(v: Int): String =
+    if (v > 0) "+"
+    else if (v < 0) "-"
+    else ""
+
+  def varianceLabel(v: Int): String =
+    if v < 0 then "contravariant"
+    else if v > 0 then "covariant"
+    else "invariant"
+
+  val alwaysInvariant: Any => Invariant.type = Function.const(Invariant)
+}
diff --git a/tests/pos-with-compiler-cc/dotc/core/classfile/AbstractFileReader.scala b/tests/pos-with-compiler-cc/dotc/core/classfile/AbstractFileReader.scala
new file mode 100644
index 000000000000..46581d00714e
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/core/classfile/AbstractFileReader.scala
@@ -0,0 +1,100 @@
+package dotty.tools
+package dotc
+package core
+package classfile
+
+import scala.language.unsafeNulls
+
+import java.lang.Float.intBitsToFloat
+import java.lang.Double.longBitsToDouble
+import java.io.{ByteArrayInputStream, DataInputStream}
+
+import io.AbstractFile
+
+/**
+ * This class reads files byte per byte. Only used by ClassFileParser
+ *
+ * @author Philippe Altherr
+ * @version 1.0, 23/03/2004
+ */
+final class AbstractFileReader(val buf: Array[Byte]) extends DataReader {
+  def this(file: AbstractFile) = this(file.toByteArray)
+
+  /** the current input pointer
+   */
+  var bp: Int = 0
+
+  /** extract a byte at position bp from buf
+   */
+  def getByte(mybp: Int): Byte =
+    buf(mybp)
+
+  def getBytes(mybp: Int, bytes: Array[Byte]): Unit = {
+    System.arraycopy(buf, mybp, bytes, 0, bytes.length)
+  }
+
+  /** return byte at offset 'pos'
+   */
+  @throws(classOf[IndexOutOfBoundsException])
+  def byteAt(pos: Int): Byte = buf(pos)
+
+  /** read a byte
+   */
+  @throws(classOf[IndexOutOfBoundsException])
+  def nextByte: Byte = {
+    val b = buf(bp)
+    bp += 1
+    b
+  }
+
+  /** read some bytes
+   */
+  def nextBytes(len: Int): Array[Byte] = {
+    bp += len
+    buf.slice(bp - len, bp)
+  }
+
+  /** read a character
+   */
+  def nextChar: Char =
+    (((nextByte & 0xff) << 8) + (nextByte & 0xff)).toChar
+
+  /** read an integer
+   */
+  def nextInt: Int =
+    ((nextByte & 0xff) << 24) + ((nextByte & 0xff) << 16) +
+    ((nextByte & 0xff) <<  8) +  (nextByte & 0xff)
+
+
+  /** extract a character at position bp from buf
+   */
+  def getChar(mybp: Int): Char =
+    (((getByte(mybp) & 0xff) << 8) + (getByte(mybp+1) & 0xff)).toChar
+
+  /** extract an integer at position bp from buf
+   */
+  def getInt(mybp: Int): Int =
+    ((getByte(mybp) & 0xff) << 24) + ((getByte(mybp + 1) & 0xff) << 16) +
+    ((getByte(mybp + 2) & 0xff) << 8) + (getByte(mybp + 3) & 0xff)
+
+  /** extract a long integer at position bp from buf
+   */
+  def getLong(mybp: Int): Long =
+    (getInt(mybp).toLong << 32) + (getInt(mybp + 4) & 0xffffffffL)
+
+  /** extract a float at position bp from buf
+   */
+  def getFloat(mybp: Int): Float = intBitsToFloat(getInt(mybp))
+
+  /** extract a double at position bp from buf
+   */
+  def getDouble(mybp: Int): Double = longBitsToDouble(getLong(mybp))
+
+  def getUTF(mybp: Int, len: Int): String =
+    new DataInputStream(new ByteArrayInputStream(buf, mybp, len)).readUTF
+
+  /** skip next 'n' bytes
+   */
+  def skip(n: Int): Unit = { bp += n }
+}
+
diff --git a/tests/pos-with-compiler-cc/dotc/core/classfile/ByteCodecs.scala b/tests/pos-with-compiler-cc/dotc/core/classfile/ByteCodecs.scala
new file mode 100644
index 000000000000..acd7982f4fd3
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/core/classfile/ByteCodecs.scala
@@ -0,0 +1,224 @@
+/*                     __                                               *\
+**     ________ ___   / /  ___     Scala API                            **
+**    / __/ __// _ | / /  / _ |    (c) 2007-2011, LAMP/EPFL             **
+**  __\ \/ /__/ __ |/ /__/ __ |    http://scala-lang.org/               **
+** /____/\___/_/ |_/____/_/ | |                                         **
+**                          |/                                          **
+\*                                                                      */
+package dotty.tools.dotc.core.classfile
+
+object ByteCodecs {
+
+  def avoidZero(src: Array[Byte]): Array[Byte] = {
+    var i = 0
+    val srclen = src.length
+    var count = 0
+    while (i < srclen) {
+      if (src(i) == 0x7f) count += 1
+      i += 1
+    }
+    val dst = new Array[Byte](srclen + count)
+    i = 0
+    var j = 0
+    while (i < srclen) {
+      val in = src(i)
+      if (in == 0x7f) {
+        dst(j) = (0xc0).toByte
+        dst(j + 1) = (0x80).toByte
+        j += 2
+      }
+      else {
+        dst(j) = (in + 1).toByte
+        j += 1
+      }
+      i += 1
+    }
+    dst
+  }
+
+  def regenerateZero(src: Array[Byte]): Int = {
+    var i = 0
+    val srclen = src.length
+    var j = 0
+    while (i < srclen) {
+      val in: Int = src(i) & 0xff
+      if (in == 0xc0 && (src(i + 1) & 0xff) == 0x80) {
+        src(j) = 0x7f
+        i += 2
+      }
+      else if (in == 0) {
+        src(j) = 0x7f
+        i += 1
+      }
+      else {
+        src(j) = (in - 1).toByte
+        i += 1
+      }
+      j += 1
+    }
+    j
+  }
+
+  def encode8to7(src: Array[Byte]): Array[Byte] = {
+    val srclen = src.length
+    val dstlen = (srclen * 8 + 6) / 7
+    val dst = new Array[Byte](dstlen)
+    var i = 0
+    var j = 0
+    while (i + 6 < srclen) {
+      var in: Int = src(i) & 0xff
+      dst(j) = (in & 0x7f).toByte
+      var out: Int = in >>> 7
+      in = src(i + 1) & 0xff
+      dst(j + 1) = (out | (in << 1) & 0x7f).toByte
+      out = in >>> 6
+      in = src(i + 2) & 0xff
+      dst(j + 2) = (out | (in << 2) & 0x7f).toByte
+      out = in >>> 5
+      in = src(i + 3) & 0xff
+      dst(j + 3) = (out | (in << 3) & 0x7f).toByte
+      out = in >>> 4
+      in = src(i + 4) & 0xff
+      dst(j + 4) = (out | (in << 4) & 0x7f).toByte
+      out = in >>> 3
+      in = src(i + 5) & 0xff
+      dst(j + 5) = (out | (in << 5) & 0x7f).toByte
+      out = in >>> 2
+      in = src(i + 6) & 0xff
+      dst(j + 6) = (out | (in << 6) & 0x7f).toByte
+      out = in >>> 1
+      dst(j + 7) = out.toByte
+      i += 7
+      j += 8
+    }
+    if (i < srclen) {
+      var in: Int = src(i) & 0xff
+      dst(j) = (in & 0x7f).toByte; j += 1
+      var out: Int = in >>> 7
+      if (i + 1 < srclen) {
+        in = src(i + 1) & 0xff
+        dst(j) = (out | (in << 1) & 0x7f).toByte; j += 1
+        out = in >>> 6
+        if (i + 2 < srclen) {
+          in = src(i + 2) & 0xff
+          dst(j) = (out | (in << 2) & 0x7f).toByte; j += 1
+          out = in >>> 5
+          if (i + 3 < srclen) {
+            in = src(i + 3) & 0xff
+            dst(j) = (out | (in << 3) & 0x7f).toByte; j += 1
+            out = in >>> 4
+            if (i + 4 < srclen) {
+              in = src(i + 4) & 0xff
+              dst(j) = (out | (in << 4) & 0x7f).toByte; j += 1
+              out = in >>> 3
+              if (i + 5 < srclen) {
+                in = src(i + 5) & 0xff
+                dst(j) = (out | (in << 5) & 0x7f).toByte; j += 1
+                out = in >>> 2
+              }
+            }
+          }
+        }
+      }
+      if (j < dstlen) dst(j) = out.toByte
+    }
+    dst
+  }
+
+  def decode7to8(src: Array[Byte], srclen: Int): Int = {
+    var i = 0
+    var j = 0
+    val dstlen = (srclen * 7 + 7) / 8
+    while (i + 7 < srclen) {
+      var out: Int = src(i)
+      var in: Byte = src(i + 1)
+      src(j) = (out | (in & 0x01) << 7).toByte
+      out = in >>> 1
+      in = src(i + 2)
+      src(j + 1) = (out | (in & 0x03) << 6).toByte
+      out = in >>> 2
+      in = src(i + 3)
+      src(j + 2) = (out | (in & 0x07) << 5).toByte
+      out = in >>> 3
+      in = src(i + 4)
+      src(j + 3) = (out | (in & 0x0f) << 4).toByte
+      out = in >>> 4
+      in = src(i + 5)
+      src(j + 4) = (out | (in & 0x1f) << 3).toByte
+      out = in >>> 5
+      in = src(i + 6)
+      src(j + 5) = (out | (in & 0x3f) << 2).toByte
+      out = in >>> 6
+      in = src(i + 7)
+      src(j + 6) = (out | in << 1).toByte
+      i += 8
+      j += 7
+    }
+    if (i < srclen) {
+      var out: Int = src(i)
+      if (i + 1 < srclen) {
+        var in: Byte = src(i + 1)
+        src(j) = (out | (in & 0x01) << 7).toByte; j += 1
+        out = in >>> 1
+        if (i + 2 < srclen) {
+          in = src(i + 2)
+          src(j) = (out | (in & 0x03) << 6).toByte; j += 1
+          out = in >>> 2
+          if (i + 3 < srclen) {
+            in = src(i + 3)
+            src(j) = (out | (in & 0x07) << 5).toByte; j += 1
+            out = in >>> 3
+            if (i + 4 < srclen) {
+              in = src(i + 4)
+              src(j) = (out | (in & 0x0f) << 4).toByte; j += 1
+              out = in >>> 4
+              if (i + 5 < srclen) {
+                in = src(i + 5)
+                src(j) = (out | (in & 0x1f) << 3).toByte; j += 1
+                out = in >>> 5
+                if (i + 6 < srclen) {
+                  in = src(i + 6)
+                  src(j) = (out | (in & 0x3f) << 2).toByte; j += 1
+                  out = in >>> 6
+                }
+              }
+            }
+          }
+        }
+      }
+      if (j < dstlen) src(j) = out.toByte
+    }
+    dstlen
+  }
+
+  def encode(xs: Array[Byte]): Array[Byte] = avoidZero(encode8to7(xs))
+
+  /**
+   * Destructively decodes array xs and returns the length of the decoded array.
+   *
+   * Sometimes returns (length + 1) of the decoded array. Example:
+   *
+   *   scala> val enc = reflect.generic.ByteCodecs.encode(Array(1,2,3))
+   *   enc: Array[Byte] = Array(2, 5, 13, 1)
+   *
+   *   scala> reflect.generic.ByteCodecs.decode(enc)
+   *   res43: Int = 4
+   *
+   *   scala> enc
+   *   res44: Array[Byte] = Array(1, 2, 3, 0)
+   *
+   * However, this does not always happen.
+   */
+  def decode(xs: Array[Byte]): Int = {
+    val len = regenerateZero(xs)
+    decode7to8(xs, len)
+  }
+}
+
+
+
+
+
+
+
+
diff --git a/tests/pos-with-compiler-cc/dotc/core/classfile/ClassfileConstants.scala b/tests/pos-with-compiler-cc/dotc/core/classfile/ClassfileConstants.scala
new file mode 100644
index 000000000000..3b05ee351b86
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/core/classfile/ClassfileConstants.scala
@@ -0,0 +1,382 @@
+package dotty.tools.dotc
+package core
+package classfile
+
+import scala.annotation.switch
+
+object ClassfileConstants {
+
+  inline val JAVA_MAGIC = 0xCAFEBABE
+  inline val JAVA_MAJOR_VERSION = 45
+  inline val JAVA_MINOR_VERSION = 3
+
+  inline val JAVA8_MAJOR_VERSION = 52
+
+  /** (see http://java.sun.com/docs/books/jvms/second_edition/jvms-clarify.html)
+   *
+   *  If the `ACC_INTERFACE` flag is set, the `ACC_ABSTRACT` flag must also
+   *  be set (ch. 2.13.1).
+   *
+   *  A class file cannot have both its `ACC_FINAL` and `ACC_ABSTRACT` flags
+   *  set (ch. 2.8.2).
+   *
+   *  A field may have at most one of its `ACC_PRIVATE`, `ACC_PROTECTED`,
+   *  `ACC_PUBLIC` flags set (ch. 2.7.4).
+   *
+   *  A field may not have both its `ACC_FINAL` and `ACC_VOLATILE` flags set
+   *  (ch. 2.9.1).
+   *
+   *  If a method has its `ACC_ABSTRACT` flag set it must not have any of its
+   *  `ACC_FINAL`, `ACC_NATIVE`, `ACC_PRIVATE`, `ACC_STATIC`, `ACC_STRICT`,
+   *  or `ACC_SYNCHRONIZED` flags set (ch. 2.13.3.2).
+   *
+   *  All interface methods must have their `ACC_ABSTRACT` and
+   *  `ACC_PUBLIC` flags set.
+   *
+   *  Note for future reference: see this thread on ACC_SUPER and
+   *  how its enforcement differs on the android vm.
+   *    https://groups.google.com/forum/?hl=en#!topic/jvm-languages/jVhzvq8-ZIk
+   *
+   */                                        // Class   Field   Method
+  inline val JAVA_ACC_PUBLIC       = 0x0001   //   X       X        X
+  inline val JAVA_ACC_PRIVATE      = 0x0002   //           X        X
+  inline val JAVA_ACC_PROTECTED    = 0x0004   //           X        X
+  inline val JAVA_ACC_STATIC       = 0x0008   //           X        X
+  inline val JAVA_ACC_FINAL        = 0x0010   //   X       X        X
+  inline val JAVA_ACC_SUPER        = 0x0020   //   X
+  inline val JAVA_ACC_SYNCHRONIZED = 0x0020   //                    X
+  inline val JAVA_ACC_VOLATILE     = 0x0040   //           X
+  inline val JAVA_ACC_BRIDGE       = 0x0040   //                    X
+  inline val JAVA_ACC_TRANSIENT    = 0x0080   //           X
+  inline val JAVA_ACC_VARARGS      = 0x0080   //                    X
+  inline val JAVA_ACC_NATIVE       = 0x0100   //                    X
+  inline val JAVA_ACC_INTERFACE    = 0x0200   //   X
+  inline val JAVA_ACC_ABSTRACT     = 0x0400   //   X                X
+  inline val JAVA_ACC_STRICT       = 0x0800   //                    X
+  inline val JAVA_ACC_SYNTHETIC    = 0x1000   //   X       X        X
+  inline val JAVA_ACC_ANNOTATION   = 0x2000   //   X
+  inline val JAVA_ACC_ENUM         = 0x4000   //   X       X
+
+  // tags describing the type of a literal in the constant pool
+  inline val CONSTANT_UTF8          =  1
+  inline val CONSTANT_UNICODE       =  2
+  inline val CONSTANT_INTEGER       =  3
+  inline val CONSTANT_FLOAT         =  4
+  inline val CONSTANT_LONG          =  5
+  inline val CONSTANT_DOUBLE        =  6
+  inline val CONSTANT_CLASS         =  7
+  inline val CONSTANT_STRING        =  8
+  inline val CONSTANT_FIELDREF      =  9
+  inline val CONSTANT_METHODREF     = 10
+  inline val CONSTANT_INTFMETHODREF = 11
+  inline val CONSTANT_NAMEANDTYPE   = 12
+
+  inline val CONSTANT_METHODHANDLE  = 15
+  inline val CONSTANT_METHODTYPE    = 16
+  inline val CONSTANT_INVOKEDYNAMIC = 18
+
+  // tags describing the type of a literal in attribute values
+  inline val BYTE_TAG   = 'B'
+  inline val CHAR_TAG   = 'C'
+  inline val DOUBLE_TAG = 'D'
+  inline val FLOAT_TAG  = 'F'
+  inline val INT_TAG    = 'I'
+  inline val LONG_TAG   = 'J'
+  inline val SHORT_TAG  = 'S'
+  inline val BOOL_TAG   = 'Z'
+  inline val STRING_TAG = 's'
+  inline val ENUM_TAG   = 'e'
+  inline val CLASS_TAG  = 'c'
+  inline val ARRAY_TAG  = '['
+  inline val VOID_TAG   = 'V'
+  inline val TVAR_TAG   = 'T'
+  inline val OBJECT_TAG = 'L'
+  inline val ANNOTATION_TAG = '@'
+  inline val SCALA_NOTHING = "scala.runtime.Nothing$"
+  inline val SCALA_NULL = "scala.runtime.Null$"
+
+
+  // tags describing the type of newarray
+  inline val T_BOOLEAN = 4
+  inline val T_CHAR    = 5
+  inline val T_FLOAT   = 6
+  inline val T_DOUBLE  = 7
+  inline val T_BYTE    = 8
+  inline val T_SHORT   = 9
+  inline val T_INT     = 10
+  inline val T_LONG    = 11
+
+  // JVM mnemonics
+  inline val nop         = 0x00
+  inline val aconst_null = 0x01
+  inline val iconst_m1   = 0x02
+
+  inline val iconst_0    = 0x03
+  inline val iconst_1    = 0x04
+  inline val iconst_2    = 0x05
+  inline val iconst_3    = 0x06
+  inline val iconst_4    = 0x07
+  inline val iconst_5    = 0x08
+
+  inline val lconst_0    = 0x09
+  inline val lconst_1    = 0x0a
+  inline val fconst_0    = 0x0b
+  inline val fconst_1    = 0x0c
+  inline val fconst_2    = 0x0d
+  inline val dconst_0    = 0x0e
+  inline val dconst_1    = 0x0f
+
+  inline val bipush      = 0x10
+  inline val sipush      = 0x11
+  inline val ldc         = 0x12
+  inline val ldc_w       = 0x13
+  inline val ldc2_w      = 0x14
+
+  inline val iload       = 0x15
+  inline val lload       = 0x16
+  inline val fload       = 0x17
+  inline val dload       = 0x18
+  inline val aload       = 0x19
+
+  inline val iload_0     = 0x1a
+  inline val iload_1     = 0x1b
+  inline val iload_2     = 0x1c
+  inline val iload_3     = 0x1d
+  inline val lload_0     = 0x1e
+  inline val lload_1     = 0x1f
+  inline val lload_2     = 0x20
+  inline val lload_3     = 0x21
+  inline val fload_0     = 0x22
+  inline val fload_1     = 0x23
+  inline val fload_2     = 0x24
+  inline val fload_3     = 0x25
+  inline val dload_0     = 0x26
+  inline val dload_1     = 0x27
+  inline val dload_2     = 0x28
+  inline val dload_3     = 0x29
+  inline val aload_0     = 0x2a
+  inline val aload_1     = 0x2b
+  inline val aload_2     = 0x2c
+  inline val aload_3     = 0x2d
+  inline val iaload      = 0x2e
+  inline val laload      = 0x2f
+  inline val faload      = 0x30
+  inline val daload      = 0x31
+  inline val aaload      = 0x32
+  inline val baload      = 0x33
+  inline val caload      = 0x34
+  inline val saload      = 0x35
+
+  inline val istore      = 0x36
+  inline val lstore      = 0x37
+  inline val fstore      = 0x38
+  inline val dstore      = 0x39
+  inline val astore      = 0x3a
+  inline val istore_0    = 0x3b
+  inline val istore_1    = 0x3c
+  inline val istore_2    = 0x3d
+  inline val istore_3    = 0x3e
+  inline val lstore_0    = 0x3f
+  inline val lstore_1    = 0x40
+  inline val lstore_2    = 0x41
+  inline val lstore_3    = 0x42
+  inline val fstore_0    = 0x43
+  inline val fstore_1    = 0x44
+  inline val fstore_2    = 0x45
+  inline val fstore_3    = 0x46
+  inline val dstore_0    = 0x47
+  inline val dstore_1    = 0x48
+  inline val dstore_2    = 0x49
+  inline val dstore_3    = 0x4a
+  inline val astore_0    = 0x4b
+  inline val astore_1    = 0x4c
+  inline val astore_2    = 0x4d
+  inline val astore_3    = 0x4e
+  inline val iastore     = 0x4f
+  inline val lastore     = 0x50
+  inline val fastore     = 0x51
+  inline val dastore     = 0x52
+  inline val aastore     = 0x53
+  inline val bastore     = 0x54
+  inline val castore     = 0x55
+  inline val sastore     = 0x56
+
+  inline val pop         = 0x57
+  inline val pop2        = 0x58
+  inline val dup         = 0x59
+  inline val dup_x1      = 0x5a
+  inline val dup_x2      = 0x5b
+  inline val dup2        = 0x5c
+  inline val dup2_x1     = 0x5d
+  inline val dup2_x2     = 0x5e
+  inline val swap        = 0x5f
+
+  inline val iadd        = 0x60
+  inline val ladd        = 0x61
+  inline val fadd        = 0x62
+  inline val dadd        = 0x63
+  inline val isub        = 0x64
+  inline val lsub        = 0x65
+  inline val fsub        = 0x66
+  inline val dsub        = 0x67
+  inline val imul        = 0x68
+  inline val lmul        = 0x69
+  inline val fmul        = 0x6a
+  inline val dmul        = 0x6b
+  inline val idiv        = 0x6c
+  inline val ldiv        = 0x6d
+  inline val fdiv        = 0x6e
+  inline val ddiv        = 0x6f
+  inline val irem        = 0x70
+  inline val lrem        = 0x71
+  inline val frem        = 0x72
+  inline val drem        = 0x73
+
+  inline val ineg        = 0x74
+  inline val lneg        = 0x75
+  inline val fneg        = 0x76
+  inline val dneg        = 0x77
+
+  inline val ishl        = 0x78
+  inline val lshl        = 0x79
+  inline val ishr        = 0x7a
+  inline val lshr        = 0x7b
+  inline val iushr       = 0x7c
+  inline val lushr       = 0x7d
+  inline val iand        = 0x7e
+  inline val land        = 0x7f
+  inline val ior         = 0x80
+  inline val lor         = 0x81
+  inline val ixor        = 0x82
+  inline val lxor        = 0x83
+  inline val iinc        = 0x84
+
+  inline val i2l         = 0x85
+  inline val i2f         = 0x86
+  inline val i2d         = 0x87
+  inline val l2i         = 0x88
+  inline val l2f         = 0x89
+  inline val l2d         = 0x8a
+  inline val f2i         = 0x8b
+  inline val f2l         = 0x8c
+  inline val f2d         = 0x8d
+  inline val d2i         = 0x8e
+  inline val d2l         = 0x8f
+  inline val d2f         = 0x90
+  inline val i2b         = 0x91
+  inline val i2c         = 0x92
+  inline val i2s         = 0x93
+
+  inline val lcmp        = 0x94
+  inline val fcmpl       = 0x95
+  inline val fcmpg       = 0x96
+  inline val dcmpl       = 0x97
+  inline val dcmpg       = 0x98
+
+  inline val ifeq        = 0x99
+  inline val ifne        = 0x9a
+  inline val iflt        = 0x9b
+  inline val ifge        = 0x9c
+  inline val ifgt        = 0x9d
+  inline val ifle        = 0x9e
+  inline val if_icmpeq   = 0x9f
+  inline val if_icmpne   = 0xa0
+  inline val if_icmplt   = 0xa1
+  inline val if_icmpge   = 0xa2
+  inline val if_icmpgt   = 0xa3
+  inline val if_icmple   = 0xa4
+  inline val if_acmpeq   = 0xa5
+  inline val if_acmpne   = 0xa6
+  inline val goto        = 0xa7
+  inline val jsr         = 0xa8
+  inline val ret         = 0xa9
+  inline val tableswitch = 0xaa
+  inline val lookupswitch = 0xab
+  inline val ireturn     = 0xac
+  inline val lreturn     = 0xad
+  inline val freturn     = 0xae
+  inline val dreturn     = 0xaf
+  inline val areturn     = 0xb0
+  inline val return_     = 0xb1
+
+  inline val getstatic   = 0xb2
+  inline val putstatic   = 0xb3
+  inline val getfield    = 0xb4
+  inline val putfield    = 0xb5
+
+  inline val invokevirtual   = 0xb6
+  inline val invokespecial   = 0xb7
+  inline val invokestatic    = 0xb8
+  inline val invokeinterface = 0xb9
+  inline val xxxunusedxxxx   = 0xba
+
+  inline val new_          = 0xbb
+  inline val newarray      = 0xbc
+  inline val anewarray     = 0xbd
+  inline val arraylength   = 0xbe
+  inline val athrow        = 0xbf
+  inline val checkcast     = 0xc0
+  inline val instanceof    = 0xc1
+  inline val monitorenter  = 0xc2
+  inline val monitorexit   = 0xc3
+  inline val wide          = 0xc4
+  inline val multianewarray = 0xc5
+  inline val ifnull        = 0xc6
+  inline val ifnonnull     = 0xc7
+  inline val goto_w        = 0xc8
+  inline val jsr_w         = 0xc9
+
+  // reserved opcodes
+  inline val breakpoint    = 0xca
+  inline val impdep1       = 0xfe
+  inline val impdep2       = 0xff
+
+  import Flags._
+  abstract class FlagTranslation {
+
+    protected def baseFlags(jflags: Int): FlagSet = EmptyFlags
+    protected def isClass: Boolean = false
+
+    private def translateFlag(jflag: Int): FlagSet = (jflag: @switch) match {
+      case JAVA_ACC_PRIVATE    => Private
+      case JAVA_ACC_PROTECTED  => Protected
+      case JAVA_ACC_FINAL      => Final
+      case JAVA_ACC_SYNTHETIC  => SyntheticArtifact
+      case JAVA_ACC_STATIC     => JavaStatic
+      case JAVA_ACC_ENUM       => Enum
+      case JAVA_ACC_ABSTRACT   => if (isClass) Abstract else Deferred
+      case JAVA_ACC_INTERFACE  => PureInterfaceCreationFlags | JavaDefined
+      case _                   => EmptyFlags
+    }
+
+    private def addFlag(base: FlagSet, jflag: Int): FlagSet =
+      if (jflag == 0) base else base | translateFlag(jflag)
+
+    private def translateFlags(jflags: Int, baseFlags: FlagSet): FlagSet = {
+      val nflags =
+        if ((jflags & JAVA_ACC_ANNOTATION) == 0) jflags
+        else jflags & ~(JAVA_ACC_ABSTRACT | JAVA_ACC_INTERFACE) // annotations are neither abstract nor interfaces
+      var res: FlagSet = baseFlags | JavaDefined
+      res = addFlag(res, nflags & JAVA_ACC_PRIVATE)
+      res = addFlag(res, nflags & JAVA_ACC_PROTECTED)
+      res = addFlag(res, nflags & JAVA_ACC_FINAL)
+      res = addFlag(res, nflags & JAVA_ACC_SYNTHETIC)
+      res = addFlag(res, nflags & JAVA_ACC_STATIC)
+      res = addFlag(res, nflags & JAVA_ACC_ENUM)
+      res = addFlag(res, nflags & JAVA_ACC_ABSTRACT)
+      res = addFlag(res, nflags & JAVA_ACC_INTERFACE)
+      res
+    }
+
+    def flags(jflags: Int): FlagSet = translateFlags(jflags, baseFlags(jflags))
+  }
+  val classTranslation: FlagTranslation = new FlagTranslation {
+    override def isClass = true
+  }
+  val fieldTranslation: FlagTranslation = new FlagTranslation {
+    override def baseFlags(jflags: Int) = if ((jflags & JAVA_ACC_FINAL) == 0) Mutable else EmptyFlags
+  }
+  val methodTranslation: FlagTranslation = new FlagTranslation {
+    override def baseFlags(jflags: Int) = if ((jflags & JAVA_ACC_BRIDGE) != 0) Bridge else EmptyFlags
+  }
+}
diff --git a/tests/pos-with-compiler-cc/dotc/core/classfile/ClassfileParser.scala b/tests/pos-with-compiler-cc/dotc/core/classfile/ClassfileParser.scala
new file mode 100644
index 000000000000..6c3fd2cf7336
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/core/classfile/ClassfileParser.scala
@@ -0,0 +1,1378 @@
+package dotty.tools
+package dotc
+package core
+package classfile
+
+import scala.language.unsafeNulls
+
+import dotty.tools.tasty.{ TastyReader, TastyHeaderUnpickler }
+
+import Contexts._, Symbols._, Types._, Names._, StdNames._, NameOps._, Scopes._, Decorators._
+import SymDenotations._, unpickleScala2.Scala2Unpickler._, Constants._, Annotations._, util.Spans._
+import Phases._
+import ast.{ tpd, untpd }
+import ast.tpd._, util._
+import java.io.{ ByteArrayOutputStream, IOException }
+
+import java.lang.Integer.toHexString
+import java.util.UUID
+
+import scala.collection.immutable
+import scala.collection.mutable.{ ListBuffer, ArrayBuffer }
+import scala.annotation.switch
+import typer.Checking.checkNonCyclic
+import io.{AbstractFile, ZipArchive}
+import scala.util.control.NonFatal
+import language.experimental.pureFunctions
+
+object ClassfileParser {
+  /** Marker trait for unpicklers that can be embedded in classfiles. */
+  trait Embedded
+
+  /** Indicate that there is nothing to unpickle and the corresponding symbols can
+    * be invalidated. */
+  object NoEmbedded extends Embedded
+
+  /** Replace raw types with wildcard applications */
+  def cook(using Context): TypeMap = new TypeMap {
+    def apply(tp: Type): Type = tp match {
+      case tp: TypeRef if tp.symbol.typeParams.nonEmpty =>
+        AppliedType(tp, tp.symbol.typeParams.map(Function.const(TypeBounds.empty)))
+      case tp @ AppliedType(tycon, args) =>
+        // disregard tycon itself, but map over it to visit the prefix
+        tp.derivedAppliedType(mapOver(tycon), args.mapConserve(this))
+      case tp @ TempPolyType(_, tpe) =>
+        val tpe1 = this(tpe)
+        if (tpe1 eq tpe) tp else tp.copy(tpe = tpe1)
+      case tp @ TempClassInfoType(parents, _, _) =>
+        val parents1 = parents.mapConserve(this)
+        if (parents eq parents1) tp else tp.copy(parentTypes = parents1)
+      case _ =>
+        mapOver(tp)
+    }
+  }
+}
+
+class ClassfileParser(
+    classfile: AbstractFile,
+    classRoot: ClassDenotation,
+    moduleRoot: ClassDenotation)(ictx: Context) {
+
+  import ClassfileConstants._
+  import ClassfileParser._
+
+  protected val staticModule: Symbol = moduleRoot.sourceModule(using ictx)
+
+  protected val instanceScope: MutableScope = newScope(0)     // the scope of all instance definitions
+  protected val staticScope: MutableScope = newScope(0)       // the scope of all static definitions
+  protected var pool: ConstantPool = _              // the classfile's constant pool
+
+  protected var currentClassName: SimpleName = _      // JVM name of the current class
+  protected var classTParams: Map[Name, Symbol] = Map()
+
+  private var Scala2UnpicklingMode = Mode.Scala2Unpickling
+
+  classRoot.info = NoLoader().withDecls(instanceScope)
+  moduleRoot.info = NoLoader().withDecls(staticScope).withSourceModule(staticModule)
+
+  private def currentIsTopLevel(using Context) = classRoot.owner.is(Flags.PackageClass)
+
+  private def mismatchError(className: SimpleName) =
+    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.withInstance { reader =>
+    implicit val reader2 = reader.reset(classfile)
+    report.debuglog("[class] >> " + classRoot.fullName)
+    parseHeader()
+    this.pool = new ConstantPool
+    val res = parseClass()
+    this.pool =  null
+    res
+  }
+  catch {
+    case e: RuntimeException =>
+      if (ctx.debug) e.printStackTrace()
+      throw new IOException(
+        i"""class file ${classfile.canonicalPath} is broken, reading aborted with ${e.getClass}
+           |${Option(e.getMessage).getOrElse("")}""")
+  }
+
+  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)}")
+    val minorVersion = in.nextChar.toInt
+    val majorVersion = in.nextChar.toInt
+    if ((majorVersion < JAVA_MAJOR_VERSION) ||
+        ((majorVersion == JAVA_MAJOR_VERSION) &&
+         (minorVersion < JAVA_MINOR_VERSION)))
+      throw new IOException(
+        s"class file '${classfile}' has unknown version $majorVersion.$minorVersion, should be at least $JAVA_MAJOR_VERSION.$JAVA_MINOR_VERSION")
+  }
+
+  /** Return the class symbol of the given name. */
+  def classNameToSymbol(name: Name)(using Context): Symbol =
+    val nameStr = name.toString
+    innerClasses.get(nameStr) match
+      case Some(entry) => innerClasses.classSymbol(entry)
+      case None =>
+        def lookupTopLevel(): Symbol = requiredClass(name)
+        // For inner classes we usually don't get to this branch: `innerClasses.classSymbol` already returns the symbol
+        // of the inner class based on the InnerClass table. However, if the classfile is missing the
+        // InnerClass entry for `name`, it might still be that there exists an inner symbol (because
+        // some other classfile _does_ have an InnerClass entry for `name`). In this case, we want to
+        // return the actual inner symbol (C.D, with owner C), not the top-level symbol C$D. This is
+        // what the logic below is for (see scala/bug#9937 / lampepfl/dotty#12086).
+        val split = nameStr.lastIndexOf('$')
+        if split < 0 || split >= nameStr.length - 1 then
+          lookupTopLevel()
+        else
+          val outerNameStr = nameStr.substring(0, split)
+          val innerNameStr = nameStr.substring(split + 1, nameStr.length)
+          val outerSym = classNameToSymbol(outerNameStr.toTypeName)
+          outerSym.denot.infoOrCompleter match
+            case _: StubInfo =>
+              // If the outer class C cannot be found, look for a top-level class C$D
+              lookupTopLevel()
+            case _ =>
+              // We have a java-defined class name C$D and look for a member D of C. But we don't know if
+              // D is declared static or not, so we have to search both in class C and its companion.
+              val innerName = innerNameStr.toTypeName
+              val r =
+                if outerSym eq classRoot.symbol then
+                  instanceScope.lookup(innerName).orElse(staticScope.lookup(innerName))
+                else
+                  outerSym.info.member(innerName).orElse(outerSym.asClass.companionModule.info.member(innerName)).symbol
+              r.orElse(lookupTopLevel())
+
+  var sawPrivateConstructor: Boolean = false
+
+  def parseClass()(using ctx: Context, in: DataReader): Option[Embedded] = {
+    val jflags       = in.nextChar
+    val isAnnotation = hasAnnotation(jflags)
+    val sflags       = classTranslation.flags(jflags)
+    val isEnum       = (jflags & JAVA_ACC_ENUM) != 0
+    val nameIdx      = in.nextChar
+    currentClassName = pool.getClassName(nameIdx).name
+
+    if (currentIsTopLevel &&
+        currentClassName != classRoot.fullName.toSimpleName &&
+        currentClassName != classRoot.fullName.encode.toSimpleName)
+      mismatchError(currentClassName)
+
+    addEnclosingTParams()
+
+    /** Parse parents for Java classes. For Scala, return AnyRef, since the real type will be unpickled.
+     *  Updates the read pointer of 'in'. */
+    def parseParents: List[Type] = {
+      val superType =
+        if (isAnnotation) {
+          in.nextChar
+          defn.AnnotationClass.typeRef
+        }
+        else if (classRoot.symbol == defn.ComparableClass ||
+                 classRoot.symbol == defn.JavaCloneableClass ||
+                 classRoot.symbol == defn.JavaSerializableClass) {
+          // Treat these interfaces as universal traits
+          in.nextChar
+          defn.AnyType
+        }
+        else
+          pool.getSuperClass(in.nextChar).typeRef
+      val ifaceCount = in.nextChar
+      var ifaces = for (i <- (0 until ifaceCount).toList) yield pool.getSuperClass(in.nextChar).typeRef
+        // Dotty deviation: was
+        //    var ifaces = for (i <- List.range(0, ifaceCount)) ...
+        // This does not typecheck because the type parameter of List is now lower-bounded by Int | Char.
+        // Consequently, no best implicit for the "Integral" evidence parameter of "range"
+        // is found. Previously, this worked because of weak conformance, which has been dropped.
+
+      if (isAnnotation) ifaces = defn.ClassfileAnnotationClass.typeRef :: ifaces
+      superType :: ifaces
+    }
+
+
+    val result = unpickleOrParseInnerClasses()
+    if (!result.isDefined) {
+      var classInfo: Type = TempClassInfoType(parseParents, instanceScope, classRoot.symbol)
+      // might be reassigned by later parseAttributes
+      val staticInfo = TempClassInfoType(List(), staticScope, moduleRoot.symbol)
+
+      enterOwnInnerClasses()
+
+      classRoot.setFlag(sflags)
+      moduleRoot.setFlag(Flags.JavaDefined | Flags.ModuleClassCreationFlags)
+
+      val privateWithin = getPrivateWithin(jflags)
+
+      classRoot.setPrivateWithin(privateWithin)
+      moduleRoot.setPrivateWithin(privateWithin)
+      moduleRoot.sourceModule.setPrivateWithin(privateWithin)
+
+      for (i <- 0 until in.nextChar) parseMember(method = false)
+      for (i <- 0 until in.nextChar) parseMember(method = true)
+
+      classRoot.registerCompanion(moduleRoot.symbol)
+      moduleRoot.registerCompanion(classRoot.symbol)
+
+      setClassInfo(moduleRoot, staticInfo, fromScala2 = false)
+
+      classInfo = parseAttributes(classRoot.symbol).complete(classInfo)
+      if (isAnnotation)
+        // classInfo must be a TempClassInfoType and not a TempPolyType,
+        // because Java annotations cannot have type parameters.
+        addAnnotationConstructor(classInfo.asInstanceOf[TempClassInfoType])
+
+      setClassInfo(classRoot, classInfo, fromScala2 = false)
+      NamerOps.addConstructorProxies(moduleRoot.classSymbol)
+    }
+    else if (result == Some(NoEmbedded))
+      for (sym <- List(moduleRoot.sourceModule, moduleRoot.symbol, classRoot.symbol)) {
+        classRoot.owner.asClass.delete(sym)
+        sym.markAbsent()
+      }
+
+    result
+  }
+
+  /** Add type parameters of enclosing classes */
+  def addEnclosingTParams()(using Context): Unit = {
+    var sym = classRoot.owner
+    while (sym.isClass && !sym.is(Flags.ModuleClass)) {
+      for (tparam <- sym.typeParams)
+        classTParams = classTParams.updated(tparam.name, tparam)
+      sym = sym.owner
+    }
+  }
+
+  def parseMember(method: Boolean)(using ctx: Context, in: DataReader): Unit = {
+    val start = indexCoord(in.bp)
+    val jflags = in.nextChar
+    val sflags =
+      if (method) Flags.Method | methodTranslation.flags(jflags)
+      else fieldTranslation.flags(jflags)
+    val preName = pool.getName(in.nextChar)
+    if (!sflags.isOneOf(Flags.PrivateOrArtifact) || preName.name == nme.CONSTRUCTOR) {
+      val sig = pool.getExternalName(in.nextChar).value
+      val completer = MemberCompleter(preName.name, jflags, sig)
+      val member = newSymbol(
+        getOwner(jflags), preName.name, sflags, completer,
+        getPrivateWithin(jflags), coord = start)
+
+      completer.attrCompleter = parseAttributes(member)
+
+      getScope(jflags).enter(member)
+
+    }
+    else {
+      in.nextChar // info
+      skipAttributes()
+    }
+  }
+
+  class MemberCompleter(name: SimpleName, jflags: Int, sig: String) extends LazyType {
+    var attrCompleter: AttributeCompleter = null
+
+    def complete(denot: SymDenotation)(using Context): Unit = {
+      val sym = denot.symbol
+      val isEnum = (jflags & JAVA_ACC_ENUM) != 0
+      val isNative = (jflags & JAVA_ACC_NATIVE) != 0
+      val isTransient = (jflags & JAVA_ACC_TRANSIENT) != 0
+      val isVolatile = (jflags & JAVA_ACC_VOLATILE) != 0
+      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.toString) match {
+        case Some(entry) if !isStatic(entry.jflags) =>
+          val mt @ MethodTpe(paramNames, paramTypes, resultType) = denot.info: @unchecked
+          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 _ =>
+      }
+
+      /** 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))
+        }
+
+        denot.info = resultType(denot.info)
+        addConstructorTypeParams(denot)
+      }
+
+      val isVarargs = denot.is(Flags.Method) && (jflags & JAVA_ACC_VARARGS) != 0
+      denot.info = sigToType(sig, isVarargs = isVarargs)
+      if (isConstructor) normalizeConstructorParams()
+      if isNative then
+        attrCompleter.annotations ::= Annotation.deferredSymAndTree(defn.NativeAnnot)(New(defn.NativeAnnot.typeRef, Nil))
+      if isTransient then
+        attrCompleter.annotations ::= Annotation.deferredSymAndTree(defn.TransientAnnot)(New(defn.TransientAnnot.typeRef, Nil))
+      if isVolatile then
+        attrCompleter.annotations ::= Annotation.deferredSymAndTree(defn.VolatileAnnot)(New(defn.VolatileAnnot.typeRef, Nil))
+      denot.info = translateTempPoly(attrCompleter.complete(denot.info, isVarargs))
+      if (isConstructor) normalizeConstructorInfo()
+
+      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))
+        }
+      }
+
+    }
+  }
+
+  def constantTagToType(tag: Int)(using Context): Type =
+    (tag: @switch) match {
+      case BYTE_TAG   => defn.ByteType
+      case CHAR_TAG   => defn.CharType
+      case DOUBLE_TAG => defn.DoubleType
+      case FLOAT_TAG  => defn.FloatType
+      case INT_TAG    => defn.IntType
+      case LONG_TAG   => defn.LongType
+      case SHORT_TAG  => defn.ShortType
+      case VOID_TAG   => defn.UnitType
+      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
+    def accept(ch: Char): Unit = {
+      assert(sig(index) == ch, (sig(index), ch))
+      index += 1
+    }
+    def subName(isDelimiter: Char => Boolean): SimpleName = {
+      val start = index
+      while (!isDelimiter(sig(index))) { index += 1 }
+      termName(sig.slice(start, index))
+    }
+    // Warning: sigToType contains nested completers which might be forced in a later run!
+    // So local methods need their own ctx parameters.
+    def sig2type(tparams: immutable.Map[Name, Symbol], skiptvs: Boolean)(using Context): Type = {
+      val tag = sig(index); index += 1
+      (tag: @switch) match {
+        case 'L' =>
+          /** A type representation where inner classes become `A#B` instead of `A.this.B` (like with `typeRef`)
+           *
+           *  Note: the symbol must not be nested in a generic class.
+           */
+          def innerType(symbol: Symbol): Type =
+            if symbol.is(Flags.Package) then
+              symbol.thisType
+            else if symbol.isType then
+              TypeRef(innerType(symbol.owner), symbol)
+            else
+              throw new RuntimeException("unexpected term symbol " + symbol)
+
+          def processTypeArgs(tp: Type): Type = tp match {
+            case tp: TypeRef =>
+              if (sig(index) == '<') {
+                accept('<')
+                val argsBuf = if (skiptvs) null else new ListBuffer[Type]
+                while (sig(index) != '>') {
+                  val arg = sig(index) match {
+                    case variance @ ('+' | '-' | '*') =>
+                      index += 1
+                      variance match {
+                        case '+' => TypeBounds.upper(sig2type(tparams, skiptvs))
+                        case '-' =>
+                          val argTp = sig2type(tparams, skiptvs)
+                          // Interpret `sig2type` returning `Any` as "no bounds";
+                          // morally equivalent to TypeBounds.empty, but we're representing Java code, so use FromJavaObjectType as the upper bound
+                          if (argTp.typeSymbol == defn.AnyClass) TypeBounds.upper(defn.FromJavaObjectType)
+                          else TypeBounds(argTp, defn.FromJavaObjectType)
+                        case '*' => TypeBounds.upper(defn.FromJavaObjectType)
+                      }
+                    case _ => sig2type(tparams, skiptvs)
+                  }
+                  if (argsBuf != null) argsBuf += arg
+                }
+                accept('>')
+                if (skiptvs) tp else AppliedType(tp, argsBuf.toList)
+              }
+              else tp
+            case tp =>
+              assert(sig(index) != '<', tp)
+              tp
+          }
+
+          val classSym = classNameToSymbol(subName(c => c == ';' || c == '<'))
+          val classTpe = if (classSym eq defn.ObjectClass) defn.FromJavaObjectType else innerType(classSym)
+          var tpe = processTypeArgs(classTpe)
+          while (sig(index) == '.') {
+            accept('.')
+            val name = subName(c => c == ';' || c == '<' || c == '.').toTypeName
+            val tp = tpe.select(name)
+            tpe = processTypeArgs(tp)
+          }
+          accept(';')
+          tpe
+        case ARRAY_TAG =>
+          while ('0' <= sig(index) && sig(index) <= '9') index += 1
+          val elemtp = sig2type(tparams, skiptvs)
+          defn.ArrayOf(elemtp.translateJavaArrayElementType)
+        case '(' =>
+          def isMethodEnd(i: Int) = sig(i) == ')'
+          def isArray(i: Int) = sig(i) == '['
+
+          /** Is this a repeated parameter type?
+           *  This is true if we're in a vararg method and this is the last parameter.
+           */
+          def isRepeatedParam(i: Int): Boolean =
+            if !isVarargs then return false
+            var cur = i
+            // Repeated parameters are represented as arrays
+            if !isArray(cur) then return false
+            // Handle nested arrays: int[]...
+            while isArray(cur) do
+              cur += 1
+            // Simple check to see if we're the last parameter: there should be no
+            // array in the signature until the method end.
+            while !isMethodEnd(cur) do
+              if isArray(cur) then return false
+              cur += 1
+            true
+          end isRepeatedParam
+
+          val paramtypes = new ListBuffer[Type]()
+          var paramnames = new ListBuffer[TermName]()
+          while !isMethodEnd(index) do
+            paramnames += nme.syntheticParamName(paramtypes.length)
+            paramtypes += {
+              if isRepeatedParam(index) then
+                index += 1
+                val elemType = sig2type(tparams, skiptvs = false)
+                // `ElimRepeated` is responsible for correctly erasing this.
+                defn.RepeatedParamType.appliedTo(elemType)
+              else
+                sig2type(tparams, skiptvs = false)
+            }
+
+          index += 1
+          val restype = sig2type(tparams, skiptvs = false)
+          MethodType(paramnames.toList, paramtypes.toList, restype)
+        case 'T' =>
+          val n = subName(';'.==).toTypeName
+          index += 1
+          //assert(tparams contains n, s"classTparams = $classTParams, tparams = $tparams, key = $n")
+          if (skiptvs) defn.AnyType else tparams(n).typeRef
+        case tag =>
+          constantTagToType(tag)
+      }
+    }
+    // sig2type(tparams, skiptvs)
+
+    def sig2typeBounds(tparams: immutable.Map[Name, Symbol], skiptvs: Boolean)(using Context): Type = {
+      val ts = new ListBuffer[Type]
+      while (sig(index) == ':') {
+        index += 1
+        if (sig(index) != ':') { // guard against empty class bound
+          val tp = sig2type(tparams, skiptvs)
+          if (!skiptvs)
+            ts += cook(tp)
+        }
+      }
+      if (!skiptvs) {
+        val bound = if ts.isEmpty then defn.AnyType else ts.reduceLeft(AndType.apply)
+        TypeBounds.upper(bound)
+      }
+      else NoType
+    }
+
+    var tparams = classTParams
+
+    def typeParamCompleter(start: Int) = new LazyType {
+      def complete(denot: SymDenotation)(using Context): Unit = {
+        val savedIndex = index
+        try {
+          index = start
+          denot.info =
+            checkNonCyclic( // we need the checkNonCyclic call to insert LazyRefs for F-bounded cycles
+                denot.symbol,
+                sig2typeBounds(tparams, skiptvs = false),
+                reportErrors = false)
+        }
+        finally
+          index = savedIndex
+      }
+    }
+
+    val newTParams = new ListBuffer[Symbol]()
+    if (sig(index) == '<') {
+      assert(owner != null)
+      index += 1
+      val start = index
+      while (sig(index) != '>') {
+        val tpname = subName(':'.==).toTypeName
+        val s = newSymbol(
+          owner, tpname, owner.typeParamCreationFlags,
+          typeParamCompleter(index), coord = indexCoord(index))
+        if (owner.isClass) owner.asClass.enter(s)
+        tparams = tparams + (tpname -> s)
+        sig2typeBounds(tparams, skiptvs = true)
+        newTParams += s
+      }
+      index += 1
+    }
+    val ownTypeParams = newTParams.toList.asInstanceOf[List[TypeSymbol]]
+    val tpe =
+      if ((owner == null) || !owner.isClass)
+        sig2type(tparams, skiptvs = false)
+      else {
+        classTParams = tparams
+        val parents = new ListBuffer[Type]()
+        while (index < end)
+          parents += sig2type(tparams, skiptvs = false) // here the variance doesn't matter
+        TempClassInfoType(parents.toList, instanceScope, owner)
+      }
+    if (ownTypeParams.isEmpty) tpe else TempPolyType(ownTypeParams, tpe)
+  }
+  // sigToType
+
+  class EnumTag(sig: String, name: NameOrString) {
+    def toTree(using ctx: Context): untpd.Tree = {
+      val enumClassTp = sigToType(sig)
+      val enumModuleClass = enumClassTp.classSymbol.companionModule
+      val tmref = TermRef(enumModuleClass.termRef, name.name)
+      untpd.TypedSplice(ref(tmref))
+    }
+  }
+
+  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
+    // early. To avoid this we store annotation arguments as untyped trees
+
+    // ... but constants need to actually be typed with a ConstantType, so we
+    // can't rely on type inference, and type them early.
+    def lit(c: Constant): untpd.Tree = untpd.TypedSplice(tpd.Literal(c))
+
+    val tag = in.nextByte.toChar
+    val index = in.nextChar
+
+    tag match {
+      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 {
+          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 =>
+        if (skip) None else Some(lit(Constant(pool.getType(index))))
+      case ENUM_TAG =>
+        val sig = pool.getExternalName(index).value
+        val enumCaseName = pool.getName(in.nextChar)
+        if (skip) None else Some(EnumTag(sig, enumCaseName))
+      case ARRAY_TAG =>
+        val arr = new ArrayBuffer[untpd.Tree]()
+        var hasError = false
+        for (i <- 0 until index)
+          parseAnnotArg(skip) match {
+            case Some(c: untpd.Tree) => arr += c
+            case Some(tag: EnumTag) => arr += tag.toTree
+            case None => hasError = true
+          }
+        if (hasError) None
+        else if (skip) None
+        else {
+          val elems = arr.toList
+          Some(untpd.JavaSeqLiteral(elems, untpd.TypeTree()))
+        }
+      case ANNOTATION_TAG =>
+        parseAnnotation(index, skip).map(_.untpdTree)
+    }
+  }
+
+  class ClassfileAnnotation(annotType: Type, lazyArgs: List[(NameOrString, untpd.Tree | EnumTag)]) extends LazyAnnotation {
+    private def args(using Context): List[untpd.Tree] =
+      lazyArgs.map {
+        case (name, tree: untpd.Tree) => untpd.NamedArg(name.name, tree).withSpan(NoSpan)
+        case (name, tag: EnumTag)     => untpd.NamedArg(name.name, tag.toTree).withSpan(NoSpan)
+      }
+
+    protected var mySym: Symbol | (Context ?-> Symbol) =
+      (ctx: Context) ?=> annotType.classSymbol
+
+    protected var myTree: Tree | (Context ?-> Tree) =
+      (ctx: Context) ?=> untpd.resolveConstructor(annotType, args)
+
+    def untpdTree(using Context): untpd.Tree =
+      untpd.New(untpd.TypeTree(annotType), List(args))
+  }
+
+  /** Parse and return a single annotation.  If it is malformed,
+   *  return None.
+   */
+  def parseAnnotation(attrNameIndex: Char, skip: Boolean = false)(using ctx: Context, in: DataReader): Option[ClassfileAnnotation] = try {
+    val attrType = pool.getType(attrNameIndex.toInt)
+    val nargs = in.nextChar.toInt
+    val argbuf = new ListBuffer[(NameOrString, untpd.Tree | EnumTag)]
+    var hasError = false
+    for (i <- 0 until nargs) {
+      val name = pool.getName(in.nextChar)
+      parseAnnotArg(skip) match {
+        case Some(arg) =>
+          argbuf += name -> arg
+
+        case None =>
+          hasError = !skip
+      }
+    }
+    attrType match
+      case tp: TypeRef if tp.denot.infoOrCompleter.isInstanceOf[StubInfo] =>
+        // Silently ignore missing annotation classes like javac
+        if ctx.debug then
+          report.warning(i"Error while parsing annotations in ${classfile}: annotation class $tp not present on classpath")
+        None
+      case _ =>
+        if (hasError || skip) None
+        else Some(ClassfileAnnotation(attrType, argbuf.toList))
+  }
+  catch {
+    case f: FatalError => throw f // don't eat fatal errors, they mean a class was not found
+    case NonFatal(ex) =>
+      // We want to be robust when annotations are unavailable, so the very least
+      // we can do is warn the user about the exception
+      // There was a reference to ticket 1135, but that is outdated: a reference to a class not on
+      // the classpath would *not* end up here. A class not found is signaled
+      // with a `FatalError` exception, handled above. Here you'd end up after a NPE (for example),
+      // and that should never be swallowed silently.
+      report.warning("Caught: " + ex + " while parsing annotations in " + classfile)
+      if (ctx.debug) ex.printStackTrace()
+
+      None // ignore malformed annotations
+  }
+
+  /** A completer for attributes
+   *
+   *  Top-level classes complete attributes eagerly, while members complete lazily.
+   *
+   *  @note We cannot simply store the bytes of attributes, as the bytes may
+   *  contain references to the constant pool, where the constants are loaded
+   *  lazily.
+   */
+  class AttributeCompleter(sym: Symbol) {
+    var sig: String = null
+    var constant: Constant = null
+    var exceptions: List[NameOrString] = Nil
+    var annotations: List[Annotation] = Nil
+    var namedParams: Map[Int, TermName] = Map.empty
+    def complete(tp: Type, isVarargs: Boolean = false)(using Context): Type = {
+      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
+        }
+
+      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))
+      }
+
+      def fillInParamNames(t: Type): Type = t match
+        case mt @ MethodType(oldp) if namedParams.nonEmpty =>
+          mt.derivedLambdaType(List.tabulate(oldp.size)(n => namedParams.getOrElse(n, oldp(n))))
+        case pt: PolyType if namedParams.nonEmpty =>
+          pt.derivedLambdaType(pt.paramNames, pt.paramInfos, fillInParamNames(pt.resultType))
+        case _ => t
+
+      cook.apply(fillInParamNames(newType))
+    }
+  }
+
+  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
+      val attrLen = in.nextInt
+      val end = in.bp + attrLen
+      attrName match {
+        case tpnme.SignatureATTR =>
+          val sig = pool.getExternalName(in.nextChar)
+          res.sig = sig.value
+
+        case tpnme.SyntheticATTR =>
+          sym.setFlag(Flags.SyntheticArtifact)
+
+        case tpnme.BridgeATTR =>
+          sym.setFlag(Flags.Bridge)
+
+        case tpnme.DeprecatedATTR =>
+          val msg = Literal(Constant("see corresponding Javadoc for more information."))
+          val since = Literal(Constant(""))
+          res.annotations ::= Annotation.deferredSymAndTree(defn.DeprecatedAnnot) {
+            New(defn.DeprecatedAnnot.typeRef, msg :: since :: Nil)
+          }
+
+        case tpnme.ConstantValueATTR =>
+          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.MethodParametersATTR =>
+          val paramCount = in.nextByte
+          for i <- 0 until paramCount do
+            val name = pool.getName(in.nextChar)
+            val flags = in.nextChar
+            if (flags & JAVA_ACC_SYNTHETIC) == 0 then
+              res.namedParams += (i -> name.name)
+
+        case tpnme.AnnotationDefaultATTR =>
+          sym.addAnnotation(Annotation(defn.AnnotationDefaultAnnot, Nil))
+
+        // Java annotations on classes / methods / fields with RetentionPolicy.RUNTIME
+        case tpnme.RuntimeVisibleAnnotationATTR
+          | tpnme.RuntimeInvisibleAnnotationATTR =>
+          parseAnnotations(attrLen)
+
+        // TODO 1: parse runtime visible annotations on parameters
+        // case tpnme.RuntimeParamAnnotationATTR
+
+        // TODO 2: also parse RuntimeInvisibleParamAnnotation
+        // i.e. java annotations with RetentionPolicy.CLASS?
+
+        case tpnme.ExceptionsATTR =>
+          parseExceptions(attrLen)
+
+        case tpnme.CodeATTR =>
+          in.skip(attrLen)
+          // flag test will trigger completion and cycles, thus have to be lazy
+          if (sym.owner.flagsUNSAFE.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.")
+          }
+
+        case _ =>
+      }
+      in.bp = end
+    }
+
+    /**
+     * Parse the "Exceptions" attribute which denotes the exceptions
+     * thrown by a method.
+     */
+    def parseExceptions(len: Int): Unit = {
+      val nClasses = in.nextChar
+      for (n <- 0 until nClasses) {
+        // FIXME: this performs an equivalent of getExceptionTypes instead of getGenericExceptionTypes (SI-7065)
+        val cls = pool.getClassName(in.nextChar.toInt)
+        res.exceptions ::= cls
+      }
+    }
+
+
+    /** Parse a sequence of annotations and attaches them to the
+     *  current symbol sym, except for the ScalaSignature annotation that it returns, if it is available. */
+    def parseAnnotations(len: Int): Unit = {
+      val nAttr = in.nextChar
+      for (n <- 0 until nAttr)
+        parseAnnotation(in.nextChar) match {
+          case Some(annot) =>
+            sym.addAnnotation(annot)
+          case None =>
+        }
+    }
+
+    // begin parseAttributes
+    for (i <- 0 until in.nextChar)
+      parseAttribute()
+
+    res
+  }
+
+  /** Annotations in Scala are assumed to get all their arguments as constructor
+   *  parameters. For Java annotations we need to fake it by making up the constructor.
+   */
+  def addAnnotationConstructor(classInfo: TempClassInfoType)(using Context): Unit =
+    newSymbol(
+      owner = classRoot.symbol,
+      name = nme.CONSTRUCTOR,
+      flags = Flags.Synthetic | Flags.JavaDefined | Flags.Method,
+      info = new AnnotConstructorCompleter(classInfo)
+    ).entered
+
+  class AnnotConstructorCompleter(classInfo: TempClassInfoType) extends LazyType {
+    def complete(denot: SymDenotation)(using Context): Unit = {
+      val attrs = classInfo.decls.toList.filter(sym => sym.isTerm && sym != denot.symbol)
+      val paramNames = attrs.map(_.name.asTermName)
+      val paramTypes = attrs.map(_.info.resultType)
+      denot.info = MethodType(paramNames, paramTypes, classRoot.typeRef)
+    }
+  }
+
+  /** Enter own inner classes in the right scope. It needs the scopes to be set up,
+   *  and implicitly current class' superclasses.
+   */
+  private def enterOwnInnerClasses()(using Context, DataReader): Unit = {
+    def enterClassAndModule(entry: InnerClassEntry, file: AbstractFile, jflags: Int) =
+      SymbolLoaders.enterClassAndModule(
+          getOwner(jflags),
+          entry.originalName,
+          new ClassfileLoader(file),
+          classTranslation.flags(jflags),
+          getScope(jflags))
+
+    for entry <- innerClasses.valuesIterator do
+      // create a new class member for immediate inner classes
+      if entry.outer.name == currentClassName then
+        val file = ctx.platform.classPath.findClassFile(entry.externalName.toString) getOrElse {
+          throw new AssertionError(entry.externalName)
+        }
+        enterClassAndModule(entry, file, entry.jflags)
+  }
+
+  // Nothing$ and Null$ were incorrectly emitted with a Scala attribute
+  // instead of ScalaSignature before 2.13.0-M2, see https://github.com/scala/scala/pull/5952
+  private val scalaUnpickleWhitelist = List(tpnme.nothingClass, tpnme.nullClass)
+
+  /** Parse inner classes. Expects `in.bp` to point to the superclass entry.
+   *  Restores the old `bp`.
+   *  @return Some(unpickler) iff classfile is from Scala, so no Java info needs to be read.
+   */
+  def unpickleOrParseInnerClasses()(using ctx: Context, in: DataReader): Option[Embedded] = {
+    val oldbp = in.bp
+    try {
+      skipSuperclasses()
+      skipMembers() // fields
+      skipMembers() // methods
+      val attrs = in.nextChar
+      val attrbp = in.bp
+
+      def scan(target: TypeName): Boolean = {
+        in.bp = attrbp
+        var i = 0
+        while (i < attrs && pool.getName(in.nextChar).name.toTypeName != target) {
+          val attrLen = in.nextInt
+          in.skip(attrLen)
+          i += 1
+        }
+        i < attrs
+      }
+
+      def unpickleScala(bytes: Array[Byte]): Some[Embedded] = {
+        val allowed = ctx.settings.Yscala2Unpickler.value
+
+        def failUnless(cond: Boolean) =
+          assert(cond,
+            s"Unpickling ${classRoot.symbol.showLocated} from ${classRoot.symbol.associatedFile} is not allowed with -Yscala2-unpickler $allowed")
+
+        if (allowed != "always") {
+          failUnless(allowed != "never")
+          val allowedList = allowed.split(java.io.File.pathSeparator).toList
+          val file = classRoot.symbol.associatedFile
+          // Using `.toString.contains` isn't great, but it's good enough for a debug flag.
+          failUnless(file == null || allowedList.exists(path => file.toString.contains(path)))
+        }
+
+        val unpickler = new unpickleScala2.Scala2Unpickler(bytes, classRoot, moduleRoot)(ctx)
+        withMode(Scala2UnpicklingMode)(unpickler.run())
+        Some(unpickler)
+      }
+
+      def unpickleTASTY(bytes: Array[Byte]): Some[Embedded]  = {
+        val unpickler = new tasty.DottyUnpickler(bytes)
+        unpickler.enter(roots = Set(classRoot, moduleRoot, moduleRoot.sourceModule))(using ctx.withSource(util.NoSource))
+        Some(unpickler)
+      }
+
+      def parseScalaSigBytes: Array[Byte] = {
+        val tag = in.nextByte.toChar
+        assert(tag == STRING_TAG, tag)
+        pool getBytes in.nextChar
+      }
+
+      def parseScalaLongSigBytes: Array[Byte] = {
+        val tag = in.nextByte.toChar
+        assert(tag == ARRAY_TAG, tag)
+        val stringCount = in.nextChar
+        val entries =
+          for (i <- 0 until stringCount) yield {
+            val stag = in.nextByte.toChar
+            assert(stag == STRING_TAG, stag)
+            in.nextChar.toInt
+          }
+        pool.getBytes(entries.toList)
+      }
+
+      if (scan(tpnme.TASTYATTR)) {
+        val attrLen = in.nextInt
+        val bytes = in.nextBytes(attrLen)
+        if (attrLen == 16) { // A tasty attribute with that has only a UUID (16 bytes) implies the existence of the .tasty file
+          val tastyBytes: Array[Byte] = classfile match { // TODO: simplify when #3552 is fixed
+            case classfile: io.ZipArchive#Entry => // We are in a jar
+              val path = classfile.parent.lookupName(
+                classfile.name.stripSuffix(".class") + ".tasty", directory = false
+              )
+              if (path != null) {
+                val stream = path.input
+                try {
+                  val tastyOutStream = new ByteArrayOutputStream()
+                  val buffer = new Array[Byte](1024)
+                  var read = stream.read(buffer, 0, buffer.length)
+                  while (read != -1) {
+                    tastyOutStream.write(buffer, 0, read)
+                    read = stream.read(buffer, 0, buffer.length)
+                  }
+                  tastyOutStream.flush()
+                  tastyOutStream.toByteArray
+                } finally {
+                  stream.close()
+                }
+              }
+              else {
+                report.error(s"Could not find $path in ${classfile.underlyingSource}")
+                Array.empty
+              }
+            case _ =>
+              val dir = classfile.container
+              val name = classfile.name.stripSuffix(".class") + ".tasty"
+              val tastyFileOrNull = dir.lookupName(name, false)
+              if (tastyFileOrNull == null) {
+                report.error(s"Could not find TASTY file $name under $dir")
+                Array.empty
+              } else
+                tastyFileOrNull.toByteArray
+          }
+          if (tastyBytes.nonEmpty) {
+            val reader = new TastyReader(bytes, 0, 16)
+            val expectedUUID = new UUID(reader.readUncompressedLong(), reader.readUncompressedLong())
+            val tastyUUID = new TastyHeaderUnpickler(tastyBytes).readHeader()
+            if (expectedUUID != tastyUUID)
+              report.warning(s"$classfile is out of sync with its TASTy file. Loaded TASTy file. Try cleaning the project to fix this issue", NoSourcePosition)
+            return unpickleTASTY(tastyBytes)
+          }
+        }
+        else return unpickleTASTY(bytes)
+      }
+
+      if scan(tpnme.ScalaATTR) && !scalaUnpickleWhitelist.contains(classRoot.name)
+        && !(classRoot.name.startsWith("Tuple") && classRoot.name.endsWith("$sp"))
+        && !(classRoot.name.startsWith("Product") && classRoot.name.endsWith("$sp"))
+      then
+        // To understand the situation, it's helpful to know that:
+        // - Scalac emits the `ScalaSig` attribute for classfiles with pickled information
+        // and the `Scala` attribute for everything else.
+        // - Dotty emits the `TASTY` attribute for classfiles with pickled information
+        // and the `Scala` attribute for _every_ classfile.
+        //
+        // Therefore, if the `Scala` attribute is present but the `TASTY`
+        // attribute isn't, this classfile is a compilation artifact.
+        return Some(NoEmbedded)
+
+      if (scan(tpnme.ScalaSignatureATTR) && scan(tpnme.RuntimeVisibleAnnotationATTR)) {
+        val attrLen = in.nextInt
+        val nAnnots = in.nextChar
+        var i = 0
+        while (i < nAnnots) {
+          val attrClass = pool.getType(in.nextChar).typeSymbol
+          val nArgs = in.nextChar
+          var j = 0
+          while (j < nArgs) {
+            val argName = pool.getName(in.nextChar)
+            if (argName.name == nme.bytes) {
+              if attrClass == defn.ScalaSignatureAnnot then
+                return unpickleScala(parseScalaSigBytes)
+              else if attrClass == defn.ScalaLongSignatureAnnot then
+                return unpickleScala(parseScalaLongSigBytes)
+            }
+            parseAnnotArg(skip = true)
+            j += 1
+          }
+          i += 1
+        }
+      }
+
+      if (scan(tpnme.InnerClassesATTR)) {
+        val attrLen = in.nextInt
+        val entries = in.nextChar.toInt
+        for (i <- 0 until entries) {
+          val innerIndex = in.nextChar
+          val outerIndex = in.nextChar
+          val nameIndex = in.nextChar
+          val jflags = in.nextChar
+          if (innerIndex != 0 && outerIndex != 0 && nameIndex != 0) {
+            val inner = pool.getClassName(innerIndex)
+            val outer = pool.getClassName(outerIndex)
+            val name  = pool.getName(nameIndex)
+            val entry = InnerClassEntry(inner, outer, name, jflags)
+            innerClasses(inner.value) = entry
+          }
+        }
+      }
+      None
+    }
+    finally in.bp = oldbp
+  }
+
+  /** An entry in the InnerClasses attribute of this class file. */
+  case class InnerClassEntry(external: NameOrString, outer: NameOrString, name: NameOrString, jflags: Int) {
+    def externalName = external.value
+    def outerName    = outer.value
+    def originalName = name.name
+
+    // The name of the outer class, without its trailing $ if it has one.
+    def strippedOuter = outer.name.stripModuleClassSuffix
+  }
+
+  private object innerClasses extends util.HashMap[String, InnerClassEntry] {
+    /** Return the Symbol of the top level class enclosing `name`,
+     *  or 'name's symbol if no entry found for `name`.
+     */
+    def topLevelClass(name: String)(using Context): Symbol = {
+      val tlName = if (contains(name)) {
+        var entry = this(name)
+        while (contains(entry.outerName))
+          entry = this(entry.outerName)
+        entry.outerName
+      }
+      else
+        name
+      classNameToSymbol(tlName.toTypeName)
+    }
+
+    /** Return the class symbol for `entry`. It looks it up in its outer class.
+     *  This might force outer class symbols.
+     */
+    def classSymbol(entry: InnerClassEntry)(using Context): Symbol = {
+      def getMember(sym: Symbol, name: Name)(using Context): Symbol =
+        if (isStatic(entry.jflags))
+          if (sym == classRoot.symbol)
+            staticScope.lookup(name)
+          else {
+            var module = sym.companionModule
+            if (!module.exists && sym.isAbsent())
+              module = sym.scalacLinkedClass
+            module.info.member(name).symbol
+          }
+        else if (sym == classRoot.symbol)
+          instanceScope.lookup(name)
+        else if (sym == classRoot.symbol.owner && name == classRoot.name)
+          classRoot.symbol
+        else
+          sym.info.member(name).symbol
+
+      val outerName = entry.strippedOuter
+      val innerName = entry.originalName
+      val owner = classNameToSymbol(outerName)
+      val result = owner.denot.infoOrCompleter match
+        case _: StubInfo if hasAnnotation(entry.jflags) =>
+          requiredClass(innerName.toTypeName)
+            // It's okay for the classfiles of Java annotations to be missing
+            // from the classpath. If an annotation is defined as an inner class
+            // we need to avoid forcing the outer class symbol here, and instead
+            // return a new stub symbol for the inner class. This is tested by
+            // `surviveMissingInnerClassAnnot` in AnnotationsTests.scala
+        case _ =>
+          atPhase(typerPhase)(getMember(owner, innerName.toTypeName))
+      assert(result ne NoSymbol,
+        i"""failure to resolve inner class:
+           |externalName = ${entry.externalName},
+           |outerName = $outerName,
+           |innerName = $innerName
+           |owner.fullName = ${owner.showFullName}
+           |while parsing ${classfile}""")
+      result
+    }
+  }
+
+  def skipAttributes()(using in: DataReader): Unit = {
+    val attrCount = in.nextChar
+    for (i <- 0 until attrCount) {
+      in.skip(2); in.skip(in.nextInt)
+    }
+  }
+
+  def skipMembers()(using in: DataReader): Unit = {
+    val memberCount = in.nextChar
+    for (i <- 0 until memberCount) {
+      in.skip(6); skipAttributes()
+    }
+  }
+
+  def skipSuperclasses()(using in: DataReader): Unit = {
+    in.skip(2) // superclass
+    val ifaces = in.nextChar
+    in.skip(2 * ifaces)
+  }
+
+  protected def getOwner(flags: Int): Symbol =
+    if (isStatic(flags)) moduleRoot.symbol else classRoot.symbol
+
+  protected def getScope(flags: Int): MutableScope =
+    if (isStatic(flags)) staticScope else instanceScope
+
+  private def getPrivateWithin(jflags: Int)(using Context): Symbol =
+    if ((jflags & (JAVA_ACC_PRIVATE | JAVA_ACC_PUBLIC)) == 0)
+      classRoot.enclosingPackageClass
+    else
+      NoSymbol
+
+  private def isPrivate(flags: Int)     = (flags & JAVA_ACC_PRIVATE) != 0
+  private def isStatic(flags: Int)      = (flags & JAVA_ACC_STATIC) != 0
+  private def hasAnnotation(flags: Int) = (flags & JAVA_ACC_ANNOTATION) != 0
+
+  protected class NameOrString(val value: String) {
+    private var _name: SimpleName = null
+    def name: SimpleName = {
+      if (_name eq null) _name = termName(value)
+      _name
+    }
+  }
+
+  def getClassSymbol(name: SimpleName)(using Context): Symbol =
+    if (name.endsWith("$") && (name ne nme.nothingRuntimeClass) && (name ne nme.nullRuntimeClass))
+      // Null$ and Nothing$ ARE classes
+      requiredModule(name.dropRight(1))
+    else classNameToSymbol(name)
+
+  class ConstantPool(using in: DataReader) {
+    private val len = in.nextChar
+    private val starts = new Array[Int](len)
+    private val values = new Array[AnyRef](len)
+    private val internalized = new Array[NameOrString](len)
+
+    { var i = 1
+      while (i < starts.length) {
+        starts(i) = in.bp
+        i += 1
+        (in.nextByte.toInt: @switch) match {
+          case CONSTANT_UTF8 | CONSTANT_UNICODE =>
+            in.skip(in.nextChar)
+          case CONSTANT_CLASS | CONSTANT_STRING | CONSTANT_METHODTYPE =>
+            in.skip(2)
+          case CONSTANT_METHODHANDLE =>
+            in.skip(3)
+          case CONSTANT_FIELDREF | CONSTANT_METHODREF | CONSTANT_INTFMETHODREF
+             | CONSTANT_NAMEANDTYPE | CONSTANT_INTEGER | CONSTANT_FLOAT
+             | CONSTANT_INVOKEDYNAMIC =>
+            in.skip(4)
+          case CONSTANT_LONG | CONSTANT_DOUBLE =>
+            in.skip(8)
+            i += 1
+          case _ =>
+            errorBadTag(in.bp - 1)
+        }
+      }
+    }
+
+    /** Return the name found at given index. */
+    def getName(index: Int)(using in: DataReader): NameOrString = {
+      if (index <= 0 || len <= index)
+        errorBadIndex(index)
+
+      values(index) match {
+        case name: NameOrString => name
+        case null   =>
+          val start = starts(index)
+          if (in.getByte(start).toInt != CONSTANT_UTF8) errorBadTag(start)
+          val len   = in.getChar(start + 1).toInt
+          val name = new NameOrString(in.getUTF(start + 1, len + 2))
+          values(index) = name
+          name
+      }
+    }
+
+    /** Return the name found at given index in the constant pool, with '/' replaced by '.'. */
+    def getExternalName(index: Int)(using in: DataReader): NameOrString = {
+      if (index <= 0 || len <= index)
+        errorBadIndex(index)
+
+      if (internalized(index) == null)
+        internalized(index) = new NameOrString(getName(index).value.replace('/', '.'))
+
+      internalized(index)
+    }
+
+    def getClassSymbol(index: Int)(using ctx: Context, in: DataReader): Symbol = {
+      if (index <= 0 || len <= index) errorBadIndex(index)
+      var c = values(index).asInstanceOf[Symbol]
+      if (c eq null) {
+        val start = starts(index)
+        if (in.getByte(start).toInt != CONSTANT_CLASS) errorBadTag(start)
+        val name = getExternalName(in.getChar(start + 1))
+        c = ClassfileParser.this.getClassSymbol(name.name)
+        values(index) = c
+      }
+      c
+    }
+
+    /** Return the external name of the class info structure found at 'index'.
+     *  Use 'getClassSymbol' if the class is sure to be a top-level class.
+     */
+    def getClassName(index: Int)(using in: DataReader): NameOrString = {
+      val start = starts(index)
+      if (in.getByte(start).toInt != CONSTANT_CLASS) errorBadTag(start)
+      getExternalName(in.getChar(start + 1))
+    }
+
+    /** Return the type of a class constant entry. Since
+     *  arrays are considered to be class types, they might
+     *  appear as entries in 'newarray' or 'cast' opcodes.
+     */
+    def getClassOrArrayType(index: Int)(using ctx: Context, in: DataReader): Type = {
+      if (index <= 0 || len <= index) errorBadIndex(index)
+      val value = values(index)
+      var c: Type = null
+      if (value eq null) {
+        val start = starts(index)
+        if (in.getByte(start).toInt != CONSTANT_CLASS) errorBadTag(start)
+        val name = getExternalName(in.getChar(start + 1))
+        if (name.value.charAt(0) == ARRAY_TAG) {
+          c = sigToType(name.value)
+          values(index) = c
+        }
+        else {
+          val sym = classNameToSymbol(name.name)
+          values(index) = sym
+          c = sym.typeRef
+        }
+      }
+      else c = value match {
+          case tp: Type => tp
+          case cls: Symbol => cls.typeRef
+      }
+      c
+    }
+
+    def getType(index: Int, isVarargs: Boolean = false)(using Context, DataReader): Type =
+      sigToType(getExternalName(index).value, isVarargs = isVarargs)
+
+    def getSuperClass(index: Int)(using Context, DataReader): Symbol = {
+      assert(index != 0, "attempt to parse java.lang.Object from classfile")
+      getClassSymbol(index)
+    }
+
+    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) {
+        val start = starts(index)
+        value = (in.getByte(start).toInt: @switch) match {
+          case CONSTANT_STRING =>
+            Constant(getName(in.getChar(start + 1).toInt).value)
+          case CONSTANT_INTEGER =>
+            Constant(in.getInt(start + 1))
+          case CONSTANT_FLOAT =>
+            Constant(in.getFloat(start + 1))
+          case CONSTANT_LONG =>
+            Constant(in.getLong(start + 1))
+          case CONSTANT_DOUBLE =>
+            Constant(in.getDouble(start + 1))
+          case CONSTANT_CLASS =>
+            getClassOrArrayType(index).typeSymbol
+          case _ =>
+            errorBadTag(start)
+        }
+        values(index) = value
+      }
+      value match {
+        case ct: Constant  => ct
+        case cls: Symbol   => Constant(cls.typeRef)
+        case arr: Type     => Constant(arr)
+      }
+    }
+
+    private def getSubArray(bytes: Array[Byte]): Array[Byte] = {
+      val decodedLength = ByteCodecs.decode(bytes)
+      val arr           = new Array[Byte](decodedLength)
+      System.arraycopy(bytes, 0, arr, 0, decodedLength)
+      arr
+    }
+
+    def getBytes(index: Int)(using in: DataReader): Array[Byte] = {
+      if (index <= 0 || len <= index) errorBadIndex(index)
+      var value = values(index).asInstanceOf[Array[Byte]]
+      if (value eq null) {
+        val start = starts(index)
+        if (in.getByte(start).toInt != CONSTANT_UTF8) errorBadTag(start)
+        val len   = in.getChar(start + 1)
+        val bytes = new Array[Byte](len)
+        in.getBytes(start + 3, bytes)
+        value = getSubArray(bytes)
+        values(index) = value
+      }
+      value
+    }
+
+    def getBytes(indices: List[Int])(using in: DataReader): Array[Byte] = {
+      assert(!indices.isEmpty, indices)
+      var value = values(indices.head).asInstanceOf[Array[Byte]]
+      if (value eq null) {
+        val bytesBuffer = ArrayBuffer.empty[Byte]
+        for (index <- indices) {
+          if (index <= 0 || ConstantPool.this.len <= index) errorBadIndex(index)
+          val start = starts(index)
+          if (in.getByte(start).toInt != CONSTANT_UTF8) errorBadTag(start)
+          val len = in.getChar(start + 1)
+          val buf = new Array[Byte](len)
+          in.getBytes(start + 3, buf)
+          bytesBuffer ++= buf
+        }
+        value = getSubArray(bytesBuffer.toArray)
+        values(indices.head) = value
+      }
+      value
+    }
+
+    /** Throws an exception signaling a bad constant index. */
+    private def errorBadIndex(index: Int)(using in: DataReader) =
+      throw new RuntimeException("bad constant pool index: " + index + " at pos: " + in.bp)
+
+    /** Throws an exception signaling a bad tag at given address. */
+    private def errorBadTag(start: Int)(using in: DataReader) =
+      throw new RuntimeException("bad constant pool tag " + in.getByte(start) + " at byte " + start)
+  }
+}
diff --git a/tests/pos-with-compiler-cc/dotc/core/classfile/DataReader.scala b/tests/pos-with-compiler-cc/dotc/core/classfile/DataReader.scala
new file mode 100644
index 000000000000..d96bebf25fb7
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/core/classfile/DataReader.scala
@@ -0,0 +1,61 @@
+package dotty.tools
+package dotc
+package core
+package classfile
+
+trait DataReader {
+
+  def bp: Int
+  def bp_=(i: Int): Unit
+
+  def buf: Array[Byte]
+
+  /** read a byte
+    */
+  @throws(classOf[IndexOutOfBoundsException])
+  def nextByte: Byte
+
+  /** read some bytes
+    */
+  def nextBytes(len: Int): Array[Byte]
+
+  /** read a character
+    */
+  def nextChar: Char
+
+  /** read an integer
+    */
+  def nextInt: Int
+
+  /** extract a character at position bp from buf
+    */
+  def getChar(mybp: Int): Char
+
+  /** extract an integer at position bp from buf
+    */
+  def getByte(mybp: Int): Byte
+
+  def getBytes(mybp: Int, bytes: Array[Byte]): Unit
+
+  /** extract an integer at position bp from buf
+    */
+  def getInt(mybp: Int): Int
+
+  /** extract a long integer at position bp from buf
+    */
+  def getLong(mybp: Int): Long
+
+  /** extract a float at position bp from buf
+    */
+  def getFloat(mybp: Int): Float
+
+  /** extract a double at position bp from buf
+    */
+  def getDouble(mybp: Int): Double
+
+  def getUTF(mybp: Int, len: Int): String
+
+  /** skip next 'n' bytes
+    */
+  def skip(n: Int): Unit
+}
diff --git a/tests/pos-with-compiler-cc/dotc/core/classfile/ReusableDataReader.scala b/tests/pos-with-compiler-cc/dotc/core/classfile/ReusableDataReader.scala
new file mode 100644
index 000000000000..eb1649091f77
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/core/classfile/ReusableDataReader.scala
@@ -0,0 +1,150 @@
+package dotty.tools
+package dotc
+package core
+package classfile
+
+import scala.language.unsafeNulls
+
+import java.io.{DataInputStream, InputStream}
+import java.nio.{BufferUnderflowException, ByteBuffer}
+
+final class ReusableDataReader() extends DataReader {
+  private[this] var data = new Array[Byte](32768)
+  private[this] var bb: ByteBuffer = ByteBuffer.wrap(data)
+  private[this] var size = 0
+  private[this] val reader: DataInputStream = {
+    val stream = new InputStream {
+      override def read(): Int = try {
+        bb.get & 0xff
+      } catch {
+        case _: BufferUnderflowException => -1
+      }
+
+      override def read(b: Array[Byte], off: Int, len: Int): Int = {
+        val pos = bb.position()
+        bb.get(b, off, len)
+        bb.position() - pos
+      }
+
+      override def markSupported(): Boolean = false
+    }
+    new DataInputStream(stream)
+  }
+
+  def buf: Array[Byte] = data
+
+  private def nextPositivePowerOfTwo(target: Int): Int = 1 << -Integer.numberOfLeadingZeros(target - 1)
+
+  def reset(file: dotty.tools.io.AbstractFile): this.type = {
+    this.size = 0
+    file.sizeOption match {
+      case Some(size) =>
+        if (size > data.length) {
+          data = new Array[Byte](nextPositivePowerOfTwo(size))
+        } else {
+          java.util.Arrays.fill(data, 0.toByte)
+        }
+        val input = file.input
+        try {
+          var endOfInput = false
+          while (!endOfInput) {
+            val remaining = data.length - this.size
+            if (remaining == 0) endOfInput = true
+            else {
+              val read = input.read(data, this.size, remaining)
+              if (read < 0) endOfInput = true
+              else this.size += read
+            }
+          }
+          bb = ByteBuffer.wrap(data, 0, size)
+        } finally {
+          input.close()
+        }
+      case None =>
+        val input = file.input
+        try {
+          var endOfInput = false
+          while (!endOfInput) {
+            val remaining = data.length - size
+            if (remaining == 0) {
+              data = java.util.Arrays.copyOf(data, nextPositivePowerOfTwo(size))
+            }
+            val read = input.read(data, this.size, data.length - this.size)
+            if (read < 0) endOfInput = true
+            else this.size += read
+          }
+          bb = ByteBuffer.wrap(data, 0, size)
+        } finally {
+          input.close()
+        }
+    }
+    this
+  }
+
+  @throws(classOf[IndexOutOfBoundsException])
+  def nextByte: Byte = bb.get
+
+  def nextBytes(len: Int): Array[Byte] = {
+    val result = new Array[Byte](len)
+    reader.readFully(result)
+    result
+  }
+
+  def nextChar: Char = bb.getChar()
+
+  def nextInt: Int = bb.getInt()
+
+  def getChar(mybp: Int): Char = {
+    bb.getChar(mybp)
+  }
+
+  def getInt(mybp: Int): Int = {
+    bb.getInt(mybp)
+  }
+
+  def getLong(mybp: Int): Long = {
+    bb.getLong(mybp)
+  }
+
+  def getFloat(mybp: Int): Float = {
+    bb.getFloat(mybp)
+  }
+
+  def getDouble(mybp: Int): Double = {
+    bb.getDouble(mybp)
+  }
+
+  def skip(n: Int): Unit = {
+    bb.position(bb.position() + n)
+  }
+  def bp: Int = bb.position()
+  def bp_=(i: Int): Unit = {
+    try {
+      bb.position(i)
+    } catch {
+      case ex: IllegalArgumentException =>
+        throw ex
+    }
+  }
+
+  def getByte(mybp: Int): Byte = {
+    bb.get(mybp)
+  }
+  def getBytes(mybp: Int, bytes: Array[Byte]): Unit = {
+    val saved = bb.position()
+    bb.position(mybp)
+    try reader.readFully(bytes)
+    finally bb.position(saved)
+  }
+  def getUTF(mybp: Int, len: Int): String = {
+    val saved = bb.position()
+    val savedLimit = bb.limit()
+    bb.position(mybp)
+    bb.limit(mybp + len)
+    try reader.readUTF()
+    finally {
+      bb.limit(savedLimit)
+      bb.position(saved)
+    }
+  }
+}
diff --git a/tests/pos-with-compiler-cc/dotc/core/tasty/CommentPickler.scala b/tests/pos-with-compiler-cc/dotc/core/tasty/CommentPickler.scala
new file mode 100644
index 000000000000..df3e4df497f8
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/core/tasty/CommentPickler.scala
@@ -0,0 +1,44 @@
+package dotty.tools.dotc.core.tasty
+
+import dotty.tools.dotc.ast.{tpd, untpd}
+import dotty.tools.dotc.core.Comments.Comment
+
+import dotty.tools.tasty.TastyBuffer
+import TastyBuffer.{Addr, NoAddr}
+import dotty.tools.tasty.TastyFormat.CommentsSection
+
+import java.nio.charset.StandardCharsets
+
+class CommentPickler(pickler: TastyPickler, addrOfTree: tpd.Tree => Addr, docString: untpd.MemberDef => Option[Comment]):
+  private val buf = new TastyBuffer(5000)
+  pickler.newSection(CommentsSection, buf)
+
+  def pickleComment(root: tpd.Tree): Unit = traverse(root)
+
+  private def pickleComment(addr: Addr, comment: Comment): Unit =
+    if addr != NoAddr then
+      val bytes = comment.raw.getBytes(StandardCharsets.UTF_8).nn
+      val length = bytes.length
+      buf.writeAddr(addr)
+      buf.writeNat(length)
+      buf.writeBytes(bytes, length)
+      buf.writeLongInt(comment.span.coords)
+
+  private def traverse(x: Any): Unit = x match
+    case x: untpd.Tree @unchecked =>
+      x match
+        case x: tpd.MemberDef @unchecked => // at this point all MembderDefs are t(y)p(e)d.
+          for comment <- docString(x) do pickleComment(addrOfTree(x), comment)
+        case _ =>
+      val limit = x.productArity
+      var n = 0
+      while n < limit do
+        traverse(x.productElement(n))
+        n += 1
+    case y :: ys =>
+      traverse(y)
+      traverse(ys)
+    case _ =>
+
+end CommentPickler
+
diff --git a/tests/pos-with-compiler-cc/dotc/core/tasty/CommentUnpickler.scala b/tests/pos-with-compiler-cc/dotc/core/tasty/CommentUnpickler.scala
new file mode 100644
index 000000000000..eb0d140df51e
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/core/tasty/CommentUnpickler.scala
@@ -0,0 +1,35 @@
+package dotty.tools.dotc
+package core.tasty
+
+import scala.language.unsafeNulls
+
+import core.Comments.Comment
+import util.Spans.Span
+import util.HashMap
+
+import dotty.tools.tasty.{TastyReader, TastyBuffer}
+import TastyBuffer.Addr
+
+import java.nio.charset.StandardCharsets
+
+class CommentUnpickler(reader: TastyReader) {
+  import reader._
+
+  private[tasty] lazy val comments: HashMap[Addr, Comment] = {
+    val comments = new HashMap[Addr, Comment]
+    while (!isAtEnd) {
+      val addr = readAddr()
+      val length = readNat()
+      if (length > 0) {
+        val bytes = readBytes(length)
+        val position = new Span(readLongInt())
+        val rawComment = new String(bytes, StandardCharsets.UTF_8)
+        comments(addr) = Comment(position, rawComment)
+      }
+    }
+    comments
+  }
+
+  def commentAt(addr: Addr): Option[Comment] =
+    comments.get(addr)
+}
diff --git a/tests/pos-with-compiler-cc/dotc/core/tasty/DottyUnpickler.scala b/tests/pos-with-compiler-cc/dotc/core/tasty/DottyUnpickler.scala
new file mode 100644
index 000000000000..b35c5c9f1acc
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/core/tasty/DottyUnpickler.scala
@@ -0,0 +1,74 @@
+package dotty.tools
+package dotc
+package core
+package tasty
+
+import scala.language.unsafeNulls
+
+import Contexts._, SymDenotations._,  Decorators._
+import dotty.tools.dotc.ast.tpd
+import TastyUnpickler._
+import classfile.ClassfileParser
+import Names.SimpleName
+import TreeUnpickler.UnpickleMode
+
+import dotty.tools.tasty.TastyReader
+import dotty.tools.tasty.TastyFormat.{ASTsSection, PositionsSection, CommentsSection}
+
+object DottyUnpickler {
+
+  /** Exception thrown if classfile is corrupted */
+  class BadSignature(msg: String) extends RuntimeException(msg)
+
+  class TreeSectionUnpickler(posUnpickler: Option[PositionUnpickler], commentUnpickler: Option[CommentUnpickler])
+  extends SectionUnpickler[TreeUnpickler](ASTsSection) {
+    def unpickle(reader: TastyReader, nameAtRef: NameTable): TreeUnpickler =
+      new TreeUnpickler(reader, nameAtRef, posUnpickler, commentUnpickler)
+  }
+
+  class PositionsSectionUnpickler extends SectionUnpickler[PositionUnpickler](PositionsSection) {
+    def unpickle(reader: TastyReader, nameAtRef: NameTable): PositionUnpickler =
+      new PositionUnpickler(reader, nameAtRef)
+  }
+
+  class CommentsSectionUnpickler extends SectionUnpickler[CommentUnpickler](CommentsSection) {
+    def unpickle(reader: TastyReader, nameAtRef: NameTable): CommentUnpickler =
+      new CommentUnpickler(reader)
+  }
+}
+
+/** A class for unpickling Tasty trees and symbols.
+ *  @param bytes         the bytearray containing the Tasty file from which we unpickle
+ *  @param mode          the tasty file contains package (TopLevel), an expression (Term) or a type (TypeTree)
+ */
+class DottyUnpickler(bytes: Array[Byte], mode: UnpickleMode = UnpickleMode.TopLevel) extends ClassfileParser.Embedded with tpd.TreeProvider {
+  import tpd._
+  import DottyUnpickler._
+
+  val unpickler: TastyUnpickler = new TastyUnpickler(bytes)
+  private val posUnpicklerOpt = unpickler.unpickle(new PositionsSectionUnpickler)
+  private val commentUnpicklerOpt = unpickler.unpickle(new CommentsSectionUnpickler)
+  private val treeUnpickler = unpickler.unpickle(treeSectionUnpickler(posUnpicklerOpt, commentUnpicklerOpt)).get
+
+  /** Enter all toplevel classes and objects into their scopes
+   *  @param roots          a set of SymDenotations that should be overwritten by unpickling
+   */
+  def enter(roots: Set[SymDenotation])(using Context): Unit =
+    treeUnpickler.enter(roots)
+
+  protected def treeSectionUnpickler(posUnpicklerOpt: Option[PositionUnpickler], commentUnpicklerOpt: Option[CommentUnpickler]): TreeSectionUnpickler =
+    new TreeSectionUnpickler(posUnpicklerOpt, commentUnpicklerOpt)
+
+  protected def computeRootTrees(using Context): List[Tree] = treeUnpickler.unpickle(mode)
+
+  private var ids: Array[String] = null
+
+  override def mightContain(id: String)(using Context): Boolean = {
+    if (ids == null)
+      ids =
+        unpickler.nameAtRef.contents.toArray.collect {
+          case name: SimpleName => name.toString
+        }.sorted
+    ids.binarySearch(id) >= 0
+  }
+}
diff --git a/tests/pos-with-compiler-cc/dotc/core/tasty/NameBuffer.scala b/tests/pos-with-compiler-cc/dotc/core/tasty/NameBuffer.scala
new file mode 100644
index 000000000000..623508780325
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/core/tasty/NameBuffer.scala
@@ -0,0 +1,126 @@
+package dotty.tools
+package dotc
+package core
+package tasty
+
+import dotty.tools.tasty.TastyBuffer
+import TastyBuffer._
+
+import collection.mutable
+import Names.{Name, chrs, SimpleName, DerivedName, TypeName}
+import NameKinds._
+import NameOps._
+import scala.io.Codec
+import NameTags.{SIGNED, TARGETSIGNED}
+
+class NameBuffer extends TastyBuffer(10000) {
+  import NameBuffer._
+
+  private val nameRefs = new mutable.LinkedHashMap[Name, NameRef]
+
+  def nameIndex(name: Name): NameRef = {
+    val name1 = name.toTermName
+    nameRefs.get(name1) match {
+      case Some(ref) =>
+        ref
+      case None =>
+        name1 match {
+          case SignedName(original, Signature(params, result), target) =>
+            nameIndex(original)
+            if !original.matchesTargetName(target) then nameIndex(target)
+            nameIndex(result)
+            params.foreach {
+              case param: TypeName =>
+                nameIndex(param)
+              case _ =>
+            }
+          case AnyQualifiedName(prefix, name) =>
+            nameIndex(prefix); nameIndex(name)
+          case AnyUniqueName(original, separator, num) =>
+            nameIndex(separator)
+            if (!original.isEmpty) nameIndex(original)
+          case DerivedName(original, _) =>
+            nameIndex(original)
+          case _ =>
+        }
+        val ref = NameRef(nameRefs.size)
+        nameRefs(name1) = ref
+        ref
+    }
+  }
+
+  private def withLength(op: => Unit, lengthWidth: Int = 1): Unit = {
+    val lengthAddr = currentAddr
+    for (i <- 0 until lengthWidth) writeByte(0)
+    op
+    val length = currentAddr.index - lengthAddr.index - lengthWidth
+    putNat(lengthAddr, length, lengthWidth)
+  }
+
+  def writeNameRef(ref: NameRef): Unit = writeNat(ref.index)
+  def writeNameRef(name: Name): Unit = writeNameRef(nameRefs(name.toTermName))
+
+  def writeParamSig(paramSig: Signature.ParamSig): Unit ={
+    val encodedValue = paramSig match {
+      case paramSig: TypeName =>
+        nameRefs(paramSig.toTermName).index
+      case paramSig: Int =>
+        -paramSig
+    }
+    writeInt(encodedValue)
+  }
+
+  def pickleNameContents(name: Name): Unit = {
+    val tag = name.toTermName.info.kind.tag
+    name.toTermName match {
+      case name: SimpleName =>
+        writeByte(tag)
+        val bytes =
+          if (name.length == 0) new Array[Byte](0)
+          else Codec.toUTF8(chrs, name.start, name.length)
+        writeNat(bytes.length)
+        writeBytes(bytes, bytes.length)
+      case AnyQualifiedName(prefix, name) =>
+        writeByte(tag)
+        withLength { writeNameRef(prefix); writeNameRef(name) }
+      case AnyUniqueName(original, separator, num) =>
+        writeByte(tag)
+        withLength {
+          writeNameRef(separator)
+          writeNat(num)
+          if (!original.isEmpty) writeNameRef(original)
+        }
+      case AnyNumberedName(original, num) =>
+        writeByte(tag)
+        withLength { writeNameRef(original); writeNat(num) }
+      case SignedName(original, Signature(paramsSig, result), target) =>
+        val needsTarget = !original.matchesTargetName(target)
+        writeByte(if needsTarget then TARGETSIGNED else SIGNED)
+        withLength(
+          { writeNameRef(original)
+            if needsTarget then writeNameRef(target)
+            writeNameRef(result)
+            paramsSig.foreach(writeParamSig)
+          },
+          if ((paramsSig.length + 3) * maxIndexWidth <= maxNumInByte) 1 else 2)
+      case DerivedName(original, _) =>
+        writeByte(tag)
+        withLength { writeNameRef(original) }
+    }
+  }
+
+  override def assemble(): Unit = {
+    var i = 0
+    for ((name, ref) <- nameRefs) {
+      assert(ref.index == i)
+      i += 1
+      pickleNameContents(name)
+    }
+  }
+}
+
+object NameBuffer {
+  private val maxIndexWidth = 3  // allows name indices up to 2^21.
+  private val payloadBitsPerByte = 7 // determined by nat encoding in TastyBuffer
+  private val maxNumInByte = (1 << payloadBitsPerByte) - 1
+}
diff --git a/tests/pos-with-compiler-cc/dotc/core/tasty/PositionPickler.scala b/tests/pos-with-compiler-cc/dotc/core/tasty/PositionPickler.scala
new file mode 100644
index 000000000000..ad0c051e1b7b
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/core/tasty/PositionPickler.scala
@@ -0,0 +1,137 @@
+package dotty.tools
+package dotc
+package core
+package tasty
+
+import dotty.tools.tasty.TastyFormat.{SOURCE, PositionsSection}
+import dotty.tools.tasty.TastyBuffer
+import TastyBuffer._
+
+import ast._
+import Trees.WithLazyField
+import util.{SourceFile, NoSource}
+import core._
+import Annotations._, Decorators._
+import collection.mutable
+import util.Spans._
+
+class PositionPickler(
+    pickler: TastyPickler,
+    addrOfTree: PositionPickler.TreeToAddr,
+    treeAnnots: untpd.MemberDef => List[tpd.Tree],
+    relativePathReference: String){
+
+  import ast.tpd._
+
+  val buf: TastyBuffer = new TastyBuffer(5000)
+  pickler.newSection(PositionsSection, buf)
+
+  private val pickledIndices = new mutable.BitSet
+
+  def header(addrDelta: Int, hasStartDelta: Boolean, hasEndDelta: Boolean, hasPoint: Boolean): Int = {
+    def toInt(b: Boolean) = if (b) 1 else 0
+    (addrDelta << 3) | (toInt(hasStartDelta) << 2) | (toInt(hasEndDelta) << 1) | toInt(hasPoint)
+  }
+
+  def picklePositions(source: SourceFile, roots: List[Tree], warnings: mutable.ListBuffer[String]): Unit = {
+    /** Pickle the number of lines followed by the length of each line */
+    def pickleLineOffsets(): Unit = {
+      val content = source.content()
+      buf.writeNat(content.count(_ == '\n') + 1) // number of lines
+      var lastIndex = content.indexOf('\n', 0)
+      buf.writeNat(lastIndex) // size of first line
+      while lastIndex != -1 do
+        val nextIndex = content.indexOf('\n', lastIndex + 1)
+        val end = if nextIndex != -1 then nextIndex else content.length
+        buf.writeNat(end - lastIndex - 1) // size of the next line
+        lastIndex = nextIndex
+    }
+    pickleLineOffsets()
+
+    var lastIndex = 0
+    var lastSpan = Span(0, 0)
+    def pickleDeltas(index: Int, span: Span) = {
+      val addrDelta = index - lastIndex
+      val startDelta = span.start - lastSpan.start
+      val endDelta = span.end - lastSpan.end
+      buf.writeInt(header(addrDelta, startDelta != 0, endDelta != 0, !span.isSynthetic))
+      if (startDelta != 0) buf.writeInt(startDelta)
+      if (endDelta != 0) buf.writeInt(endDelta)
+      if (!span.isSynthetic) buf.writeInt(span.pointDelta)
+      lastIndex = index
+      lastSpan = span
+
+      pickledIndices.addOne(index)
+        // Note `+=` boxes since it is a generic @inline function in `SetOps`
+        // that forwards to the specialized `addOne` in `BitSet`. Since the
+        // current backend does not implement `@inline` we are missing the
+        // specialization.
+    }
+
+    def pickleSource(source: SourceFile): Unit = {
+      buf.writeInt(SOURCE)
+      val relativePath = SourceFile.relativePath(source, relativePathReference)
+      buf.writeInt(pickler.nameBuffer.nameIndex(relativePath.toTermName).index)
+    }
+
+    /** True if x's position shouldn't be reconstructed automatically from its initial span
+     */
+    def alwaysNeedsPos(x: Positioned) = x match {
+      case
+          // initialSpan is inaccurate for trees with lazy field
+          _: WithLazyField[?]
+
+          // A symbol is created before the corresponding tree is unpickled,
+          // and its position cannot be changed afterwards.
+          // so we cannot use the tree initialSpan to set the symbol position.
+          // Instead, we always pickle the position of definitions.
+          | _: Trees.DefTree[?]
+
+          // package defs might be split into several Tasty files
+          | _: Trees.PackageDef[?]
+          // holes can change source files when filled, which means
+          // they might lose their position
+          | _: Trees.Hole[?] => true
+      case _ => false
+    }
+
+    def traverse(x: Any, current: SourceFile): Unit = x match {
+      case x: untpd.Tree =>
+        if (x.span.exists) {
+          val addr = addrOfTree(x)
+          if (addr != NoAddr) {
+            if (x.source != current) {
+              // we currently do not share trees when unpickling, so if one path to a tree contains
+              // a source change while another does not, we have to record the position of the tree twice
+              // in order not to miss the source change. Test case is t3232a.scala.
+              pickleDeltas(addr.index, x.span)
+              pickleSource(x.source)
+            }
+            else if (!pickledIndices.contains(addr.index) &&
+                     (x.span.toSynthetic != x.envelope(x.source) || alwaysNeedsPos(x)))
+              pickleDeltas(addr.index, x.span)
+          }
+        }
+        x match
+          case x: untpd.MemberDef => traverse(treeAnnots(x), x.source)
+          case _ =>
+        val limit = x.productArity
+        var n = 0
+        while (n < limit) {
+          traverse(x.productElement(n), x.source)
+          n += 1
+        }
+      case y :: ys =>
+        traverse(y, current)
+        traverse(ys, current)
+      case _ =>
+    }
+    for (root <- roots)
+      traverse(root, NoSource)
+  }
+}
+object PositionPickler:
+  // Note: This could be just TreeToAddr => Addr if functions are specialized to value classes.
+  // We use a SAM type to avoid boxing of Addr
+  @FunctionalInterface trait TreeToAddr:
+    def apply(x: untpd.Tree): Addr
diff --git a/tests/pos-with-compiler-cc/dotc/core/tasty/PositionUnpickler.scala b/tests/pos-with-compiler-cc/dotc/core/tasty/PositionUnpickler.scala
new file mode 100644
index 000000000000..9c66e43eae80
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/core/tasty/PositionUnpickler.scala
@@ -0,0 +1,77 @@
+package dotty.tools
+package dotc
+package core
+package tasty
+
+import dotty.tools.tasty.{TastyFormat, TastyBuffer, TastyReader}
+import TastyFormat.SOURCE
+import TastyBuffer.{Addr, NameRef}
+
+import util.Spans._
+import Names.TermName
+
+/** Unpickler for tree positions */
+class PositionUnpickler(reader: TastyReader, nameAtRef: NameRef => TermName) {
+  import reader._
+
+  private var myLineSizes: Array[Int] = _
+  private var mySpans: util.HashMap[Addr, Span] = _
+  private var mySourcePaths: util.HashMap[Addr, String] = _
+  private var isDefined = false
+
+  def ensureDefined(): Unit = {
+    if (!isDefined) {
+      val lines = readNat()
+      myLineSizes = new Array[Int](lines)
+      var i = 0
+      while i < lines do
+        myLineSizes(i) += readNat()
+        i += 1
+
+      mySpans = util.HashMap[Addr, Span]()
+      mySourcePaths = util.HashMap[Addr, String]()
+      var curIndex = 0
+      var curStart = 0
+      var curEnd = 0
+      while (!isAtEnd) {
+        val header = readInt()
+        if (header == SOURCE) {
+          val path = nameAtRef(readNameRef()).toString
+          mySourcePaths(Addr(curIndex)) = path
+        }
+        else {
+          val addrDelta = header >> 3
+          val hasStart = (header & 4) != 0
+          val hasEnd = (header & 2) != 0
+          val hasPoint = (header & 1) != 0
+          curIndex += addrDelta
+          assert(curIndex >= 0)
+          if (hasStart) curStart += readInt()
+          if (hasEnd) curEnd += readInt()
+          mySpans(Addr(curIndex)) =
+            if (hasPoint) Span(curStart, curEnd, curStart + readInt())
+            else Span(curStart, curEnd)
+        }
+      }
+      isDefined = true
+    }
+  }
+
+  private[tasty] def spans: util.ReadOnlyMap[Addr, Span] = {
+    ensureDefined()
+    mySpans
+  }
+
+  private[tasty] def sourcePaths: util.ReadOnlyMap[Addr, String] = {
+    ensureDefined()
+    mySourcePaths
+  }
+
+  private[tasty] def lineSizes: Array[Int] = {
+    ensureDefined()
+    myLineSizes
+  }
+
+  def spanAt(addr: Addr): Span = spans.getOrElse(addr, NoSpan)
+  def sourcePathAt(addr: Addr): String = sourcePaths.getOrElse(addr, "")
+}
diff --git a/tests/pos-with-compiler-cc/dotc/core/tasty/TastyAnsiiPrinter.scala b/tests/pos-with-compiler-cc/dotc/core/tasty/TastyAnsiiPrinter.scala
new file mode 100644
index 000000000000..d8d72a4e651e
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/core/tasty/TastyAnsiiPrinter.scala
@@ -0,0 +1,9 @@
+package dotty.tools.dotc
+package core
+package tasty
+
+class TastyAnsiiPrinter(bytes: Array[Byte]) extends TastyPrinter(bytes) {
+  override protected def nameStr(str: String): String = Console.MAGENTA + str + Console.RESET
+  override protected def treeStr(str: String): String = Console.YELLOW + str + Console.RESET
+  override protected def lengthStr(str: String): String = Console.CYAN + str + Console.RESET
+}
diff --git a/tests/pos-with-compiler-cc/dotc/core/tasty/TastyClassName.scala b/tests/pos-with-compiler-cc/dotc/core/tasty/TastyClassName.scala
new file mode 100644
index 000000000000..c938868a3c48
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/core/tasty/TastyClassName.scala
@@ -0,0 +1,68 @@
+package dotty.tools.dotc
+package core
+package tasty
+
+import dotty.tools.tasty.{TastyBuffer, TastyReader}
+import TastyBuffer.NameRef
+
+import Contexts._, Decorators._
+import Names.TermName
+import StdNames.nme
+import TastyUnpickler._
+import dotty.tools.tasty.TastyFormat.ASTsSection
+
+/** Reads the package and class name of the class contained in this TASTy */
+class TastyClassName(bytes: Array[Byte]) {
+
+  val unpickler: TastyUnpickler = new TastyUnpickler(bytes)
+  import unpickler.{nameAtRef, unpickle}
+
+  /** Returns a tuple with the package and class names */
+  def readName(): Option[(TermName, TermName)] = unpickle(new TreeSectionUnpickler)
+
+  class TreeSectionUnpickler extends SectionUnpickler[(TermName, TermName)](ASTsSection) {
+    import dotty.tools.tasty.TastyFormat._
+    def unpickle(reader: TastyReader, tastyName: NameTable): (TermName, TermName) = {
+      import reader._
+      def readNames(packageName: TermName): (TermName, TermName) = {
+        val tag = readByte()
+        if (tag >= firstLengthTreeTag) {
+          val len = readNat()
+          val end = currentAddr + len
+          tag match {
+            case TYPEDEF =>
+              val className = reader.readName()
+              goto(end)
+              (packageName, className)
+            case IMPORT | VALDEF =>
+              goto(end)
+              readNames(packageName)
+            case PACKAGE =>
+              readNames(packageName)
+          }
+        }
+        else tag match {
+          case TERMREFpkg | TYPEREFpkg =>
+            val subPackageName = reader.readName()
+            readNames(subPackageName)
+          case SHAREDtype =>
+            val addr = reader.readAddr()
+            val reader2 = reader.subReader(addr, reader.endAddr)
+            val tag2 = reader2.readByte()
+            assert(tag2 == TERMREFpkg || tag2 == TYPEREFpkg)
+            val subPackageName = reader2.readName()
+            readNames(subPackageName)
+          case _ =>
+            readNames(packageName)
+        }
+      }
+      readNames(nme.EMPTY_PACKAGE)
+    }
+
+    extension (reader: TastyReader) def readName() = {
+      val idx = reader.readNat()
+      nameAtRef(NameRef(idx))
+    }
+  }
+
+}
diff --git a/tests/pos-with-compiler-cc/dotc/core/tasty/TastyHTMLPrinter.scala b/tests/pos-with-compiler-cc/dotc/core/tasty/TastyHTMLPrinter.scala
new file mode 100644
index 000000000000..b234705413ae
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/core/tasty/TastyHTMLPrinter.scala
@@ -0,0 +1,9 @@
+package dotty.tools.dotc
+package core
+package tasty
+
+class TastyHTMLPrinter(bytes: Array[Byte]) extends TastyPrinter(bytes) {
+  override protected def nameStr(str: String): String = s"<span class='name'>$str</span>"
+  override protected def treeStr(str: String): String = s"<span class='tree'>$str</span>"
+  override protected def lengthStr(str: String): String = s"<span class='length'>$str</span>"
+}
diff --git a/tests/pos-with-compiler-cc/dotc/core/tasty/TastyPickler.scala b/tests/pos-with-compiler-cc/dotc/core/tasty/TastyPickler.scala
new file mode 100644
index 000000000000..aa657c393815
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/core/tasty/TastyPickler.scala
@@ -0,0 +1,80 @@
+package dotty.tools
+package dotc
+package core
+package tasty
+
+import scala.language.unsafeNulls
+
+import dotty.tools.tasty.{TastyBuffer, TastyFormat, TastyHash}
+import TastyFormat._
+import TastyBuffer._
+
+import collection.mutable
+import core.Symbols.ClassSymbol
+import Decorators._
+
+object TastyPickler {
+
+  private val versionStringBytes = {
+    val compilerString = s"Scala ${config.Properties.simpleVersionString}"
+    compilerString.getBytes(java.nio.charset.StandardCharsets.UTF_8)
+  }
+
+}
+
+class TastyPickler(val rootCls: ClassSymbol) {
+
+  private val sections = new mutable.ArrayBuffer[(NameRef, TastyBuffer)]
+
+  val nameBuffer: NameBuffer = new NameBuffer
+
+  def newSection(name: String, buf: TastyBuffer): Unit =
+    sections += ((nameBuffer.nameIndex(name.toTermName), buf))
+
+  def assembleParts(): Array[Byte] = {
+    def lengthWithLength(buf: TastyBuffer) =
+      buf.length + natSize(buf.length)
+
+    nameBuffer.assemble()
+    sections.foreach(_._2.assemble())
+
+    val nameBufferHash = TastyHash.pjwHash64(nameBuffer.bytes)
+    val treeSectionHash +: otherSectionHashes = sections.map(x => TastyHash.pjwHash64(x._2.bytes)): @unchecked
+
+    // Hash of name table and tree
+    val uuidLow: Long = nameBufferHash ^ treeSectionHash
+    // Hash of positions, comments and any additional section
+    val uuidHi: Long = otherSectionHashes.fold(0L)(_ ^ _)
+
+    val headerBuffer = {
+      val buf = new TastyBuffer(header.length + TastyPickler.versionStringBytes.length + 32)
+      for (ch <- header) buf.writeByte(ch.toByte)
+      buf.writeNat(MajorVersion)
+      buf.writeNat(MinorVersion)
+      buf.writeNat(ExperimentalVersion)
+      buf.writeNat(TastyPickler.versionStringBytes.length)
+      buf.writeBytes(TastyPickler.versionStringBytes, TastyPickler.versionStringBytes.length)
+      buf.writeUncompressedLong(uuidLow)
+      buf.writeUncompressedLong(uuidHi)
+      buf
+    }
+
+    val totalSize =
+      headerBuffer.length +
+      lengthWithLength(nameBuffer) + {
+        for ((nameRef, buf) <- sections) yield
+          natSize(nameRef.index) + lengthWithLength(buf)
+      }.sum
+    val all = new TastyBuffer(totalSize)
+    all.writeBytes(headerBuffer.bytes, headerBuffer.length)
+    all.writeNat(nameBuffer.length)
+    all.writeBytes(nameBuffer.bytes, nameBuffer.length)
+    for ((nameRef, buf) <- sections) {
+      all.writeNat(nameRef.index)
+      all.writeNat(buf.length)
+      all.writeBytes(buf.bytes, buf.length)
+    }
+    assert(all.length == totalSize && all.bytes.length == totalSize, s"totalSize = $totalSize, all.length = ${all.length}, all.bytes.length = ${all.bytes.length}")
+    all.bytes
+  }
+}
diff --git a/tests/pos-with-compiler-cc/dotc/core/tasty/TastyPrinter.scala b/tests/pos-with-compiler-cc/dotc/core/tasty/TastyPrinter.scala
new file mode 100644
index 000000000000..5876b69edfde
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/core/tasty/TastyPrinter.scala
@@ -0,0 +1,228 @@
+package dotty.tools.dotc
+package core
+package tasty
+
+import dotty.tools.tasty.{TastyBuffer, TastyReader}
+import TastyBuffer.NameRef
+
+import Contexts._, Decorators._
+import Names.Name
+import TastyUnpickler._
+import util.Spans.offsetToInt
+import dotty.tools.tasty.TastyFormat.{ASTsSection, PositionsSection, CommentsSection}
+import java.nio.file.{Files, Paths}
+import dotty.tools.io.{JarArchive, Path}
+
+object TastyPrinter:
+
+  def showContents(bytes: Array[Byte], noColor: Boolean): String =
+    val printer =
+      if noColor then new TastyPrinter(bytes)
+      else new TastyAnsiiPrinter(bytes)
+    printer.showContents()
+
+  def main(args: Array[String]): Unit = {
+    // TODO: Decouple CliCommand from Context and use CliCommand.distill?
+    val lineWidth = 80
+    val line = "-" * lineWidth
+    val noColor = args.contains("-color:never")
+    var printLastLine = false
+    def printTasty(fileName: String, bytes: Array[Byte]): Unit =
+      println(line)
+      println(fileName)
+      println(line)
+      println(showContents(bytes, noColor))
+      println()
+      printLastLine = true
+    for arg <- args do
+      if arg == "-color:never" then () // skip
+      else if arg.startsWith("-") then println(s"bad option '$arg' was ignored")
+      else if arg.endsWith(".tasty") then
+        val path = Paths.get(arg)
+        if Files.exists(path) then
+          printTasty(arg, Files.readAllBytes(path).nn)
+        else
+          println("File not found: " + arg)
+          System.exit(1)
+      else if arg.endsWith(".jar") then
+        val jar = JarArchive.open(Path(arg), create = false)
+        try
+          for file <- jar.iterator() if file.name.endsWith(".tasty") do
+            printTasty(s"$arg ${file.path}", file.toByteArray)
+        finally jar.close()
+      else
+        println(s"Not a '.tasty' or '.jar' file: $arg")
+        System.exit(1)
+
+    if printLastLine then
+      println(line)
+  }
+
+class TastyPrinter(bytes: Array[Byte]) {
+
+  private val sb: StringBuilder = new StringBuilder
+
+  private val unpickler: TastyUnpickler = new TastyUnpickler(bytes)
+  import unpickler.{nameAtRef, unpickle}
+
+  private def nameToString(name: Name): String = name.debugString
+
+  private def nameRefToString(ref: NameRef): String = nameToString(nameAtRef(ref))
+
+  private def printNames(): Unit =
+    for ((name, idx) <- nameAtRef.contents.zipWithIndex) {
+      val index = nameStr("%4d".format(idx))
+      sb.append(index).append(": ").append(nameToString(name)).append("\n")
+    }
+
+  def showContents(): String = {
+    sb.append("Names:\n")
+    printNames()
+    sb.append("\n")
+    sb.append("Trees:\n")
+    unpickle(new TreeSectionUnpickler) match {
+      case Some(s) => sb.append(s)
+      case _ =>
+    }
+    sb.append("\n\n")
+    unpickle(new PositionSectionUnpickler) match {
+      case Some(s) => sb.append(s)
+      case _ =>
+    }
+    sb.append("\n\n")
+    unpickle(new CommentSectionUnpickler) match {
+      case Some(s) => sb.append(s)
+      case _ =>
+    }
+    sb.result
+  }
+
+  class TreeSectionUnpickler extends SectionUnpickler[String](ASTsSection) {
+    import dotty.tools.tasty.TastyFormat._
+
+    private val sb: StringBuilder = new StringBuilder
+
+    def unpickle(reader: TastyReader, tastyName: NameTable): String = {
+      import reader._
+      var indent = 0
+      def newLine() = {
+        val length = treeStr("%5d".format(index(currentAddr) - index(startAddr)))
+        sb.append(s"\n $length:" + " " * indent)
+      }
+      def printNat() = sb.append(treeStr(" " + readNat()))
+      def printName() = {
+        val idx = readNat()
+        sb.append(nameStr(" " + idx + " [" + nameRefToString(NameRef(idx)) + "]"))
+      }
+      def printTree(): Unit = {
+        newLine()
+        val tag = readByte()
+        sb.append(" ").append(astTagToString(tag))
+        indent += 2
+        if (tag >= firstLengthTreeTag) {
+          val len = readNat()
+          sb.append(s"(${lengthStr(len.toString)})")
+          val end = currentAddr + len
+          def printTrees() = until(end)(printTree())
+          tag match {
+            case RENAMED =>
+              printName(); printName()
+            case VALDEF | DEFDEF | TYPEDEF | TYPEPARAM | PARAM | NAMEDARG | BIND =>
+              printName(); printTrees()
+            case REFINEDtype | TERMREFin | TYPEREFin | SELECTin =>
+              printName(); printTree(); printTrees()
+            case RETURN | HOLE =>
+              printNat(); printTrees()
+            case METHODtype | POLYtype | TYPELAMBDAtype =>
+              printTree()
+              while (currentAddr.index < end.index && !isModifierTag(nextByte)) { printTree(); printName(); }
+              printTrees()
+            case PARAMtype =>
+              printNat(); printNat()
+            case _ =>
+              printTrees()
+          }
+          if (currentAddr != end) {
+            sb.append(s"incomplete read, current = $currentAddr, end = $end\n")
+            goto(end)
+          }
+        }
+        else if (tag >= firstNatASTTreeTag) {
+          tag match {
+            case IDENT | IDENTtpt | SELECT | SELECTtpt | TERMREF | TYPEREF | SELFDEF => printName()
+            case _ => printNat()
+          }
+          printTree()
+        }
+        else if (tag >= firstASTTreeTag)
+          printTree()
+        else if (tag >= firstNatTreeTag)
+          tag match {
+            case TERMREFpkg | TYPEREFpkg | STRINGconst | IMPORTED => printName()
+            case _ => printNat()
+          }
+        indent -= 2
+      }
+      sb.append(s"start = ${reader.startAddr}, base = $base, current = $currentAddr, end = $endAddr\n")
+      sb.append(s"${endAddr.index - startAddr.index} bytes of AST, base = $currentAddr\n")
+      while (!isAtEnd) {
+        printTree()
+        newLine()
+      }
+      sb.result
+    }
+  }
+
+  class PositionSectionUnpickler extends SectionUnpickler[String](PositionsSection) {
+
+    private val sb: StringBuilder = new StringBuilder
+
+    def unpickle(reader: TastyReader, tastyName: NameTable): String = {
+      val posUnpickler = new PositionUnpickler(reader, tastyName)
+      sb.append(s" ${reader.endAddr.index - reader.currentAddr.index}")
+      sb.append(" position bytes:\n")
+      val lineSizes = posUnpickler.lineSizes
+      sb.append(s"   lines: ${lineSizes.length}\n")
+      sb.append(posUnpickler.lineSizes.mkString("   line sizes: ", ", ", "\n"))
+      sb.append("   positions:\n")
+      val spans = posUnpickler.spans
+      val sorted = spans.toSeq.sortBy(_._1.index)
+      for ((addr, pos) <- sorted) {
+        sb.append(treeStr("%10d".format(addr.index)))
+        sb.append(s": ${offsetToInt(pos.start)} .. ${pos.end}\n")
+      }
+
+      val sources = posUnpickler.sourcePaths
+      sb.append(s"\n source paths:\n")
+      val sortedPath = sources.toSeq.sortBy(_._1.index)
+      for ((addr, path) <- sortedPath) {
+        sb.append(treeStr("%10d: ".format(addr.index)))
+        sb.append(path)
+        sb.append("\n")
+      }
+
+      sb.result
+    }
+  }
+
+  class CommentSectionUnpickler extends SectionUnpickler[String](CommentsSection) {
+
+    private val sb: StringBuilder = new StringBuilder
+
+    def unpickle(reader: TastyReader, tastyName: NameTable): String = {
+      sb.append(s" ${reader.endAddr.index - reader.currentAddr.index}")
+      val comments = new CommentUnpickler(reader).comments
+      sb.append(s" comment bytes:\n")
+      val sorted = comments.toSeq.sortBy(_._1.index)
+      for ((addr, cmt) <- sorted) {
+        sb.append(treeStr("%10d".format(addr.index)))
+        sb.append(s": ${cmt.raw} (expanded = ${cmt.isExpanded})\n")
+      }
+      sb.result
+    }
+  }
+
+  protected def nameStr(str: String): String = str
+  protected def treeStr(str: String): String = str
+  protected def lengthStr(str: String): String = str
+}
diff --git a/tests/pos-with-compiler-cc/dotc/core/tasty/TastyUnpickler.scala b/tests/pos-with-compiler-cc/dotc/core/tasty/TastyUnpickler.scala
new file mode 100644
index 000000000000..5cc172c65439
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/core/tasty/TastyUnpickler.scala
@@ -0,0 +1,109 @@
+package dotty.tools.dotc
+package core
+package tasty
+
+import scala.language.unsafeNulls
+
+import dotty.tools.tasty.{TastyFormat, TastyBuffer, TastyReader, TastyHeaderUnpickler}
+import TastyFormat.NameTags._, TastyFormat.nameTagToString
+import TastyBuffer.NameRef
+
+import scala.collection.mutable
+import Names.{TermName, termName, EmptyTermName}
+import NameKinds._
+import language.experimental.pureFunctions
+
+object TastyUnpickler {
+
+  abstract class SectionUnpickler[R](val name: String) {
+    def unpickle(reader: TastyReader, nameAtRef: NameTable): R
+  }
+
+  class NameTable extends (NameRef -> TermName) {
+    private val names = new mutable.ArrayBuffer[TermName]
+    def add(name: TermName): mutable.ArrayBuffer[TermName] = names += name
+    def apply(ref: NameRef): TermName = names(ref.index)
+    def contents: Iterable[TermName] = names
+  }
+}
+
+import TastyUnpickler._
+
+class TastyUnpickler(reader: TastyReader) {
+  import reader._
+
+  def this(bytes: Array[Byte]) = this(new TastyReader(bytes))
+
+  private val sectionReader = new mutable.HashMap[String, TastyReader]
+  val nameAtRef: NameTable = new NameTable
+
+  private def readName(): TermName = nameAtRef(readNameRef())
+  private def readString(): String = readName().toString
+
+  private def readParamSig(): Signature.ParamSig = {
+    val ref = readInt()
+    if (ref < 0)
+      ref.abs
+    else
+      nameAtRef(NameRef(ref)).toTypeName
+  }
+
+  private def readNameContents(): TermName = {
+    val tag = readByte()
+    val length = readNat()
+    val start = currentAddr
+    val end = start + length
+    def readSignedRest(original: TermName, target: TermName): TermName =
+      val result = readName().toTypeName
+      val paramsSig = until(end)(readParamSig())
+      val sig = Signature(paramsSig, result)
+      SignedName(original, sig, target)
+
+    val result = tag match {
+      case UTF8 =>
+        goto(end)
+        termName(bytes, start.index, length)
+      case QUALIFIED | EXPANDED | EXPANDPREFIX =>
+        qualifiedNameKindOfTag(tag)(readName(), readName().asSimpleName)
+      case UNIQUE =>
+        val separator = readName().toString
+        val num = readNat()
+        val originals = until(end)(readName())
+        val original = if (originals.isEmpty) EmptyTermName else originals.head
+        uniqueNameKindOfSeparator(separator)(original, num)
+      case DEFAULTGETTER =>
+        numberedNameKindOfTag(tag)(readName(), readNat())
+      case SIGNED =>
+        val original = readName()
+        readSignedRest(original, original)
+      case TARGETSIGNED =>
+        val original = readName()
+        val target = readName()
+        readSignedRest(original, target)
+      case SUPERACCESSOR | INLINEACCESSOR | BODYRETAINER | OBJECTCLASS =>
+        simpleNameKindOfTag(tag)(readName())
+      case _ =>
+        throw MatchError(s"unknown name tag ${nameTagToString(tag)}")
+    }
+    assert(currentAddr == end, s"bad name $result $start $currentAddr $end")
+    result
+  }
+
+  new TastyHeaderUnpickler(reader).readHeader()
+
+  locally {
+    until(readEnd()) { nameAtRef.add(readNameContents()) }
+    while (!isAtEnd) {
+      val secName = readString()
+      val secEnd = readEnd()
+      sectionReader(secName) = new TastyReader(bytes, currentAddr.index, secEnd.index, currentAddr.index)
+      goto(secEnd)
+    }
+  }
+
+  def unpickle[R](sec: SectionUnpickler[R]): Option[R] =
+    for (reader <- sectionReader.get(sec.name)) yield
+      sec.unpickle(reader, nameAtRef)
+
+  private[dotc] def bytes: Array[Byte] = reader.bytes
+}
diff --git a/tests/pos-with-compiler-cc/dotc/core/tasty/TreeBuffer.scala b/tests/pos-with-compiler-cc/dotc/core/tasty/TreeBuffer.scala
new file mode 100644
index 000000000000..a3dedaaec685
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/core/tasty/TreeBuffer.scala
@@ -0,0 +1,189 @@
+package dotty.tools
+package dotc
+package core
+package tasty
+
+import dotty.tools.tasty.util.Util.dble
+import dotty.tools.tasty.TastyBuffer
+import TastyBuffer.{Addr, NoAddr, AddrWidth}
+
+import util.Util.bestFit
+import config.Printers.pickling
+import ast.untpd.Tree
+
+class TreeBuffer extends TastyBuffer(50000) {
+
+  private inline val ItemsOverOffsets = 2
+  private val initialOffsetSize = bytes.length / (AddrWidth * ItemsOverOffsets)
+  private var offsets = new Array[Int](initialOffsetSize)
+  private var isRelative = new Array[Boolean](initialOffsetSize)
+  private var delta: Array[Int] = _
+  private var numOffsets = 0
+
+  /** A map from trees to the address at which a tree is pickled. */
+  private val treeAddrs = util.IntMap[Tree](initialCapacity = 8192)
+
+  def registerTreeAddr(tree: Tree): Addr =
+    val idx = treeAddrs(tree)
+    if idx < 0 then
+      treeAddrs(tree) = currentAddr.index
+      currentAddr
+    else
+      Addr(idx)
+
+  def addrOfTree(tree: Tree): Addr =
+    val idx = treeAddrs(tree)
+    if idx < 0 then NoAddr else Addr(idx)
+
+  private def offset(i: Int): Addr = Addr(offsets(i))
+
+  private def keepOffset(relative: Boolean): Unit = {
+    if (numOffsets == offsets.length) {
+      offsets = dble(offsets)
+      isRelative = dble(isRelative)
+    }
+    offsets(numOffsets) = length
+    isRelative(numOffsets) = relative
+    numOffsets += 1
+  }
+
+  /** Reserve space for a reference, to be adjusted later */
+  def reserveRef(relative: Boolean): Addr = {
+    val addr = currentAddr
+    keepOffset(relative)
+    reserveAddr()
+    addr
+  }
+
+  /** Write reference right adjusted into freshly reserved field. */
+  def writeRef(target: Addr): Unit = {
+    keepOffset(relative = false)
+    fillAddr(reserveAddr(), target)
+  }
+
+  /** Fill previously reserved field with a reference */
+  def fillRef(at: Addr, target: Addr, relative: Boolean): Unit = {
+    val addr = if (relative) target.relativeTo(at) else target
+    fillAddr(at, addr)
+  }
+
+  /** The amount by which the bytes at the given address are shifted under compression */
+  def deltaAt(at: Addr): Int = {
+    val idx = bestFit(offsets, numOffsets, at.index - 1)
+    if (idx < 0) 0 else delta(idx)
+  }
+
+  /** The address to which `x` is translated under compression */
+  def adjusted(x: Addr): Addr = x - deltaAt(x)
+
+  /** Compute all shift-deltas */
+  private def computeDeltas() = {
+    delta = new Array[Int](numOffsets)
+    var lastDelta = 0
+    var i = 0
+    while (i < numOffsets) {
+      val off = offset(i)
+      val skippedOff = skipZeroes(off)
+      val skippedCount = skippedOff.index - off.index
+      assert(skippedCount < AddrWidth, s"unset field at position $off")
+      lastDelta += skippedCount
+      delta(i) = lastDelta
+      i += 1
+    }
+  }
+
+  /** The absolute or relative adjusted address at index `i` of `offsets` array*/
+  private def adjustedOffset(i: Int): Addr = {
+    val at = offset(i)
+    val original = getAddr(at)
+    if (isRelative(i)) {
+      val start = skipNat(at)
+      val len1 = original + delta(i) - deltaAt(original + start.index)
+      val len2 = adjusted(original + start.index) - adjusted(start).index
+      assert(len1 == len2,
+          s"adjusting offset #$i: $at, original = $original, len1 = $len1, len2 = $len2")
+      len1
+    }
+    else adjusted(original)
+  }
+
+  /** Adjust all offsets according to previously computed deltas */
+  private def adjustOffsets(): Unit =
+    for (i <- 0 until numOffsets) {
+      val corrected = adjustedOffset(i)
+      fillAddr(offset(i), corrected)
+    }
+
+  /** Adjust deltas to also take account references that will shrink (and thereby
+   *  generate additional zeroes that can be skipped) due to previously
+   *  computed adjustments.
+   */
+  private def adjustDeltas(): Int = {
+    val delta1 = new Array[Int](delta.length)
+    var lastDelta = 0
+    var i = 0
+    while (i < numOffsets) {
+      val corrected = adjustedOffset(i)
+      lastDelta += AddrWidth - TastyBuffer.natSize(corrected.index)
+      delta1(i) = lastDelta
+      i += 1
+    }
+    val saved =
+      if (numOffsets == 0) 0
+      else delta1(numOffsets - 1) - delta(numOffsets - 1)
+    delta = delta1
+    saved
+  }
+
+  /** Compress pickle buffer, shifting bytes to close all skipped zeroes. */
+  private def compress(): Int = {
+    var lastDelta = 0
+    var start = 0
+    var i = 0
+    var wasted = 0
+    def shift(end: Int) =
+      System.arraycopy(bytes, start, bytes, start - lastDelta, end - start)
+    while (i < numOffsets) {
+      val next = offsets(i)
+      shift(next)
+      start = next + delta(i) - lastDelta
+      val pastZeroes = skipZeroes(Addr(next)).index
+      assert(pastZeroes >= start, s"something's wrong: eliminated non-zero")
+      wasted += (pastZeroes - start)
+      lastDelta = delta(i)
+      i += 1
+    }
+    shift(length)
+    length -= lastDelta
+    wasted
+  }
+
+  def adjustTreeAddrs(): Unit =
+    var i = 0
+    while i < treeAddrs.size do
+      treeAddrs.setValue(i, adjusted(Addr(treeAddrs.value(i))).index)
+      i += 1
+
+  /** Final assembly, involving the following steps:
+   *   - compute deltas
+   *   - adjust deltas until additional savings are < 1% of total
+   *   - adjust offsets according to the adjusted deltas
+   *   - shrink buffer, skipping zeroes.
+   */
+  def compactify(): Unit = {
+    val origLength = length
+    computeDeltas()
+    //println(s"offsets: ${offsets.take(numOffsets).deep}")
+    //println(s"deltas: ${delta.take(numOffsets).deep}")
+    var saved = 0
+    while
+      saved = adjustDeltas()
+      pickling.println(s"adjusting deltas, saved = $saved")
+      saved > 0 && length / saved < 100
+    do ()
+    adjustOffsets()
+    adjustTreeAddrs()
+    val wasted = compress()
+    pickling.println(s"original length: $origLength, compressed to: $length, wasted: $wasted") // DEBUG, for now.
+  }
+}
diff --git a/tests/pos-with-compiler-cc/dotc/core/tasty/TreePickler.scala b/tests/pos-with-compiler-cc/dotc/core/tasty/TreePickler.scala
new file mode 100644
index 000000000000..34c22439a932
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/core/tasty/TreePickler.scala
@@ -0,0 +1,795 @@
+package dotty.tools
+package dotc
+package core
+package tasty
+
+import scala.language.unsafeNulls
+
+import dotty.tools.tasty.TastyFormat._
+import dotty.tools.tasty.TastyBuffer._
+
+import ast.Trees._
+import ast.{untpd, tpd}
+import Contexts._, Symbols._, Types._, Names._, Constants._, Decorators._, Annotations._, Flags._
+import Comments.{Comment, CommentsContext}
+import NameKinds._
+import StdNames.nme
+import transform.SymUtils._
+import config.Config
+import collection.mutable
+import reporting.{Profile, NoProfile}
+import dotty.tools.tasty.TastyFormat.ASTsSection
+
+
+class TreePickler(pickler: TastyPickler) {
+  val buf: TreeBuffer = new TreeBuffer
+  pickler.newSection(ASTsSection, buf)
+  import buf._
+  import pickler.nameBuffer.nameIndex
+  import tpd._
+
+  private val symRefs = Symbols.MutableSymbolMap[Addr](256)
+  private val forwardSymRefs = Symbols.MutableSymbolMap[List[Addr]]()
+  private val pickledTypes = util.EqHashMap[Type, Addr]()
+
+  /** A list of annotation trees for every member definition, so that later
+   *  parallel position pickling does not need to access and force symbols.
+   */
+  private val annotTrees = util.EqHashMap[untpd.MemberDef, mutable.ListBuffer[Tree]]()
+
+  /** A map from member definitions to their doc comments, so that later
+   *  parallel comment pickling does not need to access symbols of trees (which
+   *  would involve accessing symbols of named types and possibly changing phases
+   *  in doing so).
+   */
+  private val docStrings = util.EqHashMap[untpd.MemberDef, Comment]()
+
+  private var profile: Profile = NoProfile
+
+  def treeAnnots(tree: untpd.MemberDef): List[Tree] =
+    val ts = annotTrees.lookup(tree)
+    if ts == null then Nil else ts.toList
+
+  def docString(tree: untpd.MemberDef): Option[Comment] =
+    Option(docStrings.lookup(tree))
+
+  private def withLength(op: => Unit) = {
+    val lengthAddr = reserveRef(relative = true)
+    op
+    fillRef(lengthAddr, currentAddr, relative = true)
+  }
+
+  def addrOfSym(sym: Symbol): Option[Addr] =
+    symRefs.get(sym)
+
+  def preRegister(tree: Tree)(using Context): Unit = tree match {
+    case tree: MemberDef =>
+      if (!symRefs.contains(tree.symbol)) symRefs(tree.symbol) = NoAddr
+    case _ =>
+  }
+
+  def registerDef(sym: Symbol): Unit = {
+    symRefs(sym) = currentAddr
+    forwardSymRefs.get(sym) match {
+      case Some(refs) =>
+        refs.foreach(fillRef(_, currentAddr, relative = false))
+        forwardSymRefs -= sym
+      case None =>
+    }
+  }
+
+  def pickleName(name: Name): Unit = writeNat(nameIndex(name).index)
+
+  private def pickleNameAndSig(name: Name, sig: Signature, target: Name): Unit =
+    pickleName(
+      if (sig eq Signature.NotAMethod) name
+      else SignedName(name.toTermName, sig, target.asTermName))
+
+  private def pickleSymRef(sym: Symbol)(using Context) = symRefs.get(sym) match {
+    case Some(label) =>
+      if (label != NoAddr) writeRef(label) else pickleForwardSymRef(sym)
+    case None =>
+      // See pos/t1957.scala for an example where this can happen.
+      // I believe it's a bug in typer: the type of an implicit argument refers
+      // to a closure parameter outside the closure itself. TODO: track this down, so that we
+      // can eliminate this case.
+      report.log(i"pickling reference to as yet undefined $sym in ${sym.owner}", sym.srcPos)
+      pickleForwardSymRef(sym)
+  }
+
+  private def pickleForwardSymRef(sym: Symbol)(using Context) = {
+    val ref = reserveRef(relative = false)
+    assert(!sym.is(Flags.Package), sym)
+    forwardSymRefs(sym) = ref :: forwardSymRefs.getOrElse(sym, Nil)
+  }
+
+  private def isLocallyDefined(sym: Symbol)(using Context) =
+    sym.topLevelClass.isLinkedWith(pickler.rootCls)
+
+  def pickleConstant(c: Constant)(using Context): Unit = c.tag match {
+    case UnitTag =>
+      writeByte(UNITconst)
+    case BooleanTag =>
+      writeByte(if (c.booleanValue) TRUEconst else FALSEconst)
+    case ByteTag =>
+      writeByte(BYTEconst)
+      writeInt(c.byteValue)
+    case ShortTag =>
+      writeByte(SHORTconst)
+      writeInt(c.shortValue)
+    case CharTag =>
+      writeByte(CHARconst)
+      writeNat(c.charValue)
+    case IntTag =>
+      writeByte(INTconst)
+      writeInt(c.intValue)
+    case LongTag =>
+      writeByte(LONGconst)
+      writeLongInt(c.longValue)
+    case FloatTag =>
+      writeByte(FLOATconst)
+      writeInt(java.lang.Float.floatToRawIntBits(c.floatValue))
+    case DoubleTag =>
+      writeByte(DOUBLEconst)
+      writeLongInt(java.lang.Double.doubleToRawLongBits(c.doubleValue))
+    case StringTag =>
+      writeByte(STRINGconst)
+      pickleName(c.stringValue.toTermName)
+    case NullTag =>
+      writeByte(NULLconst)
+    case ClazzTag =>
+      writeByte(CLASSconst)
+      pickleType(c.typeValue)
+  }
+
+  def pickleVariances(tp: Type)(using Context): Unit = tp match
+    case tp: HKTypeLambda if tp.isDeclaredVarianceLambda =>
+      for v <- tp.declaredVariances do
+        writeByte(
+          if v.is(Covariant) then COVARIANT
+          else if v.is(Contravariant) then CONTRAVARIANT
+          else STABLE)
+    case _ =>
+
+  def pickleType(tpe0: Type, richTypes: Boolean = false)(using Context): Unit = {
+    val tpe = tpe0.stripTypeVar
+    try {
+      val prev: Addr | Null = pickledTypes.lookup(tpe)
+      if (prev == null) {
+        pickledTypes(tpe) = currentAddr
+        pickleNewType(tpe, richTypes)
+      }
+      else {
+        writeByte(SHAREDtype)
+        writeRef(prev.uncheckedNN)
+      }
+    }
+    catch {
+      case ex: AssertionError =>
+        println(i"error when pickling type $tpe")
+        throw ex
+    }
+  }
+
+  private def pickleNewType(tpe: Type, richTypes: Boolean)(using Context): Unit = tpe match {
+    case AppliedType(tycon, args) =>
+      if tycon.typeSymbol == defn.MatchCaseClass then
+        writeByte(MATCHCASEtype)
+        withLength { args.foreach(pickleType(_)) }
+      else
+        writeByte(APPLIEDtype)
+        withLength { pickleType(tycon); args.foreach(pickleType(_)) }
+    case ConstantType(value) =>
+      pickleConstant(value)
+    case tpe: NamedType =>
+      val sym = tpe.symbol
+      def pickleExternalRef(sym: Symbol) = {
+        val isShadowedRef =
+          sym.isClass && tpe.prefix.member(sym.name).symbol != sym
+        if (sym.is(Flags.Private) || isShadowedRef) {
+          writeByte(if (tpe.isType) TYPEREFin else TERMREFin)
+          withLength {
+            pickleNameAndSig(sym.name, sym.signature, sym.targetName)
+            pickleType(tpe.prefix)
+            pickleType(sym.owner.typeRef)
+          }
+        }
+        else {
+          writeByte(if (tpe.isType) TYPEREF else TERMREF)
+          pickleNameAndSig(sym.name, tpe.signature, sym.targetName)
+          pickleType(tpe.prefix)
+        }
+      }
+      if (sym.is(Flags.Package)) {
+        writeByte(if (tpe.isType) TYPEREFpkg else TERMREFpkg)
+        pickleName(sym.fullName)
+      }
+      else if (tpe.prefix == NoPrefix) {
+        writeByte(if (tpe.isType) TYPEREFdirect else TERMREFdirect)
+        if Config.checkLevelsOnConstraints && !symRefs.contains(sym) && !sym.isPatternBound && !sym.hasAnnotation(defn.QuotedRuntimePatterns_patternTypeAnnot) then
+          report.error(i"pickling reference to as yet undefined $tpe with symbol ${sym}", sym.srcPos)
+        pickleSymRef(sym)
+      }
+      else tpe.designator match {
+        case name: Name =>
+          writeByte(if (tpe.isType) TYPEREF else TERMREF)
+          pickleName(name); pickleType(tpe.prefix)
+        case sym: Symbol =>
+          if (isLocallyDefined(sym)) {
+            writeByte(if (tpe.isType) TYPEREFsymbol else TERMREFsymbol)
+            pickleSymRef(sym); pickleType(tpe.prefix)
+          }
+          else pickleExternalRef(sym)
+      }
+    case tpe: ThisType =>
+      if (tpe.cls.is(Flags.Package) && !tpe.cls.isEffectiveRoot) {
+        writeByte(TERMREFpkg)
+        pickleName(tpe.cls.fullName)
+      }
+      else {
+        writeByte(THIS)
+        pickleType(tpe.tref)
+      }
+    case tpe: SuperType =>
+      writeByte(SUPERtype)
+      withLength { pickleType(tpe.thistpe); pickleType(tpe.supertpe) }
+    case tpe: RecThis =>
+      writeByte(RECthis)
+      val binderAddr: Addr | Null = pickledTypes.lookup(tpe.binder)
+      assert(binderAddr != null, tpe.binder)
+      writeRef(binderAddr.uncheckedNN)
+    case tpe: SkolemType =>
+      pickleType(tpe.info)
+    case tpe: RefinedType =>
+      writeByte(REFINEDtype)
+      withLength {
+        pickleName(tpe.refinedName)
+        pickleType(tpe.parent)
+        pickleType(tpe.refinedInfo, richTypes = true)
+      }
+    case tpe: RecType =>
+      writeByte(RECtype)
+      pickleType(tpe.parent)
+    case tpe: TypeBounds =>
+      writeByte(TYPEBOUNDS)
+      withLength {
+        pickleType(tpe.lo, richTypes)
+        if !tpe.isInstanceOf[AliasingBounds] then
+          pickleType(tpe.hi, richTypes)
+        pickleVariances(tpe.hi)
+      }
+    case tpe: AnnotatedType =>
+      writeByte(ANNOTATEDtype)
+      withLength { pickleType(tpe.parent, richTypes); pickleTree(tpe.annot.tree) }
+    case tpe: AndType =>
+      writeByte(ANDtype)
+      withLength { pickleType(tpe.tp1, richTypes); pickleType(tpe.tp2, richTypes) }
+    case tpe: OrType =>
+      writeByte(ORtype)
+      withLength { pickleType(tpe.tp1, richTypes); pickleType(tpe.tp2, richTypes) }
+    case tpe: ExprType =>
+      writeByte(BYNAMEtype)
+      pickleType(tpe.underlying)
+    case tpe: HKTypeLambda =>
+      pickleMethodic(TYPELAMBDAtype, tpe, EmptyFlags)
+    case tpe: MatchType =>
+      writeByte(MATCHtype)
+      withLength {
+        pickleType(tpe.bound)
+        pickleType(tpe.scrutinee)
+        tpe.cases.foreach(pickleType(_))
+      }
+    case tpe: PolyType if richTypes =>
+      pickleMethodic(POLYtype, tpe, EmptyFlags)
+    case tpe: MethodType if richTypes =>
+      var mods = EmptyFlags
+      if tpe.isContextualMethod then mods |= Given
+      else if tpe.isImplicitMethod then mods |= Implicit
+      if tpe.isErasedMethod then mods |= Erased
+      pickleMethodic(METHODtype, tpe, mods)
+    case tpe: ParamRef =>
+      assert(pickleParamRef(tpe), s"orphan parameter reference: $tpe")
+    case tpe: LazyRef =>
+      pickleType(tpe.ref)
+  }
+
+  def pickleMethodic(tag: Int, tpe: LambdaType, mods: FlagSet)(using Context): Unit = {
+    writeByte(tag)
+    withLength {
+      pickleType(tpe.resultType, richTypes = true)
+      tpe.paramNames.lazyZip(tpe.paramInfos).foreach { (name, tpe) =>
+        pickleType(tpe); pickleName(name)
+      }
+      if (mods != EmptyFlags) pickleFlags(mods, tpe.isTermLambda)
+    }
+  }
+
+  def pickleParamRef(tpe: ParamRef)(using Context): Boolean = {
+    val binder: Addr | Null = pickledTypes.lookup(tpe.binder)
+    val pickled = binder != null
+    if (pickled) {
+      writeByte(PARAMtype)
+      withLength { writeRef(binder.uncheckedNN); writeNat(tpe.paramNum) }
+    }
+    pickled
+  }
+
+  def pickleTpt(tpt: Tree)(using Context): Unit =
+    pickleTree(tpt)
+
+  def pickleTreeUnlessEmpty(tree: Tree)(using Context): Unit = {
+    if (!tree.isEmpty) pickleTree(tree)
+  }
+
+  def pickleDef(tag: Int, mdef: MemberDef, tpt: Tree, rhs: Tree = EmptyTree, pickleParams: => Unit = ())(using Context): Unit = {
+    val sym = mdef.symbol
+
+    assert(symRefs(sym) == NoAddr, sym)
+    registerDef(sym)
+    writeByte(tag)
+    val addr = currentAddr
+    withLength {
+      pickleName(sym.name)
+      pickleParams
+      tpt match {
+        case _: Template | _: Hole => pickleTree(tpt)
+        case _ if tpt.isType => pickleTpt(tpt)
+      }
+      pickleTreeUnlessEmpty(rhs)
+      pickleModifiers(sym, mdef)
+    }
+    if sym.is(Method) && sym.owner.isClass then
+      profile.recordMethodSize(sym, currentAddr.index - addr.index, mdef.span)
+    for
+      docCtx <- ctx.docCtx
+      comment <- docCtx.docstring(sym)
+    do
+      docStrings(mdef) = comment
+  }
+
+  def pickleParam(tree: Tree)(using Context): Unit = {
+    registerTreeAddr(tree)
+    tree match {
+      case tree: ValDef  => pickleDef(PARAM, tree, tree.tpt)
+      case tree: TypeDef => pickleDef(TYPEPARAM, tree, tree.rhs)
+    }
+  }
+
+  def pickleParams(trees: List[Tree])(using Context): Unit = {
+    trees.foreach(preRegister)
+    trees.foreach(pickleParam)
+  }
+
+  def pickleStats(stats: List[Tree])(using Context): Unit = {
+    stats.foreach(preRegister)
+    stats.foreach(stat => if (!stat.isEmpty) pickleTree(stat))
+  }
+
+  def pickleTree(tree: Tree)(using Context): Unit = {
+    val addr = registerTreeAddr(tree)
+    if (addr != currentAddr) {
+      writeByte(SHAREDterm)
+      writeRef(addr)
+    }
+    else
+      try tree match {
+        case Ident(name) =>
+          tree.tpe match {
+            case tp: TermRef if name != nme.WILDCARD =>
+              // wildcards are pattern bound, need to be preserved as ids.
+              pickleType(tp)
+            case tp =>
+              writeByte(if (tree.isType) IDENTtpt else IDENT)
+              pickleName(name)
+              pickleType(tp)
+          }
+        case This(qual) =>
+          if (qual.isEmpty) pickleType(tree.tpe)
+          else {
+            writeByte(QUALTHIS)
+            val ThisType(tref) = tree.tpe: @unchecked
+            pickleTree(qual.withType(tref))
+          }
+        case Select(qual, name) =>
+          name match {
+            case OuterSelectName(_, levels) =>
+              writeByte(SELECTouter)
+              withLength {
+                writeNat(levels)
+                pickleTree(qual)
+                val SkolemType(tp) = tree.tpe: @unchecked
+                pickleType(tp)
+              }
+            case _ =>
+              val sig = tree.tpe.signature
+              var ename = tree.symbol.targetName
+              val selectFromQualifier =
+                name.isTypeName
+                || qual.isInstanceOf[Hole] // holes have no symbol
+                || sig == Signature.NotAMethod // no overload resolution necessary
+                || !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)
+                pickleNameAndSig(name, sig, ename)
+                pickleTree(qual)
+              else // select from owner
+                writeByte(SELECTin)
+                withLength {
+                  pickleNameAndSig(name, tree.symbol.signature, ename)
+                  pickleTree(qual)
+                  pickleType(tree.symbol.owner.typeRef)
+                }
+          }
+        case Apply(fun, args) =>
+          if (fun.symbol eq defn.throwMethod) {
+            writeByte(THROW)
+            pickleTree(args.head)
+          }
+          else {
+            writeByte(APPLY)
+            withLength {
+              pickleTree(fun)
+              args.foreach(pickleTree)
+            }
+          }
+        case TypeApply(fun, args) =>
+          writeByte(TYPEAPPLY)
+          withLength {
+            pickleTree(fun)
+            args.foreach(pickleTpt)
+          }
+        case Literal(const1) =>
+          pickleConstant {
+            tree.tpe match {
+              case ConstantType(const2) => const2
+              case _ => const1
+            }
+          }
+        case Super(qual, mix) =>
+          writeByte(SUPER)
+          withLength {
+            pickleTree(qual);
+            if (!mix.isEmpty) {
+              // mixinType being a TypeRef when mix is non-empty is enforced by TreeChecker#checkSuper              
+              val SuperType(_, mixinType: TypeRef) = tree.tpe: @unchecked
+              pickleTree(mix.withType(mixinType))
+            }
+          }
+        case New(tpt) =>
+          writeByte(NEW)
+          pickleTpt(tpt)
+        case Typed(expr, tpt) =>
+          writeByte(TYPED)
+          withLength { pickleTree(expr); pickleTpt(tpt) }
+        case NamedArg(name, arg) =>
+          writeByte(NAMEDARG)
+          pickleName(name)
+          pickleTree(arg)
+        case Assign(lhs, rhs) =>
+          writeByte(ASSIGN)
+          withLength { pickleTree(lhs); pickleTree(rhs) }
+        case Block(stats, expr) =>
+          writeByte(BLOCK)
+          stats.foreach(preRegister)
+          withLength { pickleTree(expr); stats.foreach(pickleTree) }
+        case tree @ If(cond, thenp, elsep) =>
+          writeByte(IF)
+          withLength {
+            if (tree.isInline) writeByte(INLINE)
+            pickleTree(cond)
+            pickleTree(thenp)
+            pickleTree(elsep)
+          }
+        case Closure(env, meth, tpt) =>
+          writeByte(LAMBDA)
+          assert(env.isEmpty)
+          withLength {
+            pickleTree(meth)
+            if (tpt.tpe.exists) pickleTpt(tpt)
+          }
+        case tree @ Match(selector, cases) =>
+          writeByte(MATCH)
+          withLength {
+            if (tree.isInline)
+              if (selector.isEmpty) writeByte(IMPLICIT)
+              else { writeByte(INLINE); pickleTree(selector) }
+            else pickleTree(selector)
+            tree.cases.foreach(pickleTree)
+          }
+        case CaseDef(pat, guard, rhs) =>
+          writeByte(CASEDEF)
+          withLength { pickleTree(pat); pickleTree(rhs); pickleTreeUnlessEmpty(guard) }
+        case Return(expr, from) =>
+          writeByte(RETURN)
+          withLength { pickleSymRef(from.symbol); pickleTreeUnlessEmpty(expr) }
+        case WhileDo(cond, body) =>
+          writeByte(WHILE)
+          withLength { pickleTree(cond); pickleTree(body) }
+        case Try(block, cases, finalizer) =>
+          writeByte(TRY)
+          withLength { pickleTree(block); cases.foreach(pickleTree); pickleTreeUnlessEmpty(finalizer) }
+        case SeqLiteral(elems, elemtpt) =>
+          writeByte(REPEATED)
+          withLength { pickleTree(elemtpt); elems.foreach(pickleTree) }
+        case Inlined(call, bindings, expansion) =>
+          writeByte(INLINED)
+          bindings.foreach(preRegister)
+          withLength {
+            pickleTree(expansion)
+            if (!call.isEmpty) pickleTree(call)
+            bindings.foreach { b =>
+              assert(b.isInstanceOf[DefDef] || b.isInstanceOf[ValDef])
+              pickleTree(b)
+            }
+          }
+        case Bind(name, body) =>
+          val sym = tree.symbol
+          registerDef(sym)
+          writeByte(BIND)
+          withLength {
+            pickleName(name)
+            pickleType(sym.info)
+            pickleTree(body)
+            pickleFlags(sym.flags &~ Case, sym.isTerm)
+          }
+        case Alternative(alts) =>
+          writeByte(ALTERNATIVE)
+          withLength { alts.foreach(pickleTree) }
+        case UnApply(fun, implicits, patterns) =>
+          writeByte(UNAPPLY)
+          withLength {
+            pickleTree(fun)
+            for (implicitArg <- implicits) {
+              writeByte(IMPLICITarg)
+              pickleTree(implicitArg)
+            }
+            pickleType(tree.tpe)
+            patterns.foreach(pickleTree)
+          }
+        case tree: ValDef =>
+          pickleDef(VALDEF, tree, tree.tpt, tree.rhs)
+        case tree: DefDef =>
+          def pickleParamss(paramss: List[ParamClause]): Unit = paramss match
+            case Nil =>
+            case Nil :: rest =>
+              writeByte(EMPTYCLAUSE)
+              pickleParamss(rest)
+            case (params @ (param1 :: _)) :: rest =>
+              pickleParams(params)
+              rest match
+                case (param2 :: _) :: _
+                if param1.isInstanceOf[untpd.TypeDef] == param2.isInstanceOf[untpd.TypeDef] =>
+                  writeByte(SPLITCLAUSE)
+                case _ =>
+              pickleParamss(rest)
+          pickleDef(DEFDEF, tree, tree.tpt, tree.rhs, pickleParamss(tree.paramss))
+        case tree: TypeDef =>
+          pickleDef(TYPEDEF, tree, tree.rhs)
+        case tree: Template =>
+          registerDef(tree.symbol)
+          writeByte(TEMPLATE)
+          val (params, rest) = decomposeTemplateBody(tree.body)
+          withLength {
+            pickleParams(params)
+            tree.parents.foreach(pickleTree)
+            val cinfo @ ClassInfo(_, _, _, _, selfInfo) = tree.symbol.owner.info: @unchecked
+            if (!tree.self.isEmpty) {
+              writeByte(SELFDEF)
+              pickleName(tree.self.name)
+
+              if (!tree.self.tpt.isEmpty) pickleTree(tree.self.tpt)
+              else {
+                if (!tree.self.isEmpty) registerTreeAddr(tree.self)
+                pickleType {
+                  selfInfo match {
+                    case sym: Symbol => sym.info
+                    case tp: Type => tp
+                  }
+                }
+              }
+            }
+            pickleStats(tree.constr :: rest)
+          }
+        case Import(expr, selectors) =>
+          writeByte(IMPORT)
+          withLength {
+            pickleTree(expr)
+            pickleSelectors(selectors)
+          }
+        case Export(expr, selectors) =>
+          writeByte(EXPORT)
+          withLength {
+            pickleTree(expr)
+            pickleSelectors(selectors)
+          }
+        case PackageDef(pid, stats) =>
+          writeByte(PACKAGE)
+          withLength { pickleType(pid.tpe); pickleStats(stats) }
+        case tree: TypeTree =>
+          pickleType(tree.tpe)
+        case SingletonTypeTree(ref) =>
+          writeByte(SINGLETONtpt)
+          pickleTree(ref)
+        case RefinedTypeTree(parent, refinements) =>
+          if (refinements.isEmpty) pickleTree(parent)
+          else {
+            val refineCls = refinements.head.symbol.owner.asClass
+            registerDef(refineCls)
+            pickledTypes(refineCls.typeRef) = currentAddr
+            writeByte(REFINEDtpt)
+            refinements.foreach(preRegister)
+            withLength { pickleTree(parent); refinements.foreach(pickleTree) }
+          }
+        case AppliedTypeTree(tycon, args) =>
+          writeByte(APPLIEDtpt)
+          withLength { pickleTree(tycon); args.foreach(pickleTree) }
+        case MatchTypeTree(bound, selector, cases) =>
+          writeByte(MATCHtpt)
+          withLength {
+            if (!bound.isEmpty) pickleTree(bound)
+            pickleTree(selector)
+            cases.foreach(pickleTree)
+          }
+        case ByNameTypeTree(tp) =>
+          writeByte(BYNAMEtpt)
+          pickleTree(tp)
+        case Annotated(tree, annot) =>
+          writeByte(ANNOTATEDtpt)
+          withLength { pickleTree(tree); pickleTree(annot) }
+        case LambdaTypeTree(tparams, body) =>
+          writeByte(LAMBDAtpt)
+          withLength { pickleParams(tparams); pickleTree(body) }
+        case TypeBoundsTree(lo, hi, alias) =>
+          writeByte(TYPEBOUNDStpt)
+          withLength {
+            pickleTree(lo);
+            if alias.isEmpty then
+              if hi ne lo then pickleTree(hi)
+            else
+              pickleTree(hi)
+              pickleTree(alias)
+          }
+        case Hole(_, idx, args, _, tpt) =>
+          writeByte(HOLE)
+          withLength {
+            writeNat(idx)
+            pickleType(tpt.tpe, richTypes = true)
+            args.foreach(pickleTree)
+          }
+      }
+      catch {
+        case ex: TypeError =>
+          report.error(ex.toMessage, tree.srcPos.focus)
+        case ex: AssertionError =>
+          println(i"error when pickling tree $tree")
+          throw ex
+      }
+  }
+
+  def pickleSelectors(selectors: List[untpd.ImportSelector])(using Context): Unit =
+    for sel <- selectors do
+      pickleSelector(IMPORTED, sel.imported)
+      sel.renamed match
+        case to @ Ident(_) => pickleSelector(RENAMED, to)
+        case _ =>
+      sel.bound match
+        case bound @ untpd.TypedSplice(tpt) =>
+          registerTreeAddr(bound)
+          writeByte(BOUNDED)
+          pickleTree(tpt)
+        case _ =>
+
+  def pickleSelector(tag: Int, id: untpd.Ident)(using Context): Unit = {
+    registerTreeAddr(id)
+    writeByte(tag)
+    pickleName(id.name)
+  }
+
+  def pickleModifiers(sym: Symbol, mdef: MemberDef)(using Context): Unit = {
+    import Flags._
+    var flags = sym.flags
+    val privateWithin = sym.privateWithin
+    if (privateWithin.exists) {
+      writeByte(if (flags.is(Protected)) PROTECTEDqualified else PRIVATEqualified)
+      pickleType(privateWithin.typeRef)
+      flags = flags &~ Protected
+    }
+    if (flags.is(ParamAccessor) && sym.isTerm && !sym.isSetter)
+      flags = flags &~ ParamAccessor // we only generate a tag for parameter setters
+    pickleFlags(flags, sym.isTerm)
+    val annots = sym.annotations.foreach(pickleAnnotation(sym, mdef, _))
+  }
+
+  def pickleFlags(flags: FlagSet, isTerm: Boolean)(using Context): Unit = {
+    import Flags._
+    def writeModTag(tag: Int) = {
+      assert(isModifierTag(tag))
+      writeByte(tag)
+    }
+    assert(!flags.is(Scala2x))
+    if (flags.is(Private)) writeModTag(PRIVATE)
+    if (flags.is(Protected)) writeModTag(PROTECTED)
+    if (flags.is(Final, butNot = Module)) writeModTag(FINAL)
+    if (flags.is(Case)) writeModTag(CASE)
+    if (flags.is(Override)) writeModTag(OVERRIDE)
+    if (flags.is(Inline)) writeModTag(INLINE)
+    if (flags.is(InlineProxy)) writeModTag(INLINEPROXY)
+    if (flags.is(Macro)) writeModTag(MACRO)
+    if (flags.is(JavaStatic)) writeModTag(STATIC)
+    if (flags.is(Module)) writeModTag(OBJECT)
+    if (flags.is(Enum)) writeModTag(ENUM)
+    if (flags.is(Local)) writeModTag(LOCAL)
+    if (flags.is(Synthetic)) writeModTag(SYNTHETIC)
+    if (flags.is(Artifact)) writeModTag(ARTIFACT)
+    if flags.is(Transparent) then writeModTag(TRANSPARENT)
+    if flags.is(Infix) then writeModTag(INFIX)
+    if flags.is(Invisible) then writeModTag(INVISIBLE)
+    if (flags.is(Erased)) writeModTag(ERASED)
+    if (flags.is(Exported)) writeModTag(EXPORTED)
+    if (flags.is(Given)) writeModTag(GIVEN)
+    if (flags.is(Implicit)) writeModTag(IMPLICIT)
+    if (isTerm) {
+      if (flags.is(Lazy, butNot = Module)) writeModTag(LAZY)
+      if (flags.is(AbsOverride)) { writeModTag(ABSTRACT); writeModTag(OVERRIDE) }
+      if (flags.is(Mutable)) writeModTag(MUTABLE)
+      if (flags.is(Accessor)) writeModTag(FIELDaccessor)
+      if (flags.is(CaseAccessor)) writeModTag(CASEaccessor)
+      if (flags.is(HasDefault)) writeModTag(HASDEFAULT)
+      if flags.isAllOf(StableMethod) then writeModTag(STABLE) // other StableRealizable flag occurrences are either implied or can be recomputed
+      if (flags.is(Extension)) writeModTag(EXTENSION)
+      if (flags.is(ParamAccessor)) writeModTag(PARAMsetter)
+      if (flags.is(SuperParamAlias)) writeModTag(PARAMalias)
+      assert(!(flags.is(Label)))
+    }
+    else {
+      if (flags.is(Sealed)) writeModTag(SEALED)
+      if (flags.is(Abstract)) writeModTag(ABSTRACT)
+      if (flags.is(Trait)) writeModTag(TRAIT)
+      if (flags.is(Covariant)) writeModTag(COVARIANT)
+      if (flags.is(Contravariant)) writeModTag(CONTRAVARIANT)
+      if (flags.is(Opaque)) writeModTag(OPAQUE)
+      if (flags.is(Open)) writeModTag(OPEN)
+    }
+  }
+
+  private def isUnpicklable(owner: Symbol, ann: Annotation)(using Context) = ann match {
+    case Annotation.Child(sym) => sym.isInaccessibleChildOf(owner)
+      // If child annotation refers to a local class or enum value under
+      // a different toplevel class, it is impossible to pickle a reference to it.
+      // Such annotations will be reconstituted when unpickling the child class.
+      // See tests/pickling/i3149.scala
+    case _ =>
+      ann.symbol == defn.BodyAnnot // inline bodies are reconstituted automatically when unpickling
+  }
+
+  def pickleAnnotation(owner: Symbol, mdef: MemberDef, ann: Annotation)(using Context): Unit =
+    if !isUnpicklable(owner, ann) then
+      writeByte(ANNOTATION)
+      withLength { pickleType(ann.symbol.typeRef); pickleTree(ann.tree) }
+      var treeBuf = annotTrees.lookup(mdef)
+      if treeBuf == null then
+        treeBuf = new mutable.ListBuffer[Tree]
+        annotTrees(mdef) = treeBuf
+      treeBuf += ann.tree
+
+// ---- main entry points ---------------------------------------
+
+  def pickle(trees: List[Tree])(using Context): Unit = {
+    profile = Profile.current
+    trees.foreach(tree => if (!tree.isEmpty) pickleTree(tree))
+    def missing = forwardSymRefs.keysIterator
+      .map(sym => i"${sym.showLocated} (line ${sym.srcPos.line}) #${sym.id}")
+      .toList
+    assert(forwardSymRefs.isEmpty, i"unresolved symbols: $missing%, % when pickling ${ctx.source}")
+  }
+
+  def compactify(): Unit = {
+    buf.compactify()
+
+    def updateMapWithDeltas(mp: MutableSymbolMap[Addr]) =
+      for (key <- mp.keysIterator.toBuffer[Symbol]) mp(key) = adjusted(mp(key))
+
+    updateMapWithDeltas(symRefs)
+  }
+}
diff --git a/tests/pos-with-compiler-cc/dotc/core/tasty/TreeUnpickler.scala b/tests/pos-with-compiler-cc/dotc/core/tasty/TreeUnpickler.scala
new file mode 100644
index 000000000000..69bd0d95ba3a
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/core/tasty/TreeUnpickler.scala
@@ -0,0 +1,1634 @@
+package dotty.tools
+package dotc
+package core
+package tasty
+
+import scala.language.unsafeNulls
+
+import Comments.CommentsContext
+import Contexts._
+import Symbols._
+import Types._
+import Scopes._
+import SymDenotations._
+import Denotations._
+import Names._
+import NameOps._
+import StdNames._
+import Flags._
+import Constants._
+import Annotations._
+import NameKinds._
+import NamerOps._
+import ContextOps._
+import Variances.Invariant
+import TastyUnpickler.NameTable
+import typer.ConstFold
+import typer.Checking.checkNonCyclic
+import typer.Nullables._
+import util.Spans._
+import util.{SourceFile, Property}
+import ast.{Trees, tpd, untpd}
+import Trees._
+import Decorators._
+import transform.SymUtils._
+import cc.{adaptFunctionTypeUnderPureFuns, adaptByNameArgUnderPureFuns}
+
+import dotty.tools.tasty.{TastyBuffer, TastyReader}
+import TastyBuffer._
+
+import scala.annotation.{switch, tailrec}
+import scala.collection.mutable.ListBuffer
+import scala.collection.mutable
+import config.Printers.pickling
+
+import dotty.tools.tasty.TastyFormat._
+
+import scala.annotation.constructorOnly
+import scala.annotation.internal.sharable
+import language.experimental.pureFunctions
+
+/** Unpickler for typed trees
+ *  @param reader              the reader from which to unpickle
+ *  @param posUnpicklerOpt     the unpickler for positions, if it exists
+ *  @param commentUnpicklerOpt the unpickler for comments, if it exists
+ */
+class TreeUnpickler(reader: TastyReader,
+                    nameAtRef: NameTable,
+                    posUnpicklerOpt: Option[PositionUnpickler],
+                    commentUnpicklerOpt: Option[CommentUnpickler]) {
+  import TreeUnpickler._
+  import tpd._
+
+  /** A map from addresses of definition entries to the symbols they define */
+  private val symAtAddr  = new mutable.HashMap[Addr, Symbol]
+
+  /** A temporary map from addresses of definition entries to the trees they define.
+   *  Used to remember trees of symbols that are created by a completion. Emptied
+   *  once the tree is inlined into a larger tree.
+   */
+  private val treeAtAddr = new mutable.HashMap[Addr, Tree]
+
+  /** A map from addresses of type entries to the types they define.
+   *  Currently only populated for types that might be recursively referenced
+   *  from within themselves (i.e. RecTypes, LambdaTypes).
+   */
+  private val typeAtAddr = new mutable.HashMap[Addr, Type]
+
+  /** The root symbol denotation which are defined by the Tasty file associated with this
+   *  TreeUnpickler. Set by `enterTopLevel`.
+   */
+  private var roots: Set[SymDenotation] = null
+
+  /** The root symbols that are defined in this Tasty file. This
+   *  is a subset of `roots.map(_.symbol)`.
+   */
+  private var seenRoots: Set[Symbol] = Set()
+
+  /** The root owner tree. See `OwnerTree` class definition. Set by `enterTopLevel`. */
+  private var ownerTree: OwnerTree = _
+
+  /** Was unpickled class compiled with pureFunctions? */
+  private var knowsPureFuns: Boolean = false
+
+  private def registerSym(addr: Addr, sym: Symbol) =
+    symAtAddr(addr) = sym
+
+  /** Enter all toplevel classes and objects into their scopes
+   *  @param roots          a set of SymDenotations that should be overwritten by unpickling
+   */
+  def enter(roots: Set[SymDenotation])(using Context): Unit = {
+    this.roots = roots
+    val rdr = new TreeReader(reader).fork
+    ownerTree = new OwnerTree(NoAddr, 0, rdr.fork, reader.endAddr)
+    if (rdr.isTopLevel)
+      rdr.indexStats(reader.endAddr)
+  }
+
+  /** The unpickled trees */
+  def unpickle(mode: UnpickleMode)(using Context): List[Tree] = {
+    assert(roots != null, "unpickle without previous enterTopLevel")
+    val rdr = new TreeReader(reader)
+    mode match {
+      case UnpickleMode.TopLevel => rdr.readTopLevel()
+      case UnpickleMode.Term => rdr.readTerm() :: Nil
+      case UnpickleMode.TypeTree => rdr.readTpt() :: Nil
+    }
+  }
+
+  class Completer(reader: TastyReader)(using @constructorOnly _ctx: Context) extends LazyType {
+    import reader._
+    val owner = ctx.owner
+    val mode = ctx.mode
+    val source = ctx.source
+    def complete(denot: SymDenotation)(using Context): Unit =
+      def fail(ex: Throwable) =
+        def where =
+          val f = denot.symbol.associatedFile
+          if f == null then "" else s" in $f"
+        if ctx.settings.YdebugUnpickling.value then throw ex
+        else throw TypeError(
+          em"""Could not read definition of $denot$where
+              |An exception was encountered:
+              |  $ex
+              |Run with -Ydebug-unpickling to see full stack trace.""")
+      treeAtAddr(currentAddr) =
+        try
+          atPhaseBeforeTransforms {
+            new TreeReader(reader).readIndexedDef()(
+              using ctx.withOwner(owner).withModeBits(mode).withSource(source))
+          }
+        catch
+          case ex: AssertionError => fail(ex)
+          case ex: Exception => fail(ex)
+  }
+
+  class TreeReader(val reader: TastyReader) {
+    import reader._
+
+    def forkAt(start: Addr): TreeReader = new TreeReader(subReader(start, endAddr))
+    def fork: TreeReader = forkAt(currentAddr)
+
+    def skipTree(tag: Int): Unit = {
+      if (tag >= firstLengthTreeTag) goto(readEnd())
+      else if (tag >= firstNatASTTreeTag) { readNat(); skipTree() }
+      else if (tag >= firstASTTreeTag) skipTree()
+      else if (tag >= firstNatTreeTag) readNat()
+    }
+    def skipTree(): Unit = skipTree(readByte())
+
+    def skipParams(): Unit =
+      while
+        val tag = nextByte
+        tag == PARAM || tag == TYPEPARAM || tag == EMPTYCLAUSE || tag == SPLITCLAUSE
+      do skipTree()
+
+    /** Record all directly nested definitions and templates in current tree
+     *  as `OwnerTree`s in `buf`.
+     *  A complication concerns member definitions. These are lexically nested in a
+     *  Template node, but need to be listed separately in the OwnerTree of the enclosing class
+     *  in order not to confuse owner chains.
+     */
+    def scanTree(buf: ListBuffer[OwnerTree], mode: MemberDefMode = AllDefs): Unit = {
+      val start = currentAddr
+      val tag = readByte()
+      tag match {
+        case VALDEF | DEFDEF | TYPEDEF | TYPEPARAM | PARAM | TEMPLATE =>
+          val end = readEnd()
+          for (i <- 0 until numRefs(tag)) readNat()
+          if (tag == TEMPLATE) {
+            // Read all member definitions now, whereas non-members are children of
+            // template's owner tree.
+            val nonMemberReader = fork
+            scanTrees(buf, end, MemberDefsOnly)
+            buf += new OwnerTree(start, tag, nonMemberReader, end)
+          }
+          else if (mode != NoMemberDefs)
+            buf += new OwnerTree(start, tag, fork, end)
+          goto(end)
+        case tag =>
+          if (mode == MemberDefsOnly) skipTree(tag)
+          else if (tag >= firstLengthTreeTag) {
+            val end = readEnd()
+            var nrefs = numRefs(tag)
+            if (nrefs < 0) {
+              for (i <- nrefs until 0) scanTree(buf)
+              goto(end)
+            }
+            else {
+              for (i <- 0 until nrefs) readNat()
+              if (tag == BIND)
+                // a Bind is never the owner of anything, so we set `end = start`
+                buf += new OwnerTree(start, tag, fork, end = start)
+
+              scanTrees(buf, end)
+            }
+          }
+          else if (tag >= firstNatASTTreeTag) { readNat(); scanTree(buf) }
+          else if (tag >= firstASTTreeTag) scanTree(buf)
+          else if (tag >= firstNatTreeTag) readNat()
+      }
+    }
+
+    /** Record all directly nested definitions and templates between current address and `end`
+     *  as `OwnerTree`s in `buf`
+     */
+    def scanTrees(buf: ListBuffer[OwnerTree], end: Addr, mode: MemberDefMode = AllDefs): Unit = {
+      while (currentAddr.index < end.index) scanTree(buf, mode)
+      assert(currentAddr.index == end.index)
+    }
+
+    /** The next tag, following through SHARED tags */
+    def nextUnsharedTag: Int = {
+      val tag = nextByte
+      if (tag == SHAREDtype || tag == SHAREDterm) {
+        val lookAhead = fork
+        lookAhead.reader.readByte()
+        forkAt(lookAhead.reader.readAddr()).nextUnsharedTag
+      }
+      else tag
+    }
+
+    def readName(): TermName = nameAtRef(readNameRef())
+
+// ------ Reading types -----------------------------------------------------
+
+    /** Read names in an interleaved sequence of types/bounds and (parameter) names,
+     *  possibly followed by a sequence of modifiers.
+     */
+    def readParamNamesAndMods(end: Addr): (List[Name], FlagSet) =
+      val names =
+        collectWhile(currentAddr != end && !isModifierTag(nextByte)) {
+          skipTree()
+          readName()
+        }
+      var mods = EmptyFlags
+      while currentAddr != end do // avoid boxing the mods
+        readByte() match
+          case IMPLICIT => mods |= Implicit
+          case ERASED   => mods |= Erased
+          case GIVEN    => mods |= Given
+      (names, mods)
+
+    /** Read `n` parameter types or bounds which are interleaved with names */
+    def readParamTypes[T <: Type](n: Int)(using Context): List[T] =
+      if n == 0 then Nil
+      else
+        val t = readType().asInstanceOf[T]
+        readNat() // skip name
+        t :: readParamTypes(n - 1)
+
+    /** Read reference to definition and return symbol created at that definition */
+    def readSymRef()(using Context): Symbol = symbolAt(readAddr())
+
+    /** The symbol at given address; createa new one if none exists yet */
+    def symbolAt(addr: Addr)(using Context): Symbol = symAtAddr.get(addr) match {
+      case Some(sym) =>
+        sym
+      case None =>
+        val sym = forkAt(addr).createSymbol()(using ctx.withOwner(ownerTree.findOwner(addr)))
+        report.log(i"forward reference to $sym")
+        sym
+    }
+
+    /** The symbol defined by current definition */
+    def symbolAtCurrent()(using Context): Symbol = symAtAddr.get(currentAddr) match {
+      case Some(sym) =>
+        assert(ctx.owner == sym.owner, i"owner discrepancy for $sym, expected: ${ctx.owner}, found: ${sym.owner}")
+        sym
+      case None =>
+        createSymbol()
+    }
+
+    def readConstant(tag: Int)(using Context): Constant = (tag: @switch) match {
+      case UNITconst =>
+        Constant(())
+      case TRUEconst =>
+        Constant(true)
+      case FALSEconst =>
+        Constant(false)
+      case BYTEconst =>
+        Constant(readInt().toByte)
+      case SHORTconst =>
+        Constant(readInt().toShort)
+      case CHARconst =>
+        Constant(readNat().toChar)
+      case INTconst =>
+        Constant(readInt())
+      case LONGconst =>
+        Constant(readLongInt())
+      case FLOATconst =>
+        Constant(java.lang.Float.intBitsToFloat(readInt()))
+      case DOUBLEconst =>
+        Constant(java.lang.Double.longBitsToDouble(readLongInt()))
+      case STRINGconst =>
+        Constant(readName().toString)
+      case NULLconst =>
+        Constant(null)
+      case CLASSconst =>
+        Constant(readType())
+    }
+
+    /** Read a type */
+    def readType()(using Context): Type = {
+      val start = currentAddr
+      val tag = readByte()
+      pickling.println(s"reading type ${astTagToString(tag)} at $start, ${ctx.source}")
+
+      def registeringType[T](tp: Type, op: => T): T = {
+        typeAtAddr(start) = tp
+        op
+      }
+
+      def readLengthType(): Type = {
+        val end = readEnd()
+
+        def readMethodic[N <: Name, PInfo <: Type, LT <: LambdaType]
+            (companionOp: FlagSet => LambdaTypeCompanion[N, PInfo, LT], nameMap: Name => N): LT = {
+          val result = typeAtAddr.getOrElse(start, {
+              val nameReader = fork
+              nameReader.skipTree() // skip result
+              val paramReader = nameReader.fork
+              val (paramNames, mods) = nameReader.readParamNamesAndMods(end)
+              companionOp(mods)(paramNames.map(nameMap))(
+                pt => registeringType(pt, paramReader.readParamTypes[PInfo](paramNames.length)),
+                pt => readType())
+            })
+          goto(end)
+          result.asInstanceOf[LT]
+        }
+
+        def readVariances(tp: Type): Type = tp match
+          case tp: HKTypeLambda if currentAddr != end =>
+            val vs = until(end) {
+              readByte() match
+                case STABLE => Invariant
+                case COVARIANT => Covariant
+                case CONTRAVARIANT => Contravariant
+            }
+            tp.withVariances(vs)
+          case _ => tp
+
+        val result =
+          (tag: @switch) match {
+            case TERMREFin =>
+              var sname = readName()
+              val prefix = readType()
+              val owner = readType()
+              sname match {
+                case SignedName(name, sig, target) =>
+                  TermRef(prefix, name, owner.decl(name).atSignature(sig, target).asSeenFrom(prefix))
+                case name =>
+                  TermRef(prefix, name, owner.decl(name).asSeenFrom(prefix))
+              }
+            case TYPEREFin =>
+              val name = readName().toTypeName
+              val prefix = readType()
+              val space = readType()
+              space.decl(name) match {
+                case symd: SymDenotation if prefix.isArgPrefixOf(symd.symbol) => TypeRef(prefix, symd.symbol)
+                case _ => TypeRef(prefix, name, space.decl(name).asSeenFrom(prefix))
+              }
+            case REFINEDtype =>
+              var name: Name = readName()
+              val parent = readType()
+              if nextUnsharedTag == TYPEBOUNDS then name = name.toTypeName
+              RefinedType(parent, name, readType())
+                // Note that the lambda "rt => ..." is not equivalent to a wildcard closure!
+                // Eta expansion of the latter puts readType() out of the expression.
+            case APPLIEDtype =>
+              postProcessFunction(readType().appliedTo(until(end)(readType())))
+            case TYPEBOUNDS =>
+              val lo = readType()
+              if nothingButMods(end) then
+                if lo.isMatch then MatchAlias(readVariances(lo))
+                else TypeAlias(readVariances(lo))
+              else
+                val hi = readVariances(readType())
+                createNullableTypeBounds(lo, hi)
+            case ANNOTATEDtype =>
+              AnnotatedType(readType(), Annotation(readTerm()))
+            case ANDtype =>
+              AndType(readType(), readType())
+            case ORtype =>
+              OrType(readType(), readType(), soft = false)
+            case SUPERtype =>
+              SuperType(readType(), readType())
+            case MATCHtype =>
+              MatchType(readType(), readType(), until(end)(readType()))
+            case MATCHCASEtype =>
+              defn.MatchCaseClass.typeRef.appliedTo(readType(), readType())
+            case POLYtype =>
+              readMethodic(_ => PolyType, _.toTypeName)
+            case METHODtype =>
+              def methodTypeCompanion(mods: FlagSet): MethodTypeCompanion =
+                if mods.is(Implicit) then ImplicitMethodType
+                else if mods.isAllOf(Erased | Given) then ErasedContextualMethodType
+                else if mods.is(Given) then ContextualMethodType
+                else if mods.is(Erased) then ErasedMethodType
+                else MethodType
+              readMethodic(methodTypeCompanion, _.toTermName)
+            case TYPELAMBDAtype =>
+              readMethodic(_ => HKTypeLambda, _.toTypeName)
+            case PARAMtype =>
+              readTypeRef() match {
+                case binder: LambdaType => binder.paramRefs(readNat())
+              }
+          }
+        assert(currentAddr == end, s"$start $currentAddr $end ${astTagToString(tag)}")
+        result
+      }
+
+      def readSimpleType(): Type = (tag: @switch) match {
+        case TYPEREFdirect | TERMREFdirect =>
+          NamedType(NoPrefix, readSymRef())
+        case TYPEREFsymbol | TERMREFsymbol =>
+          readSymNameRef()
+        case TYPEREFpkg =>
+          readPackageRef().moduleClass.typeRef
+        case TERMREFpkg =>
+          readPackageRef().termRef
+        case TYPEREF =>
+          val name = readName().toTypeName
+          TypeRef(readType(), name)
+        case TERMREF =>
+          val sname = readName()
+          val prefix = readType()
+          sname match {
+            case SignedName(name, sig, target) =>
+              TermRef(prefix, name, prefix.member(name).atSignature(sig, target))
+            case name =>
+              TermRef(prefix, name)
+          }
+        case THIS =>
+          ThisType.raw(readType().asInstanceOf[TypeRef])
+        case RECtype =>
+          typeAtAddr.get(start) match {
+            case Some(tp) =>
+              skipTree(tag)
+              tp
+            case None =>
+              RecType(rt => registeringType(rt, readType()))
+          }
+        case RECthis =>
+          readTypeRef().asInstanceOf[RecType].recThis
+        case SHAREDtype =>
+          val ref = readAddr()
+          typeAtAddr.getOrElseUpdate(ref, forkAt(ref).readType())
+        case BYNAMEtype =>
+          val arg = readType()
+          ExprType(if knowsPureFuns then arg else arg.adaptByNameArgUnderPureFuns)
+        case _ =>
+          ConstantType(readConstant(tag))
+      }
+
+      if (tag < firstLengthTreeTag) readSimpleType() else readLengthType()
+    }
+
+    private def readSymNameRef()(using Context): Type = {
+      val sym = readSymRef()
+      val prefix = readType()
+      val res = NamedType(prefix, sym)
+      prefix match {
+        case prefix: ThisType if (prefix.cls eq sym.owner) && !sym.is(Opaque) =>
+          res.withDenot(sym.denot)
+          // without this precaution we get an infinite cycle when unpickling pos/extmethods.scala
+          // the problem arises when a self type of a trait is a type parameter of the same trait.
+        case _ => res
+      }
+    }
+
+    private def readPackageRef()(using Context): TermSymbol = {
+      val name = readName()
+      if (name == nme.ROOT || name == nme.ROOTPKG) defn.RootPackage
+      else if (name == nme.EMPTY_PACKAGE) defn.EmptyPackageVal
+      else requiredPackage(name)
+    }
+
+    def readTypeRef(): Type =
+      typeAtAddr(readAddr())
+
+    def readTermRef()(using Context): TermRef =
+      readType().asInstanceOf[TermRef]
+
+    /** Under pureFunctions, map all function types to impure function types,
+     *  unless the unpickled class was also compiled with pureFunctions.
+     */
+    private def postProcessFunction(tp: Type)(using Context): Type =
+      if knowsPureFuns then tp else tp.adaptFunctionTypeUnderPureFuns
+
+// ------ Reading definitions -----------------------------------------------------
+
+    private def nothingButMods(end: Addr): Boolean =
+      currentAddr == end || isModifierTag(nextByte)
+
+    private def localContext(owner: Symbol)(using Context) =
+      ctx.fresh.setOwner(owner)
+
+    private def normalizeFlags(tag: Int, givenFlags: FlagSet, name: Name, isAbsType: Boolean, rhsIsEmpty: Boolean)(using Context): FlagSet = {
+      val lacksDefinition =
+        rhsIsEmpty &&
+          name.isTermName && !name.isConstructorName && !givenFlags.isOneOf(TermParamOrAccessor) ||
+        isAbsType
+      var flags = givenFlags
+      if (lacksDefinition && tag != PARAM) flags |= Deferred
+      if (tag == DEFDEF) flags |= Method
+      if (givenFlags.is(Module))
+        flags |= (if (tag == VALDEF) ModuleValCreationFlags else ModuleClassCreationFlags)
+      if flags.is(Enum, butNot = Method) && name.isTermName then
+        flags |= StableRealizable
+      if (ctx.owner.isClass) {
+        if (tag == TYPEPARAM) flags |= Param
+        else if (tag == PARAM) {
+          flags |= ParamAccessor
+          if (!rhsIsEmpty) // param alias
+            flags |= Method
+        }
+      }
+      else if (isParamTag(tag)) flags |= Param
+      flags
+    }
+
+    def isAbstractType(name: Name)(using Context): Boolean = nextByte match
+      case SHAREDtype =>
+        val lookAhead = fork
+        lookAhead.reader.readByte()
+        val sharedReader = forkAt(lookAhead.reader.readAddr())
+        sharedReader.isAbstractType(name)
+      case LAMBDAtpt =>
+        val rdr = fork
+        rdr.reader.readByte()  // tag
+        rdr.reader.readNat()   // length
+        rdr.skipParams()       // tparams
+        rdr.isAbstractType(name)
+      case TYPEBOUNDS =>
+        val rdr = fork
+        rdr.reader.readByte()  // tag
+        val end = rdr.reader.readEnd()
+        rdr.skipTree()         // alias, or lower bound
+        val res = !rdr.nothingButMods(end)
+        //if !res then println(i"NOT ABSTRACT $name, ${rdr.reader.nextByte}")
+        res
+      case TYPEBOUNDStpt => true
+      case _ => false
+
+    /** Create symbol of definition node and enter in symAtAddr map
+     *  @return  the created symbol
+     */
+    def createSymbol()(using Context): Symbol = nextByte match {
+      case VALDEF | DEFDEF | TYPEDEF | TYPEPARAM | PARAM =>
+        createMemberSymbol()
+      case BIND =>
+        createBindSymbol()
+      case TEMPLATE =>
+        val localDummy = newLocalDummy(ctx.owner)
+        registerSym(currentAddr, localDummy)
+        localDummy
+      case tag =>
+        throw new Error(s"illegal createSymbol at $currentAddr, tag = $tag")
+    }
+
+    private def createBindSymbol()(using Context): Symbol = {
+      val start = currentAddr
+      val tag = readByte()
+      val end = readEnd()
+      var name: Name = readName()
+      if nextUnsharedTag == TYPEBOUNDS then name = name.toTypeName
+      val typeReader = fork
+      val completer = new LazyType {
+        def complete(denot: SymDenotation)(using Context) =
+          denot.info = typeReader.readType()
+      }
+      val sym = newSymbol(ctx.owner, name, Flags.Case, completer, coord = coordAt(start))
+      registerSym(start, sym)
+      sym
+    }
+
+    /** Create symbol of member definition or parameter node and enter in symAtAddr map
+     *  @return  the created symbol
+     */
+    def createMemberSymbol()(using Context): Symbol = {
+      val start = currentAddr
+      val tag = readByte()
+      val end = readEnd()
+      var name: Name = readName()
+      if (tag == TYPEDEF || tag == TYPEPARAM) name = name.toTypeName
+      skipParams()
+      val ttag = nextUnsharedTag
+      val isAbsType = isAbstractType(name)
+      val isClass = ttag == TEMPLATE
+      val templateStart = currentAddr
+      skipTree() // tpt
+      val rhsStart = currentAddr
+      val rhsIsEmpty = nothingButMods(end)
+      if (!rhsIsEmpty) skipTree()
+      val (givenFlags, annotFns, privateWithin) = readModifiers(end)
+      pickling.println(i"creating symbol $name at $start with flags ${givenFlags.flagsString}, isAbsType = $isAbsType, $ttag")
+      val flags = normalizeFlags(tag, givenFlags, name, isAbsType, rhsIsEmpty)
+      def adjustIfModule(completer: LazyType) =
+        if (flags.is(Module)) adjustModuleCompleter(completer, name) else completer
+      val coord = coordAt(start)
+      val sym =
+        roots.find(root => (root.owner eq ctx.owner) && root.name == name) match {
+          case Some(rootd) =>
+            pickling.println(i"overwriting ${rootd.symbol} # ${rootd.hashCode}")
+            rootd.symbol.coord = coord
+            rootd.info = adjustIfModule(
+                new Completer(subReader(start, end)) with SymbolLoaders.SecondCompleter)
+            rootd.flags = flags &~ Touched // allow one more completion
+            rootd.setPrivateWithin(privateWithin)
+            seenRoots += rootd.symbol
+            rootd.symbol
+          case _ =>
+            val completer = adjustIfModule(new Completer(subReader(start, end)))
+            if (isClass)
+              newClassSymbol(ctx.owner, name.asTypeName, flags, completer, privateWithin, coord)
+            else
+              newSymbol(ctx.owner, name, flags, completer, privateWithin, coord)
+        }
+      val annots = annotFns.map(_(sym.owner))
+      sym.annotations = annots
+      if sym.isOpaqueAlias then sym.setFlag(Deferred)
+      val isScala2MacroDefinedInScala3 = flags.is(Macro, butNot = Inline) && flags.is(Erased)
+      ctx.owner match {
+        case cls: ClassSymbol if !isScala2MacroDefinedInScala3 || cls == defn.StringContextClass =>
+          // Enter all members of classes that are not Scala 2 macros.
+          //
+          // For `StringContext`, enter `s`, `f` and `raw`
+          // These definitions will be entered when defined in Scala 2. It is fine to enter them
+          // as they are intrinsic macros and are specially handled by the compiler.
+          // Dual macro definitions will not work on `StringContext` as we would enter the symbol twice.
+          // But dual macros will never be needed for those definitions due to their intinsic nature.
+          cls.enter(sym)
+        case _ =>
+      }
+      registerSym(start, sym)
+      if (isClass) {
+        if sym.owner.is(Package) && annots.exists(_.hasSymbol(defn.WithPureFunsAnnot)) then
+          knowsPureFuns = true
+        sym.completer.withDecls(newScope)
+        forkAt(templateStart).indexTemplateParams()(using localContext(sym))
+      }
+      else if (sym.isInlineMethod && !sym.is(Deferred))
+        sym.addAnnotation(LazyBodyAnnotation { (ctx0: Context) ?=>
+          val ctx1 = localContext(sym)(using ctx0).addMode(Mode.ReadPositions)
+          inContext(sourceChangeContext(Addr(0))(using ctx1)) {
+            // avoids space leaks by not capturing the current context
+            forkAt(rhsStart).readTerm()
+          }
+        })
+      goto(start)
+      sym
+    }
+
+    /** Read modifier list into triplet of flags, annotations and a privateWithin
+     *  boundary symbol.
+     */
+    def readModifiers(end: Addr)(using Context): (FlagSet, List[Symbol -> Annotation], Symbol) = {
+      var flags: FlagSet = EmptyFlags
+      var annotFns: List[Symbol -> Annotation] = Nil
+      var privateWithin: Symbol = NoSymbol
+      while (currentAddr.index != end.index) {
+        def addFlag(flag: FlagSet) = {
+          flags |= flag
+          readByte()
+        }
+        nextByte match {
+          case PRIVATE => addFlag(Private)
+          case PROTECTED => addFlag(Protected)
+          case ABSTRACT =>
+            readByte()
+            nextByte match {
+              case OVERRIDE => addFlag(AbsOverride)
+              case _ => flags |= Abstract
+            }
+          case FINAL => addFlag(Final)
+          case SEALED => addFlag(Sealed)
+          case CASE => addFlag(Case)
+          case IMPLICIT => addFlag(Implicit)
+          case ERASED => addFlag(Erased)
+          case LAZY => addFlag(Lazy)
+          case OVERRIDE => addFlag(Override)
+          case INLINE => addFlag(Inline)
+          case INLINEPROXY => addFlag(InlineProxy)
+          case MACRO => addFlag(Macro)
+          case OPAQUE => addFlag(Opaque)
+          case STATIC => addFlag(JavaStatic)
+          case OBJECT => addFlag(Module)
+          case TRAIT => addFlag(Trait)
+          case ENUM => addFlag(Enum)
+          case LOCAL => addFlag(Local)
+          case SYNTHETIC => addFlag(Synthetic)
+          case ARTIFACT => addFlag(Artifact)
+          case MUTABLE => addFlag(Mutable)
+          case FIELDaccessor => addFlag(Accessor)
+          case CASEaccessor => addFlag(CaseAccessor)
+          case COVARIANT => addFlag(Covariant)
+          case CONTRAVARIANT => addFlag(Contravariant)
+          case HASDEFAULT => addFlag(HasDefault)
+          case STABLE => addFlag(StableRealizable)
+          case EXTENSION => addFlag(Extension)
+          case GIVEN => addFlag(Given)
+          case PARAMsetter => addFlag(ParamAccessor)
+          case PARAMalias => addFlag(SuperParamAlias)
+          case EXPORTED => addFlag(Exported)
+          case OPEN => addFlag(Open)
+          case INVISIBLE => addFlag(Invisible)
+          case TRANSPARENT => addFlag(Transparent)
+          case INFIX => addFlag(Infix)
+          case PRIVATEqualified =>
+            readByte()
+            privateWithin = readWithin
+          case PROTECTEDqualified =>
+            addFlag(Protected)
+            privateWithin = readWithin
+          case ANNOTATION =>
+            annotFns = readAnnot :: annotFns
+          case tag =>
+            assert(false, s"illegal modifier tag $tag at $currentAddr, end = $end")
+        }
+      }
+      (flags, annotFns.reverse, privateWithin)
+    }
+
+    private def readWithin(using Context): Symbol = readType().typeSymbol
+
+    private def readAnnot(using Context): Symbol -> Annotation =
+      readByte()
+      val end = readEnd()
+      val tp = readType()
+      val lazyAnnotTree = readLaterWithOwner(end, _.readTerm())
+      owner =>
+        new DeferredSymAndTree(tp.typeSymbol, lazyAnnotTree(owner).complete):
+          // Only force computation of symbol if it has the right name. This added
+          // amount of laziness is sometimes necessary to avid cycles. Test case pos/i15980.
+          override def hasSymbol(sym: Symbol)(using Context) = tp match
+            case tp: TypeRef =>
+              tp.designator match
+                case name: Name => name == sym.name && tp.symbol == sym
+                case _ => tp.symbol == sym
+            case _ => this.symbol == sym
+
+    /** Create symbols for the definitions in the statement sequence between
+     *  current address and `end`.
+     *  @return  the largest subset of {NoInits, PureInterface} that a
+     *           trait owning the indexed statements can have as flags.
+     */
+    def indexStats(end: Addr)(using Context): FlagSet = {
+      var initsFlags = NoInitsInterface
+      while (currentAddr.index < end.index)
+        nextByte match {
+          case VALDEF | DEFDEF | TYPEDEF | TYPEPARAM | PARAM =>
+            val sym = symbolAtCurrent()
+            skipTree()
+            if (sym.isTerm && !sym.isOneOf(DeferredOrLazyOrMethod))
+              initsFlags = EmptyFlags
+            else if (sym.isClass ||
+              sym.is(Method, butNot = Deferred) && !sym.isConstructor)
+              initsFlags &= NoInits
+          case IMPORT | EXPORT =>
+            skipTree()
+          case PACKAGE =>
+            processPackage { (pid, end) => indexStats(end) }
+          case _ =>
+            skipTree()
+            initsFlags = EmptyFlags
+        }
+      assert(currentAddr.index == end.index)
+      initsFlags
+    }
+
+    /** Process package with given operation `op`. The operation takes as arguments
+     *   - a `RefTree` representing the `pid` of the package,
+     *   - an end address,
+     *   - a context which has the processed package as owner
+     */
+    def processPackage[T](op: (RefTree, Addr) => Context ?=> T)(using Context): T = {
+      val sctx = sourceChangeContext()
+      if (sctx `ne` ctx) return processPackage(op)(using sctx)
+      readByte()
+      val end = readEnd()
+      val pid = ref(readTermRef()).asInstanceOf[RefTree]
+      op(pid, end)(using localContext(pid.symbol.moduleClass))
+    }
+
+    /** Create symbols the longest consecutive sequence of parameters with given
+     *  `tag` starting at current address.
+     */
+    def indexParams(tag: Int)(using Context): Unit =
+      while (nextByte == tag) {
+        symbolAtCurrent()
+        skipTree()
+      }
+
+    /** Create symbols for all type and value parameters of template starting
+     *  at current address.
+     */
+    def indexTemplateParams()(using Context): Unit = {
+      assert(readByte() == TEMPLATE)
+      readEnd()
+      indexParams(TYPEPARAM)
+      indexParams(PARAM)
+    }
+
+    /** If definition was already read by a completer, return the previously read tree
+     *  or else read definition.
+     */
+    def readIndexedDef()(using Context): Tree = treeAtAddr.remove(currentAddr) match {
+      case Some(tree) =>
+        assert(tree != PoisonTree, s"Cyclic reference while unpickling definition at address ${currentAddr.index} in unit ${ctx.compilationUnit}")
+        skipTree()
+        tree
+      case none =>
+        val start = currentAddr
+        treeAtAddr(start) = PoisonTree
+        val tree = readNewDef()
+        treeAtAddr.remove(start)
+        tree
+    }
+
+    private def readNewDef()(using Context): Tree = {
+      val sctx = sourceChangeContext()
+      if (sctx `ne` ctx) return readNewDef()(using sctx)
+      val start = currentAddr
+      val sym = symAtAddr(start)
+      val tag = readByte()
+      val end = readEnd()
+
+      def readParamss()(using Context): List[ParamClause] =
+        def readRest() =
+          if nextByte == SPLITCLAUSE then readByte()
+          readParamss()
+        nextByte match
+          case PARAM => readParams[ValDef](PARAM) :: readRest()
+          case TYPEPARAM => readParams[TypeDef](TYPEPARAM) :: readRest()
+          case EMPTYCLAUSE => readByte(); Nil :: readRest()
+          case _ => Nil
+
+      val localCtx = localContext(sym)
+
+      def readRhs(using Context): LazyTree =
+        if (nothingButMods(end))
+          EmptyTree
+        else if sym.isInlineMethod && !sym.is(Deferred) then
+          // The body of an inline method is stored in an annotation, so no need to unpickle it again
+          new Trees.Lazy[Tree] {
+            def complete(using Context) = inlines.Inlines.bodyToInline(sym)
+          }
+        else
+          readLater(end, _.readTerm())
+
+      def ValDef(tpt: Tree) =
+        ta.assignType(untpd.ValDef(sym.name.asTermName, tpt, readRhs(using localCtx)), sym)
+
+      def DefDef(paramss: List[ParamClause], tpt: Tree) =
+        sym.setParamssFromDefs(paramss)
+        ta.assignType(
+          untpd.DefDef(sym.name.asTermName, paramss, tpt, readRhs(using localCtx)),
+          sym)
+
+      def TypeDef(rhs: Tree) =
+        ta.assignType(untpd.TypeDef(sym.name.asTypeName, rhs), sym)
+
+      def ta = ctx.typeAssigner
+
+      val name = readName()
+      pickling.println(s"reading def of $name at $start")
+      val tree: MemberDef = tag match {
+        case DEFDEF =>
+          val paramDefss = readParamss()(using localCtx)
+          val tpt = readTpt()(using localCtx)
+          val paramss = normalizeIfConstructor(
+              paramDefss.nestedMap(_.symbol), name == nme.CONSTRUCTOR)
+          val resType =
+            if name == nme.CONSTRUCTOR then
+              effectiveResultType(sym, paramss)
+            else
+              tpt.tpe
+          sym.info = methodType(paramss, resType)
+          DefDef(paramDefss, tpt)
+        case VALDEF =>
+          val tpt = readTpt()(using localCtx)
+          sym.info = tpt.tpe
+          ValDef(tpt)
+        case TYPEDEF | TYPEPARAM =>
+          if (sym.isClass) {
+            sym.owner.ensureCompleted() // scalacLinkedClass uses unforcedDecls. Make sure it does not miss anything.
+            val companion = sym.scalacLinkedClass
+
+            // Is the companion defined in the same Tasty file as `sym`?
+            // The only case to check here is if `sym` is a root. In this case
+            // `companion` might have been entered by the environment but it might
+            // be missing from the Tasty file. So we check explicitly for that.
+            def isCodefined = roots.contains(companion.denot) == seenRoots.contains(companion)
+
+            if (companion.exists && isCodefined) sym.registerCompanion(companion)
+            TypeDef(readTemplate(using localCtx))
+          }
+          else {
+            sym.info = TypeBounds.empty // needed to avoid cyclic references when unpickling rhs, see i3816.scala
+            sym.setFlag(Provisional)
+            val rhs = readTpt()(using localCtx)
+
+            sym.info = new NoCompleter:
+              override def completerTypeParams(sym: Symbol)(using Context) =
+                rhs.tpe.typeParams
+
+            def opaqueToBounds(info: Type): Type =
+              val tparamSyms = rhs match
+                case LambdaTypeTree(tparams, body) => tparams.map(_.symbol.asType)
+                case _ => Nil
+              sym.opaqueToBounds(info, rhs, tparamSyms)
+
+            val info = checkNonCyclic(sym, rhs.tpe.toBounds, reportErrors = false)
+            if sym.isOpaqueAlias then
+              sym.info = opaqueToBounds(info)
+              sym.typeRef.recomputeDenot() // make sure we see the new bounds from now on
+            else
+              sym.info = info
+
+            sym.resetFlag(Provisional)
+            TypeDef(rhs)
+          }
+        case PARAM =>
+          val tpt = readTpt()(using localCtx)
+          assert(nothingButMods(end))
+          sym.info = tpt.tpe
+          ValDef(tpt)
+      }
+      goto(end)
+      setSpan(start, tree)
+
+      // Dealias any non-accessible type alias in the type of `sym`. This can be
+      // skipped for types (see `checkNoPrivateLeaks` for why) as well as for
+      // param accessors since they can't refer to an inaccesible type member of
+      // the class.
+      if !sym.isType && !sym.is(ParamAccessor) then
+        sym.info = ta.avoidPrivateLeaks(sym)
+
+      if (ctx.settings.YreadComments.value) {
+        assert(ctx.docCtx.isDefined, "`-Yread-docs` enabled, but no `docCtx` is set.")
+        commentUnpicklerOpt.foreach { commentUnpickler =>
+          val comment = commentUnpickler.commentAt(start)
+          ctx.docCtx.get.addDocstring(tree.symbol, comment)
+          tree.setComment(comment)
+        }
+      }
+
+      tree.setDefTree
+    }
+
+    private def readTemplate(using Context): Template = {
+      val start = currentAddr
+      assert(sourcePathAt(start).isEmpty)
+      val cls = ctx.owner.asClass
+      val assumedSelfType =
+        if (cls.is(Module) && cls.owner.isClass) TermRef(cls.owner.thisType, cls.name.sourceModuleName)
+        else NoType
+      cls.info = new TempClassInfo(cls.owner.thisType, cls, cls.unforcedDecls, assumedSelfType)
+      val localDummy = symbolAtCurrent()
+      val parentCtx = ctx.withOwner(localDummy)
+      assert(readByte() == TEMPLATE)
+      val end = readEnd()
+      val tparams = readIndexedParams[TypeDef](TYPEPARAM)
+      val vparams = readIndexedParams[ValDef](PARAM)
+      // It's important to index the class definitions before unpickling the parents
+      // (see the parents-cycle test for examples where this matter)
+      val bodyFlags = {
+        val bodyIndexer = fork
+        // The first DEFDEF corresponds to the primary constructor
+        while (bodyIndexer.reader.nextByte != DEFDEF) bodyIndexer.skipTree()
+        bodyIndexer.indexStats(end)
+      }
+      val parents = collectWhile(nextByte != SELFDEF && nextByte != DEFDEF) {
+        nextUnsharedTag match {
+          case APPLY | TYPEAPPLY | BLOCK => readTerm()(using parentCtx)
+          case _ => readTpt()(using parentCtx)
+        }
+      }
+      val parentTypes = parents.map(_.tpe.dealias)
+      val self =
+        if (nextByte == SELFDEF) {
+          readByte()
+          untpd.ValDef(readName(), readTpt(), EmptyTree).withType(NoType)
+        }
+        else EmptyValDef
+      cls.setNoInitsFlags(parentsKind(parents), bodyFlags)
+      cls.info = ClassInfo(
+        cls.owner.thisType, cls, parentTypes, cls.unforcedDecls,
+        selfInfo = if (self.isEmpty) NoType else self.tpt.tpe)
+        .integrateOpaqueMembers
+      val constr = readIndexedDef().asInstanceOf[DefDef]
+      val mappedParents = parents.map(_.changeOwner(localDummy, constr.symbol))
+
+      val lazyStats = readLater(end, rdr => {
+        val stats = rdr.readIndexedStats(localDummy, end)
+        tparams ++ vparams ++ stats
+      })
+      defn.patchStdLibClass(cls)
+      NamerOps.addConstructorProxies(cls)
+      setSpan(start,
+        untpd.Template(constr, mappedParents, Nil, self, lazyStats)
+          .withType(localDummy.termRef))
+    }
+
+    def skipToplevel()(using Context): Unit= {
+      if (!isAtEnd && isTopLevel) {
+        skipTree()
+        skipToplevel()
+      }
+    }
+
+    def isTopLevel(using Context): Boolean =
+      nextByte == IMPORT || nextByte == PACKAGE
+
+    def readTopLevel()(using Context): List[Tree] = {
+      @tailrec def read(acc: ListBuffer[Tree]): List[Tree] =
+        if (isTopLevel) {
+          acc += readIndexedStat(NoSymbol)
+          if (!isAtEnd) read(acc) else acc.toList
+        }
+        else // top-level trees which are not imports or packages are not part of tree
+          acc.toList
+      read(new ListBuffer[tpd.Tree])
+    }
+
+    def readIndexedStat(exprOwner: Symbol)(using Context): Tree = nextByte match {
+      case TYPEDEF | VALDEF | DEFDEF =>
+        readIndexedDef()
+      case IMPORT =>
+        readImportOrExport(Import(_, _))()
+      case EXPORT =>
+        readImportOrExport(Export(_, _))()
+      case PACKAGE =>
+        val start = currentAddr
+        processPackage { (pid, end) =>
+          setSpan(start, PackageDef(pid, readIndexedStats(exprOwner, end)))
+        }
+      case _ =>
+        readTerm()(using ctx.withOwner(exprOwner))
+    }
+
+    inline def readImportOrExport(inline mkTree:
+        (Tree, List[untpd.ImportSelector]) => Tree)()(using Context): Tree = {
+      val start = currentAddr
+      assert(sourcePathAt(start).isEmpty)
+      readByte()
+      readEnd()
+      val expr = readTerm()
+      setSpan(start, mkTree(expr, readSelectors()))
+    }
+
+    def readSelectors()(using Context): List[untpd.ImportSelector] =
+      if nextByte == IMPORTED then
+        val start = currentAddr
+        assert(sourcePathAt(start).isEmpty)
+        readByte()
+        val name = readName()
+        val from = setSpan(start, untpd.Ident(name))
+        val selector = nextByte match
+          case RENAMED =>
+            val start2 = currentAddr
+            readByte()
+            val to = setSpan(start2, untpd.Ident(readName()))
+            untpd.ImportSelector(from, to, EmptyTree)
+          case BOUNDED =>
+            val start2 = currentAddr
+            readByte()
+            val bound = setSpan(start2, untpd.TypedSplice(readTpt()))
+            untpd.ImportSelector(from, EmptyTree, bound)
+          case _ =>
+            untpd.ImportSelector(from)
+        selector :: readSelectors()
+      else
+        Nil
+
+    def readIndexedStats[T](exprOwner: Symbol, end: Addr, k: (List[Tree], Context) => T = sameTrees)(using Context): T =
+      val buf = new mutable.ListBuffer[Tree]
+      var curCtx = ctx
+      while currentAddr.index < end.index do
+        val stat = readIndexedStat(exprOwner)(using curCtx)
+        buf += stat
+        stat match
+          case stat: Import => curCtx = curCtx.importContext(stat, stat.symbol)
+          case _ =>
+      assert(currentAddr.index == end.index)
+      k(buf.toList, curCtx)
+
+    def readStats[T](exprOwner: Symbol, end: Addr, k: (List[Tree], Context) => T = sameTrees)(using Context): T = {
+      fork.indexStats(end)
+      readIndexedStats(exprOwner, end, k)
+    }
+
+    private def sameTrees(xs: List[Tree], ctx: Context) = xs
+
+    def readIndexedParams[T <: MemberDef](tag: Int)(using Context): List[T] =
+      collectWhile(nextByte == tag) { readIndexedDef().asInstanceOf[T] }
+
+    def readParams[T <: MemberDef](tag: Int)(using Context): List[T] =
+      if nextByte == tag then
+        fork.indexParams(tag)
+        readIndexedParams(tag)
+      else Nil
+
+// ------ Reading trees -----------------------------------------------------
+
+    def readTerm()(using Context): Tree = {  // TODO: rename to readTree
+      val sctx = sourceChangeContext()
+      if (sctx `ne` ctx) return readTerm()(using sctx)
+      val start = currentAddr
+      val tag = readByte()
+      pickling.println(s"reading term ${astTagToString(tag)} at $start, ${ctx.source}")
+
+      def readPathTerm(): Tree = {
+        goto(start)
+        readType() match {
+          case path: TypeRef => TypeTree(path)
+          case path: TermRef => ref(path)
+          case path: ThisType => untpd.This(untpd.EmptyTypeIdent).withType(path)
+          case path: ConstantType => Literal(path.value)
+        }
+      }
+
+      def makeSelect(qual: Tree, name: Name, denot: Denotation): Select =
+        var qualType = qual.tpe.widenIfUnstable
+        val owner = denot.symbol.maybeOwner
+        val tpe0 = name match
+          case name: TypeName => TypeRef(qualType, name, denot)
+          case name: TermName => TermRef(qualType, name, denot)
+        val tpe = TypeOps.makePackageObjPrefixExplicit(tpe0)
+        ConstFold.Select(untpd.Select(qual, name).withType(tpe))
+
+      def completeSelect(name: Name, sig: Signature, target: Name): Select =
+        val qual = readTerm()
+        val denot = accessibleDenot(qual.tpe.widenIfUnstable, name, sig, target)
+        makeSelect(qual, name, denot)
+
+      def readQualId(): (untpd.Ident, TypeRef) =
+        val qual = readTerm().asInstanceOf[untpd.Ident]
+        (untpd.Ident(qual.name).withSpan(qual.span), qual.tpe.asInstanceOf[TypeRef])
+
+      def accessibleDenot(qualType: Type, name: Name, sig: Signature, target: Name) = {
+        val pre = ctx.typeAssigner.maybeSkolemizePrefix(qualType, name)
+        val d = qualType.findMember(name, pre).atSignature(sig, target)
+        if (!d.symbol.exists || d.symbol.isAccessibleFrom(pre)) d
+        else qualType.findMember(name, pre, excluded = Private).atSignature(sig, target)
+      }
+
+      def readSimpleTerm(): Tree = tag match {
+        case SHAREDterm =>
+          forkAt(readAddr()).readTerm()
+        case IDENT =>
+          untpd.Ident(readName()).withType(readType())
+        case IDENTtpt =>
+          untpd.Ident(readName().toTypeName).withType(readType())
+        case SELECT =>
+          readName() match {
+            case SignedName(name, sig, target) => completeSelect(name, sig, target)
+            case name => completeSelect(name, Signature.NotAMethod, EmptyTermName)
+          }
+        case SELECTtpt =>
+          val name = readName().toTypeName
+          completeSelect(name, Signature.NotAMethod, EmptyTermName)
+        case QUALTHIS =>
+          val (qual, tref) = readQualId()
+          untpd.This(qual).withType(ThisType.raw(tref))
+        case NEW =>
+          New(readTpt())
+        case THROW =>
+          Throw(readTerm())
+        case SINGLETONtpt =>
+          SingletonTypeTree(readTerm())
+        case BYNAMEtpt =>
+          val arg = readTpt()
+          ByNameTypeTree(if knowsPureFuns then arg else arg.adaptByNameArgUnderPureFuns)
+        case NAMEDARG =>
+          NamedArg(readName(), readTerm())
+        case _ =>
+          readPathTerm()
+      }
+
+      /** Adapt constructor calls where class has only using clauses from old to new scheme.
+       *  or class has mixed using clauses and other clauses.
+       *  Old: leading (), new: nothing, or trailing () if all clauses are using clauses.
+       *  This is neccessary so that we can read pre-3.2 Tasty correctly. There,
+       *  constructor calls use the old scheme, but constructor definitions already
+       *  use the new scheme, since they are reconstituted with normalizeIfConstructor.
+       */
+      def constructorApply(fn: Tree, args: List[Tree]): Tree =
+        if fn.tpe.widen.isContextualMethod && args.isEmpty then
+          fn.withAttachment(SuppressedApplyToNone, ())
+        else
+          val fn1 = fn match
+            case Apply(fn1, Nil) if fn.removeAttachment(InsertedApplyToNone).isDefined =>
+              // We thought we inserted a final `()` but hit a user-written `()` instead.
+              // Remove the inserted `()`.
+              fn1
+            case _ =>
+              fn
+          val res = tpd.Apply(fn1, args)
+          if fn.removeAttachment(SuppressedApplyToNone).isEmpty then
+            res
+          else res.tpe.widen match
+            case mt @ MethodType(params) =>
+              if params.isEmpty then
+                // Assume it's the final synthesized `()` parameter
+                res.appliedToNone.withAttachment(InsertedApplyToNone, ())
+              else if mt.isContextualMethod then
+                res.withAttachment(SuppressedApplyToNone, ())
+              else res
+
+      def simplifyLub(tree: Tree): Tree =
+        tree.overwriteType(tree.tpe.simplified)
+        tree
+
+      def readLengthTerm(): Tree = {
+        val end = readEnd()
+        val result =
+          (tag: @switch) match {
+            case SUPER =>
+              val qual = readTerm()
+              val (mixId, mixTpe) = ifBefore(end)(readQualId(), (untpd.EmptyTypeIdent, NoType))
+              tpd.Super(qual, mixId, mixTpe.typeSymbol)
+            case APPLY =>
+              val fn = readTerm()
+              val args = until(end)(readTerm())
+              if fn.symbol.isConstructor then constructorApply(fn, args)
+              else tpd.Apply(fn, args)
+            case TYPEAPPLY =>
+              tpd.TypeApply(readTerm(), until(end)(readTpt()))
+            case TYPED =>
+              val expr = readTerm()
+              val tpt = readTpt()
+              Typed(expr, tpt)
+            case ASSIGN =>
+              Assign(readTerm(), readTerm())
+            case BLOCK =>
+              val exprReader = fork
+              skipTree()
+              readStats(ctx.owner, end,
+                (stats, ctx) => Block(stats, exprReader.readTerm()(using ctx)))
+            case INLINED =>
+              val exprReader = fork
+              skipTree()
+              def maybeCall = nextUnsharedTag match {
+                case VALDEF | DEFDEF => EmptyTree
+                case _ => readTerm()
+              }
+              val call = ifBefore(end)(maybeCall, EmptyTree)
+              val bindings = readStats(ctx.owner, end).asInstanceOf[List[ValOrDefDef]]
+              val expansion = exprReader.readTerm() // need bindings in scope, so needs to be read before
+              Inlined(call, bindings, expansion)
+            case IF =>
+              if (nextByte == INLINE) {
+                readByte()
+                InlineIf(readTerm(), readTerm(), readTerm())
+              }
+              else
+                If(readTerm(), readTerm(), readTerm())
+            case LAMBDA =>
+              val meth = readTerm()
+              val tpt = ifBefore(end)(readTpt(), EmptyTree)
+              Closure(Nil, meth, tpt)
+            case MATCH =>
+              simplifyLub(
+                if (nextByte == IMPLICIT) {
+                  readByte()
+                  InlineMatch(EmptyTree, readCases(end))
+                }
+                else if (nextByte == INLINE) {
+                  readByte()
+                  InlineMatch(readTerm(), readCases(end))
+                }
+                else Match(readTerm(), readCases(end)))
+            case RETURN =>
+              val from = readSymRef()
+              val expr = ifBefore(end)(readTerm(), EmptyTree)
+              Return(expr, Ident(from.termRef))
+            case WHILE =>
+              WhileDo(readTerm(), readTerm())
+            case TRY =>
+              simplifyLub(
+                Try(readTerm(), readCases(end), ifBefore(end)(readTerm(), EmptyTree)))
+            case SELECTouter =>
+              val levels = readNat()
+              readTerm().outerSelect(levels, SkolemType(readType()))
+            case SELECTin =>
+              var sname = readName()
+              val qual = readTerm()
+              val ownerTpe = readType()
+              val owner = ownerTpe.typeSymbol
+              val SignedName(name, sig, target) = sname: @unchecked // only methods with params use SELECTin
+              val qualType = qual.tpe.widenIfUnstable
+              val prefix = ctx.typeAssigner.maybeSkolemizePrefix(qualType, name)
+
+              /** Tasty should still be able to resolve a method from another root class,
+               *  even if it has been moved to a super type,
+               *  or an override has been removed.
+               *
+               *  This is tested in
+               *  - sbt-test/tasty-compat/remove-override
+               *  - sbt-test/tasty-compat/move-method
+               */
+              def lookupInSuper =
+                val cls = ownerTpe.classSymbol
+                if cls.exists then
+                  cls.asClass.classDenot
+                    .findMember(name, cls.thisType, EmptyFlags, excluded=Private)
+                    .atSignature(sig, target)
+                else
+                  NoDenotation
+
+              val denot =
+                val d = ownerTpe.decl(name).atSignature(sig, target)
+                (if !d.exists then lookupInSuper else d).asSeenFrom(prefix)
+
+              makeSelect(qual, name, denot)
+            case REPEATED =>
+              val elemtpt = readTpt()
+              SeqLiteral(until(end)(readTerm()), elemtpt)
+            case BIND =>
+              val sym = symAtAddr.getOrElse(start, forkAt(start).createSymbol())
+              readName()
+              readType()
+              val body = readTerm()
+              val (givenFlags, _, _) = readModifiers(end)
+              sym.setFlag(givenFlags)
+              Bind(sym, body)
+            case ALTERNATIVE =>
+              Alternative(until(end)(readTerm()))
+            case UNAPPLY =>
+              val fn = readTerm()
+              val implicitArgs =
+                collectWhile(nextByte == IMPLICITarg) {
+                  readByte()
+                  readTerm()
+                }
+              val patType = readType()
+              val argPats = until(end)(readTerm())
+              UnApply(fn, implicitArgs, argPats, patType)
+            case REFINEDtpt =>
+              val refineCls = symAtAddr.getOrElse(start,
+                newRefinedClassSymbol(coordAt(start))).asClass
+              registerSym(start, refineCls)
+              typeAtAddr(start) = refineCls.typeRef
+              val parent = readTpt()
+              val refinements = readStats(refineCls, end)(using localContext(refineCls))
+              RefinedTypeTree(parent, refinements, refineCls)
+            case APPLIEDtpt =>
+              // If we do directly a tpd.AppliedType tree we might get a
+              // wrong number of arguments in some scenarios reading F-bounded
+              // types. This came up in #137 of collection strawman.
+              val tycon = readTpt()
+              val args = until(end)(readTpt())
+              val tree = untpd.AppliedTypeTree(tycon, args)
+              val ownType = ctx.typeAssigner.processAppliedType(tree, tycon.tpe.safeAppliedTo(args.tpes))
+              tree.withType(postProcessFunction(ownType))
+            case ANNOTATEDtpt =>
+              Annotated(readTpt(), readTerm())
+            case LAMBDAtpt =>
+              val tparams = readParams[TypeDef](TYPEPARAM)
+              val body = readTpt()
+              LambdaTypeTree(tparams, body)
+            case MATCHtpt =>
+              val fst = readTpt()
+              val (bound, scrut) =
+                if (nextUnsharedTag == CASEDEF) (EmptyTree, fst) else (fst, readTpt())
+              MatchTypeTree(bound, scrut, readCases(end))
+            case TYPEBOUNDStpt =>
+              val lo = readTpt()
+              val hi = if currentAddr == end then lo else readTpt()
+              val alias = if currentAddr == end then EmptyTree else readTpt()
+              createNullableTypeBoundsTree(lo, hi, alias)
+            case HOLE =>
+              val idx = readNat()
+              val tpe = readType()
+              val args = until(end)(readTerm())
+              Hole(true, idx, args, EmptyTree, TypeTree(tpe)).withType(tpe)
+            case _ =>
+              readPathTerm()
+          }
+        assert(currentAddr == end, s"$start $currentAddr $end ${astTagToString(tag)}")
+        result
+      }
+
+      val tree = if (tag < firstLengthTreeTag) readSimpleTerm() else readLengthTerm()
+      setSpan(start, tree)
+    }
+
+    def readTpt()(using Context): Tree = {
+      val sctx = sourceChangeContext()
+      if (sctx `ne` ctx) return readTpt()(using sctx)
+      val start = currentAddr
+      val tree = nextByte match {
+        case SHAREDterm =>
+          readByte()
+          forkAt(readAddr()).readTpt()
+        case BLOCK =>
+          readByte()
+          val end = readEnd()
+          val typeReader = fork
+          skipTree()
+          val aliases = readStats(ctx.owner, end)
+          val tpt = typeReader.readTpt()
+          Block(aliases, tpt)
+        case HOLE =>
+          readByte()
+          val end = readEnd()
+          val idx = readNat()
+          val tpe = readType()
+          val args = until(end)(readTerm())
+          Hole(false, idx, args, EmptyTree, TypeTree(tpe)).withType(tpe)
+        case _ =>
+          if (isTypeTreeTag(nextByte)) readTerm()
+          else {
+            val start = currentAddr
+            val tp = readType()
+            if (tp.exists) setSpan(start, TypeTree(tp)) else EmptyTree
+          }
+      }
+      setSpan(start, tree)
+    }
+
+    def readCases(end: Addr)(using Context): List[CaseDef] =
+      collectWhile((nextUnsharedTag == CASEDEF) && currentAddr != end) {
+        if (nextByte == SHAREDterm) {
+          readByte()
+          forkAt(readAddr()).readCase()(using ctx.fresh.setNewScope)
+        }
+        else readCase()(using ctx.fresh.setNewScope)
+      }
+
+    def readCase()(using Context): CaseDef = {
+      val sctx = sourceChangeContext()
+      if (sctx `ne` ctx) return readCase()(using sctx)
+      val start = currentAddr
+      assert(readByte() == CASEDEF)
+      val end = readEnd()
+      val pat = readTerm()
+      val rhs = readTerm()
+      val guard = ifBefore(end)(readTerm(), EmptyTree)
+      setSpan(start, CaseDef(pat, guard, rhs))
+    }
+
+    def readLater[T <: AnyRef](end: Addr, op: TreeReader -> Context ?-> T)(using Context): Trees.Lazy[T] =
+      readLaterWithOwner(end, op)(ctx.owner)
+
+    def readLaterWithOwner[T <: AnyRef](end: Addr, op: TreeReader -> Context ?-> T)(using Context): Symbol -> Trees.Lazy[T] = {
+      val localReader = fork
+      goto(end)
+      val mode = ctx.mode
+      val source = ctx.source
+      owner => new LazyReader(localReader, owner, mode, source, op)
+    }
+
+// ------ Setting positions ------------------------------------------------
+
+    /** Pickled span for `addr`. */
+    def spanAt(addr: Addr)(using Context): Span =
+      if (ctx.mode.is(Mode.ReadPositions))
+        posUnpicklerOpt match {
+          case Some(posUnpickler) =>
+            posUnpickler.spanAt(addr)
+          case _  =>
+            NoSpan
+        }
+      else NoSpan
+
+    /** Coordinate for the symbol at `addr`. */
+    def coordAt(addr: Addr)(using Context): Coord = {
+      val span = spanAt(addr)
+      if (span.exists)
+        spanCoord(span)
+      else
+        indexCoord(addr.index)
+    }
+
+    /** Pickled source path at `addr`. */
+    def sourcePathAt(addr: Addr)(using Context): String =
+      if (ctx.mode.is(Mode.ReadPositions))
+        posUnpicklerOpt match {
+          case Some(posUnpickler) =>
+            posUnpickler.sourcePathAt(addr)
+          case _  =>
+            ""
+        }
+      else ""
+
+    /** If currentAddr carries a source path, the current context with
+     *  the source of that path, otherwise the current context itself.
+     */
+    def sourceChangeContext(addr: Addr = currentAddr)(using Context): Context = {
+      val path = sourcePathAt(addr)
+      if (path.nonEmpty) {
+        val sourceFile = ctx.getSource(path)
+        posUnpicklerOpt match
+          case Some(posUnpickler) if !sourceFile.initialized =>
+            sourceFile.setLineIndicesFromLineSizes(posUnpickler.lineSizes)
+          case _ =>
+        pickling.println(i"source change at $addr: $path")
+        ctx.withSource(sourceFile)
+      }
+      else ctx
+    }
+
+    /** Set position of `tree` at given `addr`. */
+    def setSpan[T <: untpd.Tree](addr: Addr, tree: T)(using Context): tree.type = {
+      val span = spanAt(addr)
+      if (span.exists) tree.span = span
+      tree
+    }
+  }
+
+  class LazyReader[T <: AnyRef](
+      reader: TreeReader, owner: Symbol, mode: Mode, source: SourceFile,
+      op: TreeReader => Context ?=> T) extends Trees.Lazy[T] {
+    def complete(using Context): T = {
+      pickling.println(i"starting to read at ${reader.reader.currentAddr} with owner $owner")
+      atPhaseBeforeTransforms {
+        op(reader)(using ctx
+          .withOwner(owner)
+          .withModeBits(mode)
+          .withSource(source))
+      }
+    }
+  }
+
+  /** A lazy datastructure that records how definitions are nested in TASTY data.
+   *  The structure is lazy because it needs to be computed only for forward references
+   *  to symbols that happen before the referenced symbol is created (see `symbolAt`).
+   *  Such forward references are rare.
+   *
+   *  @param   addr    The address of tree representing an owning definition, NoAddr for root tree
+   *  @param   tag     The tag at `addr`. Used to determine which subtrees to scan for children
+   *                   (i.e. if `tag` is template, don't scan member defs, as these belong already
+   *                    to enclosing class).
+   *  @param   reader  The reader to be used for scanning for children
+   *  @param   end     The end of the owning definition
+   */
+  class OwnerTree(val addr: Addr, tag: Int, reader: TreeReader, val end: Addr) {
+
+    private var myChildren: List[OwnerTree] = null
+
+    /** All definitions that have the definition at `addr` as closest enclosing definition */
+    def children: List[OwnerTree] = {
+      if (myChildren == null) myChildren = {
+        val buf = new ListBuffer[OwnerTree]
+        reader.scanTrees(buf, end, if (tag == TEMPLATE) NoMemberDefs else AllDefs)
+        buf.toList
+      }
+      myChildren
+    }
+
+    /** Find the owner of definition at `addr` */
+    def findOwner(addr: Addr)(using Context): Symbol = {
+      def search(cs: List[OwnerTree], current: Symbol): Symbol =
+        try cs match {
+          case ot :: cs1 =>
+            if (ot.addr.index == addr.index) {
+              assert(current.exists, i"no symbol at $addr")
+              current
+            }
+            else if (ot.addr.index < addr.index && addr.index < ot.end.index)
+              search(ot.children, reader.symbolAt(ot.addr))
+            else
+              search(cs1, current)
+          case Nil =>
+            throw new TreeWithoutOwner
+        }
+        catch {
+          case ex: TreeWithoutOwner =>
+            pickling.println(i"no owner for $addr among $cs%, %")
+            throw ex
+        }
+      try search(children, NoSymbol)
+      catch {
+        case ex: TreeWithoutOwner =>
+          pickling.println(s"ownerTree = $ownerTree")
+          throw ex
+      }
+    }
+
+    override def toString: String =
+      s"OwnerTree(${addr.index}, ${end.index}, ${if (myChildren == null) "?" else myChildren.mkString(" ")})"
+  }
+}
+
+object TreeUnpickler {
+
+  /** Define the expected format of the tasty bytes
+   *   - TopLevel: Tasty that contains a full class nested in its package
+   *   - Term: Tasty that contains only a term tree
+   *   - TypeTree: Tasty that contains only a type tree or a reference to a type
+   */
+  sealed trait UnpickleMode
+  object UnpickleMode {
+    /** Unpickle a full class in some package */
+    object TopLevel extends UnpickleMode
+    /** Unpickle as a TermTree */
+    object Term extends UnpickleMode
+    /** Unpickle as a TypeTree */
+    object TypeTree extends UnpickleMode
+  }
+
+  /** A marker value used to detect cyclic reference while unpickling definitions. */
+  @sharable val PoisonTree: tpd.Tree = new EmptyTree
+
+  /** An enumeration indicating which subtrees should be added to an OwnerTree. */
+  type MemberDefMode = Int
+  inline val MemberDefsOnly = 0   // add only member defs; skip other statements
+  inline val NoMemberDefs = 1     // add only statements that are not member defs
+  inline val AllDefs = 2          // add everything
+
+  class TreeWithoutOwner extends Exception
+
+  /** An attachment key indicating that an old-style leading () in a constructor
+   *  call that is followed by a using clause was suppressed.
+   */
+  val SuppressedApplyToNone: Property.Key[Unit] = Property.Key()
+
+  /** An attachment key indicating that a trailing () in a constructor
+   *  call that has otherwise only using clauses was inserted.
+   */
+  val InsertedApplyToNone: Property.Key[Unit] = Property.Key()
+}
diff --git a/tests/pos-with-compiler-cc/dotc/core/unpickleScala2/PickleBuffer.scala b/tests/pos-with-compiler-cc/dotc/core/unpickleScala2/PickleBuffer.scala
new file mode 100644
index 000000000000..2aeb1bdeefcc
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/core/unpickleScala2/PickleBuffer.scala
@@ -0,0 +1,292 @@
+package dotty.tools
+package dotc
+package core
+package unpickleScala2
+
+import Flags._
+
+/** Variable length byte arrays, with methods for basic pickling and unpickling.
+ *
+ *  @param data The initial buffer
+ *  @param from The first index where defined data are found
+ *  @param to   The first index where new data can be written
+ */
+class PickleBuffer(data: Array[Byte], from: Int, to: Int) {
+
+  var bytes: Array[Byte] = data
+  var readIndex: Int = from
+  var writeIndex: Int = to
+
+  /** Double bytes array */
+  private def dble(): Unit = {
+    val bytes1 = new Array[Byte](bytes.length * 2)
+    System.arraycopy(bytes, 0, bytes1, 0, writeIndex)
+    bytes = bytes1
+  }
+
+  def ensureCapacity(capacity: Int): Unit =
+    while (bytes.length < writeIndex + capacity) dble()
+
+  // -- Basic output routines --------------------------------------------
+
+  /** Write a byte of data */
+  def writeByte(b: Int): Unit = {
+    if (writeIndex == bytes.length) dble()
+    bytes(writeIndex) = b.toByte
+    writeIndex += 1
+  }
+
+  /** Write a natural number in big endian format, base 128.
+   *  All but the last digits have bit 0x80 set.
+   */
+  def writeNat(x: Int): Unit =
+    writeLongNat(x.toLong & 0x00000000FFFFFFFFL)
+
+  /**
+   * Like writeNat, but for longs. This is not the same as
+   * writeLong, which writes in base 256. Note that the
+   * binary representation of LongNat is identical to Nat
+   * if the long value is in the range Int.MIN_VALUE to
+   * Int.MAX_VALUE.
+   */
+  def writeLongNat(x: Long): Unit = {
+    def writeNatPrefix(x: Long): Unit = {
+      val y = x >>> 7
+      if (y != 0L) writeNatPrefix(y)
+      writeByte(((x & 0x7f) | 0x80).toInt)
+    }
+    val y = x >>> 7
+    if (y != 0L) writeNatPrefix(y)
+    writeByte((x & 0x7f).toInt)
+  }
+
+  /** Write a natural number <code>x</code> at position <code>pos</code>.
+   *  If number is more than one byte, shift rest of array to make space.
+   *
+   *  @param pos ...
+   *  @param x   ...
+   */
+  def patchNat(pos: Int, x: Int): Unit = {
+    def patchNatPrefix(x: Int): Unit = {
+      writeByte(0)
+      System.arraycopy(bytes, pos, bytes, pos + 1, writeIndex - (pos + 1))
+      bytes(pos) = ((x & 0x7f) | 0x80).toByte
+      val y = x >>> 7
+      if (y != 0) patchNatPrefix(y)
+    }
+    bytes(pos) = (x & 0x7f).toByte
+    val y = x >>> 7
+    if (y != 0) patchNatPrefix(y)
+  }
+
+  /** Write a long number <code>x</code> in signed big endian format, base 256.
+   *
+   *  @param x The long number to be written.
+   */
+  def writeLong(x: Long): Unit = {
+    val y = x >> 8
+    val z = x & 0xff
+    if (-y != (z >> 7)) writeLong(y)
+    writeByte(z.toInt)
+  }
+
+  // -- Basic input routines --------------------------------------------
+
+  /** Peek at the current byte without moving the read index */
+  def peekByte(): Int = bytes(readIndex)
+
+  /** Read a byte */
+  def readByte(): Int = {
+    val x = bytes(readIndex); readIndex += 1; x
+  }
+
+  /** Read a natural number in big endian format, base 128.
+   *  All but the last digits have bit 0x80 set.*/
+  def readNat(): Int = readLongNat().toInt
+
+  def readLongNat(): Long = {
+    var b = 0L
+    var x = 0L
+    while ({
+      b = readByte()
+      x = (x << 7) + (b & 0x7f)
+      (b & 0x80) != 0L
+    })
+    ()
+    x
+  }
+
+  /** Read a long number in signed big endian format, base 256. */
+  def readLong(len: Int): Long = {
+    var x = 0L
+    var i = 0
+    while (i < len) {
+      x = (x << 8) + (readByte() & 0xff)
+      i += 1
+    }
+    val leading = 64 - (len << 3)
+    x << leading >> leading
+  }
+
+  /** Returns the buffer as a sequence of (Int, Array[Byte]) representing
+   *  (tag, data) of the individual entries.  Saves and restores buffer state.
+   */
+
+  def toIndexedSeq: IndexedSeq[(Int, Array[Byte])] = {
+    val saved = readIndex
+    readIndex = 0
+    readNat() ; readNat()     // discarding version
+    val result = new Array[(Int, Array[Byte])](readNat())
+
+    result.indices foreach { index =>
+      val tag = readNat()
+      val len = readNat()
+      val bytes = data.slice(readIndex, len + readIndex)
+      readIndex += len
+
+      result(index) = tag -> bytes
+    }
+
+    readIndex = saved
+    result.toIndexedSeq
+  }
+
+  /** Perform operation <code>op</code> until the condition
+   *  <code>readIndex == end</code> is satisfied.
+   *  Concatenate results into a list.
+   *
+   *  @param end ...
+   *  @param op  ...
+   *  @return    ...
+   */
+  def until[T](end: Int, op: () => T): List[T] =
+    if (readIndex == end) List() else op() :: until(end, op)
+
+  /** Perform operation <code>op</code> the number of
+   *  times specified.  Concatenate the results into a list.
+   */
+  def times[T](n: Int, op: ()=>T): List[T] =
+    if (n == 0) List() else op() :: times(n-1, op)
+
+  /** Pickle = majorVersion_Nat minorVersion_Nat nbEntries_Nat {Entry}
+   *  Entry  = type_Nat length_Nat [actual entries]
+   *
+   *  Assumes that the ..Version_Nat are already consumed.
+   *
+   *  @return an array mapping entry numbers to locations in
+   *  the byte array where the entries start.
+   */
+  def createIndex: Array[Int] = {
+    val index = new Array[Int](readNat()) // nbEntries_Nat
+    for (i <- 0 until index.length) {
+      index(i) = readIndex
+      readByte() // skip type_Nat
+      readIndex = readNat() + readIndex // read length_Nat, jump to next entry
+    }
+    index
+  }
+}
+
+object PickleBuffer {
+
+  private inline val ScalaFlagEnd = 48
+  private inline val ChunkBits = 8
+  private inline val ChunkSize = 1 << ChunkBits
+  private type FlagMap = Array[Array[Long]]
+
+  private val (scalaTermFlagMap, scalaTypeFlagMap) = {
+    import Scala2Flags._
+
+    val corr = Map(
+      PROTECTED_PKL -> Protected,
+      OVERRIDE_PKL -> Override,
+      PRIVATE_PKL -> Private,
+      ABSTRACT_PKL -> Abstract,
+      DEFERRED_PKL -> Deferred,
+      FINAL_PKL -> Final,
+      METHOD_PKL -> Method,
+      INTERFACE_PKL -> NoInitsInterface,
+      MODULE_PKL -> (Module | Lazy, Module),
+      IMPLICIT_PKL -> Implicit,
+      SEALED_PKL -> Sealed,
+      CASE_PKL -> Case,
+      MUTABLE -> Mutable,
+      PARAM -> Param,
+      PACKAGE -> Package,
+      MACRO -> Macro,
+      BYNAMEPARAM -> (Method, Covariant),
+      LABEL -> (Label, Contravariant),
+      ABSOVERRIDE -> AbsOverride,
+      LOCAL -> Local,
+      JAVA -> JavaDefined,
+      SYNTHETIC -> Synthetic,
+      STABLE -> StableRealizable,
+      STATIC -> JavaStatic,
+      CASEACCESSOR -> CaseAccessor,
+      DEFAULTPARAM -> (HasDefault, Trait),
+      BRIDGE -> Bridge,
+      ACCESSOR -> Accessor,
+      SUPERACCESSOR -> Scala2SuperAccessor,
+      PARAMACCESSOR -> ParamAccessor,
+      MODULEVAR -> Scala2ModuleVar,
+      LAZY -> Lazy,
+      MIXEDIN -> (MixedIn, Scala2Existential),
+      EXPANDEDNAME -> Scala2ExpandedName,
+      SPECIALIZED -> Specialized,
+      VBRIDGE -> EmptyFlags,
+      VARARGS -> JavaVarargs,
+      ENUM -> Enum)
+
+    // generate initial maps from Scala flags to Dotty flags
+    val termMap, typeMap = new Array[Long](64)
+    for (idx <- 0 until ScalaFlagEnd)
+      corr get (1L << idx) match {
+        case Some((termFlag: FlagSet @unchecked, typeFlag: FlagSet @unchecked)) =>
+          termMap(idx) |= termFlag.bits
+          typeMap(idx) |= typeFlag.bits
+        case Some(commonFlag: FlagSet @unchecked) =>
+          termMap(idx) |= commonFlag.toTermFlags.bits
+          typeMap(idx) |= commonFlag.toTypeFlags.bits
+        case _ =>
+      }
+
+    // Convert map so that it maps chunks of ChunkBits size at once
+    // instead of single bits.
+    def chunkMap(xs: Array[Long]): FlagMap = {
+      val size = (xs.length + ChunkBits - 1) / ChunkBits
+      val chunked = Array.ofDim[Long](size, ChunkSize)
+      var i = 0
+      while (i < size) {
+        var j = 0
+        while (j < ChunkSize) {
+          var k = 0
+          while (k < ChunkBits) {
+            if ((j & (1 << k)) != 0)
+              chunked(i)(j) |= xs(i * ChunkBits + k)
+            k += 1
+          }
+          j += 1
+        }
+        i += 1
+      }
+      chunked
+    }
+
+    (chunkMap(termMap), chunkMap(typeMap))
+  }
+
+  def unpickleScalaFlags(sflags: Long, isType: Boolean): FlagSet = {
+    val map: FlagMap = if (isType) scalaTypeFlagMap else scalaTermFlagMap
+    val shift = ChunkBits
+    val mask = ChunkSize - 1
+    assert(6 * ChunkBits == ScalaFlagEnd)
+    FlagSet(
+      map(0)((sflags >>> (shift * 0)).toInt & mask) |
+      map(1)((sflags >>> (shift * 1)).toInt & mask) |
+      map(2)((sflags >>> (shift * 2)).toInt & mask) |
+      map(3)((sflags >>> (shift * 3)).toInt & mask) |
+      map(4)((sflags >>> (shift * 4)).toInt & mask) |
+      map(5)((sflags >>> (shift * 5)).toInt & mask)
+    )
+  }
+}
diff --git a/tests/pos-with-compiler-cc/dotc/core/unpickleScala2/PickleFormat.scala b/tests/pos-with-compiler-cc/dotc/core/unpickleScala2/PickleFormat.scala
new file mode 100644
index 000000000000..f135de7e43e9
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/core/unpickleScala2/PickleFormat.scala
@@ -0,0 +1,227 @@
+package dotty.tools
+package dotc
+package core
+package unpickleScala2
+
+/** This object provides constants for pickling attributes.
+ *
+ *  If you extend the format, be sure to increase the
+ *  version minor number.
+ *
+ *  This was adapted from https://github.com/scala/scala/blob/2.11.x/src/reflect/scala/reflect/internal/pickling/PickleFormat.scala
+ *
+ *  @author Martin Odersky
+ *  @version 1.0
+ */
+object PickleFormat {
+
+/***************************************************
+ * Symbol table attribute format:
+ *   Symtab         = nentries_Nat {Entry}
+ *   Entry          = 1 TERMNAME len_Nat NameInfo
+ *                  | 2 TYPENAME len_Nat NameInfo
+ *                  | 3 NONEsym len_Nat
+ *                  | 4 TYPEsym len_Nat SymbolInfo
+ *                  | 5 ALIASsym len_Nat SymbolInfo
+ *                  | 6 CLASSsym len_Nat SymbolInfo [thistype_Ref]
+ *                  | 7 MODULEsym len_Nat SymbolInfo
+ *                  | 8 VALsym len_Nat [defaultGetter_Ref /* no longer needed*/] SymbolInfo [alias_Ref]
+ *                  | 9 EXTref len_Nat name_Ref [owner_Ref]
+ *                  | 10 EXTMODCLASSref len_Nat name_Ref [owner_Ref]
+ *                  | 11 NOtpe len_Nat
+ *                  | 12 NOPREFIXtpe len_Nat
+ *                  | 13 THIStpe len_Nat sym_Ref
+ *                  | 14 SINGLEtpe len_Nat type_Ref sym_Ref
+ *                  | 15 CONSTANTtpe len_Nat constant_Ref
+ *                  | 16 TYPEREFtpe len_Nat type_Ref sym_Ref {targ_Ref}
+ *                  | 17 TYPEBOUNDStpe len_Nat tpe_Ref tpe_Ref
+ *                  | 18 REFINEDtpe len_Nat classsym_Ref {tpe_Ref}
+ *                  | 19 CLASSINFOtpe len_Nat classsym_Ref {tpe_Ref}
+ *                  | 20 METHODtpe len_Nat tpe_Ref {sym_Ref}
+ *                  | 21 POLYTtpe len_Nat tpe_Ref {sym_Ref}
+ *                  | 22 IMPLICITMETHODtpe len_Nat tpe_Ref {sym_Ref} /* no longer needed */
+ *                  | 52 SUPERtpe len_Nat tpe_Ref tpe_Ref
+ *                  | 24 LITERALunit len_Nat
+ *                  | 25 LITERALboolean len_Nat value_Long
+ *                  | 26 LITERALbyte len_Nat value_Long
+ *                  | 27 LITERALshort len_Nat value_Long
+ *                  | 28 LITERALchar len_Nat value_Long
+ *                  | 29 LITERALint len_Nat value_Long
+ *                  | 30 LITERALlong len_Nat value_Long
+ *                  | 31 LITERALfloat len_Nat value_Long
+ *                  | 32 LITERALdouble len_Nat value_Long
+ *                  | 33 LITERALstring len_Nat name_Ref
+ *                  | 34 LITERALnull len_Nat
+ *                  | 35 LITERALclass len_Nat tpe_Ref
+ *                  | 36 LITERALenum len_Nat sym_Ref
+ *                  | 40 SYMANNOT len_Nat sym_Ref AnnotInfoBody
+ *                  | 41 CHILDREN len_Nat sym_Ref {sym_Ref}
+ *                  | 42 ANNOTATEDtpe len_Nat [sym_Ref /* no longer needed */] tpe_Ref {annotinfo_Ref}
+ *                  | 43 ANNOTINFO len_Nat AnnotInfoBody
+ *                  | 44 ANNOTARGARRAY len_Nat {constAnnotArg_Ref}
+ *                  | 47 DEBRUIJNINDEXtpe len_Nat level_Nat index_Nat /* no longer needed */
+ *                  | 48 EXISTENTIALtpe len_Nat type_Ref {symbol_Ref}
+ *                  | 49 TREE len_Nat 1 EMPTYtree
+ *                  | 49 TREE len_Nat 2 PACKAGEtree type_Ref sym_Ref mods_Ref name_Ref {tree_Ref}
+ *                  | 49 TREE len_Nat 3 CLASStree type_Ref sym_Ref mods_Ref name_Ref tree_Ref {tree_Ref}
+ *                  | 49 TREE len_Nat 4 MODULEtree type_Ref sym_Ref mods_Ref name_Ref tree_Ref
+ *                  | 49 TREE len_Nat 5 VALDEFtree type_Ref sym_Ref mods_Ref name_Ref tree_Ref tree_Ref
+ *                  | 49 TREE len_Nat 6 DEFDEFtree type_Ref sym_Ref mods_Ref name_Ref numtparams_Nat {tree_Ref} numparamss_Nat {numparams_Nat {tree_Ref}} tree_Ref tree_Ref
+ *                  | 49 TREE len_Nat 7 TYPEDEFtree type_Ref sym_Ref mods_Ref name_Ref tree_Ref {tree_Ref}
+ *                  | 49 TREE len_Nat 8 LABELtree type_Ref sym_Ref tree_Ref {tree_Ref}
+ *                  | 49 TREE len_Nat 9 IMPORTtree type_Ref sym_Ref tree_Ref {name_Ref name_Ref}
+ *                  | 49 TREE len_Nat 11 DOCDEFtree type_Ref sym_Ref string_Ref tree_Ref
+ *                  | 49 TREE len_Nat 12 TEMPLATEtree type_Ref sym_Ref numparents_Nat {tree_Ref} tree_Ref {tree_Ref}
+ *                  | 49 TREE len_Nat 13 BLOCKtree type_Ref tree_Ref {tree_Ref}
+ *                  | 49 TREE len_Nat 14 CASEtree type_Ref tree_Ref tree_Ref tree_Ref
+ *                  | 49 TREE len_Nat 15 SEQUENCEtree type_Ref {tree_Ref}
+ *                  | 49 TREE len_Nat 16 ALTERNATIVEtree type_Ref {tree_Ref}
+ *                  | 49 TREE len_Nat 17 STARtree type_Ref {tree_Ref}
+ *                  | 49 TREE len_Nat 18 BINDtree type_Ref sym_Ref name_Ref tree_Ref
+ *                  | 49 TREE len_Nat 19 UNAPPLYtree type_Ref tree_Ref {tree_Ref}
+ *                  | 49 TREE len_Nat 20 ARRAYVALUEtree type_Ref tree_Ref {tree_Ref}
+ *                  | 49 TREE len_Nat 21 FUNCTIONtree type_Ref sym_Ref tree_Ref {tree_Ref}
+ *                  | 49 TREE len_Nat 22 ASSIGNtree type_Ref tree_Ref tree_Ref
+ *                  | 49 TREE len_Nat 23 IFtree type_Ref tree_Ref tree_Ref tree_Ref
+ *                  | 49 TREE len_Nat 24 MATCHtree type_Ref tree_Ref {tree_Ref}
+ *                  | 49 TREE len_Nat 25 RETURNtree type_Ref sym_Ref tree_Ref
+ *                  | 49 TREE len_Nat 26 TREtree type_Ref tree_Ref tree_Ref {tree_Ref}
+ *                  | 49 TREE len_Nat 27 THROWtree type_Ref tree_Ref
+ *                  | 49 TREE len_Nat 28 NEWtree type_Ref tree_Ref
+ *                  | 49 TREE len_Nat 29 TYPEDtree type_Ref tree_Ref tree_Ref
+ *                  | 49 TREE len_Nat 30 TYPEAPPLYtree type_Ref tree_Ref {tree_Ref}
+ *                  | 49 TREE len_Nat 31 APPLYtree type_Ref tree_Ref {tree_Ref}
+ *                  | 49 TREE len_Nat 32 APPLYDYNAMICtree type_Ref sym_Ref tree_Ref {tree_Ref}
+ *                  | 49 TREE len_Nat 33 SUPERtree type_Ref sym_Ref tree_Ref name_Ref
+ *                  | 49 TREE len_Nat 34 THIStree type_Ref sym_Ref  name_Ref
+ *                  | 49 TREE len_Nat 35 SELECTtree type_Ref sym_Ref tree_Ref name_Ref
+ *                  | 49 TREE len_Nat 36 IDENTtree type_Ref sym_Ref name_Ref
+ *                  | 49 TREE len_Nat 37 LITERALtree type_Ref constant_Ref
+ *                  | 49 TREE len_Nat 38 TYPEtree type_Ref
+ *                  | 49 TREE len_Nat 39 ANNOTATEDtree type_Ref tree_Ref tree_Ref
+ *                  | 49 TREE len_Nat 40 SINGLETONTYPEtree type_Ref tree_Ref
+ *                  | 49 TREE len_Nat 41 SELECTFROMTYPEtree type_Ref tree_Ref name_Ref
+ *                  | 49 TREE len_Nat 42 COMPOUNDTYPEtree type_Ref tree_Ref
+ *                  | 49 TREE len_Nat 43 APPLIEDTYPEtree type_Ref tree_Ref {tree_Ref}
+ *                  | 49 TREE len_Nat 44 TYPEBOUNDStree type_Ref tree_Ref tree_Ref
+ *                  | 49 TREE len_Nat 45 EXISTENTIALTYPEtree type_Ref tree_Ref {tree_Ref}
+ *                  | 50 MODIFIERS len_Nat flags_Long privateWithin_Ref
+ *   SymbolInfo     = name_Ref owner_Ref flags_LongNat [privateWithin_Ref] info_Ref
+ *   NameInfo       = <character sequence of length len_Nat in Utf8 format>
+ *   NumInfo        = <len_Nat-byte signed number in big endian format>
+ *   Ref            = Nat
+ *   AnnotInfoBody  = info_Ref {annotArg_Ref} {name_Ref constAnnotArg_Ref}
+ *   AnnotArg       = Tree | Constant
+ *   ConstAnnotArg  = Constant | AnnotInfo | AnnotArgArray
+ *
+ *   len is remaining length after `len`.
+ */
+  val MajorVersion: Int = 5
+  val MinorVersion: Int = 2
+
+  inline val TERMname = 1
+  inline val TYPEname = 2
+  inline val NONEsym = 3
+  inline val TYPEsym = 4
+  inline val ALIASsym = 5
+  inline val CLASSsym = 6
+  inline val MODULEsym = 7
+  inline val VALsym = 8
+  inline val EXTref = 9
+  inline val EXTMODCLASSref = 10
+  inline val NOtpe = 11
+  inline val NOPREFIXtpe = 12
+  inline val THIStpe = 13
+  inline val SINGLEtpe = 14
+  inline val CONSTANTtpe = 15
+  inline val TYPEREFtpe = 16
+  inline val TYPEBOUNDStpe = 17
+  inline val REFINEDtpe = 18
+  inline val CLASSINFOtpe = 19
+  inline val METHODtpe = 20
+  inline val POLYtpe = 21
+  inline val IMPLICITMETHODtpe = 22    // no longer generated
+
+  inline val LITERAL = 23   // base line for literals
+  inline val LITERALunit = 24
+  inline val LITERALboolean = 25
+  inline val LITERALbyte = 26
+  inline val LITERALshort = 27
+  inline val LITERALchar = 28
+  inline val LITERALint = 29
+  inline val LITERALlong = 30
+  inline val LITERALfloat = 31
+  inline val LITERALdouble = 32
+  inline val LITERALstring = 33
+  inline val LITERALnull = 34
+  inline val LITERALclass = 35
+  inline val LITERALenum = 36
+  inline val SYMANNOT = 40
+  inline val CHILDREN = 41
+  inline val ANNOTATEDtpe = 42
+  inline val ANNOTINFO = 43
+  inline val ANNOTARGARRAY = 44
+
+  inline val SUPERtpe = 46
+  inline val DEBRUIJNINDEXtpe = 47   // no longer generated
+  inline val EXISTENTIALtpe = 48
+
+  inline val TREE = 49      // prefix code that means a tree is coming
+    inline val EMPTYtree = 1
+    inline val PACKAGEtree = 2
+    inline val CLASStree = 3
+    inline val MODULEtree = 4
+    inline val VALDEFtree = 5
+    inline val DEFDEFtree = 6
+    inline val TYPEDEFtree = 7
+    inline val LABELtree = 8
+    inline val IMPORTtree = 9
+    inline val DOCDEFtree = 11
+    inline val TEMPLATEtree = 12
+    inline val BLOCKtree = 13
+    inline val CASEtree = 14
+    // This node type has been removed.
+    // inline val SEQUENCEtree = 15
+    inline val ALTERNATIVEtree = 16
+    inline val STARtree = 17
+    inline val BINDtree = 18
+    inline val UNAPPLYtree = 19
+    inline val ARRAYVALUEtree = 20
+    inline val FUNCTIONtree = 21
+    inline val ASSIGNtree = 22
+    inline val IFtree = 23
+    inline val MATCHtree = 24
+    inline val RETURNtree = 25
+    inline val TREtree = 26
+    inline val THROWtree = 27
+    inline val NEWtree = 28
+    inline val TYPEDtree = 29
+    inline val TYPEAPPLYtree = 30
+    inline val APPLYtree = 31
+    inline val APPLYDYNAMICtree = 32
+    inline val SUPERtree = 33
+    inline val THIStree = 34
+    inline val SELECTtree = 35
+    inline val IDENTtree = 36
+    inline val LITERALtree = 37
+    inline val TYPEtree = 38
+    inline val ANNOTATEDtree = 39
+    inline val SINGLETONTYPEtree = 40
+    inline val SELECTFROMTYPEtree = 41
+    inline val COMPOUNDTYPEtree = 42
+    inline val APPLIEDTYPEtree = 43
+    inline val TYPEBOUNDStree = 44
+    inline val EXISTENTIALTYPEtree = 45
+
+  inline val MODIFIERS = 50
+
+  inline val firstSymTag = NONEsym
+  inline val lastSymTag = VALsym
+  inline val lastExtSymTag = EXTMODCLASSref
+}
+
+
+  //The following two are no longer accurate, because ANNOTATEDtpe,
+  //SUPERtpe, ... are not in the same range as the other types
+  //inline val firstTypeTag = NOtpe
+  //inline val lastTypeTag = POLYtpe
diff --git a/tests/pos-with-compiler-cc/dotc/core/unpickleScala2/Scala2Erasure.scala b/tests/pos-with-compiler-cc/dotc/core/unpickleScala2/Scala2Erasure.scala
new file mode 100644
index 000000000000..f2d25d0f34b5
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/core/unpickleScala2/Scala2Erasure.scala
@@ -0,0 +1,257 @@
+package dotty.tools
+package dotc
+package core
+package unpickleScala2
+
+import Symbols._, Types._, Contexts._, Flags._, Names._, StdNames._, Phases._
+import Decorators._
+import scala.collection.mutable.ListBuffer
+
+/** Erasure logic specific to Scala 2 symbols. */
+object Scala2Erasure:
+  /** Is this a supported Scala 2 refinement or parent of such a type?
+   *
+   *  We do not allow types that look like:
+   *    ((A with B) @foo) with C
+   *  or:
+   *    (A { type X <: ... })#X with C`
+   *
+   *  as it would make our implementation of Scala 2 intersection erasure
+   *  significantly more complicated. The problem is that each textual
+   *  appearance of an intersection or refinement in a parent corresponds to a
+   *  fresh instance of RefinedType (because Scala 2 does not hash-cons these
+   *  types) with a fresh synthetic class symbol, thus affecting the result of
+   *  `isNonBottomSubClass`. To complicate the matter, the Scala 2 UnCurry phase
+   *  will also recursively dealias parent types, thus creating distinct class
+   *  symbols even in situations where the same type alias is used to refer to a
+   *  given refinement. Note that types like `(A with B) with C` do not run into
+   *  these issues because they get flattened into a single RefinedType with
+   *  three parents, cf `flattenedParents`.
+   *
+   *  See sbt-test/scala2-compat/erasure/changes/Main.scala for examples.
+   *
+   *  @throws TypeError if this type is unsupported.
+   */
+  def checkSupported(tp: Type)(using Context): Unit = tp match
+    case AndType(tp1, tp2) =>
+      checkSupported(tp1)
+      checkSupported(tp2)
+    case RefinedType(parent, _, _) =>
+      checkSupported(parent)
+    case AnnotatedType(parent, _) if parent.dealias.isInstanceOf[Scala2RefinedType] =>
+      throw new TypeError(i"Unsupported Scala 2 type: Component $parent of intersection is annotated.")
+    case tp @ TypeRef(prefix, _) if !tp.symbol.exists && prefix.dealias.isInstanceOf[Scala2RefinedType] =>
+      throw new TypeError(i"Unsupported Scala 2 type: Prefix $prefix of intersection component is an intersection or refinement.")
+    case _ =>
+
+  /** A type that would be represented as a RefinedType in Scala 2.
+   *
+   *  The `RefinedType` of Scala 2 contains both a list of parents
+   *  and a list of refinements, intersections are represented as a RefinedType
+   *  with no refinements.
+   */
+  type Scala2RefinedType = RefinedType | AndType
+
+  /** A TypeRef that is known to represent a member of a structural type. */
+  type StructuralRef = TypeRef
+
+  /** The equivalent of a Scala 2 type symbol.
+   *
+   *  In some situations, nsc will create a symbol for a type where we wouldn't:
+   *
+   *  - `A with B with C { ... }` is represented with a RefinedType whose
+   *    symbol is a fresh class symbol whose parents are `A`, `B`, `C`.
+   *  - Structural members also get their own symbols.
+   *
+   *  To emulate this, we simply use the type itself as a stand-in for its symbol.
+   *
+   *  See also `sameSymbol` which determines if two pseudo-symbols are really the same.
+   */
+  type PseudoSymbol = Symbol | StructuralRef | Scala2RefinedType
+
+  /** The pseudo symbol of `tp`, see `PseudoSymbol`.
+   *
+   *  The pseudo-symbol representation of a given type is chosen such that
+   *  `isNonBottomSubClass` behaves like it would in Scala 2, in particular
+   *  this lets us strip all aliases.
+   */
+  def pseudoSymbol(tp: Type)(using Context): PseudoSymbol = tp.widenDealias match
+    case tpw: Scala2RefinedType =>
+      checkSupported(tpw)
+      tpw
+    case tpw: TypeRef =>
+      val sym = tpw.symbol
+      if !sym.exists then
+        // Since we don't have symbols for structural type members we use the
+        // type itself and rely on `sameSymbol` to determine whether two
+        // such types would be represented with the same Scala 2 symbol.
+        tpw
+      else
+        sym
+    case tpw: TypeProxy =>
+      pseudoSymbol(tpw.underlying)
+    case tpw: JavaArrayType =>
+      defn.ArrayClass
+    case tpw: OrType =>
+      pseudoSymbol(TypeErasure.scala2Erasure(tpw))
+    case tpw: ErrorType =>
+      defn.ObjectClass
+    case tpw =>
+      throw new Error(s"Internal error: unhandled class ${tpw.getClass} for type $tpw in pseudoSymbol($tp)")
+
+  extension (psym: PseudoSymbol)(using Context)
+    /** Would these two pseudo-symbols be represented with the same symbol in Scala 2? */
+    def sameSymbol(other: PseudoSymbol): Boolean =
+      // Pattern match on (psym1, psym2) desugared by hand to avoid allocating a tuple
+      if psym.isInstanceOf[StructuralRef] && other.isInstanceOf[StructuralRef] then
+        val tp1 = psym.asInstanceOf[StructuralRef]
+        val tp2 = other.asInstanceOf[StructuralRef]
+        // Two structural members will have the same Scala 2 symbol if they
+        // point to the same member. We can't just call `=:=` since different
+        // prefixes will still have the same symbol.
+        (tp1.name eq tp2.name) && pseudoSymbol(tp1.prefix).sameSymbol(pseudoSymbol(tp2.prefix))
+      else
+        // We intentionally use referential equality here even though we may end
+        // up comparing two equivalent intersection types, because Scala 2 will
+        // create fresh symbols for each appearance of an intersection type in
+        // source code.
+        psym eq other
+
+    /** Is this a class symbol? Also returns true for refinements
+     *  since they get a class symbol in Scala 2.
+     */
+    def isClass: Boolean = psym match
+      case sym: Symbol =>
+        sym.isClass
+      case _: Scala2RefinedType =>
+        true
+      case _ =>
+        false
+
+    /** Is this a trait symbol? */
+    def isTrait: Boolean = psym match
+      case sym: Symbol =>
+        sym.is(Trait)
+      case _ =>
+        false
+
+    /** An emulation of `Symbol#isNonBottomSubClass` from Scala 2.
+     *
+     *  The documentation of the original method is:
+     *
+     *  > Is this class symbol a subclass of that symbol,
+     *  > and is this class symbol also different from Null or Nothing?
+     *
+     *  Which sounds fine, except that it is also used with non-class symbols,
+     *  so what does it do then? Its implementation delegates to `Type#baseTypeSeq`
+     *  whose documentation states:
+     *
+     *  > The base type sequence of T is the smallest set of [...] class types Ti, so that [...]
+     *
+     *  But this is also wrong: the sequence returned by `baseTypeSeq` can
+     *  contain non-class symbols.
+     *
+     *  Given that we cannot rely on the documentation and that the
+     *  implementation is extremely complex, this reimplementation is mostly
+     *  based on reverse-engineering rules derived from the observed behavior of
+     *  the original method.
+     */
+    def isNonBottomSubClass(that: PseudoSymbol): Boolean =
+      /** Recurse on the upper-bound of `psym`: an abstract type is a sub of a
+       *  pseudo-symbol, if its upper-bound is a sub of that pseudo-symbol.
+       */
+      def goUpperBound(psym: Symbol | StructuralRef): Boolean =
+        val info = psym match
+          case sym: Symbol => sym.info
+          case tp: StructuralRef => tp.info
+        info match
+          case info: TypeBounds =>
+            go(pseudoSymbol(info.hi))
+          case _ =>
+            false
+
+      def go(psym: PseudoSymbol): Boolean =
+        psym.sameSymbol(that) ||
+        // As mentioned in the documentation of `Scala2RefinedType`, in Scala 2
+        // these types get their own unique synthetic class symbol, therefore they
+        // don't have any sub-class Note that we must return false even if the lhs
+        // is an abstract type upper-bounded by this refinement, since each
+        // textual appearance of a refinement will have its own class symbol.
+        !that.isInstanceOf[Scala2RefinedType] &&
+        psym.match
+          case sym1: Symbol => that match
+            case sym2: Symbol =>
+              if sym1.isClass && sym2.isClass then
+                sym1.derivesFrom(sym2)
+              else if !sym1.isClass then
+                goUpperBound(sym1)
+              else
+                // sym2 is an abstract type, return false because
+                // `isNonBottomSubClass` in Scala 2 never considers a class C to
+                // be a a sub of an abstract type T, even if it was declared as
+                // `type T >: C`.
+                false
+            case _ =>
+              goUpperBound(sym1)
+          case tp1: StructuralRef =>
+            goUpperBound(tp1)
+          case tp1: RefinedType =>
+            go(pseudoSymbol(tp1.parent))
+          case AndType(tp11, tp12) =>
+            go(pseudoSymbol(tp11)) || go(pseudoSymbol(tp12))
+      end go
+
+      go(psym)
+    end isNonBottomSubClass
+  end extension
+
+  /** An emulation of `Erasure#intersectionDominator` from Scala 2.
+   *
+   *  Accurately reproducing the behavior of this method is extremely difficult
+   *  because it operates on the symbols of the _non-erased_ parent types, an
+   *  implementation detail of the compiler. Furthermore, these non-class
+   *  symbols are passed to methods such as `isNonBottomSubClass` whose behavior
+   *  is only specified for class symbols. Therefore, the accuracy of this
+   *  method cannot be guaranteed, the best we can do is make sure it works on
+   *  as many test cases as possible which can be run from sbt using:
+   *  > sbt-test/scripted scala2-compat/erasure
+   *
+   *  The body of this method is made to look as much as the Scala 2 version as
+   *  possible to make them easier to compare, cf:
+   *  https://github.com/scala/scala/blob/v2.13.5/src/reflect/scala/reflect/internal/transform/Erasure.scala#L356-L389
+   */
+  def intersectionDominator(parents: List[Type])(using Context): Type =
+    val psyms = parents.map(pseudoSymbol)
+    if (psyms.contains(defn.ArrayClass)) {
+      defn.ArrayOf(
+        intersectionDominator(parents.collect { case defn.ArrayOf(arg) => arg }))
+    } else {
+      def isUnshadowed(psym: PseudoSymbol) =
+        !(psyms.exists(qsym => !psym.sameSymbol(qsym) && qsym.isNonBottomSubClass(psym)))
+      val cs = parents.iterator.filter { p =>
+        val psym = pseudoSymbol(p)
+        psym.isClass && !psym.isTrait && isUnshadowed(psym)
+      }
+      (if (cs.hasNext) cs else parents.iterator.filter(p => isUnshadowed(pseudoSymbol(p)))).next()
+    }
+
+  /** A flattened list of parents of this intersection.
+   *
+   *  Mimic what Scala 2 does: intersections like `A with (B with C)` are
+   *  flattened to three parents.
+   */
+  def flattenedParents(tp: AndType)(using Context): List[Type] =
+    val parents = ListBuffer[Type]()
+
+    def collect(parent: Type, parents: ListBuffer[Type]): Unit = parent.dealiasKeepAnnots match
+      case AndType(tp1, tp2) =>
+        collect(tp1, parents)
+        collect(tp2, parents)
+      case _ =>
+        checkSupported(parent)
+        parents += parent
+
+    collect(tp, parents)
+    parents.toList
+  end flattenedParents
+end Scala2Erasure
diff --git a/tests/pos-with-compiler-cc/dotc/core/unpickleScala2/Scala2Flags.scala b/tests/pos-with-compiler-cc/dotc/core/unpickleScala2/Scala2Flags.scala
new file mode 100644
index 000000000000..6cf08b3384d9
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/core/unpickleScala2/Scala2Flags.scala
@@ -0,0 +1,107 @@
+/* NSC -- new Scala compiler
+ * Copyright 2005-2013 LAMP/EPFL
+ * @author  Martin Odersky
+ */
+
+package dotty.tools
+package dotc
+package core
+package unpickleScala2
+
+
+/** Scala2 flags, adapted from https://github.com/scala/scala/blob/2.11.x/src/reflect/scala/reflect/internal/Flags.scala
+ */
+object Scala2Flags {
+  inline val IMPLICIT      = 1 << 9
+  inline val FINAL         = 1 << 5    // May not be overridden. Note that java final implies much more than scala final.
+  inline val PRIVATE       = 1 << 2
+  inline val PROTECTED     = 1 << 0
+
+  inline val SEALED        = 1 << 10
+  inline val OVERRIDE      = 1 << 1
+  inline val CASE          = 1 << 11
+  inline val ABSTRACT      = 1 << 3        // abstract class, or used in conjunction with abstract override.
+                                          // Note difference to DEFERRED!
+  inline val DEFERRED      = 1 << 4        // was `abstract' for members | trait is virtual
+  inline val INTERFACE     = 1 << 7        // symbol is an interface (i.e. a trait which defines only abstract methods)
+  inline val MUTABLE       = 1 << 12       // symbol is a mutable variable.
+  inline val PARAM         = 1 << 13       // symbol is a (value or type) parameter to a method
+  inline val MACRO         = 1 << 15       // symbol is a macro definition
+
+  inline val COVARIANT     = 1 << 16       // symbol is a covariant type variable
+  inline val BYNAMEPARAM   = 1 << 16       // parameter is by name
+  inline val CONTRAVARIANT = 1 << 17       // symbol is a contravariant type variable
+  inline val ABSOVERRIDE   = 1 << 18       // combination of abstract & override
+  inline val LOCAL         = 1 << 19       // symbol is local to current class (i.e. private[this] or protected
+                                          // pre: PRIVATE or PROTECTED are also set
+  inline val JAVA          = 1 << 20       // symbol was defined by a Java class
+  inline val STATIC        = 1 << 23       // static field, method or class
+  inline val CASEACCESSOR  = 1 << 24       // symbol is a case parameter (or its accessor, or a GADT skolem)
+  inline val TRAIT         = 1 << 25       // symbol is a trait
+  inline val DEFAULTPARAM  = 1 << 25       // the parameter has a default value
+  inline val PARAMACCESSOR = 1 << 29       // for field definitions generated for primary constructor
+                                          //   parameters (no matter if it's a 'val' parameter or not)
+                                          // for parameters of a primary constructor ('val' or not)
+                                          // for the accessor methods generated for 'val' or 'var' parameters
+  inline val LAZY          = 1L << 31      // symbol is a lazy val. can't have MUTABLE unless transformed by typer
+  inline val PRESUPER      = 1L << 37      // value is evaluated before super call
+  inline val DEFAULTINIT   = 1L << 41      // symbol is initialized to the default value: used by -Xcheckinit
+  inline val ARTIFACT      = 1L << 46      // symbol should be ignored when typechecking; will be marked ACC_SYNTHETIC in bytecode
+                                          // to see which symbols are marked as ARTIFACT, see scaladocs for FlagValues.ARTIFACT
+  inline val DEFAULTMETHOD = 1L << 47      // symbol is a java default method
+  inline val ENUM          = 1L << 48      // symbol is an enum
+
+  inline val PrivateLocal   = PRIVATE | LOCAL
+  inline val ProtectedLocal = PROTECTED | LOCAL
+  inline val AccessFlags    = PRIVATE | PROTECTED | LOCAL
+
+  inline val METHOD        = 1 << 6        // a method
+  inline val MODULE        = 1 << 8        // symbol is module or class implementing a module
+  inline val PACKAGE       = 1 << 14       // symbol is a java package
+
+  inline val CAPTURED      = 1 << 16       // variable is accessed from nested function.  Set by LambdaLift.
+  inline val LABEL         = 1 << 17       // method symbol is a label. Set by TailCall
+  inline val INCONSTRUCTOR = 1 << 17       // class symbol is defined in this/superclass constructor.
+  inline val SYNTHETIC     = 1 << 21       // symbol is compiler-generated (compare with ARTIFACT)
+  inline val STABLE        = 1 << 22       // functions that are assumed to be stable
+                                          // (typically, access methods for valdefs)
+                                          // or classes that do not contain abstract types.
+  inline val BRIDGE        = 1 << 26       // function is a bridge method. Set by Erasure
+  inline val ACCESSOR      = 1 << 27       // a value or variable accessor (getter or setter)
+
+  inline val SUPERACCESSOR = 1 << 28       // a super accessor
+  inline val MODULEVAR     = 1 << 30       // for variables: is the variable caching a module value
+
+  inline val IS_ERROR      = 1L << 32      // symbol is an error symbol
+  inline val OVERLOADED    = 1L << 33      // symbol is overloaded
+  inline val LIFTED        = 1L << 34      // class has been lifted out to package level
+                                          // local value has been lifted out to class level
+                                          // todo: make LIFTED = latePRIVATE?
+  inline val MIXEDIN       = 1L << 35      // term member has been mixed in
+  inline val EXISTENTIAL   = 1L << 35      // type is an existential parameter or skolem
+  inline val EXPANDEDNAME  = 1L << 36      // name has been expanded with class suffix
+  inline val TRANS_FLAG    = 1L << 38      // transient flag guaranteed to be reset after each phase.
+
+  inline val LOCKED        = 1L << 39      // temporary flag to catch cyclic dependencies
+  inline val SPECIALIZED   = 1L << 40      // symbol is a generated specialized member
+  inline val VBRIDGE       = 1L << 42      // symbol is a varargs bridge
+
+  inline val VARARGS       = 1L << 43      // symbol is a Java-style varargs method
+  inline val TRIEDCOOKING  = 1L << 44      // `Cooking` has been tried on this symbol
+                                          // A Java method's type is `cooked` by transforming raw types to existentials
+
+  inline val SYNCHRONIZED  = 1L << 45      // symbol is a method which should be marked ACC_SYNCHRONIZED
+
+  inline val IMPLICIT_PKL   = (1 << 0)
+  inline val FINAL_PKL      = (1 << 1)
+  inline val PRIVATE_PKL    = (1 << 2)
+  inline val PROTECTED_PKL  = (1 << 3)
+  inline val SEALED_PKL     = (1 << 4)
+  inline val OVERRIDE_PKL   = (1 << 5)
+  inline val CASE_PKL       = (1 << 6)
+  inline val ABSTRACT_PKL   = (1 << 7)
+  inline val DEFERRED_PKL   = (1 << 8)
+  inline val METHOD_PKL     = (1 << 9)
+  inline val MODULE_PKL     = (1 << 10)
+  inline val INTERFACE_PKL  = (1 << 11)
+}
diff --git a/tests/pos-with-compiler-cc/dotc/core/unpickleScala2/Scala2Unpickler.scala b/tests/pos-with-compiler-cc/dotc/core/unpickleScala2/Scala2Unpickler.scala
new file mode 100644
index 000000000000..561b1eac2391
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/core/unpickleScala2/Scala2Unpickler.scala
@@ -0,0 +1,1381 @@
+package dotty.tools
+package dotc
+package core
+package unpickleScala2
+
+import scala.language.unsafeNulls
+
+import java.io.IOException
+import java.lang.Float.intBitsToFloat
+import java.lang.Double.longBitsToDouble
+
+import Contexts._, Symbols._, Types._, Scopes._, SymDenotations._, Names._, NameOps._
+import StdNames._, Denotations._, NameOps._, Flags._, Constants._, Annotations._, Phases._
+import NameKinds.{Scala2MethodNameKinds, SuperAccessorName, ExpandedName}
+import util.Spans._
+import dotty.tools.dotc.ast.{tpd, untpd}, ast.tpd._
+import ast.untpd.Modifiers
+import backend.sjs.JSDefinitions
+import printing.Texts._
+import printing.Printer
+import io.AbstractFile
+import util.common._
+import util.NoSourcePosition
+import typer.Checking.checkNonCyclic
+import typer.Nullables._
+import transform.SymUtils._
+import PickleBuffer._
+import PickleFormat._
+import Decorators._
+import TypeApplications._
+import classfile.ClassfileParser
+import scala.collection.mutable
+import scala.collection.mutable.ListBuffer
+import scala.annotation.switch
+import reporting._
+import cc.{adaptFunctionTypeUnderPureFuns, adaptByNameArgUnderPureFuns}
+
+object Scala2Unpickler {
+
+  /** Exception thrown if classfile is corrupted */
+  class BadSignature(msg: String) extends RuntimeException(msg)
+
+  case class TempPolyType(tparams: List[TypeSymbol], tpe: Type) extends UncachedGroundType {
+    override def fallbackToText(printer: Printer): Text =
+      "[" ~ printer.dclsText(tparams, ", ") ~ "]" ~ printer.toText(tpe)
+  }
+
+  /** Temporary type for classinfos, will be decomposed on completion of the class */
+  case class TempClassInfoType(parentTypes: List[Type], decls: Scope, clazz: Symbol) extends UncachedGroundType
+
+  /** Convert temp poly type to poly type and leave other types alone. */
+  def translateTempPoly(tp: Type)(using Context): Type = tp match {
+    case TempPolyType(tparams, restpe) =>
+      // This check used to read `owner.isTerm` but that wasn't always correct,
+      // I'm not sure `owner.is(Method)` is 100% correct either but it seems to
+      // work better. See the commit message where this change was introduced
+      // for more information.
+      (if (tparams.head.owner.is(Method)) PolyType else HKTypeLambda)
+        .fromParams(tparams, restpe)
+    case tp => tp
+  }
+
+  def addConstructorTypeParams(denot: SymDenotation)(using Context): Unit = {
+    assert(denot.isConstructor)
+    denot.info = PolyType.fromParams(denot.owner.typeParams, denot.info)
+  }
+
+  def ensureConstructor(cls: ClassSymbol, clsDenot: ClassDenotation, scope: Scope)(using Context): Unit = {
+    if (scope.lookup(nme.CONSTRUCTOR) == NoSymbol) {
+      val constr = newDefaultConstructor(cls)
+      // Scala 2 traits have a constructor iff they have initialization code
+      // In dotc we represent that as !StableRealizable, which is also owner.is(NoInits)
+      if clsDenot.flagsUNSAFE.is(Trait) then
+        constr.setFlag(StableRealizable)
+        clsDenot.setFlag(NoInits)
+      addConstructorTypeParams(constr)
+      cls.enter(constr, scope)
+    }
+  }
+
+  def setClassInfo(denot: ClassDenotation, info: Type, fromScala2: Boolean, selfInfo: Type = NoType)(using Context): Unit = {
+    val cls = denot.classSymbol
+    val (tparams, TempClassInfoType(parents, decls, clazz)) = info match {
+      case TempPolyType(tps, cinfo) => (tps, cinfo)
+      case cinfo => (Nil, cinfo)
+    }: @unchecked
+    val ost =
+      if (selfInfo eq NoType) && denot.is(ModuleClass) then
+        val sourceModule = denot.sourceModule.orElse {
+          // For non-toplevel modules, `sourceModule` won't be set when completing
+          // the module class, we need to go find it ourselves.
+          NamerOps.findModuleBuddy(cls.name.sourceModuleName, denot.owner.info.decls)
+        }
+        denot.owner.thisType.select(sourceModule)
+      else selfInfo
+    val tempInfo = new TempClassInfo(denot.owner.thisType, cls, decls, ost)
+    denot.info = tempInfo // first rough info to avoid CyclicReferences
+    val parents1 = if (parents.isEmpty) defn.ObjectType :: Nil else parents.map(_.dealias)
+    // Adjust parents of the tuple classes and BoxedUnit from the standard library
+    // If from Scala 2, adjust for tuple classes; if not, it's from Java, and adjust for BoxedUnit
+    val normalizedParents =
+      if (fromScala2) defn.adjustForTuple(cls, tparams, parents1)
+      else defn.adjustForBoxedUnit(cls, parents1)
+    for (tparam <- tparams) {
+      val tsym = decls.lookup(tparam.name)
+      if (tsym.exists) tsym.setFlag(TypeParam)
+      else denot.enter(tparam, decls)
+    }
+    if (!denot.flagsUNSAFE.isAllOf(JavaModule)) ensureConstructor(cls, denot, decls)
+
+    val scalacCompanion = denot.classSymbol.scalacLinkedClass
+
+    def registerCompanionPair(module: Symbol, claz: Symbol) = {
+      module.registerCompanion(claz)
+      claz.registerCompanion(module)
+    }
+
+    if (denot.flagsUNSAFE.is(Module))
+      registerCompanionPair(denot.classSymbol, scalacCompanion)
+    else
+      registerCompanionPair(scalacCompanion, denot.classSymbol)
+
+    denot.info = tempInfo.finalized(normalizedParents)
+    denot.ensureTypeParamsInCorrectOrder()
+    defn.patchStdLibClass(denot)
+  }
+}
+
+/** Unpickle symbol table information descending from a class and/or module root
+ *  from an array of bytes.
+ *  @param bytes      bytearray from which we unpickle
+ *  @param classroot  the top-level class which is unpickled, or NoSymbol if inapplicable
+ *  @param moduleroot the top-level module class which is unpickled, or NoSymbol if inapplicable
+ *  @param filename   filename associated with bytearray, only used for error messages
+ */
+class Scala2Unpickler(bytes: Array[Byte], classRoot: ClassDenotation, moduleClassRoot: ClassDenotation)(ictx: Context)
+  extends PickleBuffer(bytes, 0, -1) with ClassfileParser.Embedded {
+
+  def showPickled(): Unit =
+    atReadPos(0, () => {
+      println(s"classRoot = ${classRoot.debugString}, moduleClassRoot = ${moduleClassRoot.debugString}")
+      util.ShowPickled.printFile(this)
+    })
+
+  // print("unpickling "); showPickled() // !!! DEBUG
+
+  import Scala2Unpickler._
+
+  val moduleRoot: SymDenotation = inContext(ictx) { moduleClassRoot.sourceModule.denot }
+  assert(moduleRoot.isTerm)
+
+  checkVersion(using ictx)
+
+  private val loadingMirror = defn(using ictx) // was: mirrorThatLoaded(classRoot)
+
+  /** A map from entry numbers to array offsets */
+  private val index = createIndex
+
+  /** A map from entry numbers to symbols, types, or annotations */
+  private val entries = new Array[AnyRef](index.length)
+
+  /** A map from symbols to their associated `decls` scopes */
+  private val symScopes = mutable.AnyRefMap[Symbol, Scope]()
+
+  /** A mapping from method types to the parameters used in constructing them */
+  private val paramsOfMethodType = new java.util.IdentityHashMap[MethodType, List[Symbol]]
+
+  protected def errorBadSignature(msg: String, original: Option[RuntimeException] = None)(using Context): Nothing = {
+    val ex = new BadSignature(
+      i"""error reading Scala signature of $classRoot from $source:
+         |error occurred at position $readIndex: $msg""")
+    if (ctx.settings.YdebugMissingRefs.value) original.getOrElse(ex).printStackTrace()
+    throw ex
+  }
+
+  protected def handleRuntimeException(ex: RuntimeException)(using Context): Nothing = ex match {
+    case ex: BadSignature => throw ex
+    case _ => errorBadSignature(s"a runtime exception occurred: $ex", Some(ex))
+  }
+
+  def run()(using Context): Unit =
+    try {
+      var i = 0
+      while (i < index.length) {
+        if (entries(i) == null && isSymbolEntry(i)) {
+          val savedIndex = readIndex
+          readIndex = index(i)
+          val sym = readSymbol()
+          if sym.exists then
+            entries(i) = sym
+            sym.infoOrCompleter match {
+              case info: ClassUnpickler => info.init()
+              case _ =>
+            }
+          readIndex = savedIndex
+        }
+        i += 1
+      }
+      // read children last, fix for #3951
+      i = 0
+      while (i < index.length) {
+        if (entries(i) == null) {
+          if (isSymbolAnnotationEntry(i)) {
+            val savedIndex = readIndex
+            readIndex = index(i)
+            readSymbolAnnotation()
+            readIndex = savedIndex
+          }
+          else if (isChildrenEntry(i)) {
+            val savedIndex = readIndex
+            readIndex = index(i)
+            readChildren()
+            readIndex = savedIndex
+          }
+        }
+        i += 1
+      }
+    }
+    catch {
+      case ex: RuntimeException => handleRuntimeException(ex)
+    }
+
+  def source(using Context): AbstractFile = {
+    val f = classRoot.symbol.associatedFile
+    if (f != null) f else moduleClassRoot.symbol.associatedFile
+  }
+
+  private def checkVersion(using Context): Unit = {
+    val major = readNat()
+    val minor = readNat()
+    if (major != MajorVersion || minor > MinorVersion)
+      throw new IOException("Scala signature " + classRoot.fullName +
+        " has wrong version\n expected: " +
+        MajorVersion + "." + MinorVersion +
+        "\n found: " + major + "." + minor +
+        " in " + source)
+  }
+
+  /** The `decls` scope associated with given symbol */
+  protected def symScope(sym: Symbol): Scope = symScopes.getOrElseUpdate(sym, newScope(0))
+
+  /** Does entry represent an (internal) symbol */
+  protected def isSymbolEntry(i: Int)(using Context): Boolean = {
+    val tag = bytes(index(i)).toInt
+    (firstSymTag <= tag && tag <= lastSymTag &&
+      (tag != CLASSsym || !isRefinementSymbolEntry(i)))
+  }
+
+  /** Does entry represent an (internal or external) symbol */
+  protected def isSymbolRef(i: Int): Boolean = {
+    val tag = bytes(index(i))
+    (firstSymTag <= tag && tag <= lastExtSymTag)
+  }
+
+  /** Does entry represent a name? */
+  protected def isNameEntry(i: Int): Boolean = {
+    val tag = bytes(index(i)).toInt
+    tag == TERMname || tag == TYPEname
+  }
+
+  /** Does entry represent a symbol annotation? */
+  protected def isSymbolAnnotationEntry(i: Int): Boolean = {
+    val tag = bytes(index(i)).toInt
+    tag == SYMANNOT
+  }
+
+  /** Does the entry represent children of a symbol? */
+  protected def isChildrenEntry(i: Int): Boolean = {
+    val tag = bytes(index(i)).toInt
+    tag == CHILDREN
+  }
+
+  /** Does entry represent a refinement symbol?
+   *  pre: Entry is a class symbol
+   */
+  protected def isRefinementSymbolEntry(i: Int)(using Context): Boolean = {
+    val savedIndex = readIndex
+    readIndex = index(i)
+    val tag = readByte().toInt
+    assert(tag == CLASSsym)
+
+    readNat(); // read length
+    val result = readNameRef() == tpnme.REFINE_CLASS
+    readIndex = savedIndex
+    result
+  }
+
+  protected def isRefinementClass(sym: Symbol)(using Context): Boolean =
+    sym.name == tpnme.REFINE_CLASS
+
+  protected def isLocal(sym: Symbol)(using Context): Boolean = isUnpickleRoot(sym.topLevelClass)
+
+  protected def isUnpickleRoot(sym: Symbol)(using Context): Boolean = {
+    val d = sym.denot
+    d == moduleRoot || d == moduleClassRoot || d == classRoot
+  }
+
+  /** If entry at <code>i</code> is undefined, define it by performing
+   *  operation <code>op</code> with <code>readIndex at start of i'th
+   *  entry. Restore <code>readIndex</code> afterwards.
+   */
+  protected def at[T <: AnyRef](i: Int, op: () => T): T = {
+    var r = entries(i)
+    if (r eq null) {
+      r = atReadPos(index(i), op)
+      assert(entries(i) eq null, entries(i))
+      entries(i) = r
+    }
+    r.asInstanceOf[T]
+  }
+
+  protected def atReadPos[T](start: Int, op: () => T): T = {
+    val savedIndex = readIndex
+    readIndex = start
+    try op()
+    finally readIndex = savedIndex
+  }
+
+  /** Read a name */
+  protected def readName()(using Context): Name = {
+    val tag = readByte()
+    val len = readNat()
+    tag match {
+      case TERMname => termName(bytes, readIndex, len)
+      case TYPEname => typeName(bytes, readIndex, len)
+      case _ => errorBadSignature("bad name tag: " + tag)
+    }
+  }
+  protected def readTermName()(using Context): TermName = readName().toTermName
+  protected def readTypeName()(using Context): TypeName = readName().toTypeName
+
+  /** Read a symbol */
+  protected def readSymbol()(using Context): Symbol = readDisambiguatedSymbol(alwaysTrue)()
+
+  /** Read a symbol, with possible disambiguation */
+  protected def readDisambiguatedSymbol(p: Symbol => Boolean)()(using Context): Symbol = {
+    val start = indexCoord(readIndex)
+    val tag = readByte()
+    val end = readNat() + readIndex
+    def atEnd = readIndex == end
+
+    def readExtSymbol(): Symbol = {
+      val nameRef = readNameRef()
+      var name = nameRef.decode
+
+      // If the symbol tag is EXTMODCLASSref, then we know that the method names
+      // mangling do not make sense, but in general we don't know what kind of
+      // symbol we're reading at this point, so we don't know which unmanglings
+      // are safe to apply. Empirically, we at least need to unmangle default
+      // getter names, since they're used to encode the default parameters of
+      // annotations, but more might be needed.
+      if (tag != EXTMODCLASSref)
+        name = name.unmangle(Scala2MethodNameKinds)
+
+      val owner = if (atEnd) loadingMirror.RootClass else readSymbolRef()
+
+      def adjust(denot: Denotation) = {
+        val denot1 = denot.disambiguate(p)
+        val sym = denot1.symbol
+        if (denot.exists && !denot1.exists) { // !!!DEBUG
+          val alts = denot.alternatives map (d => s"$d:${d.info}/${d.signature}")
+          System.err.println(s"!!! disambiguation failure: $alts")
+          val members = denot.alternatives.head.symbol.owner.info.decls.toList map (d => s"$d:${d.info}/${d.signature}")
+          System.err.println(s"!!! all members: $members")
+        }
+        if (tag == EXTref) sym else sym.moduleClass
+      }
+
+      def fromName(name: Name): Symbol = name.toTermName match {
+        case nme.ROOT => loadingMirror.RootClass
+        case nme.ROOTPKG => loadingMirror.RootPackage
+        case _ =>
+          def declIn(owner: Symbol) = adjust(owner.info.decl(name))
+          val sym = declIn(owner)
+          if (sym.exists || owner.ne(defn.ObjectClass)) sym else declIn(defn.AnyClass)
+      }
+
+      def slowSearch(name: Name): Symbol =
+        owner.info.decls.find(_.name == name)
+
+      def nestedObjectSymbol: Symbol =
+        // If the owner is overloaded (i.e. a method), it's not possible to select the
+        // right member, so return NoSymbol. This can only happen when unpickling a tree.
+        // the "case Apply" in readTree() takes care of selecting the correct alternative
+        //  after parsing the arguments.
+        //if (owner.isOverloaded)
+        //  return NoSymbol
+
+        if (tag == EXTMODCLASSref) {
+          val module = owner.info.decl(name.toTermName).suchThat(_.is(Module))
+          module.info // force it, as completer does not yet point to module class.
+          module.symbol.moduleClass
+        }
+
+          /* was:
+            val moduleVar = owner.info.decl(name.toTermName.moduleVarName).symbol
+            if (moduleVar.isLazyAccessor)
+              return moduleVar.lazyAccessor.lazyAccessor
+           */
+        else NoSymbol
+
+      // println(s"read ext symbol $name from ${owner.denot.debugString} in ${classRoot.debugString}")  // !!! DEBUG
+
+      // (1) Try name.
+      fromName(name) orElse {
+        // (2) Try with expanded name.  Can happen if references to private
+        // symbols are read from outside: for instance when checking the children
+        // of a class.  See #1722.
+        fromName(name.toTermName.expandedName(owner)) orElse {
+          // (3) Try as a nested object symbol.
+          nestedObjectSymbol orElse {
+            // (4) Call the mirror's "missing" hook.
+            adjust(missingHook(owner, name)) orElse {
+              // println(owner.info.decls.toList.map(_.debugString).mkString("\n  ")) // !!! DEBUG
+              //              }
+              // (5) Create a stub symbol to defer hard failure a little longer.
+              System.err.println(i"***** missing reference, looking for ${name.debugString} in $owner")
+              System.err.println(i"decls = ${owner.info.decls}")
+              owner.info.decls.checkConsistent()
+              if (slowSearch(name).exists)
+                System.err.println(i"**** slow search found: ${slowSearch(name)}")
+              if (ctx.settings.YdebugMissingRefs.value) Thread.dumpStack()
+              newStubSymbol(owner, name, source)
+            }
+          }
+        }
+      }
+    }
+
+    tag match {
+      case NONEsym => return NoSymbol
+      case EXTref | EXTMODCLASSref => return readExtSymbol()
+      case _ =>
+    }
+
+    // symbols that were pickled with Pickler.writeSymInfo
+    val nameref = readNat()
+    var name = at(nameref, () => readName()(using ctx))
+    val owner = readSymbolRef()
+
+    var flags = unpickleScalaFlags(readLongNat(), name.isTypeName)
+
+    if (name eq nme.getClass_) && defn.hasProblematicGetClass(owner.name)
+       // Scala 2 sometimes pickle the same type parameter symbol multiple times
+       // (see i11173 for an example), but we should only unpickle it once.
+       || tag == TYPEsym && flags.is(TypeParam) && symScope(owner).lookup(name.asTypeName).exists
+    then
+      // skip this member
+      return NoSymbol
+
+    name = name.adjustIfModuleClass(flags)
+    if (flags.is(Method))
+      name =
+        if (name == nme.TRAIT_CONSTRUCTOR) nme.CONSTRUCTOR
+        else name.asTermName.unmangle(Scala2MethodNameKinds)
+    if ((flags.is(Scala2ExpandedName))) {
+      name = name.unmangle(ExpandedName)
+      flags = flags &~ Scala2ExpandedName
+    }
+    if (flags.is(Scala2SuperAccessor)) {
+      /* Scala 2 super accessors are pickled as private, but are compiled as public expanded.
+       * Dotty super accessors, however, are already pickled as public expanded.
+       * We bridge the gap right now.
+       */
+      name = name.asTermName.unmangle(SuperAccessorName).expandedName(owner)
+      flags = flags &~ (Scala2SuperAccessor | Private)
+    }
+    name = name.mapLast(_.decode)
+
+    def nameMatches(rootName: Name) = name == rootName
+    def isClassRoot = nameMatches(classRoot.name) && (owner == classRoot.owner) && !flags.is(ModuleClass)
+    def isModuleClassRoot = nameMatches(moduleClassRoot.name) && (owner == moduleClassRoot.owner) && flags.is(Module)
+    def isModuleRoot = nameMatches(moduleClassRoot.name.sourceModuleName) && (owner == moduleClassRoot.owner) && flags.is(Module)
+
+    //if (isClassRoot) println(s"classRoot of $classRoot found at $readIndex, flags = ${flags.flagsString}") // !!! DEBUG
+    //if (isModuleRoot) println(s"moduleRoot of $moduleRoot found at $readIndex, flags = ${flags.flagsString}") // !!! DEBUG
+    //if (isModuleClassRoot) println(s"moduleClassRoot of $moduleClassRoot found at $readIndex, flags = ${flags.flagsString}") // !!! DEBUG
+
+    def completeRoot(denot: ClassDenotation, completer: LazyType, privateWithin: Symbol): Symbol = {
+      denot.setFlag(flags)
+      denot.resetFlag(Touched) // allow one more completion
+
+      // Temporary measure, as long as we do not recompile these traits with Scala 3.
+      // Scala 2 is more aggressive when it comes to defining a $init$ method than Scala 3.
+      // Any concrete definition, even a `def`, causes a trait to receive a $init$ method
+      // to be created, even if it does not do anything, and hence causes not have the NoInits flag.
+      // We override this for Product so that cases classes can be pure.
+      // A full solution requires that we compile Product with Scala 3 in the future.
+      if (owner == defn.ScalaPackageClass && (name eq tpnme.Product))
+        denot.setFlag(NoInits)
+
+      denot.setPrivateWithin(privateWithin)
+      denot.info = completer
+      denot.symbol
+    }
+
+    def finishSym(sym: Symbol): Symbol = {
+      if (sym.isClass)
+        sym.setFlag(Scala2x)
+      if (!(isRefinementClass(sym) || isUnpickleRoot(sym) || sym.is(Scala2Existential))) {
+        val owner = sym.owner
+        val canEnter =
+          owner.isClass &&
+          (!sym.is(TypeParam) ||
+            owner.infoOrCompleter.match
+              case completer: ClassUnpickler =>
+                // Type parameters seen after class initialization are not
+                // actually type parameters of the current class but of some
+                // external class because of the bizarre way in which Scala 2
+                // pickles them (see
+                // https://github.com/scala/scala/blob/aa31e3e6bb945f5d69740d379ede1cd514904109/src/compiler/scala/tools/nsc/symtab/classfile/Pickler.scala#L181-L197).
+                // Make sure we don't enter them in the class otherwise the
+                // compiler will get very confused (testcase in sbt-test/scala2-compat/i12641).
+                // Note: I don't actually know if these stray type parameters
+                // can also show up before initialization, if that's the case
+                // we'll need to study more closely how Scala 2 handles type
+                // parameter unpickling and try to emulate it.
+                !completer.areParamsInitialized
+              case _ =>
+                true)
+
+        if (canEnter)
+          owner.asClass.enter(sym, symScope(owner))
+      }
+      sym
+    }
+
+    val (privateWithin, infoRef) = {
+      val ref = readNat()
+      if (!isSymbolRef(ref))
+        (NoSymbol, ref)
+      else {
+        val pw = at(ref, () => readSymbol())
+        (pw, readNat())
+      }
+    }
+
+    finishSym(tag match {
+      case TYPEsym | ALIASsym =>
+        var name1 = name.asTypeName
+        var flags1 = flags
+        if (flags.is(TypeParam)) flags1 |= owner.typeParamCreationFlags
+        newSymbol(owner, name1, flags1, localMemberUnpickler, privateWithin, coord = start)
+      case CLASSsym =>
+        if (isClassRoot)
+          completeRoot(
+            classRoot, rootClassUnpickler(start, classRoot.symbol, NoSymbol, infoRef), privateWithin)
+        else if (isModuleClassRoot)
+          completeRoot(
+            moduleClassRoot, rootClassUnpickler(start, moduleClassRoot.symbol, moduleClassRoot.sourceModule, infoRef), privateWithin)
+        else {
+          def completer(cls: Symbol) = {
+            val unpickler = new ClassUnpickler(infoRef) withDecls symScope(cls)
+            if (flags.is(ModuleClass))
+              unpickler.withSourceModule(
+                cls.owner.info.decls.lookup(cls.name.sourceModuleName)
+                  .suchThat(_.is(Module)).symbol)
+            else unpickler
+          }
+          newClassSymbol(owner, name.asTypeName, flags, completer, privateWithin, coord = start)
+        }
+      case VALsym =>
+        newSymbol(owner, name.asTermName, flags, localMemberUnpickler, privateWithin, coord = start)
+      case MODULEsym =>
+        if (isModuleRoot) {
+          moduleRoot setFlag flags
+          moduleRoot.symbol
+        } else newSymbol(owner, name.asTermName, flags,
+          new LocalUnpickler().withModuleClass(
+            owner.info.decls.lookup(name.moduleClassName)
+              .suchThat(_.is(Module)).symbol)
+          , privateWithin, coord = start)
+      case _ =>
+        errorBadSignature("bad symbol tag: " + tag)
+    })
+  }
+
+  class LocalUnpickler extends LazyType {
+    def startCoord(denot: SymDenotation): Coord = denot.symbol.coord
+
+    def paramssOfType(tp: Type): List[List[Symbol]] = tp match
+      case TempPolyType(tparams, restpe) => tparams :: paramssOfType(restpe)
+      case mt: MethodType =>
+        val params = paramsOfMethodType.remove(mt)
+        val rest = paramssOfType(mt.resType)
+        if params == null then rest else params :: rest
+      case _ => Nil
+
+    def complete(denot: SymDenotation)(using Context): Unit = try {
+      def parseToCompletion(denot: SymDenotation)(using Context) = {
+        val tag = readByte()
+        val end = readNat() + readIndex
+        def atEnd = readIndex == end
+        val unusedNameref = readNat()
+        val unusedOwnerref = readNat()
+        val unusedFlags = readLongNat()
+
+        var inforef = readNat()
+        if (isSymbolRef(inforef)) inforef = readNat()
+
+        // println("reading type for " + denot) // !!! DEBUG
+        val tp = at(inforef, () => readType()(using ctx))
+        if denot.is(Method) then
+          var params = paramssOfType(tp)
+          if denot.isConstructor && denot.owner.typeParams.nonEmpty then
+            params = denot.owner.typeParams :: params
+          denot.rawParamss = params
+
+        denot match {
+          case denot: ClassDenotation if !isRefinementClass(denot.symbol) =>
+            val selfInfo = if (atEnd) NoType else readTypeRef()
+            setClassInfo(denot, tp, fromScala2 = true, selfInfo)
+            NamerOps.addConstructorProxies(denot.classSymbol)
+          case denot =>
+            val tp1 = translateTempPoly(tp)
+            denot.info =
+              if (tag == ALIASsym) TypeAlias(tp1)
+              else if (denot.isType) checkNonCyclic(denot.symbol, tp1, reportErrors = false)
+                // we need the checkNonCyclic call to insert LazyRefs for F-bounded cycles
+              else if (!denot.is(Param)) tp1.translateFromRepeated(toArray = false)
+              else tp1
+            if (denot.isConstructor)
+              denot.owner.setStableConstructor()
+              addConstructorTypeParams(denot)
+            if (atEnd)
+              assert(!denot.symbol.isSuperAccessor, denot)
+            else {
+              assert(denot.is(ParamAccessor) || denot.symbol.isSuperAccessor, denot)
+              def disambiguate(alt: Symbol) = // !!! DEBUG
+                trace.onDebug(s"disambiguating ${denot.info} =:= ${denot.owner.thisType.memberInfo(alt)} ${denot.owner}") {
+                  denot.info matches denot.owner.thisType.memberInfo(alt)
+                }
+              val alias = readDisambiguatedSymbolRef(disambiguate).asTerm
+              if alias.name == denot.name then denot.setFlag(SuperParamAlias)
+            }
+        }
+        // println(s"unpickled ${denot.debugString}, info = ${denot.info}") !!! DEBUG
+      }
+      atReadPos(startCoord(denot).toIndex,
+          () => withMode(Mode.Scala2Unpickling) {
+            atPhaseBeforeTransforms {
+              parseToCompletion(denot)
+            }
+          })
+    }
+    catch {
+      case ex: RuntimeException => handleRuntimeException(ex)
+    }
+  }
+
+  object localMemberUnpickler extends LocalUnpickler
+
+  class ClassUnpickler(infoRef: Int) extends LocalUnpickler with TypeParamsCompleter {
+    private var myTypeParams: List[TypeSymbol] = null
+
+    private def readTypeParams()(using Context): Unit = {
+      val tag = readByte()
+      val end = readNat() + readIndex
+      myTypeParams =
+        if (tag == POLYtpe) {
+          val unusedRestpeRef = readNat()
+          until(end, () => readSymbolRef()(using ctx)).asInstanceOf[List[TypeSymbol]]
+        } else Nil
+    }
+    private def loadTypeParams()(using Context) =
+      atReadPos(index(infoRef), () => readTypeParams()(using ctx))
+
+    /** Have the type params of this class already been unpickled? */
+    def areParamsInitialized: Boolean = myTypeParams ne null
+
+    /** Force reading type params early, we need them in setClassInfo of subclasses. */
+    def init()(using Context): List[TypeSymbol] =
+      if !areParamsInitialized then loadTypeParams()
+      myTypeParams
+
+    override def completerTypeParams(sym: Symbol)(using Context): List[TypeSymbol] =
+      init()
+  }
+
+  def rootClassUnpickler(start: Coord, cls: Symbol, module: Symbol, infoRef: Int): ClassUnpickler =
+    (new ClassUnpickler(infoRef) with SymbolLoaders.SecondCompleter {
+      override def startCoord(denot: SymDenotation): Coord = start
+    }).withDecls(symScope(cls)).withSourceModule(module)
+
+  /** Convert
+   *    tp { type name = sym } forSome { sym >: L <: H }
+   *  to
+   *    tp { name >: L <: H }
+   *  and
+   *    tp { name: sym } forSome { sym <: T with Singleton }
+   *  to
+   *    tp { name: T }
+   */
+  def elimExistentials(boundSyms: List[Symbol], tp: Type)(using Context): Type = {
+    // Need to be careful not to run into cyclic references here (observed when
+    // compiling t247.scala). That's why we avoid taking `symbol` of a TypeRef
+    // unless names match up.
+    val isBound = { (tp: Type) =>
+      def refersTo(tp: Type, sym: Symbol): Boolean = tp match {
+        case tp: TypeRef => sym.name == tp.name && sym == tp.symbol
+        case tp: TypeVar => refersTo(tp.underlying, sym)
+        case tp : LazyRef => refersTo(tp.ref, sym)
+        case _ => false
+      }
+      boundSyms.exists(refersTo(tp, _))
+    }
+    // Cannot use standard `existsPart` method because it calls `lookupRefined`
+    // which can cause CyclicReference errors.
+    val isBoundAccumulator = new ExistsAccumulator(isBound, StopAt.Static, forceLazy = true):
+      override def foldOver(x: Boolean, tp: Type): Boolean = tp match
+        case tp: TypeRef => applyToPrefix(x, tp)
+        case _ => super.foldOver(x, tp)
+
+    def removeSingleton(tp: Type): Type =
+      if (tp isRef defn.SingletonClass) defn.AnyType else tp
+    def mapArg(arg: Type) = arg match {
+      case arg: TypeRef if isBound(arg) => arg.symbol.info
+      case _ => arg
+    }
+    def elim(tp: Type): Type = tp match {
+      case tp @ RefinedType(parent, name, rinfo) =>
+        val parent1 = elim(tp.parent)
+        rinfo match {
+          case TypeAlias(info: TypeRef) if isBound(info) =>
+            RefinedType(parent1, name, info.symbol.info)
+          case info: TypeRef if isBound(info) =>
+            val info1 = info.symbol.info
+            assert(info1.derivesFrom(defn.SingletonClass))
+            RefinedType(parent1, name, info1.mapReduceAnd(removeSingleton)(_ & _))
+          case info =>
+            tp.derivedRefinedType(parent1, name, info)
+        }
+      case tp @ AppliedType(tycon, args) =>
+        val tycon1 = tycon.safeDealias
+        if (tycon1 ne tycon) elim(tycon1.appliedTo(args))
+        else tp.derivedAppliedType(tycon, args.map(mapArg))
+      case tp: AndOrType =>
+        // scalajs.js.|.UnionOps has a type parameter upper-bounded by `_ | _`
+        tp.derivedAndOrType(mapArg(tp.tp1).bounds.hi, mapArg(tp.tp2).bounds.hi)
+      case _ =>
+        tp
+    }
+    val tp1 = elim(tp)
+    if (isBoundAccumulator(false, tp1)) {
+      val anyTypes = boundSyms map (_ => defn.AnyType)
+      val boundBounds = boundSyms map (_.info.bounds.hi)
+      val tp2 = tp1.subst(boundSyms, boundBounds).subst(boundSyms, anyTypes)
+      report.warning(FailureToEliminateExistential(tp, tp1, tp2, boundSyms, classRoot.symbol), NoSourcePosition)
+      tp2
+    }
+    else tp1
+  }
+
+  /** Read type ref, mapping a TypeRef to a package to the package's ThisType
+   *  Package references should be TermRefs or ThisTypes but it was observed that
+   *  nsc sometimes pickles them as TypeRefs instead.
+   */
+  private def readPrefix()(using Context): Type = readTypeRef() match {
+    case pre: TypeRef if pre.symbol.is(Package) => pre.symbol.thisType
+    case pre => pre
+  }
+
+  /** Read a type
+   *
+   *  @param forceProperType is used to ease the transition to NullaryMethodTypes (commentmarker: NMT_TRANSITION)
+   *        the flag say that a type of kind * is expected, so that PolyType(tps, restpe) can be disambiguated to PolyType(tps, NullaryMethodType(restpe))
+   *        (if restpe is not a ClassInfoType, a MethodType or a NullaryMethodType, which leaves TypeRef/SingletonType -- the latter would make the polytype a type constructor)
+   */
+  protected def readType()(using Context): Type = {
+    def select(pre: Type, sym: Symbol): Type =
+      // structural members need to be selected by name, their symbols are only
+      // valid in the synthetic refinement class that defines them.
+      if !pre.isInstanceOf[ThisType] && isRefinementClass(sym.owner) then pre.select(sym.name) else pre.select(sym)
+
+    val tag = readByte()
+    val end = readNat() + readIndex
+    (tag: @switch) match {
+      case NOtpe =>
+        NoType
+      case NOPREFIXtpe =>
+        NoPrefix
+      case THIStpe =>
+        readSymbolRef().thisType
+      case SINGLEtpe =>
+        val pre = readPrefix()
+        val sym = readDisambiguatedSymbolRef(_.info.isParameterless)
+        select(pre, sym)
+      case SUPERtpe =>
+        val thistpe = readTypeRef()
+        val supertpe = readTypeRef()
+        SuperType(thistpe, supertpe)
+      case CONSTANTtpe =>
+        readConstantRef() match
+          case c: Constant => ConstantType(c)
+          case tp: TermRef => tp
+      case TYPEREFtpe =>
+        var pre = readPrefix()
+        val sym = readSymbolRef()
+        pre match {
+          case thispre: ThisType =>
+            // The problem is that class references super.C get pickled as
+            // this.C. Dereferencing the member might then get an overriding class
+            // instance. The problem arises for instance for LinkedHashMap#MapValues
+            // and also for the inner Transform class in all views. We fix it by
+            // replacing the this with the appropriate super.
+            if (sym.owner != thispre.cls) {
+              val overriding = thispre.cls.info.decls.lookup(sym.name)
+              if (overriding.exists && overriding != sym) {
+                val base = pre.baseType(sym.owner)
+                assert(base.exists)
+                pre = SuperType(thispre, base)
+              }
+            }
+          case NoPrefix if sym.is(TypeParam) =>
+            pre = sym.owner.thisType
+          case _ =>
+        }
+        val tycon = select(pre, sym)
+        val args = until(end, () => readTypeRef())
+        if (sym == defn.ByNameParamClass2x) ExprType(args.head.adaptByNameArgUnderPureFuns)
+        else if (ctx.settings.scalajs.value && args.length == 2 &&
+            sym.owner == JSDefinitions.jsdefn.ScalaJSJSPackageClass && sym == JSDefinitions.jsdefn.PseudoUnionClass) {
+          // Treat Scala.js pseudo-unions as real unions, this requires a
+          // special-case in erasure, see TypeErasure#eraseInfo.
+          OrType(args(0), args(1), soft = false)
+        }
+        else if args.nonEmpty then
+          tycon.safeAppliedTo(EtaExpandIfHK(sym.typeParams, args.map(translateTempPoly)))
+            .adaptFunctionTypeUnderPureFuns
+        else if (sym.typeParams.nonEmpty) tycon.EtaExpand(sym.typeParams)
+        else tycon
+      case TYPEBOUNDStpe =>
+        val lo = readTypeRef()
+        val hi = readTypeRef()
+        createNullableTypeBounds(lo, hi)
+      case REFINEDtpe =>
+        val clazz = readSymbolRef().asClass
+        val decls = symScope(clazz)
+        symScopes(clazz) = EmptyScope // prevent further additions
+        val parents = until(end, () => readTypeRef())
+        val parent = parents.reduceLeft(AndType(_, _))
+        if (decls.isEmpty) parent
+        else {
+          def subst(info: Type, rt: RecType) = info.substThis(clazz.asClass, rt.recThis)
+          def addRefinement(tp: Type, sym: Symbol) = RefinedType(tp, sym.name, sym.info)
+          val refined = decls.toList.foldLeft(parent)(addRefinement)
+          RecType.closeOver(rt => refined.substThis(clazz, rt.recThis))
+        }
+      case CLASSINFOtpe =>
+        val clazz = readSymbolRef()
+        TempClassInfoType(until(end, () => readTypeRef()), symScope(clazz), clazz)
+      case METHODtpe | IMPLICITMETHODtpe =>
+        val restpe = readTypeRef()
+        val params = until(end, () => readSymbolRef())
+        val maker = MethodType.companion(
+          isImplicit = tag == IMPLICITMETHODtpe || params.nonEmpty && params.head.is(Implicit))
+        val result = maker.fromSymbols(params, restpe)
+        result.resType match
+          case restpe1: MethodType if restpe1 ne restpe =>
+            val prevResParams = paramsOfMethodType.remove(restpe)
+            if prevResParams != null then
+              paramsOfMethodType.put(restpe1, prevResParams)
+          case _ =>
+        if params.nonEmpty then paramsOfMethodType.put(result, params)
+        result
+      case POLYtpe =>
+        val restpe = readTypeRef()
+        val typeParams = until(end, () => readSymbolRef())
+        if typeParams.nonEmpty then
+          TempPolyType(typeParams.asInstanceOf[List[TypeSymbol]], restpe.widenExpr)
+        else
+          ExprType(restpe)
+      case EXISTENTIALtpe =>
+        val restpe = readTypeRef()
+        val boundSyms = until(end, () => readSymbolRef())
+        elimExistentials(boundSyms, restpe)
+      case ANNOTATEDtpe =>
+        AnnotatedType.make(readTypeRef(), until(end, () => readAnnotationRef()))
+      case _ =>
+        noSuchTypeTag(tag, end)
+    }
+  }
+
+  def readTypeParams()(using Context): List[Symbol] = {
+    val tag = readByte()
+    val end = readNat() + readIndex
+    if (tag == POLYtpe) {
+      val unusedRestperef = readNat()
+      until(end, () => readSymbolRef())
+    }
+    else Nil
+  }
+
+  def noSuchTypeTag(tag: Int, end: Int)(using Context): Type =
+    errorBadSignature("bad type tag: " + tag)
+
+  /** Read a constant */
+  protected def readConstant()(using Context): Constant | TermRef = {
+    val tag = readByte().toInt
+    val len = readNat()
+    (tag: @switch) match {
+      case LITERALunit => Constant(())
+      case LITERALboolean => Constant(readLong(len) != 0L)
+      case LITERALbyte => Constant(readLong(len).toByte)
+      case LITERALshort => Constant(readLong(len).toShort)
+      case LITERALchar => Constant(readLong(len).toChar)
+      case LITERALint => Constant(readLong(len).toInt)
+      case LITERALlong => Constant(readLong(len))
+      case LITERALfloat => Constant(intBitsToFloat(readLong(len).toInt))
+      case LITERALdouble => Constant(longBitsToDouble(readLong(len)))
+      case LITERALstring => Constant(readNameRef().toString)
+      case LITERALnull => Constant(null)
+      case LITERALclass => Constant(readTypeRef())
+      case LITERALenum => readSymbolRef().termRef
+      case _ => noSuchConstantTag(tag, len)
+    }
+  }
+
+  def noSuchConstantTag(tag: Int, len: Int)(using Context): Constant =
+    errorBadSignature("bad constant tag: " + tag)
+
+  /** Read children and store them into the corresponding symbol.
+   */
+  protected def readChildren()(using Context): Unit = {
+    val tag = readByte()
+    assert(tag == CHILDREN)
+    val end = readNat() + readIndex
+    val target = readSymbolRef()
+    while (readIndex != end) {
+      val start = readIndex
+      readNat() // skip reference for now
+      target.addAnnotation(
+          Annotation.Child.later(atReadPos(start, () => readSymbolRef()), NoSpan))
+    }
+  }
+
+  /* Read a reference to a pickled item */
+  protected def readSymbolRef()(using Context): Symbol = { //OPT inlined from: at(readNat(), readSymbol) to save on closure creation
+    val i = readNat()
+    var r = entries(i)
+    if (r eq null) {
+      val savedIndex = readIndex
+      readIndex = index(i)
+      r = readSymbol()
+      assert(entries(i) eq null, entries(i))
+      entries(i) = r
+      readIndex = savedIndex
+    }
+    r.asInstanceOf[Symbol]
+  }
+
+  protected def readDisambiguatedSymbolRef(p: Symbol => Boolean)(using Context): Symbol =
+    at(readNat(), () => readDisambiguatedSymbol(p)())
+
+  protected def readNameRef()(using Context): Name = at(readNat(), () => readName())
+  protected def readTypeRef()(using Context): Type = at(readNat(), () => readType()) // after the NMT_TRANSITION period, we can leave off the () => ... ()
+  protected def readConstantRef()(using Context): Constant | TermRef = at(readNat(), () => readConstant())
+
+  protected def readTypeNameRef()(using Context): TypeName = readNameRef().toTypeName
+  protected def readTermNameRef()(using Context): TermName = readNameRef().toTermName
+
+  protected def readAnnotationRef()(using Context): Annotation = at(readNat(), () => readAnnotation())
+
+  protected def readModifiersRef(isType: Boolean)(using Context): Modifiers = at(readNat(), () => readModifiers(isType))
+  protected def readTreeRef()(using Context): Tree = at(readNat(), () => readTree())
+
+  /** Read an annotation argument, which is pickled either
+   *  as a Constant or a Tree.
+   */
+  protected def readAnnotArg(i: Int)(using Context): untpd.Tree = untpd.TypedSplice(bytes(index(i)) match
+    case TREE => at(i, () => readTree())
+    case _ => at(i, () =>
+      readConstant() match
+        case c: Constant => Literal(c)
+        case tp: TermRef => ref(tp)
+    )
+  )
+
+  /** Read a ClassfileAnnotArg (argument to a classfile annotation)
+   */
+  private def readArrayAnnotArg()(using Context): untpd.Tree = {
+    readByte() // skip the `annotargarray` tag
+    val end = readNat() + readIndex
+    // array elements are trees representing instances of scala.annotation.Annotation
+    untpd.JavaSeqLiteral(
+      until(end, () => readClassfileAnnotArg(readNat())),
+      untpd.TypeTree())
+  }
+
+  private def readAnnotInfoArg()(using Context): untpd.Tree = untpd.TypedSplice {
+    readByte() // skip the `annotinfo` tag
+    val end = readNat() + readIndex
+    readAnnotationContents(end)
+  }
+
+  protected def readClassfileAnnotArg(i: Int)(using Context): untpd.Tree = bytes(index(i)) match {
+    case ANNOTINFO => at(i, () => readAnnotInfoArg())
+    case ANNOTARGARRAY => at(i, () => readArrayAnnotArg())
+    case _ => readAnnotArg(i)
+  }
+
+  /** Read an annotation's contents. Not to be called directly, use
+   *  readAnnotation, readSymbolAnnotation, or readAnnotInfoArg
+   */
+  protected def readAnnotationContents(end: Int)(using Context): Tree = {
+    val atp = readTypeRef()
+    val args = {
+      val t = new ListBuffer[untpd.Tree]
+
+      while (readIndex != end) {
+        val argref = readNat()
+        t += {
+          if (isNameEntry(argref)) {
+            val name = at(argref, () => readName())
+            val arg = readClassfileAnnotArg(readNat())
+            untpd.NamedArg(name.asTermName, arg)
+          }
+          else readAnnotArg(argref)
+        }
+      }
+      t.toList
+    }
+    untpd.resolveConstructor(atp, args)
+  }
+
+  /** Read an annotation and as a side effect store it into
+   *  the symbol it requests. Called at top-level, for all
+   *  (symbol, annotInfo) entries.
+   */
+  protected def readSymbolAnnotation()(using Context): Unit = {
+    val tag = readByte()
+    if (tag != SYMANNOT)
+      errorBadSignature("symbol annotation expected (" + tag + ")")
+    val end = readNat() + readIndex
+    val target = readSymbolRef()
+    target.addAnnotation(deferredAnnot(end))
+  }
+
+  /** Read an annotation and return it. Used when unpickling
+   *  an ANNOTATED(WSELF)tpe or a NestedAnnotArg
+   */
+  protected def readAnnotation()(using Context): Annotation = {
+    val tag = readByte()
+    if (tag != ANNOTINFO)
+      errorBadSignature("annotation expected (" + tag + ")")
+    val end = readNat() + readIndex
+    deferredAnnot(end)
+  }
+
+  /** A deferred annotation that can be completed by reading
+   *  the bytes between `readIndex` and `end`.
+   */
+  protected def deferredAnnot(end: Int)(using Context): Annotation = {
+    val start = readIndex
+    val phase = ctx.phase
+    Annotation.deferredSymAndTree(
+        atReadPos(start, () => atPhase(phase)(readTypeRef().typeSymbol)))(
+        atReadPos(start, () => atPhase(phase)(readAnnotationContents(end))))
+  }
+
+  /* Read an abstract syntax tree */
+  protected def readTree()(using Context): Tree = {
+    val outerTag = readByte()
+    if (outerTag != TREE)
+      errorBadSignature("tree expected (" + outerTag + ")")
+    val end = readNat() + readIndex
+    val tag = readByte()
+    val tpe = if (tag == EMPTYtree) NoType else readTypeRef()
+
+    // Set by the three functions to follow.  If symbol is non-null
+    // after the new tree 't' has been created, t has its Symbol
+    // set to symbol; and it always has its Type set to tpe.
+    var symbol: Symbol = null
+    var mods: Modifiers = null
+    var name: Name = null
+
+    /** Read a Symbol, Modifiers, and a Name */
+    def setSymModsName(): Unit = {
+      symbol = readSymbolRef()
+      mods = readModifiersRef(symbol.isType)
+      name = readNameRef()
+    }
+    /** Read a Symbol and a Name */
+    def setSymName(): Unit = {
+      symbol = readSymbolRef()
+      name = readNameRef()
+    }
+    /** Read a Symbol */
+    def setSym(): Unit =
+      symbol = readSymbolRef()
+
+    implicit val span: Span = NoSpan
+
+    tag match {
+      case EMPTYtree =>
+        EmptyTree
+
+      case PACKAGEtree =>
+        setSym()
+        val pid = readTreeRef().asInstanceOf[RefTree]
+        val stats = until(end, () => readTreeRef())
+        PackageDef(pid, stats)
+
+      case CLASStree =>
+        setSymModsName()
+        val impl = readTemplateRef()
+        val tparams = until(end, () => readTypeDefRef())
+        val cls = symbol.asClass
+        val ((constr: DefDef) :: Nil, stats) =
+          impl.body.partition(_.symbol == cls.primaryConstructor): @unchecked
+        ClassDef(cls, constr, tparams ++ stats)
+
+      case MODULEtree =>
+        setSymModsName()
+        ModuleDef(symbol.asTerm, readTemplateRef().body)
+
+      case VALDEFtree =>
+        setSymModsName()
+        val tpt = readTreeRef()
+        val rhs = readTreeRef()
+        ValDef(symbol.asTerm, rhs)
+
+      case DEFDEFtree =>
+        setSymModsName()
+        val tparams = times(readNat(), () => readTypeDefRef())
+        val vparamss = times(readNat(), () => times(readNat(), () => readValDefRef()))
+        val tpt = readTreeRef()
+        val rhs = readTreeRef()
+        DefDef(symbol.asTerm, rhs)
+
+      case TYPEDEFtree =>
+        setSymModsName()
+        val rhs = readTreeRef()
+        val tparams = until(end, () => readTypeDefRef())
+        TypeDef(symbol.asType)
+
+      case LABELtree =>
+        ???
+        setSymName()
+        val rhs = readTreeRef()
+        val params = until(end, () => readIdentRef())
+        val ldef = DefDef(symbol.asTerm, rhs)
+        def isCaseLabel(sym: Symbol) = sym.name.startsWith(nme.CASEkw.toString)
+        if (isCaseLabel(symbol)) ldef
+        else Block(ldef :: Nil, Apply(Ident(symbol.termRef), Nil))
+
+      case IMPORTtree =>
+        setSym()
+        val expr = readTreeRef()
+        val selectors = until(end, () => {
+          val fromName = readNameRef()
+          val toName = readNameRef()
+          untpd.ImportSelector(
+            untpd.Ident(fromName),
+            if toName.isEmpty then EmptyTree else untpd.Ident(toName))
+        })
+        Import(expr, selectors)
+
+      case TEMPLATEtree =>
+        setSym()
+        val parents = times(readNat(), () => readTreeRef())
+        val self = readValDefRef()
+        val body = until(end, () => readTreeRef())
+        untpd.Template(???, parents, Nil, self, body) // !!! TODO: pull out primary constructor
+          .withType(symbol.namedType)
+
+      case BLOCKtree =>
+        val expr = readTreeRef()
+        val stats = until(end, () => readTreeRef())
+        Block(stats, expr)
+
+      case CASEtree =>
+        val pat = readTreeRef()
+        val guard = readTreeRef()
+        val body = readTreeRef()
+        CaseDef(pat, guard, body)
+
+      case ALTERNATIVEtree =>
+        Alternative(until(end, () => readTreeRef()))
+
+      case STARtree =>
+        readTreeRef()
+        unimplementedTree("STAR")
+
+      case BINDtree =>
+        setSymName()
+        Bind(symbol.asTerm, readTreeRef())
+
+      case UNAPPLYtree =>
+        val fun = readTreeRef()
+        val args = until(end, () => readTreeRef())
+        UnApply(fun, Nil, args, defn.AnyType) // !!! this is wrong in general
+
+      case ARRAYVALUEtree =>
+        val elemtpt = readTreeRef()
+        val trees = until(end, () => readTreeRef())
+        SeqLiteral(trees, elemtpt)
+          // note can't deal with trees passed to Java methods as arrays here
+
+      case FUNCTIONtree =>
+        setSym()
+        val body = readTreeRef()
+        val vparams = until(end, () => readValDefRef())
+        val applyType = MethodType(vparams map (_.name), vparams map (_.tpt.tpe), body.tpe)
+        val applyMeth = newSymbol(symbol.owner, nme.apply, Method, applyType)
+        Closure(applyMeth, Function.const(body.changeOwner(symbol, applyMeth)) _)
+
+      case ASSIGNtree =>
+        val lhs = readTreeRef()
+        val rhs = readTreeRef()
+        Assign(lhs, rhs)
+
+      case IFtree =>
+        val cond = readTreeRef()
+        val thenp = readTreeRef()
+        val elsep = readTreeRef()
+        If(cond, thenp, elsep)
+
+      case MATCHtree =>
+        val selector = readTreeRef()
+        val cases = until(end, () => readCaseDefRef())
+        Match(selector, cases)
+
+      case RETURNtree =>
+        setSym()
+        Return(readTreeRef(), Ident(symbol.termRef))
+
+      case TREtree =>
+        val block = readTreeRef()
+        val finalizer = readTreeRef()
+        val catches = until(end, () => readCaseDefRef())
+        Try(block, catches, finalizer)
+
+      case THROWtree =>
+        Throw(readTreeRef())
+
+      case NEWtree =>
+        New(readTreeRef().tpe)
+
+      case TYPEDtree =>
+        val expr = readTreeRef()
+        val tpt = readTreeRef()
+        Typed(expr, tpt)
+
+      case TYPEAPPLYtree =>
+        val fun = readTreeRef()
+        val args = until(end, () => readTreeRef())
+        TypeApply(fun, args)
+
+      case APPLYtree =>
+        val fun = readTreeRef()
+        val args = until(end, () => readTreeRef())
+        /*
+          if (fun.symbol.isOverloaded) {
+            fun.setType(fun.symbol.info)
+            inferMethodAlternative(fun, args map (_.tpe), tpe)
+          }
+*/
+        Apply(fun, args) // note: can't deal with overloaded syms yet
+
+      case APPLYDYNAMICtree =>
+        setSym()
+        val qual = readTreeRef()
+        val args = until(end, () => readTreeRef())
+        unimplementedTree("APPLYDYNAMIC")
+
+      case SUPERtree =>
+        setSym()
+        val qual = readTreeRef()
+        val mix = readTypeNameRef()
+        Super(qual, mix)
+
+      case THIStree =>
+        setSym()
+        val name = readTypeNameRef()
+        This(symbol.asClass)
+
+      case SELECTtree =>
+        setSym()
+        val qualifier = readTreeRef()
+        val selector = readNameRef()
+        qualifier.select(symbol.namedType)
+      case IDENTtree =>
+        setSymName()
+        Ident(symbol.namedType)
+
+      case LITERALtree =>
+        readConstantRef() match
+          case c: Constant => Literal(c)
+          case tp: TermRef => ref(tp)
+
+      case TYPEtree =>
+        TypeTree(tpe)
+
+      case ANNOTATEDtree =>
+        val annot = readTreeRef()
+        val arg = readTreeRef()
+        Annotated(arg, annot)
+
+      case SINGLETONTYPEtree =>
+        SingletonTypeTree(readTreeRef())
+
+      case SELECTFROMTYPEtree =>
+        val qualifier = readTreeRef()
+        val selector = readTypeNameRef()
+        Select(qualifier, symbol.namedType)
+
+      case COMPOUNDTYPEtree =>
+        readTemplateRef()
+        TypeTree(tpe)
+
+      case APPLIEDTYPEtree =>
+        val tpt = readTreeRef()
+        val args = until(end, () => readTreeRef())
+        AppliedTypeTree(tpt, args)
+
+      case TYPEBOUNDStree =>
+        val lo = readTreeRef()
+        val hi = readTreeRef()
+        createNullableTypeBoundsTree(lo, hi)
+
+      case EXISTENTIALTYPEtree =>
+        val tpt = readTreeRef()
+        val whereClauses = until(end, () => readTreeRef())
+        TypeTree(tpe)
+
+      case _ =>
+        noSuchTreeTag(tag, end)
+    }
+  }
+
+  def noSuchTreeTag(tag: Int, end: Int)(using Context): Nothing =
+    errorBadSignature("unknown tree type (" + tag + ")")
+
+  def unimplementedTree(what: String)(using Context): Nothing =
+    errorBadSignature(s"cannot read $what trees from Scala 2.x signatures")
+
+  def readModifiers(isType: Boolean)(using Context): Modifiers = {
+    val tag = readNat()
+    if (tag != MODIFIERS)
+      errorBadSignature("expected a modifiers tag (" + tag + ")")
+    val end = readNat() + readIndex
+    val pflagsHi = readNat()
+    val pflagsLo = readNat()
+    val pflags = (pflagsHi.toLong << 32) + pflagsLo
+    val flags = unpickleScalaFlags(pflags, isType)
+    val privateWithin = readNameRef().asTypeName
+    Modifiers(flags, privateWithin, Nil)
+  }
+
+  protected def readTemplateRef()(using Context): Template =
+    readTreeRef() match {
+      case templ: Template => templ
+      case other =>
+        errorBadSignature("expected a template (" + other + ")")
+    }
+  protected def readCaseDefRef()(using Context): CaseDef =
+    readTreeRef() match {
+      case tree: CaseDef => tree
+      case other =>
+        errorBadSignature("expected a case def (" + other + ")")
+    }
+  protected def readValDefRef()(using Context): ValDef =
+    readTreeRef() match {
+      case tree: ValDef => tree
+      case other =>
+        errorBadSignature("expected a ValDef (" + other + ")")
+    }
+  protected def readIdentRef()(using Context): Ident =
+    readTreeRef() match {
+      case tree: Ident => tree
+      case other =>
+        errorBadSignature("expected an Ident (" + other + ")")
+    }
+  protected def readTypeDefRef()(using Context): TypeDef =
+    readTreeRef() match {
+      case tree: TypeDef => tree
+      case other =>
+        errorBadSignature("expected an TypeDef (" + other + ")")
+    }
+}
diff --git a/tests/pos-with-compiler-cc/dotc/coverage/Coverage.scala b/tests/pos-with-compiler-cc/dotc/coverage/Coverage.scala
new file mode 100644
index 000000000000..e41bfcd5d09a
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/coverage/Coverage.scala
@@ -0,0 +1,26 @@
+package dotty.tools.dotc
+package coverage
+
+import scala.collection.mutable
+
+/** Holds a list of statements to include in the coverage reports. */
+class Coverage:
+  private val statementsById = new mutable.LongMap[Statement](256)
+
+  def statements: Iterable[Statement] = statementsById.values
+
+  def addStatement(stmt: Statement): Unit = statementsById(stmt.id) = stmt
+
+/** A statement that can be invoked, and thus counted as "covered" by code coverage tools. */
+case class Statement(
+    location: Location,
+    id: Int,
+    start: Int,
+    end: Int,
+    line: Int,
+    desc: String,
+    symbolName: String,
+    treeName: String,
+    branch: Boolean,
+    ignored: Boolean = false
+)
\ No newline at end of file
diff --git a/tests/pos-with-compiler-cc/dotc/coverage/Location.scala b/tests/pos-with-compiler-cc/dotc/coverage/Location.scala
new file mode 100644
index 000000000000..c565c2bb1116
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/coverage/Location.scala
@@ -0,0 +1,50 @@
+package dotty.tools.dotc
+package coverage
+
+import ast.tpd._
+import dotty.tools.dotc.core.Contexts.Context
+import dotty.tools.dotc.core.Flags.*
+import java.nio.file.Path
+import dotty.tools.dotc.util.SourceFile
+
+/** Information about the location of a coverable piece of code.
+  *
+  * @param packageName    name of the enclosing package
+  * @param className      name of the closest enclosing class
+  * @param fullClassName  fully qualified name of the closest enclosing class
+  * @param classType      "type" of the closest enclosing class: Class, Trait or Object
+  * @param method         name of the closest enclosing method
+  * @param sourcePath     absolute path of the source file
+  */
+final case class Location(
+    packageName: String,
+    className: String,
+    fullClassName: String,
+    classType: String,
+    methodName: String,
+    sourcePath: Path
+)
+
+object Location:
+  /** Extracts the location info of a Tree. */
+  def apply(tree: Tree, source: SourceFile)(using ctx: Context): Location =
+
+    val ownerDenot = ctx.owner.denot
+    val enclosingClass = ownerDenot.enclosingClass
+    val packageName = ownerDenot.enclosingPackageClass.fullName.toSimpleName.toString
+    val className = enclosingClass.name.toSimpleName.toString
+    val methodName = ownerDenot.enclosingMethod.name.toSimpleName.toString
+
+    val classType: String =
+      if enclosingClass.is(Trait) then "Trait"
+      else if enclosingClass.is(ModuleClass) then "Object"
+      else "Class"
+
+    Location(
+      packageName,
+      className,
+      s"$packageName.$className",
+      classType,
+      methodName,
+      source.file.absolute.jpath
+    )
diff --git a/tests/pos-with-compiler-cc/dotc/coverage/Serializer.scala b/tests/pos-with-compiler-cc/dotc/coverage/Serializer.scala
new file mode 100644
index 000000000000..26efa8934e00
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/coverage/Serializer.scala
@@ -0,0 +1,111 @@
+package dotty.tools.dotc
+package coverage
+
+import java.nio.file.{Path, Paths, Files}
+import java.io.Writer
+import scala.language.unsafeNulls
+import scala.collection.mutable.StringBuilder
+
+/**
+ * Serializes scoverage data.
+ * @see https://github.com/scoverage/scalac-scoverage-plugin/blob/main/scalac-scoverage-plugin/src/main/scala/scoverage/Serializer.scala
+ */
+object Serializer:
+
+  private val CoverageFileName = "scoverage.coverage"
+  private val CoverageDataFormatVersion = "3.0"
+
+  /** Write out coverage data to the given data directory, using the default coverage filename */
+  def serialize(coverage: Coverage, dataDir: String, sourceRoot: String): Unit =
+    serialize(coverage, Paths.get(dataDir, CoverageFileName).toAbsolutePath, Paths.get(sourceRoot).toAbsolutePath)
+
+  /** Write out coverage data to a file. */
+  def serialize(coverage: Coverage, file: Path, sourceRoot: Path): Unit =
+    val writer = Files.newBufferedWriter(file)
+    try
+      serialize(coverage, writer, sourceRoot)
+    finally
+      writer.close()
+
+  /** Write out coverage data (info about each statement that can be covered) to a writer.
+   */
+  def serialize(coverage: Coverage, writer: Writer, sourceRoot: Path): Unit =
+
+    def getRelativePath(filePath: Path): String =
+      // We need to normalize the path here because the relativizing paths containing '.' or '..' differs between Java versions
+      // https://bugs.openjdk.java.net/browse/JDK-8066943
+      val relPath = sourceRoot.normalize.relativize(filePath)
+      relPath.toString
+
+    def writeHeader(writer: Writer): Unit =
+      writer.write(s"""# Coverage data, format version: $CoverageDataFormatVersion
+                      |# Statement data:
+                      |# - id
+                      |# - source path
+                      |# - package name
+                      |# - class name
+                      |# - class type (Class, Object or Trait)
+                      |# - full class name
+                      |# - method name
+                      |# - start offset
+                      |# - end offset
+                      |# - line number
+                      |# - symbol name
+                      |# - tree name
+                      |# - is branch
+                      |# - invocations count
+                      |# - is ignored
+                      |# - description (can be multi-line)
+                      |# '\f' sign
+                      |# ------------------------------------------
+                      |""".stripMargin)
+
+    def writeStatement(stmt: Statement, writer: Writer): Unit =
+      // Note: we write 0 for the count because we have not measured the actual coverage at this point
+      writer.write(s"""${stmt.id}
+                      |${getRelativePath(stmt.location.sourcePath).escaped}
+                      |${stmt.location.packageName.escaped}
+                      |${stmt.location.className.escaped}
+                      |${stmt.location.classType}
+                      |${stmt.location.fullClassName.escaped}
+                      |${stmt.location.methodName.escaped}
+                      |${stmt.start}
+                      |${stmt.end}
+                      |${stmt.line}
+                      |${stmt.symbolName.escaped}
+                      |${stmt.treeName}
+                      |${stmt.branch}
+                      |0
+                      |${stmt.ignored}
+                      |${stmt.desc.escaped}
+                      |\f
+                      |""".stripMargin)
+
+    writeHeader(writer)
+    coverage.statements.toSeq
+      .sortBy(_.id)
+      .foreach(stmt => writeStatement(stmt, writer))
+
+  /** Makes a String suitable for output in the coverage statement data as a single line.
+   * Escaped characters: '\\' (backslash), '\n', '\r', '\f'
+   */
+  extension (str: String) def escaped: String =
+    val builder = StringBuilder(str.length)
+    var i = 0
+    while
+      i < str.length
+    do
+      str.charAt(i) match
+        case '\\' =>
+          builder ++= "\\\\"
+        case '\n' =>
+          builder ++= "\\n"
+        case '\r' =>
+          builder ++= "\\r"
+        case '\f' =>
+          builder ++= "\\f"
+        case c =>
+          builder += c
+      i += 1
+    end while
+    builder.result()
diff --git a/tests/pos-with-compiler-cc/dotc/decompiler/DecompilationPrinter.scala b/tests/pos-with-compiler-cc/dotc/decompiler/DecompilationPrinter.scala
new file mode 100644
index 000000000000..85a56b9f1d15
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/decompiler/DecompilationPrinter.scala
@@ -0,0 +1,48 @@
+package dotty.tools.dotc
+package decompiler
+
+import scala.language.unsafeNulls
+
+import java.io.{OutputStream, PrintStream}
+import java.nio.charset.StandardCharsets
+
+import scala.io.Codec
+
+import dotty.tools.dotc.core.Contexts._
+import dotty.tools.dotc.core.Phases.Phase
+import dotty.tools.io.File
+
+import scala.quoted.runtime.impl.QuotesImpl
+
+/** Phase that prints the trees in all loaded compilation units.
+ *
+ *  @author Nicolas Stucki
+ */
+class DecompilationPrinter extends Phase {
+
+  override def phaseName: String = "decompilationPrinter"
+
+  override def run(using Context): Unit =
+    if (ctx.settings.outputDir.isDefault) printToOutput(System.out)
+    else {
+      val outputDir = ctx.settings.outputDir.value
+      var os: OutputStream = null
+      var ps: PrintStream = null
+      try {
+        os = File(outputDir.fileNamed("decompiled.scala").path)(Codec.UTF8).outputStream(append = true)
+        ps = new PrintStream(os, /* autoFlush = */ false, StandardCharsets.UTF_8.name)
+        printToOutput(ps)
+      }
+      finally {
+        if (os ne null) os.close()
+        if (ps ne null) ps.close()
+      }
+    }
+
+  private def printToOutput(out: PrintStream)(using Context): Unit = {
+    val unit = ctx.compilationUnit
+    val unitFile = unit.source.toString.replace("\\", "/").replace(".class", ".tasty")
+    out.println(s"/** Decompiled from $unitFile */")
+    out.println(QuotesImpl.showDecompiledTree(unit.tpdTree))
+  }
+}
diff --git a/tests/pos-with-compiler-cc/dotc/decompiler/IDEDecompilerDriver.scala b/tests/pos-with-compiler-cc/dotc/decompiler/IDEDecompilerDriver.scala
new file mode 100644
index 000000000000..5bf526bd4bdd
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/decompiler/IDEDecompilerDriver.scala
@@ -0,0 +1,50 @@
+package dotty.tools
+package dotc
+package decompiler
+
+import scala.language.unsafeNulls
+
+import dotty.tools.dotc.core.Contexts._
+import dotty.tools.dotc.core._
+import dotty.tools.dotc.core.tasty.TastyHTMLPrinter
+import dotty.tools.dotc.reporting._
+import dotty.tools.io.AbstractFile
+
+import scala.quoted.runtime.impl.QuotesImpl
+import caps.unsafe.unsafeUnbox
+
+/**
+  * Decompiler to be used with IDEs
+  */
+class IDEDecompilerDriver(val settings: List[String]) extends dotc.Driver {
+
+  private val myInitCtx: Context = {
+    val rootCtx = initCtx.fresh.addMode(Mode.Interactive | Mode.ReadPositions)
+    rootCtx.setSetting(rootCtx.settings.YreadComments, true)
+    rootCtx.setSetting(rootCtx.settings.YretainTrees, true)
+    rootCtx.setSetting(rootCtx.settings.fromTasty, true)
+    val ctx = setup(settings.toArray :+ "dummy.scala", rootCtx).get._2
+    ctx.initialize()(using ctx)
+    ctx
+  }
+
+  private val decompiler = new PartialTASTYDecompiler
+
+  def run(tastyFile: AbstractFile): (String, String) = {
+    val reporter = new StoreReporter(null) with HideNonSensicalMessages
+
+    val run = decompiler.newRun(using myInitCtx.fresh.setReporter(reporter))
+
+    inContext(run.runContext) {
+      run.compile(List(tastyFile))
+      run.printSummary()
+      val unit = ctx.run.nn.units.head
+
+      val decompiled = QuotesImpl.showDecompiledTree(unit.tpdTree)
+      val tree = new TastyHTMLPrinter(unit.pickled.head._2.unsafeUnbox()).showContents()
+
+      reporter.removeBufferedMessages.foreach(message => System.err.println(message))
+      (tree, decompiled)
+    }
+  }
+}
diff --git a/tests/pos-with-compiler-cc/dotc/decompiler/Main.scala b/tests/pos-with-compiler-cc/dotc/decompiler/Main.scala
new file mode 100644
index 000000000000..3cc94f782793
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/decompiler/Main.scala
@@ -0,0 +1,27 @@
+package dotty.tools.dotc.decompiler
+
+import java.nio.file.Files
+
+import dotty.tools.dotc
+import dotty.tools.dotc.core.Contexts._
+import dotty.tools.io.AbstractFile
+
+/** Main class of the `dotc -decompiler` decompiler.
+ *
+ * @author Nicolas Stucki
+ */
+object Main extends dotc.Driver {
+  override protected def newCompiler(using Context): dotc.Compiler = {
+    assert(ctx.settings.fromTasty.value)
+    if (!ctx.settings.outputDir.isDefault)
+      Files.deleteIfExists(ctx.settings.outputDir.value.fileNamed("decompiled.scala").jpath)
+    new TASTYDecompiler
+  }
+
+  override def setup(args0: Array[String], rootCtx: Context): Option[(List[AbstractFile], Context)] = {
+    var args = args0.filter(a => a != "-decompile")
+    if (!args.contains("-from-tasty")) args = "-from-tasty" +: args
+    if (args.contains("-d")) args = "-color:never" +: args
+    super.setup(args, rootCtx)
+  }
+}
diff --git a/tests/pos-with-compiler-cc/dotc/decompiler/PartialTASTYDecompiler.scala b/tests/pos-with-compiler-cc/dotc/decompiler/PartialTASTYDecompiler.scala
new file mode 100644
index 000000000000..62bf158d0ef6
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/decompiler/PartialTASTYDecompiler.scala
@@ -0,0 +1,11 @@
+package dotty.tools.dotc.decompiler
+
+import dotty.tools.dotc.core.Phases.Phase
+
+/** Partial TASTYDecompiler that doesn't execute the backendPhases
+  * allowing to control decompiler output by manually running it
+  * on the CompilationUnits
+ */
+class PartialTASTYDecompiler extends TASTYDecompiler {
+  override protected def backendPhases: List[List[Phase]] = Nil
+}
diff --git a/tests/pos-with-compiler-cc/dotc/decompiler/TASTYDecompiler.scala b/tests/pos-with-compiler-cc/dotc/decompiler/TASTYDecompiler.scala
new file mode 100644
index 000000000000..62f3e75d2001
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/decompiler/TASTYDecompiler.scala
@@ -0,0 +1,23 @@
+package dotty.tools.dotc.decompiler
+
+import dotty.tools.dotc.fromtasty._
+import dotty.tools.dotc.core.Phases.Phase
+
+/** Compiler from tasty to user readable high text representation
+ *  of the compiled scala code.
+ *
+ * @author Nicolas Stucki
+ */
+class TASTYDecompiler extends TASTYCompiler {
+
+  override protected def frontendPhases: List[List[Phase]] =
+    List(new ReadTasty) :: // Load trees from TASTY files
+    Nil
+
+  override protected def picklerPhases: List[List[Phase]] = Nil
+  override protected def transformPhases: List[List[Phase]] = Nil
+
+  override protected def backendPhases: List[List[Phase]] =
+    List(new DecompilationPrinter) ::  // Print all loaded classes
+    Nil
+}
diff --git a/tests/pos-with-compiler-cc/dotc/fromtasty/AlreadyLoadedCompilationUnit.scala b/tests/pos-with-compiler-cc/dotc/fromtasty/AlreadyLoadedCompilationUnit.scala
new file mode 100644
index 000000000000..74c680bda1b7
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/fromtasty/AlreadyLoadedCompilationUnit.scala
@@ -0,0 +1,10 @@
+package dotty.tools.dotc.fromtasty
+
+import dotty.tools.dotc.CompilationUnit
+import dotty.tools.dotc.util.NoSource
+
+/** A marker CompilationUnit to return up the call stack from ReadTasty.  This will tell us that we've
+ *  encountered, and attempted to inspect, something that has already been loaded, for example a Scala primitive or a
+ *  library class like Option.
+ */
+class AlreadyLoadedCompilationUnit(val className: String) extends CompilationUnit(NoSource)
diff --git a/tests/pos-with-compiler-cc/dotc/fromtasty/Debug.scala b/tests/pos-with-compiler-cc/dotc/fromtasty/Debug.scala
new file mode 100644
index 000000000000..979fae239e59
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/fromtasty/Debug.scala
@@ -0,0 +1,74 @@
+package dotty.tools
+package dotc
+package fromtasty
+
+import scala.language.unsafeNulls
+
+import scala.util.control.NonFatal
+
+import dotty.tools.io.Directory
+
+import java.io.{File => JFile}
+import java.nio.file.{Files, Paths}
+
+object Debug {
+  def main(args: Array[String]): Unit = {
+    // Preload scala.util.control.NonFatal. Otherwise, when trying to catch a StackOverflowError,
+    // we may try to load it but fail with another StackOverflowError and lose the original exception,
+    // see <https://groups.google.com/forum/#!topic/scala-user/kte6nak-zPM>.
+    val _ = NonFatal
+
+    assert(!args.contains("-d"))
+
+    val outPath = Paths.get("out")
+    Directory(outPath).createDirectory()
+
+    val tmpOut = Files.createTempDirectory(outPath.toAbsolutePath, "from-tasty-tmp")
+
+    val fromSourcesOut = Files.createDirectory(tmpOut.resolve("from-source"))
+
+    println("Compiling from .scala sources")
+    val compilation1 = dotc.Main.process("-d" +: fromSourcesOut.toString +: args)
+
+    if (compilation1.hasErrors) {
+      println("Failed compilation from sources")
+      Directory(tmpOut).deleteRecursively()
+      sys.exit(1)
+    }
+
+    val fromTastyOut = Files.createDirectory(tmpOut.resolve("from-tasty"))
+
+    val tastyFiles =
+      Directory(fromSourcesOut).walk
+        .filter(x => x.isFile && "tasty".equalsIgnoreCase(x.extension))
+        .map(_.toString)
+        .toList
+
+    val fromTastyArgs =
+      "-from-tasty" ::
+      "-d" :: fromTastyOut.toString ::
+      insertClasspathInArgs(args.filterNot(_.endsWith(".scala")).toList, fromSourcesOut.toString) :::
+      tastyFiles
+
+    println("Compiling from .tasty sources")
+    val compilation2 = dotc.Main.process(fromTastyArgs.toArray)
+
+    if (compilation2.hasErrors) {
+      println("Failed compilation from TASTY")
+      println("Compilation input: " + fromSourcesOut)
+      // In this case we do not delete the generated class files to allow further debugging.
+      // For example `dotc -decompile` on one of the intermediate class files.
+      sys.exit(1)
+    } else {
+      println("Recompilation successful")
+    }
+
+    Directory(tmpOut).deleteRecursively()
+  }
+
+  private def insertClasspathInArgs(args: List[String], cp: String): List[String] = {
+    val (beforeCp, fromCp) = args.span(_ != "-classpath")
+    val classpath = fromCp.drop(1).headOption.fold(cp)(_ + JFile.pathSeparator + cp)
+    "-classpath" :: classpath :: beforeCp ::: fromCp.drop(2)
+  }
+}
diff --git a/tests/pos-with-compiler-cc/dotc/fromtasty/ReadTasty.scala b/tests/pos-with-compiler-cc/dotc/fromtasty/ReadTasty.scala
new file mode 100644
index 000000000000..864f5277bff3
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/fromtasty/ReadTasty.scala
@@ -0,0 +1,84 @@
+package dotty.tools
+package dotc
+package fromtasty
+
+import core._
+import Decorators._
+import Contexts._
+import Symbols.{Symbol, ClassSymbol}
+import SymDenotations.ClassDenotation
+import Denotations.staticRef
+import NameOps._
+import ast.Trees.Tree
+import Phases.Phase
+
+
+/** Load trees from TASTY files */
+class ReadTasty extends Phase {
+
+  def phaseName: String = "readTasty"
+
+  override def isRunnable(using Context): Boolean =
+    ctx.settings.fromTasty.value
+
+  override def runOn(units: List[CompilationUnit])(using Context): List[CompilationUnit] =
+    withMode(Mode.ReadPositions)(units.flatMap(readTASTY(_)))
+
+  def readTASTY(unit: CompilationUnit)(using Context): Option[CompilationUnit] = unit match {
+    case unit: TASTYCompilationUnit =>
+      val className = unit.className.toTypeName
+
+      def cannotUnpickle(reason: String): None.type = {
+        report.error(s"class $className cannot be unpickled because $reason")
+        None
+      }
+
+      def compilationUnit(cls: Symbol): Option[CompilationUnit] = cls match {
+        case cls: ClassSymbol =>
+          (cls.rootTreeOrProvider: @unchecked) match {
+            case unpickler: tasty.DottyUnpickler =>
+              if (cls.rootTree.isEmpty) None
+              else {
+                val unit = CompilationUnit(cls, cls.rootTree, forceTrees = true)
+                unit.pickled += (cls -> (() => unpickler.unpickler.bytes))
+                Some(unit)
+              }
+            case tree: Tree[?] =>
+              // TODO handle correctly this case correctly to get the tree or avoid it completely.
+              cls.denot.infoOrCompleter match {
+                case _ => Some(AlreadyLoadedCompilationUnit(cls.denot.fullName.toString))
+              }
+            case _ =>
+              cannotUnpickle(s"its class file does not have a TASTY attribute")
+          }
+        case _ => None
+      }
+
+      // The TASTY section in a/b/C.class may either contain a class a.b.C, an object a.b.C, or both.
+      // We first try to load the class and fallback to loading the object if the class doesn't exist.
+      // Note that if both the class and the object are present, then loading the class will also load
+      // the object, this is why we use orElse here, otherwise we could load the object twice and
+      // create ambiguities!
+      staticRef(className) match {
+        case clsd: ClassDenotation =>
+          clsd.infoOrCompleter match {
+            case info: ClassfileLoader =>
+              info.load(clsd) // sets cls.rootTreeOrProvider and cls.moduleClass.treeProvider as a side-effect
+            case _ =>
+          }
+          def moduleClass = clsd.owner.info.member(className.moduleClassName).symbol
+          compilationUnit(clsd.classSymbol).orElse(compilationUnit(moduleClass))
+        case _ =>
+          staticRef(className.moduleClassName) match {
+            case clsd: ClassDenotation =>
+              compilationUnit(clsd.classSymbol)
+            case denot =>
+              cannotUnpickle(s"no class file was found for denot: $denot")
+          }
+      }
+    case unit =>
+     Some(unit)
+  }
+
+  def run(using Context): Unit = unsupported("run")
+}
diff --git a/tests/pos-with-compiler-cc/dotc/fromtasty/TASTYCompilationUnit.scala b/tests/pos-with-compiler-cc/dotc/fromtasty/TASTYCompilationUnit.scala
new file mode 100644
index 000000000000..77021efa3050
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/fromtasty/TASTYCompilationUnit.scala
@@ -0,0 +1,8 @@
+package dotty.tools.dotc.fromtasty
+
+import dotty.tools.dotc.CompilationUnit
+import dotty.tools.dotc.util.NoSource
+
+class TASTYCompilationUnit(val className: String) extends CompilationUnit(NoSource) {
+  override def toString: String = s"class file $className"
+}
diff --git a/tests/pos-with-compiler-cc/dotc/fromtasty/TASTYCompiler.scala b/tests/pos-with-compiler-cc/dotc/fromtasty/TASTYCompiler.scala
new file mode 100644
index 000000000000..923892b62f13
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/fromtasty/TASTYCompiler.scala
@@ -0,0 +1,18 @@
+package dotty.tools
+package dotc
+package fromtasty
+
+import core._
+import Contexts._
+import Phases.Phase
+
+class TASTYCompiler extends Compiler {
+
+  override protected def frontendPhases: List[List[Phase]] =
+    List(new ReadTasty) :: Nil
+
+  override def newRun(using Context): Run = {
+    reset()
+    new TASTYRun(this, ctx.addMode(Mode.ReadPositions))
+  }
+}
diff --git a/tests/pos-with-compiler-cc/dotc/fromtasty/TASTYRun.scala b/tests/pos-with-compiler-cc/dotc/fromtasty/TASTYRun.scala
new file mode 100644
index 000000000000..04c65a3d3882
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/fromtasty/TASTYRun.scala
@@ -0,0 +1,34 @@
+package dotty.tools
+package dotc
+package fromtasty
+
+import scala.language.unsafeNulls
+
+import io.{JarArchive, AbstractFile, Path}
+import core.Contexts._
+import java.io.File
+
+class TASTYRun(comp: Compiler, ictx: Context) extends Run(comp, ictx) {
+  override def compile(files: List[AbstractFile]): Unit = {
+    val units = tastyUnits(files)
+    compileUnits(units)
+  }
+
+  private def tastyUnits(files: List[AbstractFile]): List[TASTYCompilationUnit] =
+    val fromTastyIgnoreList = ctx.settings.YfromTastyIgnoreList.value.toSet
+    // Resolve class names of tasty and jar files
+    val classNames = files.flatMap { file =>
+      file.extension match
+        case "jar" =>
+          JarArchive.open(Path(file.path), create = false).allFileNames()
+            .map(_.stripPrefix(File.separator)) // change paths from absolute to relative
+            .filter(e => Path.extension(e) == "tasty" && !fromTastyIgnoreList(e))
+            .map(e => e.stripSuffix(".tasty").replace(File.separator, "."))
+            .toList
+        case "tasty" => TastyFileUtil.getClassName(file)
+        case _ =>
+          report.error(s"File extension is not `tasty` or `jar`: ${file.path}")
+          Nil
+    }
+    classNames.map(new TASTYCompilationUnit(_))
+}
diff --git a/tests/pos-with-compiler-cc/dotc/fromtasty/TastyFileUtil.scala b/tests/pos-with-compiler-cc/dotc/fromtasty/TastyFileUtil.scala
new file mode 100644
index 000000000000..bc04cc648a65
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/fromtasty/TastyFileUtil.scala
@@ -0,0 +1,50 @@
+package dotty.tools.dotc
+package fromtasty
+
+import scala.language.unsafeNulls
+
+import dotty.tools.dotc.core.tasty.TastyClassName
+import dotty.tools.dotc.core.StdNames.nme.EMPTY_PACKAGE
+import dotty.tools.io.AbstractFile
+
+object TastyFileUtil {
+  /** Get the class path of a tasty file
+   *
+   *  If
+   *  ```scala
+   *    package foo
+   *    class Foo
+   *  ```
+   *  then `getClassName("./out/foo/Foo.tasty") returns `Some("./out")`
+   */
+  def getClassPath(file: AbstractFile): Option[String] =
+    getClassName(file).map { className =>
+      val classInPath = className.replace(".", java.io.File.separator) + ".tasty"
+      file.path.replace(classInPath, "")
+    }
+
+  /** Get the class path of a tasty file
+   *
+   *  If
+   *  ```scala
+   *    package foo
+   *    class Foo
+   *  ```
+   *  then `getClassName("./out/foo/Foo.tasty") returns `Some("foo.Foo")`
+   */
+  def getClassName(file: AbstractFile): Option[String] = {
+    assert(file.exists)
+    assert(file.extension == "tasty")
+    val bytes = file.toByteArray
+    val names = new TastyClassName(bytes).readName()
+    names.map { case (packageName, className) =>
+      val fullName = packageName match {
+        case EMPTY_PACKAGE => s"${className.lastPart}"
+        case _ => s"$packageName.${className.lastPart}"
+      }
+      fullName
+    }
+  }
+}
+
+
diff --git a/tests/pos-with-compiler-cc/dotc/inlines/InlineReducer.scala b/tests/pos-with-compiler-cc/dotc/inlines/InlineReducer.scala
new file mode 100644
index 000000000000..debf51872d5a
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/inlines/InlineReducer.scala
@@ -0,0 +1,431 @@
+package dotty.tools
+package dotc
+package inlines
+
+import ast.*, core.*
+import Flags.*, Symbols.*, Types.*, Decorators.*, Contexts.*
+import StdNames.nme
+import transform.SymUtils.*
+import typer.*
+import Names.TermName
+import NameKinds.{InlineAccessorName, InlineBinderName, InlineScrutineeName}
+import config.Printers.inlining
+import util.SimpleIdentityMap
+
+import collection.mutable
+
+/** A utility class offering methods for rewriting inlined code */
+class InlineReducer(inliner: Inliner)(using Context):
+  import tpd.*
+  import Inliner.{isElideableExpr, DefBuffer}
+  import inliner.{call, newSym, tryInlineArg, paramBindingDef}
+
+  extension (tp: Type)
+    /** same as widenTermRefExpr, but preserves modules and singleton enum values */
+    private def widenInlineScrutinee(using Context): Type = tp.stripTypeVar match
+      case tp: TermRef  =>
+        val sym = tp.termSymbol
+        if sym.isAllOf(EnumCase, butNot=JavaDefined) || sym.is(Module) then tp
+        else if !tp.isOverloaded then tp.underlying.widenExpr.widenInlineScrutinee
+        else tp
+      case _ => tp
+
+  /** An extractor for terms equivalent to `new C(args)`, returning the class `C`,
+   *  a list of bindings, and the arguments `args`. Can see inside blocks and Inlined nodes and can
+   *  follow a reference to an inline value binding to its right hand side.
+   *
+   *  @return    optionally, a triple consisting of
+   *             - the class `C`
+   *             - the arguments `args`
+   *             - any bindings that wrap the instance creation
+   *             - whether the instance creation is precomputed or by-name
+   */
+  private object NewInstance {
+    def unapply(tree: Tree)(using Context): Option[(Symbol, List[Tree], List[Tree], Boolean)] = {
+      def unapplyLet(bindings: List[Tree], expr: Tree) =
+        unapply(expr) map {
+          case (cls, reduced, prefix, precomputed) => (cls, reduced, bindings ::: prefix, precomputed)
+        }
+      tree match {
+        case Apply(fn, args) =>
+          fn match {
+            case Select(New(tpt), nme.CONSTRUCTOR) =>
+              Some((tpt.tpe.classSymbol, args, Nil, false))
+            case TypeApply(Select(New(tpt), nme.CONSTRUCTOR), _) =>
+              Some((tpt.tpe.classSymbol, args, Nil, false))
+            case _ =>
+              val meth = fn.symbol
+              if (meth.name == nme.apply &&
+                  meth.flags.is(Synthetic) &&
+                  meth.owner.linkedClass.is(Case))
+                Some(meth.owner.linkedClass, args, Nil, false)
+              else None
+          }
+        case Typed(inner, _) =>
+          // drop the ascribed tpt. We only need it if we can't find a NewInstance
+          unapply(inner)
+        case Ident(_) =>
+          val binding = tree.symbol.defTree
+          for ((cls, reduced, prefix, precomputed) <- unapply(binding))
+          yield (cls, reduced, prefix, precomputed || binding.isInstanceOf[ValDef])
+        case Inlined(_, bindings, expansion) =>
+          unapplyLet(bindings, expansion)
+        case Block(stats, expr) if isElideableExpr(tree) =>
+          unapplyLet(stats, expr)
+        case _ =>
+          None
+      }
+    }
+  }
+
+  /** If `tree` is equivalent to `new C(args).x` where class `C` does not have
+   *  initialization code and `x` is a parameter corresponding to one of the
+   *  arguments `args`, the corresponding argument, otherwise `tree` itself.
+   *  Side effects of original arguments need to be preserved.
+   */
+  def reduceProjection(tree: Tree)(using Context): Tree = {
+    if (ctx.debug) inlining.println(i"try reduce projection $tree")
+    tree match {
+      case Select(NewInstance(cls, args, prefix, precomputed), field) if cls.isNoInitsRealClass =>
+        def matches(param: Symbol, selection: Symbol): Boolean =
+          param == selection || {
+            selection.name match {
+              case InlineAccessorName(underlying) =>
+                param.name == underlying && selection.info.isInstanceOf[ExprType]
+              case _ =>
+                false
+            }
+          }
+        val idx = cls.asClass.paramAccessors.indexWhere(matches(_, tree.symbol))
+        if (idx >= 0 && idx < args.length) {
+          def finish(arg: Tree) =
+            new TreeTypeMap().transform(arg) // make sure local bindings in argument have fresh symbols
+              .showing(i"projecting $tree -> $result", inlining)
+          val arg = args(idx)
+          if (precomputed)
+            if (isElideableExpr(arg)) finish(arg)
+            else tree // nothing we can do here, projection would duplicate side effect
+          else {
+            // newInstance is evaluated in place, need to reflect side effects of
+            // arguments in the order they were written originally
+            def collectImpure(from: Int, end: Int) =
+              (from until end).filterNot(i => isElideableExpr(args(i))).toList.map(args)
+            val leading = collectImpure(0, idx)
+            val trailing = collectImpure(idx + 1, args.length)
+            val argInPlace =
+              if (trailing.isEmpty) arg
+              else
+                def argsSpan = trailing.map(_.span).foldLeft(arg.span)(_.union(_))
+                letBindUnless(TreeInfo.Pure, arg)(Block(trailing, _).withSpan(argsSpan))
+            val blockSpan = (prefix ::: leading).map(_.span).foldLeft(argInPlace.span)(_.union(_))
+            finish(seq(prefix, seq(leading, argInPlace)).withSpan(blockSpan))
+          }
+        }
+        else tree
+      case Block(stats, expr) if stats.forall(isPureBinding) =>
+        cpy.Block(tree)(stats, reduceProjection(expr))
+      case _ => tree
+    }
+  }
+
+  /** If this is a value binding:
+    *   - reduce its rhs if it is a projection and adjust its type accordingly,
+    *   - record symbol -> rhs in the InlineBindings context propery.
+    */
+  def normalizeBinding(binding: ValOrDefDef)(using Context) = {
+    val binding1 = binding match {
+      case binding: ValDef =>
+        val rhs1 = reduceProjection(binding.rhs)
+        binding.symbol.defTree = rhs1
+        if (rhs1 `eq` binding.rhs) binding
+        else {
+          binding.symbol.info = rhs1.tpe
+          cpy.ValDef(binding)(tpt = TypeTree(rhs1.tpe), rhs = rhs1)
+        }
+      case _ =>
+        binding
+    }
+    binding1.withSpan(call.span)
+  }
+
+  /** Rewrite an application
+    *
+    *    ((x1, ..., xn) => b)(e1, ..., en)
+    *
+    *  to
+    *
+    *    val/def x1 = e1; ...; val/def xn = en; b
+    *
+    *  where `def` is used for call-by-name parameters. However, we shortcut any NoPrefix
+    *  refs among the ei's directly without creating an intermediate binding.
+    */
+  def betaReduce(tree: Tree)(using Context): Tree = tree match {
+    case Apply(Select(cl @ closureDef(ddef), nme.apply), args) if defn.isFunctionType(cl.tpe) =>
+      // closureDef also returns a result for closures wrapped in Inlined nodes.
+      // These need to be preserved.
+      def recur(cl: Tree): Tree = cl match
+        case Inlined(call, bindings, expr) =>
+          cpy.Inlined(cl)(call, bindings, recur(expr))
+        case _ => ddef.tpe.widen match
+          case mt: MethodType if ddef.paramss.head.length == args.length =>
+            val bindingsBuf = new DefBuffer
+            val argSyms = mt.paramNames.lazyZip(mt.paramInfos).lazyZip(args).map { (name, paramtp, arg) =>
+              arg.tpe.dealias match {
+                case ref @ TermRef(NoPrefix, _) => ref.symbol
+                case _ =>
+                  paramBindingDef(name, paramtp, arg, bindingsBuf)(
+                    using ctx.withSource(cl.source)
+                  ).symbol
+              }
+            }
+            val expander = new TreeTypeMap(
+              oldOwners = ddef.symbol :: Nil,
+              newOwners = ctx.owner :: Nil,
+              substFrom = ddef.paramss.head.map(_.symbol),
+              substTo = argSyms)
+            Block(bindingsBuf.toList, expander.transform(ddef.rhs)).withSpan(tree.span)
+          case _ => tree
+      recur(cl)
+    case _ => tree
+  }
+
+  /** The result type of reducing a match. It consists optionally of a list of bindings
+   *  for the pattern-bound variables and the RHS of the selected case.
+   *  Returns `None` if no case was selected.
+   */
+  type MatchRedux = Option[(List[MemberDef], Tree)]
+
+  /** Same as MatchRedux, but also includes a boolean
+   *  that is true if the guard can be checked at compile time.
+   */
+  type MatchReduxWithGuard = Option[(List[MemberDef], Tree, Boolean)]
+
+  /** Reduce an inline match
+    *   @param     mtch          the match tree
+    *   @param     scrutinee     the scrutinee expression, assumed to be pure, or
+    *                            EmptyTree for a summonFrom
+    *   @param     scrutType     its fully defined type, or
+    *                            ImplicitScrutineeTypeRef for a summonFrom
+    *   @param     typer         The current inline typer
+    *   @return    optionally, if match can be reduced to a matching case: A pair of
+    *              bindings for all pattern-bound variables and the RHS of the case.
+    */
+  def reduceInlineMatch(scrutinee: Tree, scrutType: Type, cases: List[CaseDef], typer: Typer)(using Context): MatchRedux = {
+
+    val isImplicit = scrutinee.isEmpty
+
+    /** Try to match pattern `pat` against scrutinee reference `scrut`. If successful add
+     *  bindings for variables bound in this pattern to `caseBindingMap`.
+     */
+    def reducePattern(
+      caseBindingMap: mutable.ListBuffer[(Symbol, MemberDef)],
+      scrut: TermRef,
+      pat: Tree
+    )(using Context): Boolean = {
+
+      /** Create a binding of a pattern bound variable with matching part of
+       *  scrutinee as RHS and type that corresponds to RHS.
+       */
+      def newTermBinding(sym: TermSymbol, rhs: Tree): Unit = {
+        val copied = sym.copy(info = rhs.tpe.widenInlineScrutinee, coord = sym.coord, flags = sym.flags &~ Case).asTerm
+        caseBindingMap += ((sym, ValDef(copied, constToLiteral(rhs)).withSpan(sym.span)))
+      }
+
+      def newTypeBinding(sym: TypeSymbol, alias: Type): Unit = {
+        val copied = sym.copy(info = TypeAlias(alias), coord = sym.coord).asType
+        caseBindingMap += ((sym, TypeDef(copied)))
+      }
+
+      def searchImplicit(sym: TermSymbol, tpt: Tree) = {
+        val evTyper = new Typer(ctx.nestingLevel + 1)
+        val evCtx = ctx.fresh.setTyper(evTyper)
+        inContext(evCtx) {
+          val evidence = evTyper.inferImplicitArg(tpt.tpe, tpt.span)
+          evidence.tpe match {
+            case fail: Implicits.AmbiguousImplicits =>
+              report.error(evTyper.missingArgMsg(evidence, tpt.tpe, ""), tpt.srcPos)
+              true // hard error: return true to stop implicit search here
+            case fail: Implicits.SearchFailureType =>
+              false
+            case _ =>
+              //inlining.println(i"inferred implicit $sym: ${sym.info} with $evidence: ${evidence.tpe.widen}, ${evCtx.gadt.constraint}, ${evCtx.typerState.constraint}")
+              newTermBinding(sym, evidence)
+              true
+          }
+        }
+      }
+
+      type TypeBindsMap = SimpleIdentityMap[TypeSymbol, java.lang.Boolean]
+
+      def getTypeBindsMap(pat: Tree, tpt: Tree): TypeBindsMap = {
+        val getBinds = new TreeAccumulator[Set[TypeSymbol]] {
+          def apply(syms: Set[TypeSymbol], t: Tree)(using Context): Set[TypeSymbol] = {
+            val syms1 = t match {
+              case t: Bind if t.symbol.isType =>
+                syms + t.symbol.asType
+              case _ => syms
+            }
+            foldOver(syms1, t)
+          }
+        }
+
+        // Extractors contain Bind nodes in type parameter lists, the tree looks like this:
+        //   UnApply[t @ t](pats)(implicits): T[t]
+        // Test case is pos/inline-caseclass.scala.
+        val binds: Set[TypeSymbol] = pat match {
+          case UnApply(TypeApply(_, tpts), _, _) => getBinds(Set.empty[TypeSymbol], tpts)
+          case _ => getBinds(Set.empty[TypeSymbol], tpt)
+        }
+
+        val extractBindVariance = new TypeAccumulator[TypeBindsMap] {
+          def apply(syms: TypeBindsMap, t: Type) = {
+            val syms1 = t match {
+              // `binds` is used to check if the symbol was actually bound by the pattern we're processing
+              case tr: TypeRef if tr.symbol.is(Case) && binds.contains(tr.symbol.asType) =>
+                val trSym = tr.symbol.asType
+                // Exact same logic as in IsFullyDefinedAccumulator:
+                // the binding is to be maximized iff it only occurs contravariantly in the type
+                val wasToBeMinimized: Boolean = {
+                  val v = syms(trSym)
+                  if (v != null) v else false
+                }
+                syms.updated(trSym, wasToBeMinimized || variance >= 0 : java.lang.Boolean)
+              case _ =>
+                syms
+            }
+            foldOver(syms1, t)
+          }
+        }
+
+        extractBindVariance(SimpleIdentityMap.empty, tpt.tpe)
+      }
+
+      def addTypeBindings(typeBinds: TypeBindsMap)(using Context): Unit =
+        typeBinds.foreachBinding { case (sym, shouldBeMinimized) =>
+          newTypeBinding(sym,
+            ctx.gadt.approximation(sym, fromBelow = shouldBeMinimized, maxLevel = Int.MaxValue))
+        }
+
+      def registerAsGadtSyms(typeBinds: TypeBindsMap)(using Context): Unit =
+        if (typeBinds.size > 0) ctx.gadt.addToConstraint(typeBinds.keys)
+
+      pat match {
+        case Typed(pat1, tpt) =>
+          val typeBinds = getTypeBindsMap(pat1, tpt)
+          registerAsGadtSyms(typeBinds)
+          scrut <:< tpt.tpe && {
+            addTypeBindings(typeBinds)
+            reducePattern(caseBindingMap, scrut, pat1)
+          }
+        case pat @ Bind(name: TermName, Typed(_, tpt)) if isImplicit =>
+          val typeBinds = getTypeBindsMap(tpt, tpt)
+          registerAsGadtSyms(typeBinds)
+          searchImplicit(pat.symbol.asTerm, tpt) && {
+            addTypeBindings(typeBinds)
+            true
+          }
+        case pat @ Bind(name: TermName, body) =>
+          reducePattern(caseBindingMap, scrut, body) && {
+            if (name != nme.WILDCARD) newTermBinding(pat.symbol.asTerm, ref(scrut))
+            true
+          }
+        case Ident(nme.WILDCARD) =>
+          true
+        case pat: Literal =>
+          scrut.widenTermRefExpr =:= pat.tpe
+        case pat: RefTree =>
+          scrut =:= pat.tpe ||
+          scrut.classSymbol.is(Module) && scrut.widen =:= pat.tpe.widen && {
+            scrut.prefix match {
+              case _: SingletonType | NoPrefix => true
+              case _ => false
+            }
+          }
+        case UnApply(unapp, _, pats) =>
+          unapp.tpe.widen match {
+            case mt: MethodType if mt.paramInfos.length == 1 =>
+
+              def reduceSubPatterns(pats: List[Tree], selectors: List[Tree]): Boolean = (pats, selectors) match {
+                case (Nil, Nil) => true
+                case (pat :: pats1, selector :: selectors1) =>
+                  val elem = newSym(InlineBinderName.fresh(), Synthetic, selector.tpe.widenInlineScrutinee).asTerm
+                  val rhs = constToLiteral(selector)
+                  elem.defTree = rhs
+                  caseBindingMap += ((NoSymbol, ValDef(elem, rhs).withSpan(elem.span)))
+                  reducePattern(caseBindingMap, elem.termRef, pat) &&
+                  reduceSubPatterns(pats1, selectors1)
+                case _ => false
+              }
+
+              val paramType = mt.paramInfos.head
+              val paramCls = paramType.classSymbol
+              if (paramCls.is(Case) && unapp.symbol.is(Synthetic) && scrut <:< paramType) {
+                val caseAccessors =
+                  if (paramCls.is(Scala2x)) paramCls.caseAccessors.filter(_.is(Method))
+                  else paramCls.asClass.paramAccessors
+                val selectors =
+                  for (accessor <- caseAccessors)
+                  yield constToLiteral(reduceProjection(ref(scrut).select(accessor).ensureApplied))
+                caseAccessors.length == pats.length && reduceSubPatterns(pats, selectors)
+              }
+              else false
+            case _ =>
+              false
+          }
+        case Alternative(pats) =>
+          pats.exists(reducePattern(caseBindingMap, scrut, _))
+        case Inlined(EmptyTree, Nil, ipat) =>
+          reducePattern(caseBindingMap, scrut, ipat)
+        case _ => false
+      }
+    }
+
+    /** The initial scrutinee binding: `val $scrutineeN = <scrutinee>` */
+    val scrutineeSym = newSym(InlineScrutineeName.fresh(), Synthetic, scrutType).asTerm
+    val scrutineeBinding = normalizeBinding(ValDef(scrutineeSym, scrutinee))
+
+    def reduceCase(cdef: CaseDef): MatchReduxWithGuard = {
+      val caseBindingMap = new mutable.ListBuffer[(Symbol, MemberDef)]()
+
+      def substBindings(
+          bindings: List[(Symbol, MemberDef)],
+          bbuf: mutable.ListBuffer[MemberDef],
+          from: List[Symbol], to: List[Symbol]): (List[MemberDef], List[Symbol], List[Symbol]) =
+        bindings match {
+          case (sym, binding) :: rest =>
+            bbuf += binding.subst(from, to).asInstanceOf[MemberDef]
+            if (sym.exists) substBindings(rest, bbuf, sym :: from, binding.symbol :: to)
+            else substBindings(rest, bbuf, from, to)
+          case Nil => (bbuf.toList, from, to)
+        }
+
+      if (!isImplicit) caseBindingMap += ((NoSymbol, scrutineeBinding))
+      val gadtCtx = ctx.fresh.setFreshGADTBounds.addMode(Mode.GadtConstraintInference)
+      if (reducePattern(caseBindingMap, scrutineeSym.termRef, cdef.pat)(using gadtCtx)) {
+        val (caseBindings, from, to) = substBindings(caseBindingMap.toList, mutable.ListBuffer(), Nil, Nil)
+        val (guardOK, canReduceGuard) =
+          if cdef.guard.isEmpty then (true, true)
+          else typer.typed(cdef.guard.subst(from, to), defn.BooleanType) match {
+            case ConstantValue(v: Boolean) => (v, true)
+            case _ => (false, false)
+          }
+        if guardOK then Some((caseBindings.map(_.subst(from, to)), cdef.body.subst(from, to), canReduceGuard))
+        else if canReduceGuard then None
+        else Some((caseBindings.map(_.subst(from, to)), cdef.body.subst(from, to), canReduceGuard))
+      }
+      else None
+    }
+
+    def recur(cases: List[CaseDef]): MatchRedux = cases match {
+      case Nil => None
+      case cdef :: cases1 =>
+        reduceCase(cdef) match
+          case None => recur(cases1)
+          case r @ Some((caseBindings, rhs, canReduceGuard)) if canReduceGuard => Some((caseBindings, rhs))
+          case _ => None
+    }
+
+    recur(cases)
+  }
+end InlineReducer
+
diff --git a/tests/pos-with-compiler-cc/dotc/inlines/Inliner.scala b/tests/pos-with-compiler-cc/dotc/inlines/Inliner.scala
new file mode 100644
index 000000000000..a23af052ca24
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/inlines/Inliner.scala
@@ -0,0 +1,1081 @@
+package dotty.tools
+package dotc
+package inlines
+
+import ast.*, core.*
+import Flags.*, Symbols.*, Types.*, Decorators.*, Constants.*, Contexts.*
+import transform.SymUtils.*
+import StdNames.nme
+import typer.*
+import Names.Name
+import NameKinds.InlineBinderName
+import ProtoTypes.shallowSelectionProto
+import SymDenotations.SymDenotation
+import Inferencing.isFullyDefined
+import config.Printers.inlining
+import ErrorReporting.errorTree
+import util.{SimpleIdentitySet, SrcPos}
+import Nullables.computeNullableDeeply
+
+import collection.mutable
+import reporting.trace
+import util.Spans.Span
+import dotty.tools.dotc.transform.Splicer
+import quoted.QuoteUtils
+import scala.annotation.constructorOnly
+import language.experimental.pureFunctions
+
+/** General support for inlining */
+object Inliner:
+  import tpd._
+
+  private[inlines] type DefBuffer = mutable.ListBuffer[ValOrDefDef]
+
+  /** Very similar to TreeInfo.isPureExpr, but with the following inliner-only exceptions:
+   *  - synthetic case class apply methods, when the case class constructor is empty, are
+   *    elideable but not pure. Elsewhere, accessing the apply method might cause the initialization
+   *    of a containing object so they are merely idempotent.
+   */
+  object isElideableExpr:
+    def isStatElideable(tree: Tree)(using Context): Boolean = unsplice(tree) match {
+      case EmptyTree
+         | TypeDef(_, _)
+         | Import(_, _)
+         | DefDef(_, _, _, _) =>
+        true
+      case vdef @ ValDef(_, _, _) =>
+        if (vdef.symbol.flags is Mutable) false else apply(vdef.rhs)
+      case _ =>
+        false
+    }
+
+    def apply(tree: Tree)(using Context): Boolean = unsplice(tree) match {
+      case EmptyTree
+         | This(_)
+         | Super(_, _)
+         | Literal(_) =>
+        true
+      case Ident(_) =>
+        isPureRef(tree) || tree.symbol.isAllOf(InlineParam)
+      case Select(qual, _) =>
+        if (tree.symbol.is(Erased)) true
+        else isPureRef(tree) && apply(qual)
+      case New(_) | Closure(_, _, _) =>
+        true
+      case TypeApply(fn, _) =>
+        if (fn.symbol.is(Erased) || fn.symbol == defn.QuotedTypeModule_of) true else apply(fn)
+      case Apply(fn, args) =>
+        val isCaseClassApply = {
+          val cls = tree.tpe.classSymbol
+          val meth = fn.symbol
+          meth.name == nme.apply &&
+          meth.flags.is(Synthetic) &&
+          meth.owner.linkedClass.is(Case) &&
+          cls.isNoInitsRealClass &&
+          funPart(fn).match
+            case Select(qual, _) => qual.symbol.is(Synthetic) // e.g: disallow `{ ..; Foo }.apply(..)`
+            case meth @ Ident(_) => meth.symbol.is(Synthetic) // e.g: allow `import Foo.{ apply => foo }; foo(..)`
+            case _               => false
+        }
+        if isPureApply(tree, fn) then
+          apply(fn) && args.forall(apply)
+        else if (isCaseClassApply)
+          args.forall(apply)
+        else if (fn.symbol.is(Erased)) true
+        else false
+      case Typed(expr, _) =>
+        apply(expr)
+      case Block(stats, expr) =>
+        apply(expr) && stats.forall(isStatElideable)
+      case Inlined(_, bindings, expr) =>
+        apply(expr) && bindings.forall(isStatElideable)
+      case NamedArg(_, expr) =>
+        apply(expr)
+      case _ =>
+        false
+    }
+  end isElideableExpr
+
+  // InlineCopier is a more fault-tolerant copier that does not cause errors when
+  // function types in applications are undefined. This is necessary since we copy at
+  // the same time as establishing the proper context in which the copied tree should
+  // be evaluated. This matters for opaque types, see neg/i14653.scala.
+  private class InlineCopier() extends TypedTreeCopier:
+    override def Apply(tree: Tree)(fun: Tree, args: List[Tree])(using Context): Apply =
+      if fun.tpe.widen.exists then super.Apply(tree)(fun, args)
+      else untpd.cpy.Apply(tree)(fun, args).withTypeUnchecked(tree.tpe)
+
+  // InlinerMap is a TreeTypeMap with special treatment for inlined arguments:
+  // They are generally left alone (not mapped further, and if they wrap a type
+  // the type Inlined wrapper gets dropped
+  private class InlinerMap(
+      typeMap: Type -> Type,
+      treeMap: Tree -> Tree,
+      oldOwners: List[Symbol],
+      newOwners: List[Symbol],
+      substFrom: List[Symbol],
+      substTo: List[Symbol])(using Context)
+    extends TreeTypeMap(
+      typeMap, treeMap, oldOwners, newOwners, substFrom, substTo, InlineCopier()):
+
+    override def copy(
+        typeMap: Type -> Type,
+        treeMap: Tree -> Tree,
+        oldOwners: List[Symbol],
+        newOwners: List[Symbol],
+        substFrom: List[Symbol],
+        substTo: List[Symbol])(using Context) =
+      new InlinerMap(typeMap, treeMap, oldOwners, newOwners, substFrom, substTo)
+
+    override def transformInlined(tree: Inlined)(using Context) =
+      if tree.call.isEmpty then
+        tree.expansion match
+          case expansion: TypeTree => expansion
+          case _ => tree
+      else super.transformInlined(tree)
+  end InlinerMap
+end Inliner
+
+/** Produces an inlined version of `call` via its `inlined` method.
+ *
+ *  @param  call         the original call to an inlineable method
+ *  @param  rhsToInline  the body of the inlineable method that replaces the call.
+ */
+class Inliner(val call: tpd.Tree)(using Context):
+  import tpd._
+  import Inliner._
+
+  private val methPart = funPart(call)
+  protected val callTypeArgs = typeArgss(call).flatten
+  protected val callValueArgss = termArgss(call)
+  protected val inlinedMethod = methPart.symbol
+  private val inlineCallPrefix =
+     qualifier(methPart).orElse(This(inlinedMethod.enclosingClass.asClass))
+
+  // Make sure all type arguments to the call are fully determined,
+  // but continue if that's not achievable (or else i7459.scala would crash).
+  for arg <- callTypeArgs do
+    isFullyDefined(arg.tpe, ForceDegree.flipBottom)
+
+  /** A map from parameter names of the inlineable method to references of the actual arguments.
+   *  For a type argument this is the full argument type.
+   *  For a value argument, it is a reference to either the argument value
+   *  (if the argument is a pure expression of singleton type), or to `val` or `def` acting
+   *  as a proxy (if the argument is something else).
+   */
+  private val paramBinding = new mutable.HashMap[Name, Type]
+
+  /** A map from parameter names of the inlineable method to spans of the actual arguments */
+  private val paramSpan = new mutable.HashMap[Name, Span]
+
+  /** A map from references to (type and value) parameters of the inlineable method
+   *  to their corresponding argument or proxy references, as given by `paramBinding`.
+   */
+  private[inlines] val paramProxy: mutable.HashMap[Type, Type] = new mutable.HashMap
+
+  /** A map from the classes of (direct and outer) this references in `rhsToInline`
+   *  to references of their proxies.
+   *  Note that we can't index by the ThisType itself since there are several
+   *  possible forms to express what is logicaly the same ThisType. E.g.
+   *
+   *     ThisType(TypeRef(ThisType(p), cls))
+   *
+   *  vs
+   *
+   *     ThisType(TypeRef(TermRef(ThisType(<root>), p), cls))
+   *
+   *  These are different (wrt ==) types but represent logically the same key
+   */
+  private val thisProxy = new mutable.HashMap[ClassSymbol, TermRef]
+
+  /** A buffer for bindings that define proxies for actual arguments */
+  private val bindingsBuf = new mutable.ListBuffer[ValOrDefDef]
+
+  private[inlines] def newSym(name: Name, flags: FlagSet, info: Type)(using Context): Symbol =
+    newSymbol(ctx.owner, name, flags, info, coord = call.span)
+
+  /** A binding for the parameter of an inline method. This is a `val` def for
+   *  by-value parameters and a `def` def for by-name parameters. `val` defs inherit
+   *  inline annotations from their parameters. The generated `def` is appended
+   *  to `buf`.
+   *  @param name        the name of the parameter
+   *  @param formal      the type of the parameter
+   *  @param arg         the argument corresponding to the parameter
+   *  @param buf         the buffer to which the definition should be appended
+   */
+  private[inlines] def paramBindingDef(name: Name, formal: Type, arg0: Tree,
+                              buf: DefBuffer)(using Context): ValOrDefDef = {
+    val isByName = formal.dealias.isInstanceOf[ExprType]
+    val arg = arg0 match {
+      case Typed(arg1, tpt) if tpt.tpe.isRepeatedParam && arg1.tpe.derivesFrom(defn.ArrayClass) =>
+        wrapArray(arg1, arg0.tpe.elemType)
+      case _ => arg0
+    }
+    val argtpe = arg.tpe.dealiasKeepAnnots.translateFromRepeated(toArray = false)
+    val argIsBottom = argtpe.isBottomTypeAfterErasure
+    val bindingType =
+      if argIsBottom then formal
+      else if isByName then ExprType(argtpe.widen)
+      else argtpe.widen
+    var bindingFlags: FlagSet = InlineProxy
+    if formal.widenExpr.hasAnnotation(defn.InlineParamAnnot) then
+      bindingFlags |= Inline
+    if formal.widenExpr.hasAnnotation(defn.ErasedParamAnnot) then
+      bindingFlags |= Erased
+    if isByName then
+      bindingFlags |= Method
+    val boundSym = newSym(InlineBinderName.fresh(name.asTermName), bindingFlags, bindingType).asTerm
+    val binding = {
+      var newArg = arg.changeOwner(ctx.owner, boundSym)
+      if bindingFlags.is(Inline) && argIsBottom then
+        newArg = Typed(newArg, TypeTree(formal)) // type ascribe RHS to avoid type errors in expansion. See i8612.scala
+      if isByName then DefDef(boundSym, newArg)
+      else ValDef(boundSym, newArg)
+    }.withSpan(boundSym.span)
+    inlining.println(i"parameter binding: $binding, $argIsBottom")
+    buf += binding
+    binding
+  }
+
+  /** Populate `paramBinding` and `buf` by matching parameters with
+   *  corresponding arguments. `bindingbuf` will be further extended later by
+   *  proxies to this-references. Issue an error if some arguments are missing.
+   */
+  private def computeParamBindings(
+      tp: Type, targs: List[Tree],
+      argss: List[List[Tree]], formalss: List[List[Type]],
+      buf: DefBuffer): Boolean =
+    tp match
+      case tp: PolyType =>
+        tp.paramNames.lazyZip(targs).foreach { (name, arg) =>
+          paramSpan(name) = arg.span
+          paramBinding(name) = arg.tpe.stripTypeVar
+        }
+        computeParamBindings(tp.resultType, targs.drop(tp.paramNames.length), argss, formalss, buf)
+      case tp: MethodType =>
+        if argss.isEmpty then
+          report.error(i"missing arguments for inline method $inlinedMethod", call.srcPos)
+          false
+        else
+          tp.paramNames.lazyZip(formalss.head).lazyZip(argss.head).foreach { (name, formal, arg) =>
+            paramSpan(name) = arg.span
+            paramBinding(name) = arg.tpe.dealias match
+              case _: SingletonType if isIdempotentPath(arg) =>
+                arg.tpe
+              case _ =>
+                paramBindingDef(name, formal, arg, buf).symbol.termRef
+          }
+          computeParamBindings(tp.resultType, targs, argss.tail, formalss.tail, buf)
+      case _ =>
+        assert(targs.isEmpty)
+        assert(argss.isEmpty)
+        true
+
+  /** The number of enclosing classes of this class, plus one */
+  private def classNestingLevel(cls: Symbol) = cls.ownersIterator.count(_.isClass)
+
+  // Compute val-definitions for all this-proxies and append them to `bindingsBuf`
+  private def computeThisBindings() = {
+    // All needed this-proxies, paired-with and sorted-by nesting depth of
+    // the classes they represent (innermost first)
+    val sortedProxies = thisProxy.toList
+      .map((cls, proxy) => (classNestingLevel(cls), proxy.symbol, cls))
+      .sortBy(-_._1)
+
+    def outerSelect(prefix: Tree, prefixCls: Symbol, hops: Int, info: Type) =
+      val tpt = TypeTree(adaptToPrefix(prefixCls.appliedRef))
+      val qual = Typed(prefix, tpt)
+      qual.outerSelect(hops, info)
+
+    var lastSelf: Symbol = NoSymbol
+    var lastCls: Symbol = NoSymbol
+    var lastLevel: Int = 0
+    for ((level, selfSym, cls) <- sortedProxies) {
+      val rhs = selfSym.info.dealias match
+        case info: TermRef
+        if info.isStable && (lastSelf.exists || isPureExpr(inlineCallPrefix)) =>
+          // If this is the first proxy, optimize to `ref(info)` only if call prefix is pure.
+          // Otherwise we might forget side effects. See run/i12829.scala.
+          ref(info)
+        case info =>
+          val rhsClsSym = info.widenDealias.classSymbol
+          if rhsClsSym.is(Module) && rhsClsSym.isStatic then
+            ref(rhsClsSym.sourceModule)
+          else if lastSelf.exists then
+            outerSelect(ref(lastSelf), lastCls, lastLevel - level, selfSym.info)
+          else
+            val pre = inlineCallPrefix match
+              case Super(qual, _) => qual
+              case pre => pre
+            val preLevel = classNestingLevel(inlinedMethod.owner)
+            if preLevel > level then outerSelect(pre, inlinedMethod.owner, preLevel - level, selfSym.info)
+            else pre
+
+      val binding = accountForOpaques(
+        ValDef(selfSym.asTerm, QuoteUtils.changeOwnerOfTree(rhs, selfSym)).withSpan(selfSym.span))
+      bindingsBuf += binding
+      inlining.println(i"proxy at $level: $selfSym = ${bindingsBuf.last}")
+      lastSelf = selfSym
+      lastLevel = level
+      lastCls = cls
+    }
+  }
+
+  /** A list of pairs between TermRefs appearing in thisProxy bindings that
+   *  refer to objects with opaque type aliases and local proxy symbols
+   *  that contain refined versions of these TermRefs where the aliases
+   *  are exposed.
+   */
+  private val opaqueProxies = new mutable.ListBuffer[(TermRef, TermRef)]
+
+  protected def hasOpaqueProxies = opaqueProxies.nonEmpty
+
+  /** Map first halfs of opaqueProxies pairs to second halfs, using =:= as equality */
+  private def mapRef(ref: TermRef): Option[TermRef] =
+    opaqueProxies.collectFirst {
+      case (from, to) if from.symbol == ref.symbol && from =:= ref => to
+    }
+
+  /** If `tp` contains TermRefs that refer to objects with opaque
+   *  type aliases, add proxy definitions to `opaqueProxies` that expose these aliases.
+   */
+  private def addOpaqueProxies(tp: Type, span: Span, forThisProxy: Boolean)(using Context): Unit =
+    tp.foreachPart {
+      case ref: TermRef =>
+        for cls <- ref.widen.baseClasses do
+          if cls.containsOpaques
+             && (forThisProxy || inlinedMethod.isContainedIn(cls))
+             && mapRef(ref).isEmpty
+          then
+            def openOpaqueAliases(selfType: Type): List[(Name, Type)] = selfType match
+              case RefinedType(parent, rname, TypeAlias(alias)) =>
+                val opaq = cls.info.member(rname).symbol
+                if opaq.isOpaqueAlias then
+                  (rname, alias.stripLazyRef.asSeenFrom(ref, cls))
+                  :: openOpaqueAliases(parent)
+                else Nil
+              case _ =>
+                Nil
+            val refinements = openOpaqueAliases(cls.givenSelfType)
+            val refinedType = refinements.foldLeft(ref: Type) ((parent, refinement) =>
+              RefinedType(parent, refinement._1, TypeAlias(refinement._2))
+            )
+            val refiningSym = newSym(InlineBinderName.fresh(), Synthetic, refinedType).asTerm
+            val refiningDef = ValDef(refiningSym, tpd.ref(ref).cast(refinedType)).withSpan(span)
+            inlining.println(i"add opaque alias proxy $refiningDef for $ref in $tp")
+            bindingsBuf += refiningDef
+            opaqueProxies += ((ref, refiningSym.termRef))
+      case _ =>
+    }
+
+  /** Map all TermRefs that match left element in `opaqueProxies` to the
+   *  corresponding right element.
+   */
+  private val mapOpaques = TreeTypeMap(
+      typeMap = new TypeMap:
+          override def stopAt = StopAt.Package
+          def apply(t: Type) = mapOver {
+            t match
+              case ref: TermRef => mapRef(ref).getOrElse(ref)
+              case _ => t
+          }
+    )
+
+  /** If `binding` contains TermRefs that refer to objects with opaque
+   *  type aliases, add proxy definitions that expose these aliases
+   *  and substitute such TermRefs with theproxies. Example from pos/opaque-inline1.scala:
+   *
+   *  object refined:
+   *    opaque type Positive = Int
+   *    inline def Positive(value: Int): Positive = f(value)
+   *    def f(x: Positive): Positive = x
+   *  def run: Unit = { val x = 9; val nine = refined.Positive(x) }
+   *
+   *  This generates the following proxies:
+   *
+   *    val $proxy1: refined.type{type Positive = Int} =
+   *      refined.$asInstanceOf$[refined.type{type Positive = Int}]
+   *    val refined$_this: ($proxy1 : refined.type{Positive = Int}) =
+   *      $proxy1
+   *
+   *  and every reference to `refined` in the inlined expression is replaced by
+   *  `refined_$this`.
+   */
+  private def accountForOpaques(binding: ValDef)(using Context): ValDef =
+    addOpaqueProxies(binding.symbol.info, binding.span, forThisProxy = true)
+    if opaqueProxies.isEmpty then binding
+    else
+      binding.symbol.info = mapOpaques.typeMap(binding.symbol.info)
+      mapOpaques.transform(binding).asInstanceOf[ValDef]
+        .showing(i"transformed this binding exposing opaque aliases: $result", inlining)
+  end accountForOpaques
+
+  /** If value argument contains references to objects that contain opaque types,
+   *  map them to their opaque proxies.
+   */
+  private def mapOpaquesInValueArg(arg: Tree)(using Context): Tree =
+    val argType = arg.tpe.widenDealias
+    addOpaqueProxies(argType, arg.span, forThisProxy = false)
+    if opaqueProxies.nonEmpty then
+      val mappedType = mapOpaques.typeMap(argType)
+      if mappedType ne argType then arg.cast(AndType(arg.tpe, mappedType))
+      else arg
+    else arg
+
+  private def canElideThis(tpe: ThisType): Boolean =
+    inlineCallPrefix.tpe == tpe && ctx.owner.isContainedIn(tpe.cls)
+    || tpe.cls.isContainedIn(inlinedMethod)
+    || tpe.cls.is(Package)
+    || tpe.cls.isStaticOwner && !(tpe.cls.seesOpaques && inlinedMethod.isContainedIn(tpe.cls))
+
+  private def adaptToPrefix(tp: Type) = tp.asSeenFrom(inlineCallPrefix.tpe, inlinedMethod.owner)
+
+  /** Populate `thisProxy` and `paramProxy` as follows:
+   *
+   *  1a. If given type refers to a static this, thisProxy binds it to corresponding global reference,
+   *  1b. If given type refers to an instance this to a class that is not contained in the
+   *      inline method, create a proxy symbol and bind the thistype to refer to the proxy.
+   *      The proxy is not yet entered in `bindingsBuf`; that will come later.
+   *  2.  If given type refers to a parameter, make `paramProxy` refer to the entry stored
+   *      in `paramNames` under the parameter's name. This roundabout way to bind parameter
+   *      references to proxies is done because  we don't know a priori what the parameter
+   *      references of a method are (we only know the method's type, but that contains TypeParamRefs
+   *      and MethodParams, not TypeRefs or TermRefs.
+   */
+  private def registerType(tpe: Type): Unit = tpe match {
+    case tpe: ThisType if !canElideThis(tpe) && !thisProxy.contains(tpe.cls) =>
+      val proxyName = s"${tpe.cls.name}_this".toTermName
+      val proxyType = inlineCallPrefix.tpe.dealias.tryNormalize match {
+        case typeMatchResult if typeMatchResult.exists => typeMatchResult
+        case _ => adaptToPrefix(tpe).widenIfUnstable
+      }
+      thisProxy(tpe.cls) = newSym(proxyName, InlineProxy, proxyType).termRef
+      for (param <- tpe.cls.typeParams)
+        paramProxy(param.typeRef) = adaptToPrefix(param.typeRef)
+    case tpe: NamedType
+    if tpe.symbol.is(Param)
+        && tpe.symbol.owner == inlinedMethod
+        && (tpe.symbol.isTerm || inlinedMethod.paramSymss.exists(_.contains(tpe.symbol)))
+          // this test is needed to rule out nested LambdaTypeTree parameters
+          // with the same name as the method's parameters. Note that the nested
+          // LambdaTypeTree parameters also have the inlineMethod as owner. C.f. i13460.scala.
+        && !paramProxy.contains(tpe) =>
+      paramBinding.get(tpe.name) match
+        case Some(bound) => paramProxy(tpe) = bound
+        case _ =>  // can happen for params bound by type-lambda trees.
+
+      // The widened type may contain param types too (see tests/pos/i12379a.scala)
+      if tpe.isTerm then registerType(tpe.widenTermRefExpr)
+    case _ =>
+  }
+
+  private val registerTypes = new TypeTraverser:
+    override def stopAt = StopAt.Package
+    override def traverse(t: Type) =
+      registerType(t)
+      traverseChildren(t)
+
+  /** Register type of leaf node */
+  private def registerLeaf(tree: Tree): Unit = tree match
+    case _: This | _: Ident | _: TypeTree => registerTypes.traverse(tree.typeOpt)
+    case _ =>
+
+  /** Make `tree` part of inlined expansion. This means its owner has to be changed
+   *  from its `originalOwner`, and, if it comes from outside the inlined method
+   *  itself, it has to be marked as an inlined argument.
+   */
+  private def integrate(tree: Tree, originalOwner: Symbol)(using Context): Tree =
+    // assertAllPositioned(tree)   // debug
+    tree.changeOwner(originalOwner, ctx.owner)
+
+  def tryConstValue: Tree =
+    TypeComparer.constValue(callTypeArgs.head.tpe) match {
+      case Some(c) => Literal(c).withSpan(call.span)
+      case _ => EmptyTree
+    }
+
+  val reducer = new InlineReducer(this)
+
+  /** The Inlined node representing the inlined call */
+  def inlined(rhsToInline: tpd.Tree): (List[MemberDef], Tree) =
+
+    inlining.println(i"-----------------------\nInlining $call\nWith RHS $rhsToInline")
+
+    def paramTypess(call: Tree, acc: List[List[Type]]): List[List[Type]] = call match
+      case Apply(fn, args) =>
+        fn.tpe.widen.match
+          case mt: MethodType => paramTypess(fn, mt.instantiateParamInfos(args.tpes) :: acc)
+          case _ => Nil
+      case TypeApply(fn, _) => paramTypess(fn, acc)
+      case _ => acc
+
+    val paramBindings =
+      val mappedCallValueArgss = callValueArgss.nestedMapConserve(mapOpaquesInValueArg)
+      if mappedCallValueArgss ne callValueArgss then
+        inlining.println(i"mapped value args = ${mappedCallValueArgss.flatten}%, %")
+
+      val paramBindingsBuf = new DefBuffer
+      // Compute bindings for all parameters, appending them to bindingsBuf
+      if !computeParamBindings(
+          inlinedMethod.info, callTypeArgs,
+          mappedCallValueArgss, paramTypess(call, Nil),
+          paramBindingsBuf)
+      then
+        return (Nil, EmptyTree)
+
+      paramBindingsBuf.toList
+    end paramBindings
+
+    // make sure prefix is executed if it is impure
+    if !isIdempotentExpr(inlineCallPrefix) then registerType(inlinedMethod.owner.thisType)
+
+    // Register types of all leaves of inlined body so that the `paramProxy` and `thisProxy` maps are defined.
+    rhsToInline.foreachSubTree(registerLeaf)
+
+    // Compute bindings for all this-proxies, appending them to bindingsBuf
+    computeThisBindings()
+
+    // Parameter bindings come after this bindings, reflecting order of evaluation
+    bindingsBuf ++= paramBindings
+
+    val inlineTyper = new InlineTyper(ctx.reporter.errorCount)
+
+    val inlineCtx = inlineContext(call).fresh.setTyper(inlineTyper).setNewScope
+
+    def inlinedFromOutside(tree: Tree)(span: Span): Tree =
+      Inlined(EmptyTree, Nil, tree)(using ctx.withSource(inlinedMethod.topLevelClass.source)).withSpan(span)
+
+    // A tree type map to prepare the inlined body for typechecked.
+    // The translation maps references to `this` and parameters to
+    // corresponding arguments or proxies on the type and term level. It also changes
+    // the owner from the inlined method to the current owner.
+    val inliner = new InlinerMap(
+      typeMap =
+        new DeepTypeMap {
+          override def stopAt =
+            if opaqueProxies.isEmpty then StopAt.Static else StopAt.Package
+          def apply(t: Type) = t match {
+            case t: ThisType => thisProxy.getOrElse(t.cls, t)
+            case t: TypeRef => paramProxy.getOrElse(t, mapOver(t))
+            case t: SingletonType =>
+              if t.termSymbol.isAllOf(InlineParam) then apply(t.widenTermRefExpr)
+              else paramProxy.getOrElse(t, mapOver(t))
+            case t => mapOver(t)
+          }
+        },
+      treeMap = {
+        case tree: This =>
+          tree.tpe match {
+            case thistpe: ThisType =>
+              thisProxy.get(thistpe.cls) match {
+                case Some(t) =>
+                  val thisRef = ref(t).withSpan(call.span)
+                  inlinedFromOutside(thisRef)(tree.span)
+                case None => tree
+              }
+            case _ => tree
+          }
+        case tree: Ident =>
+          /* Span of the argument. Used when the argument is inlined directly without a binding */
+          def argSpan =
+            if (tree.name == nme.WILDCARD) tree.span // From type match
+            else if (tree.symbol.isTypeParam && tree.symbol.owner.isClass) tree.span // TODO is this the correct span?
+            else paramSpan(tree.name)
+          val inlinedCtx = ctx.withSource(inlinedMethod.topLevelClass.source)
+          paramProxy.get(tree.tpe) match {
+            case Some(t) if tree.isTerm && t.isSingleton =>
+              val inlinedSingleton = singleton(t).withSpan(argSpan)
+              inlinedFromOutside(inlinedSingleton)(tree.span)
+            case Some(t) if tree.isType =>
+              inlinedFromOutside(TypeTree(t).withSpan(argSpan))(tree.span)
+            case _ => tree
+          }
+        case tree @ Select(qual: This, name) if tree.symbol.is(Private) && tree.symbol.isInlineMethod =>
+          // This inline method refers to another (private) inline method (see tests/pos/i14042.scala).
+          // We insert upcast to access the private inline method once inlined. This makes the selection
+          // keep the symbol when re-typechecking in the InlineTyper. The method is inlined and hence no
+          // reference to a private method is kept at runtime.
+          cpy.Select(tree)(qual.asInstance(qual.tpe.widen), name)
+
+        case tree => tree
+      },
+      oldOwners = inlinedMethod :: Nil,
+      newOwners = ctx.owner :: Nil,
+      substFrom = Nil,
+      substTo = Nil
+    )(using inlineCtx)
+
+    inlining.println(
+      i"""inliner transform with
+         |thisProxy = ${thisProxy.toList.map(_._1)}%, % --> ${thisProxy.toList.map(_._2)}%, %
+         |paramProxy = ${paramProxy.toList.map(_._1.typeSymbol.showLocated)}%, % --> ${paramProxy.toList.map(_._2)}%, %""")
+
+    // Apply inliner to `rhsToInline`, split off any implicit bindings from result, and
+    // make them part of `bindingsBuf`. The expansion is then the tree that remains.
+    val expansion = inliner.transform(rhsToInline)
+
+    def issueError() = callValueArgss match {
+      case (msgArg :: Nil) :: Nil =>
+        val message = msgArg.tpe match {
+          case ConstantType(Constant(msg: String)) => msg
+          case _ => s"A literal string is expected as an argument to `compiletime.error`. Got ${msgArg.show}"
+        }
+        // Usually `error` is called from within a rewrite method. In this
+        // case we need to report the error at the point of the outermost enclosing inline
+        // call. This way, a defensively written rewrite method can always
+        // report bad inputs at the point of call instead of revealing its internals.
+        val callToReport = if (enclosingInlineds.nonEmpty) enclosingInlineds.last else call
+        val ctxToReport = ctx.outersIterator.dropWhile(enclosingInlineds(using _).nonEmpty).next
+        // The context in which we report should still use the existing context reporter
+        val ctxOrigReporter = ctxToReport.fresh.setReporter(ctx.reporter)
+        inContext(ctxOrigReporter) {
+          report.error(message, callToReport.srcPos)
+        }
+      case _ =>
+    }
+
+    /** The number of nodes in this tree, excluding code in nested inline
+     *  calls and annotations of definitions.
+     */
+    def treeSize(x: Any): Int =
+      var siz = 0
+      x match
+        case x: Trees.Inlined[_] =>
+        case x: Positioned =>
+          var i = 0
+          while i < x.productArity do
+            siz += treeSize(x.productElement(i))
+            i += 1
+        case x: List[_] =>
+          var xs = x
+          while xs.nonEmpty do
+            siz += treeSize(xs.head)
+            xs = xs.tail
+        case _ =>
+      siz
+
+    trace(i"inlining $call", inlining, show = true) {
+
+      // The normalized bindings collected in `bindingsBuf`
+      bindingsBuf.mapInPlace { binding =>
+        // Set trees to symbols allow macros to see the definition tree.
+        // This is used by `underlyingArgument`.
+        val binding1 = reducer.normalizeBinding(binding)(using inlineCtx).setDefTree
+        binding1.foreachSubTree {
+          case tree: MemberDef => tree.setDefTree
+          case _ =>
+        }
+        binding1
+      }
+
+      // Run a typing pass over the inlined tree. See InlineTyper for details.
+      val expansion1 = inlineTyper.typed(expansion)(using inlineCtx)
+
+      if (ctx.settings.verbose.value) {
+        inlining.println(i"to inline = $rhsToInline")
+        inlining.println(i"original bindings = ${bindingsBuf.toList}%\n%")
+        inlining.println(i"original expansion = $expansion1")
+      }
+
+      // Drop unused bindings
+      val (finalBindings, finalExpansion) = dropUnusedDefs(bindingsBuf.toList, expansion1)
+
+      if (inlinedMethod == defn.Compiletime_error) issueError()
+
+      addInlinedTrees(treeSize(finalExpansion))
+
+      (finalBindings, finalExpansion)
+    }
+  end inlined
+
+  /** An extractor for references to inlineable arguments. These are :
+    *   - by-value arguments marked with `inline`
+    *   - all by-name arguments
+    */
+  private object InlineableArg {
+    lazy val paramProxies = paramProxy.values.toSet
+    def unapply(tree: Trees.Ident[?])(using Context): Option[Tree] = {
+      def search(buf: DefBuffer) = buf.find(_.name == tree.name)
+      if (paramProxies.contains(tree.typeOpt))
+        search(bindingsBuf) match {
+          case Some(bind: ValOrDefDef) if bind.symbol.is(Inline) =>
+            Some(integrate(bind.rhs, bind.symbol))
+          case _ => None
+        }
+      else None
+    }
+  }
+
+  private[inlines] def tryInlineArg(tree: Tree)(using Context): Tree = tree match {
+    case InlineableArg(rhs) =>
+      inlining.println(i"inline arg $tree -> $rhs")
+      rhs
+    case _ =>
+      EmptyTree
+  }
+
+  /** A typer for inlined bodies. Beyond standard typing, an inline typer performs
+   *  the following functions:
+   *
+   *  1. Implement constant folding over inlined code
+   *  2. Selectively expand ifs with constant conditions
+   *  3. Inline arguments that are by-name closures
+   *  4. Make sure inlined code is type-correct.
+   *  5. Make sure that the tree's typing is idempotent (so that future -Ycheck passes succeed)
+   */
+  class InlineTyper(initialErrorCount: Int, @constructorOnly nestingLevel: Int = ctx.nestingLevel + 1)
+  extends ReTyper(nestingLevel):
+    import reducer._
+
+    override def ensureAccessible(tpe: Type, superAccess: Boolean, pos: SrcPos)(using Context): Type = {
+      tpe match {
+        case tpe: NamedType if tpe.symbol.exists && !tpe.symbol.isAccessibleFrom(tpe.prefix, superAccess) =>
+          tpe.info match {
+            case TypeAlias(alias) => return ensureAccessible(alias, superAccess, pos)
+            case info: ConstantType if tpe.symbol.isStableMember => return info
+            case _ =>
+          }
+        case _ =>
+      }
+      super.ensureAccessible(tpe, superAccess, pos)
+    }
+
+    /** Enter implicits in scope so that they can be found in implicit search.
+     *  This is important for non-transparent inlines
+     */
+    override def index(trees: List[untpd.Tree])(using Context): Context =
+      for case tree: untpd.MemberDef <- trees do
+        if tree.symbol.isOneOf(Flags.GivenOrImplicit) then
+          ctx.scope.openForMutations.enter(tree.symbol)
+      ctx
+
+    override def typedIdent(tree: untpd.Ident, pt: Type)(using Context): Tree =
+      val tree1 = inlineIfNeeded(
+          tryInlineArg(tree.asInstanceOf[tpd.Tree]) `orElse` super.typedIdent(tree, pt)
+        )
+      tree1 match
+        case id: Ident if tpd.needsSelect(id.tpe) =>
+          inlining.println(i"expanding $id to selection")
+          ref(id.tpe.asInstanceOf[TermRef]).withSpan(id.span)
+        case _ =>
+          tree1
+
+    override def typedSelect(tree: untpd.Select, pt: Type)(using Context): Tree = {
+      val qual1 = typed(tree.qualifier, shallowSelectionProto(tree.name, pt, this))
+      val resNoReduce = untpd.cpy.Select(tree)(qual1, tree.name).withType(tree.typeOpt)
+      val reducedProjection = reducer.reduceProjection(resNoReduce)
+      if reducedProjection.isType then
+        //if the projection leads to a typed tree then we stop reduction
+        resNoReduce
+      else
+        val res = constToLiteral(reducedProjection)
+        if resNoReduce ne res then
+          typed(res, pt) // redo typecheck if reduction changed something
+        else if res.symbol.isInlineMethod then
+          inlineIfNeeded(res)
+        else
+          ensureAccessible(res.tpe, tree.qualifier.isInstanceOf[untpd.Super], tree.srcPos)
+          res
+    }
+
+    override def typedIf(tree: untpd.If, pt: Type)(using Context): Tree =
+      val condCtx = if tree.isInline then ctx.addMode(Mode.ForceInline) else ctx
+      typed(tree.cond, defn.BooleanType)(using condCtx) match {
+        case cond1 @ ConstantValue(b: Boolean) =>
+          val selected0 = if (b) tree.thenp else tree.elsep
+          val selected = if (selected0.isEmpty) tpd.Literal(Constant(())) else typed(selected0, pt)
+          if (isIdempotentExpr(cond1)) selected
+          else Block(cond1 :: Nil, selected)
+        case cond1 =>
+          if (tree.isInline)
+            errorTree(tree,
+              em"Cannot reduce `inline if` because its condition is not a constant value: $cond1")
+          else
+            cond1.computeNullableDeeply()
+            val if1 = untpd.cpy.If(tree)(cond = untpd.TypedSplice(cond1))
+            super.typedIf(if1, pt)
+      }
+
+    override def typedValDef(vdef: untpd.ValDef, sym: Symbol)(using Context): Tree =
+      val vdef1 =
+        if sym.is(Inline) then
+          val rhs = typed(vdef.rhs)
+          sym.info = rhs.tpe
+          untpd.cpy.ValDef(vdef)(vdef.name, untpd.TypeTree(rhs.tpe), untpd.TypedSplice(rhs))
+        else vdef
+      super.typedValDef(vdef1, sym)
+
+    override def typedApply(tree: untpd.Apply, pt: Type)(using Context): Tree =
+      def cancelQuotes(tree: Tree): Tree =
+        tree match
+          case Quoted(Spliced(inner)) => inner
+          case _ => tree
+      val res = cancelQuotes(constToLiteral(betaReduce(super.typedApply(tree, pt)))) match {
+        case res: Apply if res.symbol == defn.QuotedRuntime_exprSplice
+                        && StagingContext.level == 0
+                        && !hasInliningErrors =>
+          val expanded = expandMacro(res.args.head, tree.srcPos)
+          typedExpr(expanded) // Inline calls and constant fold code generated by the macro
+        case res =>
+          specializeEq(inlineIfNeeded(res))
+      }
+      res
+
+    override def typedTypeApply(tree: untpd.TypeApply, pt: Type)(using Context): Tree =
+      val tree1 = inlineIfNeeded(constToLiteral(betaReduce(super.typedTypeApply(tree, pt))))
+      if tree1.symbol.isQuote then
+        ctx.compilationUnit.needsStaging = true
+      tree1
+
+    override def typedMatch(tree: untpd.Match, pt: Type)(using Context): Tree =
+      val tree1 =
+        if tree.isInline then
+          // TODO this might not be useful if we do not support #11291
+          val sel1 = typedExpr(tree.selector)(using ctx.addMode(Mode.ForceInline))
+          untpd.cpy.Match(tree)(sel1, tree.cases)
+        else tree
+      super.typedMatch(tree1, pt)
+
+    override def typedMatchFinish(tree: untpd.Match, sel: Tree, wideSelType: Type, cases: List[untpd.CaseDef], pt: Type)(using Context) =
+      if (!tree.isInline || ctx.owner.isInlineMethod) // don't reduce match of nested inline method yet
+        super.typedMatchFinish(tree, sel, wideSelType, cases, pt)
+      else {
+        def selTyped(sel: Tree): Type = sel match {
+          case Typed(sel2, _) => selTyped(sel2)
+          case Block(Nil, sel2) => selTyped(sel2)
+          case Inlined(_, Nil, sel2) => selTyped(sel2)
+          case _ => sel.tpe
+        }
+        val selType = if (sel.isEmpty) wideSelType else selTyped(sel)
+        reduceInlineMatch(sel, selType, cases.asInstanceOf[List[CaseDef]], this) match {
+          case Some((caseBindings, rhs0)) =>
+            // drop type ascriptions/casts hiding pattern-bound types (which are now aliases after reducing the match)
+            // note that any actually necessary casts will be reinserted by the typing pass below
+            val rhs1 = rhs0 match {
+              case Block(stats, t) if t.span.isSynthetic =>
+                t match {
+                  case Typed(expr, _) =>
+                    Block(stats, expr)
+                  case TypeApply(sel@Select(expr, _), _) if sel.symbol.isTypeCast =>
+                    Block(stats, expr)
+                  case _ =>
+                    rhs0
+                }
+              case _ => rhs0
+            }
+            val (usedBindings, rhs2) = dropUnusedDefs(caseBindings, rhs1)
+            val rhs = seq(usedBindings, rhs2)
+            inlining.println(i"""--- reduce:
+                                |$tree
+                                |--- to:
+                                |$rhs""")
+            typedExpr(rhs, pt)
+          case None =>
+            def guardStr(guard: untpd.Tree) = if (guard.isEmpty) "" else i" if $guard"
+            def patStr(cdef: untpd.CaseDef) = i"case ${cdef.pat}${guardStr(cdef.guard)}"
+            val msg =
+              if (tree.selector.isEmpty)
+                em"""cannot reduce summonFrom with
+                   | patterns :  ${tree.cases.map(patStr).mkString("\n             ")}"""
+              else
+                em"""cannot reduce inline match with
+                    | scrutinee:  $sel : ${selType}
+                    | patterns :  ${tree.cases.map(patStr).mkString("\n             ")}"""
+            errorTree(tree, msg)
+        }
+      }
+
+    override def newLikeThis(nestingLevel: Int): Typer = new InlineTyper(initialErrorCount, nestingLevel)
+
+    /** True if this inline typer has already issued errors */
+    override def hasInliningErrors(using Context) = ctx.reporter.errorCount > initialErrorCount
+
+    private def inlineIfNeeded(tree: Tree)(using Context): Tree =
+      val meth = tree.symbol
+      if meth.isAllOf(DeferredInline) then
+        errorTree(tree, i"Deferred inline ${meth.showLocated} cannot be invoked")
+      else if Inlines.needsInlining(tree) then Inlines.inlineCall(tree)
+      else tree
+
+    override def typedUnadapted(tree: untpd.Tree, pt: Type, locked: TypeVars)(using Context): Tree =
+      super.typedUnadapted(tree, pt, locked) match
+        case member: MemberDef => member.setDefTree
+        case tree => tree
+
+    private def specializeEq(tree: Tree): Tree =
+      tree match
+        case Apply(sel @ Select(arg1, opName), arg2 :: Nil)
+        if sel.symbol == defn.Any_== || sel.symbol == defn.Any_!= =>
+          defn.ScalaValueClasses().find { cls =>
+            arg1.tpe.derivesFrom(cls) && arg2.tpe.derivesFrom(cls)
+          } match
+            case Some(cls) =>
+              val newOp = cls.requiredMethod(opName, List(cls.typeRef))
+              arg1.select(newOp).withSpan(sel.span).appliedTo(arg2).withSpan(tree.span)
+            case None => tree
+        case _ =>
+          tree
+  end InlineTyper
+
+  /** Drop any side-effect-free bindings that are unused in expansion or other reachable bindings.
+   *  Inline def bindings that are used only once.
+   */
+  private def dropUnusedDefs(bindings: List[MemberDef], tree: Tree)(using Context): (List[MemberDef], Tree) = {
+    // inlining.println(i"drop unused $bindings%, % in $tree")
+    val (termBindings, typeBindings) = bindings.partition(_.symbol.isTerm)
+    if (typeBindings.nonEmpty) {
+      val typeBindingsSet = typeBindings.foldLeft[SimpleIdentitySet[Symbol]](SimpleIdentitySet.empty)(_ + _.symbol)
+      val inlineTypeBindings = new TreeTypeMap(
+        typeMap = new TypeMap() {
+          override def apply(tp: Type): Type = tp match {
+            case tr: TypeRef if tr.prefix.eq(NoPrefix) && typeBindingsSet.contains(tr.symbol) =>
+              val TypeAlias(res) = tr.info: @unchecked
+              res
+            case tp => mapOver(tp)
+          }
+        },
+        treeMap = {
+          case ident: Ident if ident.isType && typeBindingsSet.contains(ident.symbol) =>
+            val TypeAlias(r) = ident.symbol.info: @unchecked
+            TypeTree(r).withSpan(ident.span)
+          case tree => tree
+        }
+      )
+      val Block(termBindings1, tree1) = inlineTypeBindings(Block(termBindings, tree))
+      dropUnusedDefs(termBindings1.asInstanceOf[List[ValOrDefDef]], tree1)
+    }
+    else {
+      val refCount = MutableSymbolMap[Int]()
+      val bindingOfSym = MutableSymbolMap[MemberDef]()
+
+      def isInlineable(binding: MemberDef) = binding match {
+        case ddef @ DefDef(_, Nil, _, _) => isElideableExpr(ddef.rhs)
+        case vdef @ ValDef(_, _, _) => isElideableExpr(vdef.rhs)
+        case _ => false
+      }
+      for (binding <- bindings if isInlineable(binding)) {
+        refCount(binding.symbol) = 0
+        bindingOfSym(binding.symbol) = binding
+      }
+
+      val countRefs = new TreeTraverser {
+        override def traverse(t: Tree)(using Context) = {
+          def updateRefCount(sym: Symbol, inc: Int) =
+            for (x <- refCount.get(sym)) refCount(sym) = x + inc
+          def updateTermRefCounts(t: Tree) =
+            t.typeOpt.foreachPart {
+              case ref: TermRef => updateRefCount(ref.symbol, 2) // can't be inlined, so make sure refCount is at least 2
+              case _ =>
+            }
+
+          t match {
+            case t: RefTree =>
+              updateRefCount(t.symbol, 1)
+              updateTermRefCounts(t)
+            case _: New | _: TypeTree =>
+              updateTermRefCounts(t)
+            case _ =>
+          }
+          traverseChildren(t)
+        }
+      }
+      countRefs.traverse(tree)
+      for (binding <- bindings) countRefs.traverse(binding)
+
+      def retain(boundSym: Symbol) = {
+        refCount.get(boundSym) match {
+          case Some(x) => x > 1 || x == 1 && !boundSym.is(Method)
+          case none => true
+        }
+      } && !boundSym.is(Inline)
+
+      val inlineBindings = new TreeMap {
+        override def transform(t: Tree)(using Context) = t match {
+          case t: RefTree =>
+            val sym = t.symbol
+            val t1 = refCount.get(sym) match {
+              case Some(1) =>
+                bindingOfSym(sym) match {
+                  case binding: ValOrDefDef => integrate(binding.rhs, sym)
+                }
+              case none => t
+            }
+            super.transform(t1)
+          case t: Apply =>
+            val t1 = super.transform(t)
+            if (t1 `eq` t) t else reducer.betaReduce(t1)
+          case Block(Nil, expr) =>
+            super.transform(expr)
+          case _ =>
+            super.transform(t)
+        }
+      }
+
+      val retained = bindings.filterConserve(binding => retain(binding.symbol))
+      if (retained `eq` bindings)
+        (bindings, tree)
+      else {
+        val expanded = inlineBindings.transform(tree)
+        dropUnusedDefs(retained, expanded)
+      }
+    }
+  }
+
+  private def expandMacro(body: Tree, splicePos: SrcPos)(using Context) = {
+    assert(StagingContext.level == 0)
+    val inlinedFrom = enclosingInlineds.last
+    val dependencies = macroDependencies(body)
+    val suspendable = ctx.compilationUnit.isSuspendable
+    if dependencies.nonEmpty && !ctx.reporter.errorsReported then
+      for sym <- dependencies do
+        if ctx.compilationUnit.source.file == sym.associatedFile then
+          report.error(em"Cannot call macro $sym defined in the same source file", call.srcPos)
+        if (suspendable && ctx.settings.XprintSuspension.value)
+          report.echo(i"suspension triggered by macro call to ${sym.showLocated} in ${sym.associatedFile}", call.srcPos)
+      if suspendable then
+        ctx.compilationUnit.suspend() // this throws a SuspendException
+
+    val evaluatedSplice = inContext(quoted.MacroExpansion.context(inlinedFrom)) {
+      Splicer.splice(body, splicePos, inlinedFrom.srcPos, MacroClassLoader.fromContext)
+    }
+    val inlinedNormailizer = new TreeMap {
+      override def transform(tree: tpd.Tree)(using Context): tpd.Tree = tree match {
+        case Inlined(EmptyTree, Nil, expr) if enclosingInlineds.isEmpty => transform(expr)
+        case _ => super.transform(tree)
+      }
+    }
+    val normalizedSplice = inlinedNormailizer.transform(evaluatedSplice)
+    if (normalizedSplice.isEmpty) normalizedSplice
+    else normalizedSplice.withSpan(splicePos.span)
+  }
+
+  /** Return the set of symbols that are referred at level -1 by the tree and defined in the current run.
+   *  This corresponds to the symbols that will need to be interpreted.
+   */
+  private def macroDependencies(tree: Tree)(using Context) =
+    new TreeAccumulator[List[Symbol]] {
+      private var level = -1
+      override def apply(syms: List[Symbol], tree: tpd.Tree)(using Context): List[Symbol] =
+        if level != -1 then foldOver(syms, tree)
+        else tree match {
+          case tree: RefTree if tree.isTerm && tree.symbol.isDefinedInCurrentRun && !tree.symbol.isLocal =>
+            foldOver(tree.symbol :: syms, tree)
+          case Quoted(body) =>
+            level += 1
+            try apply(syms, body)
+            finally level -= 1
+          case Spliced(body) =>
+            level -= 1
+            try apply(syms, body)
+            finally level += 1
+          case SplicedType(body) =>
+            level -= 1
+            try apply(syms, body)
+            finally level += 1
+          case _: TypTree =>
+            syms
+          case _ =>
+            foldOver(syms, tree)
+        }
+    }.apply(Nil, tree)
+end Inliner
diff --git a/tests/pos-with-compiler-cc/dotc/inlines/Inlines.scala b/tests/pos-with-compiler-cc/dotc/inlines/Inlines.scala
new file mode 100644
index 000000000000..8be23b932e98
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/inlines/Inlines.scala
@@ -0,0 +1,469 @@
+package dotty.tools
+package dotc
+package inlines
+
+import ast.*, core.*
+import Flags.*, Symbols.*, Types.*, Decorators.*, Constants.*, Contexts.*
+import StdNames.tpnme
+import transform.SymUtils._
+import typer.*
+import NameKinds.BodyRetainerName
+import SymDenotations.SymDenotation
+import config.Printers.inlining
+import ErrorReporting.errorTree
+import dotty.tools.dotc.util.{SourceFile, SourcePosition, SrcPos}
+import parsing.Parsers.Parser
+import transform.{PostTyper, Inlining, CrossVersionChecks}
+
+import collection.mutable
+import reporting.trace
+import util.Spans.Span
+
+/** Support for querying inlineable methods and for inlining calls to such methods */
+object Inlines:
+  import tpd._
+
+  /** An exception signalling that an inline info cannot be computed due to a
+   *  cyclic reference. i14772.scala shows a case where this happens.
+   */
+  private[dotc] class MissingInlineInfo extends Exception
+
+  /** `sym` is an inline method with a known body to inline.
+   */
+  def hasBodyToInline(sym: SymDenotation)(using Context): Boolean =
+    sym.isInlineMethod && sym.hasAnnotation(defn.BodyAnnot)
+
+  /** The body to inline for method `sym`, or `EmptyTree` if none exists.
+   *  @pre  hasBodyToInline(sym)
+   */
+  def bodyToInline(sym: SymDenotation)(using Context): Tree =
+    if hasBodyToInline(sym) then
+      sym.getAnnotation(defn.BodyAnnot).get.tree
+    else
+      EmptyTree
+
+  /** Are we in an inline method body? */
+  def inInlineMethod(using Context): Boolean =
+    ctx.owner.ownersIterator.exists(_.isInlineMethod)
+
+  /** Can a call to method `meth` be inlined? */
+  def isInlineable(meth: Symbol)(using Context): Boolean =
+    meth.is(Inline) && meth.hasAnnotation(defn.BodyAnnot) && !inInlineMethod
+
+  /** Should call be inlined in this context? */
+  def needsInlining(tree: Tree)(using Context): Boolean = tree match {
+    case Block(_, expr) => needsInlining(expr)
+    case _ =>
+      isInlineable(tree.symbol)
+      && !tree.tpe.widenTermRefExpr.isInstanceOf[MethodOrPoly]
+      && StagingContext.level == 0
+      && (
+        ctx.phase == Phases.inliningPhase
+        || (ctx.phase == Phases.typerPhase && needsTransparentInlining(tree))
+      )
+      && !ctx.typer.hasInliningErrors
+      && !ctx.base.stopInlining
+  }
+
+  private def needsTransparentInlining(tree: Tree)(using Context): Boolean =
+    tree.symbol.is(Transparent)
+    || ctx.mode.is(Mode.ForceInline)
+    || ctx.settings.YforceInlineWhileTyping.value
+
+  /** Try to inline a call to an inline method. Fail with error if the maximal
+   *  inline depth is exceeded.
+   *
+   *  @param tree   The call to inline
+   *  @param pt     The expected type of the call.
+   *  @return   An `Inlined` node that refers to the original call and the inlined bindings
+   *            and body that replace it.
+   */
+  def inlineCall(tree: Tree)(using Context): Tree =
+    if tree.symbol.denot != SymDenotations.NoDenotation
+      && tree.symbol.effectiveOwner == defn.CompiletimeTestingPackage.moduleClass
+    then
+      if (tree.symbol == defn.CompiletimeTesting_typeChecks) return Intrinsics.typeChecks(tree)
+      if (tree.symbol == defn.CompiletimeTesting_typeCheckErrors) return Intrinsics.typeCheckErrors(tree)
+
+    CrossVersionChecks.checkExperimentalRef(tree.symbol, tree.srcPos)
+
+    if tree.symbol.isConstructor then return tree // error already reported for the inline constructor definition
+
+    /** Set the position of all trees logically contained in the expansion of
+     *  inlined call `call` to the position of `call`. This transform is necessary
+     *  when lifting bindings from the expansion to the outside of the call.
+     */
+    def liftFromInlined(call: Tree) = new TreeMap:
+      override def transform(t: Tree)(using Context) =
+        if call.span.exists then
+          t match
+            case Inlined(t, Nil, expr) if t.isEmpty => expr
+            case _ if t.isEmpty => t
+            case _ => super.transform(t.withSpan(call.span))
+        else t
+    end liftFromInlined
+
+    val bindings = new mutable.ListBuffer[Tree]
+
+    /** Lift bindings around inline call or in its function part to
+     *  the `bindings` buffer. This is done as an optimization to keep
+     *  inline call expansions smaller.
+     */
+    def liftBindings(tree: Tree, liftPos: Tree => Tree): Tree = tree match {
+      case Block(stats, expr) =>
+        bindings ++= stats.map(liftPos)
+        liftBindings(expr, liftPos)
+      case Inlined(call, stats, expr) =>
+        bindings ++= stats.map(liftPos)
+        val lifter = liftFromInlined(call)
+        cpy.Inlined(tree)(call, Nil, liftBindings(expr, liftFromInlined(call).transform(_)))
+      case Apply(fn, args) =>
+        cpy.Apply(tree)(liftBindings(fn, liftPos), args)
+      case TypeApply(fn, args) =>
+        fn.tpe.widenTermRefExpr match
+          case tp: PolyType =>
+            val targBounds = tp.instantiateParamInfos(args.map(_.tpe))
+            for case (arg, bounds: TypeBounds) <- args.zip(targBounds) if !bounds.contains(arg.tpe) do
+              val boundsStr =
+                if bounds == TypeBounds.empty then " <: Any. Note that this type is higher-kinded."
+                else bounds.show
+              report.error(em"${arg.tpe} does not conform to bound$boundsStr", arg)
+        cpy.TypeApply(tree)(liftBindings(fn, liftPos), args)
+      case Select(qual, name) =>
+        cpy.Select(tree)(liftBindings(qual, liftPos), name)
+      case _ =>
+        tree
+    }
+
+    // assertAllPositioned(tree)   // debug
+    val tree1 = liftBindings(tree, identity)
+    val tree2  =
+      if bindings.nonEmpty then
+        cpy.Block(tree)(bindings.toList, inlineCall(tree1))
+      else if enclosingInlineds.length < ctx.settings.XmaxInlines.value && !reachedInlinedTreesLimit then
+        val body =
+          try bodyToInline(tree.symbol) // can typecheck the tree and thereby produce errors
+          catch case _: MissingInlineInfo =>
+            throw CyclicReference(ctx.owner)
+        new InlineCall(tree).expand(body)
+      else
+        ctx.base.stopInlining = true
+        val (reason, setting) =
+          if reachedInlinedTreesLimit then ("inlined trees", ctx.settings.XmaxInlinedTrees)
+          else ("successive inlines", ctx.settings.XmaxInlines)
+        errorTree(
+          tree,
+          i"""|Maximal number of $reason (${setting.value}) exceeded,
+              |Maybe this is caused by a recursive inline method?
+              |You can use ${setting.name} to change the limit.""".toMessage,
+          (tree :: enclosingInlineds).last.srcPos
+        )
+    if ctx.base.stopInlining && enclosingInlineds.isEmpty then
+      ctx.base.stopInlining = false
+        // we have completely backed out of the call that overflowed;
+        // reset so that further inline calls can be expanded
+    tree2
+  end inlineCall
+
+  /** Try to inline a pattern with an inline unapply method. Fail with error if the maximal
+   *  inline depth is exceeded.
+   *
+   *  @param unapp   The tree of the pattern to inline
+   *  @return   An `Unapply` with a `fun` containing the inlined call to the unapply
+   */
+  def inlinedUnapply(unapp: tpd.UnApply)(using Context): Tree =
+    // We cannot inline the unapply directly, since the pattern matcher relies on unapply applications
+    // as signposts what to do. On the other hand, we can do the inlining only in typer, not afterwards.
+    // So the trick is to create a "wrapper" unapply in an anonymous class that has the inlined unapply
+    // as its right hand side. The call to the wrapper unapply serves as the signpost for pattern matching.
+    // After pattern matching, the anonymous class is removed in phase InlinePatterns with a beta reduction step.
+    //
+    // An inline unapply `P.unapply` in a plattern `P(x1,x2,...)` is transformed into
+    // `{ class $anon { def unapply(t0: T0)(using t1: T1, t2: T2, ...): R = P.unapply(t0)(using t1, t2, ...) }; new $anon }.unapply`
+    // and the call `P.unapply(x1, x2, ...)` is inlined.
+    // This serves as a placeholder for the inlined body until the `patternMatcher` phase. After pattern matcher
+    // transforms the patterns into terms, the `inlinePatterns` phase removes this anonymous class by β-reducing
+    // the call to the `unapply`.
+
+    object SplitFunAndGivenArgs:
+      def unapply(tree: Tree): (Tree, List[List[Tree]]) = tree match
+        case Apply(SplitFunAndGivenArgs(fn, argss), args) => (fn, argss :+ args)
+        case _ => (tree, Nil)
+    val UnApply(SplitFunAndGivenArgs(fun, leadingImplicits), trailingImplicits, patterns) = unapp
+    if leadingImplicits.flatten.nonEmpty then
+      // To support them see https://github.com/lampepfl/dotty/pull/13158
+      report.error("inline unapply methods with given parameters before the scrutinee are not supported", fun)
+
+    val sym = unapp.symbol
+
+    var unapplySym1: Symbol = NoSymbol // created from within AnonClass() and used afterwards
+
+    val newUnapply = AnonClass(ctx.owner, List(defn.ObjectType), sym.coord) { cls =>
+      val targs = fun match
+        case TypeApply(_, targs) => targs
+        case _ => Nil
+      val unapplyInfo = sym.info match
+        case info: PolyType => info.instantiate(targs.map(_.tpe))
+        case info => info
+
+      val unapplySym = newSymbol(cls, sym.name.toTermName, Synthetic | Method, unapplyInfo, coord = sym.coord).entered
+      val unapply = DefDef(unapplySym.asTerm, argss =>
+        inlineCall(fun.appliedToArgss(argss).withSpan(unapp.span))(using ctx.withOwner(unapplySym))
+      )
+      unapplySym1 = unapplySym
+      List(unapply)
+    }
+
+    val newFun = newUnapply.select(unapplySym1).withSpan(unapp.span)
+    cpy.UnApply(unapp)(newFun, trailingImplicits, patterns)
+  end inlinedUnapply
+
+  /** For a retained inline method, another method that keeps track of
+   *  the body that is kept at runtime. For instance, an inline method
+   *
+   *      inline override def f(x: T) = b
+   *
+   *  is complemented by the body retainer method
+   *
+   *      private def f$retainedBody(x: T) = f(x)
+   *
+   *  where the call `f(x)` is inline-expanded. This body is then transferred
+   *  back to `f` at erasure, using method addRetainedInlineBodies.
+   */
+  def bodyRetainer(mdef: DefDef)(using Context): DefDef =
+    val meth = mdef.symbol.asTerm
+
+    val retainer = meth.copy(
+      name = BodyRetainerName(meth.name),
+      flags = meth.flags &~ (Inline | Macro | Override) | Private,
+      coord = mdef.rhs.span.startPos).asTerm
+    retainer.deriveTargetNameAnnotation(meth, name => BodyRetainerName(name.asTermName))
+    DefDef(retainer, prefss =>
+      inlineCall(
+        ref(meth).appliedToArgss(prefss).withSpan(mdef.rhs.span.startPos))(
+        using ctx.withOwner(retainer)))
+    .showing(i"retainer for $meth: $result", inlining)
+
+  /** Replace `Inlined` node by a block that contains its bindings and expansion */
+  def dropInlined(inlined: Inlined)(using Context): Tree =
+    val tree1 =
+      if inlined.bindings.isEmpty then inlined.expansion
+      else cpy.Block(inlined)(inlined.bindings, inlined.expansion)
+    // Reposition in the outer most inlined call
+    if (enclosingInlineds.nonEmpty) tree1 else reposition(tree1, inlined.span)
+
+  def reposition(tree: Tree, callSpan: Span)(using Context): Tree =
+    // Reference test tests/run/i4947b
+
+    val curSource = ctx.compilationUnit.source
+
+    // Tree copier that changes the source of all trees to `curSource`
+    val cpyWithNewSource = new TypedTreeCopier {
+      override protected def sourceFile(tree: tpd.Tree): SourceFile = curSource
+      override protected val untpdCpy: untpd.UntypedTreeCopier = new untpd.UntypedTreeCopier {
+        override protected def sourceFile(tree: untpd.Tree): SourceFile = curSource
+      }
+    }
+
+    /** Removes all Inlined trees, replacing them with blocks.
+     *  Repositions all trees directly inside an inlined expansion of a non empty call to the position of the call.
+     *  Any tree directly inside an empty call (inlined in the inlined code) retains their position.
+     *
+     *  Until we implement JSR-45, we cannot represent in output positions in other source files.
+     *  So, reposition inlined code from other files with the call position.
+     */
+    class Reposition extends TreeMap(cpyWithNewSource) {
+
+      override def transform(tree: Tree)(using Context): Tree = {
+        def fixSpan[T <: untpd.Tree](copied: T): T =
+          copied.withSpan(if tree.source == curSource then tree.span else callSpan)
+        def finalize(copied: untpd.Tree) =
+          fixSpan(copied).withAttachmentsFrom(tree).withTypeUnchecked(tree.tpe)
+
+        inContext(ctx.withSource(curSource)) {
+          tree match
+            case tree: Ident => finalize(untpd.Ident(tree.name)(curSource))
+            case tree: Literal => finalize(untpd.Literal(tree.const)(curSource))
+            case tree: This => finalize(untpd.This(tree.qual)(curSource))
+            case tree: JavaSeqLiteral => finalize(untpd.JavaSeqLiteral(transform(tree.elems), transform(tree.elemtpt))(curSource))
+            case tree: SeqLiteral => finalize(untpd.SeqLiteral(transform(tree.elems), transform(tree.elemtpt))(curSource))
+            case tree: Bind => finalize(untpd.Bind(tree.name, transform(tree.body))(curSource))
+            case tree: TypeTree => finalize(tpd.TypeTree(tree.tpe))
+            case tree: DefTree => super.transform(tree).setDefTree
+            case EmptyTree => tree
+            case _ => fixSpan(super.transform(tree))
+        }
+      }
+    }
+
+    (new Reposition).transform(tree)
+  end reposition
+
+  /** Leave only a call trace consisting of
+   *  - a reference to the top-level class from which the call was inlined,
+   *  - the call's position
+   *  in the call field of an Inlined node.
+   *  The trace has enough info to completely reconstruct positions.
+   *  Note: For macros it returns a Select and for other inline methods it returns an Ident (this distinction is only temporary to be able to run YCheckPositions)
+   */
+  def inlineCallTrace(callSym: Symbol, pos: SourcePosition)(using Context): Tree = {
+    assert(ctx.source == pos.source)
+    val topLevelCls = callSym.topLevelClass
+    if (callSym.is(Macro)) ref(topLevelCls.owner).select(topLevelCls.name)(using ctx.withOwner(topLevelCls.owner)).withSpan(pos.span)
+    else Ident(topLevelCls.typeRef).withSpan(pos.span)
+  }
+
+  private object Intrinsics:
+    import dotty.tools.dotc.reporting.Diagnostic.Error
+    private enum ErrorKind:
+      case Parser, Typer
+
+    private def compileForErrors(tree: Tree)(using Context): List[(ErrorKind, Error)] =
+      assert(tree.symbol == defn.CompiletimeTesting_typeChecks || tree.symbol == defn.CompiletimeTesting_typeCheckErrors)
+      def stripTyped(t: Tree): Tree = t match {
+        case Typed(t2, _) => stripTyped(t2)
+        case Block(Nil, t2) => stripTyped(t2)
+        case Inlined(_, Nil, t2) => stripTyped(t2)
+        case _ => t
+      }
+
+      val Apply(_, codeArg :: Nil) = tree: @unchecked
+      val codeArg1 = stripTyped(codeArg.underlying)
+      val underlyingCodeArg =
+        if Inlines.isInlineable(codeArg1.symbol) then stripTyped(Inlines.inlineCall(codeArg1))
+        else codeArg1
+
+      ConstFold(underlyingCodeArg).tpe.widenTermRefExpr match {
+        case ConstantType(Constant(code: String)) =>
+          val source2 = SourceFile.virtual("tasty-reflect", code)
+          inContext(ctx.fresh.setNewTyperState().setTyper(new Typer(ctx.nestingLevel + 1)).setSource(source2)) {
+            val tree2 = new Parser(source2).block()
+            if ctx.reporter.allErrors.nonEmpty then
+              ctx.reporter.allErrors.map((ErrorKind.Parser, _))
+            else
+              val tree3 = ctx.typer.typed(tree2)
+              ctx.base.postTyperPhase match
+                case postTyper: PostTyper if ctx.reporter.allErrors.isEmpty =>
+                  val tree4 = atPhase(postTyper) { postTyper.newTransformer.transform(tree3) }
+                  ctx.base.inliningPhase match
+                    case inlining: Inlining if ctx.reporter.allErrors.isEmpty =>
+                      atPhase(inlining) { inlining.newTransformer.transform(tree4) }
+                    case _ =>
+                case _ =>
+              ctx.reporter.allErrors.map((ErrorKind.Typer, _))
+          }
+        case t =>
+          report.error(em"argument to compileError must be a statically known String but was: $codeArg", codeArg1.srcPos)
+          Nil
+      }
+
+    private def packError(kind: ErrorKind, error: Error)(using Context): Tree =
+      def lit(x: Any) = Literal(Constant(x))
+      val constructor: Tree = ref(defn.CompiletimeTesting_Error_apply)
+      val parserErrorKind: Tree = ref(defn.CompiletimeTesting_ErrorKind_Parser)
+      val typerErrorKind: Tree = ref(defn.CompiletimeTesting_ErrorKind_Typer)
+
+      constructor.appliedTo(
+        lit(error.message),
+        lit(error.pos.lineContent.reverse.dropWhile("\n ".contains).reverse),
+        lit(error.pos.column),
+        if kind == ErrorKind.Parser then parserErrorKind else typerErrorKind)
+
+    private def packErrors(errors: List[(ErrorKind, Error)], pos: SrcPos)(using Context): Tree =
+      val individualErrors: List[Tree] = errors.map(packError)
+      val errorTpt = ref(defn.CompiletimeTesting_ErrorClass).withSpan(pos.span)
+      mkList(individualErrors, errorTpt)
+
+    /** Expand call to scala.compiletime.testing.typeChecks */
+    def typeChecks(tree: Tree)(using Context): Tree =
+      val errors = compileForErrors(tree)
+      Literal(Constant(errors.isEmpty)).withSpan(tree.span)
+
+    /** Expand call to scala.compiletime.testing.typeCheckErrors */
+    def typeCheckErrors(tree: Tree)(using Context): Tree =
+      val errors = compileForErrors(tree)
+      packErrors(errors, tree)
+
+    /** Expand call to scala.compiletime.codeOf */
+    def codeOf(arg: Tree, pos: SrcPos)(using Context): Tree =
+      val ctx1 = ctx.fresh.setSetting(ctx.settings.color, "never")
+      Literal(Constant(arg.show(using ctx1))).withSpan(pos.span)
+  end Intrinsics
+
+  /** Produces an inlined version of `call` via its `inlined` method.
+   *
+   *  @param  call         the original call to an inlineable method
+   *  @param  rhsToInline  the body of the inlineable method that replaces the call.
+   */
+  private class InlineCall(call: tpd.Tree)(using Context) extends Inliner(call):
+    import tpd._
+    import Inlines.*
+
+    /** The Inlined node representing the inlined call */
+    def expand(rhsToInline: Tree): Tree =
+
+      // Special handling of `requireConst` and `codeOf`
+      callValueArgss match
+        case (arg :: Nil) :: Nil =>
+          if inlinedMethod == defn.Compiletime_requireConst then
+            arg match
+              case ConstantValue(_) | Inlined(_, Nil, Typed(ConstantValue(_), _)) => // ok
+              case _ => report.error(em"expected a constant value but found: $arg", arg.srcPos)
+            return Literal(Constant(())).withSpan(call.span)
+          else if inlinedMethod == defn.Compiletime_codeOf then
+            return Intrinsics.codeOf(arg, call.srcPos)
+        case _ =>
+
+      // Special handling of `constValue[T]`, `constValueOpt[T], and summonInline[T]`
+      if callTypeArgs.length == 1 then
+        if (inlinedMethod == defn.Compiletime_constValue) {
+          val constVal = tryConstValue
+          if constVal.isEmpty then
+            val msg = em"not a constant type: ${callTypeArgs.head}; cannot take constValue"
+            return ref(defn.Predef_undefined).withSpan(call.span).withType(ErrorType(msg))
+          else
+            return constVal
+        }
+        else if (inlinedMethod == defn.Compiletime_constValueOpt) {
+          val constVal = tryConstValue
+          return (
+            if (constVal.isEmpty) ref(defn.NoneModule.termRef)
+            else New(defn.SomeClass.typeRef.appliedTo(constVal.tpe), constVal :: Nil)
+          )
+        }
+        else if (inlinedMethod == defn.Compiletime_summonInline) {
+          def searchImplicit(tpt: Tree) =
+            val evTyper = new Typer(ctx.nestingLevel + 1)
+            val evCtx = ctx.fresh.setTyper(evTyper)
+            inContext(evCtx) {
+              val evidence = evTyper.inferImplicitArg(tpt.tpe, tpt.span)
+              evidence.tpe match
+                case fail: Implicits.SearchFailureType =>
+                  val msg = evTyper.missingArgMsg(evidence, tpt.tpe, "")
+                  errorTree(call, em"$msg")
+                case _ =>
+                  evidence
+            }
+          return searchImplicit(callTypeArgs.head)
+        }
+      end if
+
+      val (bindings, expansion) = super.inlined(rhsToInline)
+
+      // Take care that only argument bindings go into `bindings`, since positions are
+      // different for bindings from arguments and bindings from body.
+      val res = tpd.Inlined(call, bindings, expansion)
+
+      if !hasOpaqueProxies then res
+      else
+        val target =
+          if inlinedMethod.is(Transparent) then call.tpe & res.tpe
+          else call.tpe
+        res.ensureConforms(target)
+          // Make sure that the sealing with the declared type
+          // is type correct. Without it we might get problems since the
+          // expression's type is the opaque alias but the call's type is
+          // the opaque type itself. An example is in pos/opaque-inline1.scala.
+    end expand
+  end InlineCall
+end Inlines
diff --git a/tests/pos-with-compiler-cc/dotc/inlines/PrepareInlineable.scala b/tests/pos-with-compiler-cc/dotc/inlines/PrepareInlineable.scala
new file mode 100644
index 000000000000..db52712c39e2
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/inlines/PrepareInlineable.scala
@@ -0,0 +1,323 @@
+package dotty.tools
+package dotc
+package inlines
+
+import dotty.tools.dotc.ast.{Trees, tpd, untpd}
+import Trees._
+import core._
+import Flags._
+import Symbols._
+import Flags._
+import Types._
+import Decorators._
+import StdNames.nme
+import Contexts._
+import Names.{Name, TermName}
+import NameKinds.{InlineAccessorName, UniqueInlineName}
+import inlines.Inlines
+import NameOps._
+import Annotations._
+import transform.{AccessProxies, PCPCheckAndHeal, Splicer}
+import transform.SymUtils.*
+import config.Printers.inlining
+import util.Property
+import dotty.tools.dotc.transform.TreeMapWithStages._
+import language.experimental.pureFunctions
+
+object PrepareInlineable {
+  import tpd._
+
+  private val InlineAccessorsKey = new Property.Key[InlineAccessors]
+
+  def initContext(ctx: Context): Context =
+    ctx.fresh.setProperty(InlineAccessorsKey, new InlineAccessors)
+
+  def makeInlineable(tree: Tree)(using Context): Tree =
+    ctx.property(InlineAccessorsKey).get.makeInlineable(tree)
+
+  def addAccessorDefs(cls: Symbol, body: List[Tree])(using Context): List[Tree] =
+    ctx.property(InlineAccessorsKey) match
+      case Some(inlineAccessors) => inlineAccessors.addAccessorDefs(cls, body)
+      case _ => body
+
+  class InlineAccessors extends AccessProxies {
+
+    /** If an inline accessor name wraps a unique inline name, this is taken as indication
+     *  that the inline accessor takes its receiver as first parameter. Such accessors
+     *  are created by MakeInlineablePassing.
+     */
+    override def passReceiverAsArg(name: Name)(using Context): Boolean = name match {
+      case InlineAccessorName(UniqueInlineName(_, _)) => true
+      case _ => false
+    }
+
+    /** A tree map which inserts accessors for non-public term members accessed from inlined code.
+     */
+    abstract class MakeInlineableMap(val inlineSym: Symbol) extends TreeMap with Insert {
+      def accessorNameOf(name: TermName, site: Symbol)(using Context): TermName =
+        val accName = InlineAccessorName(name)
+        if site.isExtensibleClass then accName.expandedName(site) else accName
+
+      /** A definition needs an accessor if it is private, protected, or qualified private
+       *  and it is not part of the tree that gets inlined. The latter test is implemented
+       *  by excluding all symbols properly contained in the inline method.
+       *
+       *  Constant vals don't need accessors since they are inlined in FirstTransform.
+       *  Inline methods don't need accessors since they are inlined in Typer.
+       *
+       *  When creating accessors for staged/quoted code we only need to create accessors
+       *  for the code that is staged. This excludes code at level 0 (except if it is inlined).
+       */
+      def needsAccessor(sym: Symbol)(using Context): Boolean =
+        sym.isTerm &&
+        (sym.isOneOf(AccessFlags) || sym.privateWithin.exists) &&
+        !sym.isContainedIn(inlineSym) &&
+        !(sym.isStableMember && sym.info.widenTermRefExpr.isInstanceOf[ConstantType]) &&
+        !sym.isInlineMethod &&
+        (Inlines.inInlineMethod || StagingContext.level > 0)
+
+      def preTransform(tree: Tree)(using Context): Tree
+
+      def postTransform(tree: Tree)(using Context): Tree = tree match {
+        case Assign(lhs, rhs) if lhs.symbol.name.is(InlineAccessorName) =>
+          cpy.Apply(tree)(useSetter(lhs), rhs :: Nil)
+        case _ =>
+          tree
+      }
+
+      override def transform(tree: Tree)(using Context): Tree =
+        inContext(stagingContext(tree)) {
+          postTransform(super.transform(preTransform(tree)))
+        }
+
+      private def stagingContext(tree: Tree)(using Context): Context = tree match
+        case tree: Apply if tree.symbol.isQuote => StagingContext.quoteContext
+        case tree: Apply if tree.symbol.isExprSplice => StagingContext.spliceContext
+        case _ => ctx
+    }
+
+    /** Direct approach: place the accessor with the accessed symbol. This has the
+     *  advantage that we can re-use the receiver as is. But it is only
+     *  possible if the receiver is essentially this or an outer this, which is indicated
+     *  by the test that we can find a host for the accessor.
+     */
+    class MakeInlineableDirect(inlineSym: Symbol) extends MakeInlineableMap(inlineSym) {
+      def preTransform(tree: Tree)(using Context): Tree = tree match {
+        case tree: RefTree if needsAccessor(tree.symbol) =>
+          if (tree.symbol.isConstructor) {
+            report.error("Implementation restriction: cannot use private constructors in inline methods", tree.srcPos)
+            tree // TODO: create a proper accessor for the private constructor
+          }
+          else useAccessor(tree)
+        case _ =>
+          tree
+      }
+      override def ifNoHost(reference: RefTree)(using Context): Tree = reference
+    }
+
+    /** Fallback approach if the direct approach does not work: Place the accessor method
+     *  in the same class as the inline method, and let it take the receiver as parameter.
+     *  This is tricky, since we have to find a suitable type for the parameter, which might
+     *  require additional type parameters for the inline accessor. An example is in the
+     *  `TestPassing` class in test `run/inline/inlines_1`:
+     *
+     *    class C[T](x: T) {
+     *      private[inlines] def next[U](y: U): (T, U) = (x, y)
+     *    }
+     *    class TestPassing {
+     *      inline def foo[A](x: A): (A, Int) = {
+     *      val c = new C[A](x)
+     *      c.next(1)
+     *    }
+     *    inline def bar[A](x: A): (A, String) = {
+     *      val c = new C[A](x)
+     *      c.next("")
+     *    }
+     *
+     *  `C` could be compiled separately, so we cannot place the inline accessor in it.
+     *  Instead, the inline accessor goes into `TestPassing` and takes the actual receiver
+     *  type as argument:
+     *
+     *    def inline$next$i1[A, U](x$0: C[A])(y: U): (A, U) =
+     *      x$0.next[U](y)
+     *
+     *  Since different calls might have different receiver types, we need to generate one
+     *  such accessor per call, so they need to have unique names.
+     */
+    class MakeInlineablePassing(inlineSym: Symbol) extends MakeInlineableMap(inlineSym) {
+
+      def preTransform(tree: Tree)(using Context): Tree = tree match {
+        case _: Apply | _: TypeApply | _: RefTree
+        if needsAccessor(tree.symbol) && tree.isTerm && !tree.symbol.isConstructor =>
+          val refPart = funPart(tree)
+          val argss = allArgss(tree)
+          val qual = qualifier(refPart)
+          inlining.println(i"adding receiver passing inline accessor for $tree/$refPart -> (${qual.tpe}, $refPart: ${refPart.getClass}, $argss%, %")
+
+          // Need to dealias in order to cagtch all possible references to abstracted over types in
+          // substitutions
+          val dealiasMap = new TypeMap {
+            def apply(t: Type) = mapOver(t.dealias)
+          }
+          val qualType = dealiasMap(qual.tpe.widen)
+
+          // The types that are local to the inline method, and that therefore have
+          // to be abstracted out in the accessor, which is external to the inline method
+          val localRefs = qualType.namedPartsWith(ref =>
+            ref.isType && ref.symbol.isContainedIn(inlineSym)).toList
+
+          // Add qualifier type as leading method argument to argument `tp`
+          def addQualType(tp: Type): Type = tp match {
+            case tp: PolyType => tp.derivedLambdaType(tp.paramNames, tp.paramInfos, addQualType(tp.resultType))
+            case tp: ExprType => addQualType(tp.resultType)
+            case tp => MethodType(qualType.simplified :: Nil, tp)
+          }
+
+          // Abstract accessed type over local refs
+          def abstractQualType(mtpe: Type): Type =
+            if (localRefs.isEmpty) mtpe
+            else PolyType.fromParams(localRefs.map(_.symbol.asType), mtpe)
+              .asInstanceOf[PolyType].flatten
+
+          val accessed = refPart.symbol.asTerm
+          val accessedType = refPart.tpe.widen
+          val accessor = accessorSymbol(
+            owner = inlineSym.owner,
+            accessorName = InlineAccessorName(UniqueInlineName.fresh(accessed.name)),
+            accessorInfo = abstractQualType(addQualType(dealiasMap(accessedType))),
+            accessed = accessed)
+
+          val (leadingTypeArgs, otherArgss) = splitArgs(argss)
+          val argss1 = joinArgs(
+            localRefs.map(TypeTree(_)) ++ leadingTypeArgs, // TODO: pass type parameters in two sections?
+            (qual :: Nil) :: otherArgss
+          )
+          ref(accessor).appliedToArgss(argss1).withSpan(tree.span)
+
+            // TODO: Handle references to non-public types.
+            // This is quite tricky, as such types can appear anywhere, including as parts
+            // of types of other things. For the moment we do nothing and complain
+            // at the implicit expansion site if there's a reference to an inaccessible type.
+            // Draft code (incomplete):
+            //
+            //  val accessor = accessorSymbol(tree, TypeAlias(tree.tpe)).asType
+            //  myAccessors += TypeDef(accessor).withPos(tree.pos.focus)
+            //  ref(accessor).withSpan(tree.span)
+            //
+        case _: TypeDef if tree.symbol.is(Case) =>
+          report.error(reporting.CaseClassInInlinedCode(tree), tree)
+          tree
+        case _ =>
+          tree
+      }
+    }
+
+    /** Adds accessors for all non-public term members accessed
+     *  from `tree`. Non-public type members are currently left as they are.
+     *  This means that references to a private type will lead to typing failures
+     *  on the code when it is inlined. Less than ideal, but hard to do better (see below).
+     *
+     *  @return If there are accessors generated, a thicket consisting of the rewritten `tree`
+     *          and all accessors, otherwise the original tree.
+     */
+    def makeInlineable(tree: Tree)(using Context): Tree = {
+      val inlineSym = ctx.owner
+      if (inlineSym.owner.isTerm)
+        // Inlineable methods in local scopes can only be called in the scope they are defined,
+        // so no accessors are needed for them.
+        tree
+      else
+        new MakeInlineablePassing(inlineSym).transform(
+          new MakeInlineableDirect(inlineSym).transform(tree))
+    }
+  }
+
+  def isLocalOrParam(sym: Symbol, inlineMethod: Symbol)(using Context): Boolean =
+    sym.isContainedIn(inlineMethod) && sym != inlineMethod
+
+  def isLocal(sym: Symbol, inlineMethod: Symbol)(using Context): Boolean =
+    isLocalOrParam(sym, inlineMethod) && !(sym.is(Param) && sym.owner == inlineMethod)
+
+  /** The type ascription `rhs: tpt`, unless `original` is `transparent`. */
+  def wrapRHS(original: untpd.DefDef, tpt: Tree, rhs: Tree)(using Context): Tree =
+    if original.mods.is(Transparent) then rhs else Typed(rhs, tpt)
+
+  /** Return result of evaluating `op`, but drop `Inline` flag and `Body` annotation
+   *  of `sym` in case that leads to errors.
+   */
+  def dropInlineIfError(sym: Symbol, op: => Tree)(using Context): Tree =
+    val initialErrorCount = ctx.reporter.errorCount
+    try op
+    finally
+      if ctx.reporter.errorCount != initialErrorCount then
+        sym.resetFlag(Inline)
+        sym.resetFlag(Transparent)
+        sym.removeAnnotation(defn.BodyAnnot)
+
+  /** Register inline info for given inlineable method `sym`.
+   *
+   *  @param sym         The symbol denotation of the inlineable method for which info is registered
+   *  @param treeExpr    A function that computes the tree to be inlined, given a context
+   *                     This tree may still refer to non-public members.
+   *  @param ctx         The context to use for evaluating `treeExpr`. It needs
+   *                     to have the inline method as owner.
+   */
+  def registerInlineInfo(
+      inlined: Symbol, treeExpr: Context ?-> Tree)(using Context): Unit =
+    inlined.unforcedAnnotation(defn.BodyAnnot) match {
+      case Some(ann: ConcreteBodyAnnotation) =>
+      case Some(ann: LazyBodyAnnotation) if ann.isEvaluated || ann.isEvaluating =>
+      case _ =>
+        if (!ctx.isAfterTyper) {
+          val inlineCtx = ctx
+          inlined.updateAnnotation(LazyBodyAnnotation {
+            given ctx: Context = inlineCtx
+            var inlinedBody = dropInlineIfError(inlined, treeExpr)
+            if inlined.isInlineMethod then
+              inlinedBody = dropInlineIfError(inlined,
+                checkInlineMethod(inlined,
+                  PrepareInlineable.makeInlineable(inlinedBody)))
+            inlining.println(i"Body to inline for $inlined: $inlinedBody")
+            inlinedBody
+          })
+        }
+    }
+
+  private def checkInlineMethod(inlined: Symbol, body: Tree)(using Context): body.type = {
+    if Inlines.inInlineMethod(using ctx.outer) then
+      report.error(ex"Implementation restriction: nested inline methods are not supported", inlined.srcPos)
+
+    if (inlined.is(Macro) && !ctx.isAfterTyper) {
+
+      def checkMacro(tree: Tree): Unit = tree match {
+        case Spliced(code) =>
+          if (code.symbol.flags.is(Inline))
+            report.error("Macro cannot be implemented with an `inline` method", code.srcPos)
+          Splicer.checkValidMacroBody(code)
+          new PCPCheckAndHeal(freshStagingContext).transform(body) // Ignore output, only check PCP
+        case Block(List(stat), Literal(Constants.Constant(()))) => checkMacro(stat)
+        case Block(Nil, expr) => checkMacro(expr)
+        case Typed(expr, _) => checkMacro(expr)
+        case Block(DefDef(nme.ANON_FUN, _, _, _) :: Nil, Closure(_, fn, _)) if fn.symbol.info.isImplicitMethod =>
+          // TODO Support this pattern
+          report.error(
+            """Macros using a return type of the form `foo(): X ?=> Y` are not yet supported.
+              |
+              |Place the implicit as an argument (`foo()(using X): Y`) to overcome this limitation.
+              |""".stripMargin, tree.srcPos)
+        case _ =>
+          report.error(
+            """Malformed macro.
+              |
+              |Expected the splice ${...} to be at the top of the RHS:
+              |  inline def foo(inline x: X, ..., y: Y): Int = ${ impl('x, ... 'y) }
+              |
+              | * The contents of the splice must call a static method
+              | * All arguments must be quoted
+            """.stripMargin, inlined.srcPos)
+      }
+      checkMacro(body)
+    }
+    body
+  }
+}
diff --git a/tests/pos-with-compiler-cc/dotc/interactive/Completion.scala b/tests/pos-with-compiler-cc/dotc/interactive/Completion.scala
new file mode 100644
index 000000000000..414d406e870a
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/interactive/Completion.scala
@@ -0,0 +1,564 @@
+package dotty.tools.dotc.interactive
+
+import scala.language.unsafeNulls
+
+import dotty.tools.dotc.ast.untpd
+import dotty.tools.dotc.config.Printers.interactiv
+import dotty.tools.dotc.core.Contexts._
+import dotty.tools.dotc.core.Decorators._
+import dotty.tools.dotc.core.Denotations.SingleDenotation
+import dotty.tools.dotc.core.Flags._
+import dotty.tools.dotc.core.Names.{Name, TermName}
+import dotty.tools.dotc.core.NameKinds.SimpleNameKind
+import dotty.tools.dotc.core.NameOps._
+import dotty.tools.dotc.core.Scopes._
+import dotty.tools.dotc.core.Symbols.{NoSymbol, Symbol, defn, newSymbol}
+import dotty.tools.dotc.core.StdNames.nme
+import dotty.tools.dotc.core.SymDenotations.SymDenotation
+import dotty.tools.dotc.core.TypeError
+import dotty.tools.dotc.core.Types.{AppliedType, ExprType, MethodOrPoly, NameFilter, NoType, RefinedType, TermRef, Type, TypeProxy}
+import dotty.tools.dotc.parsing.Tokens
+import dotty.tools.dotc.util.Chars
+import dotty.tools.dotc.util.SourcePosition
+
+import scala.collection.mutable
+import scala.util.control.NonFatal
+
+/**
+ * One of the results of a completion query.
+ *
+ * @param label         The label of this completion result, or the text that this completion result
+ *                      should insert in the scope where the completion request happened.
+ * @param description   The description of this completion result: the fully qualified name for
+ *                      types, or the type for terms.
+ * @param symbols       The symbols that are matched by this completion result.
+ */
+case class Completion(label: String, description: String, symbols: List[Symbol])
+
+object Completion {
+
+  import dotty.tools.dotc.ast.tpd._
+
+  /** Get possible completions from tree at `pos`
+   *
+   *  @return offset and list of symbols for possible completions
+   */
+  def completions(pos: SourcePosition)(using Context): (Int, List[Completion]) = {
+    val path = Interactive.pathTo(ctx.compilationUnit.tpdTree, pos.span)
+    computeCompletions(pos, path)(using Interactive.contextOfPath(path))
+  }
+
+  /**
+   * Inspect `path` to determine what kinds of symbols should be considered.
+   *
+   * If the path starts with:
+   *  - a `RefTree`, then accept symbols of the same kind as its name;
+   *  - a renaming import, and the cursor is on the renamee, accept both terms and types;
+   *  - an import, accept both terms and types;
+   *
+   * Otherwise, provide no completion suggestion.
+   */
+  def completionMode(path: List[Tree], pos: SourcePosition): Mode =
+    path match {
+      case Ident(_) :: Import(_, _) :: _ => Mode.ImportOrExport
+      case (ref: RefTree) :: _ =>
+        if (ref.name.isTermName) Mode.Term
+        else if (ref.name.isTypeName) Mode.Type
+        else Mode.None
+
+      case (sel: untpd.ImportSelector) :: _ =>
+        if sel.imported.span.contains(pos.span) then Mode.ImportOrExport
+        else Mode.None // Can't help completing the renaming
+
+      case (_: ImportOrExport) :: _ => Mode.ImportOrExport
+      case _ => Mode.None
+    }
+
+  /** When dealing with <errors> in varios palces we check to see if they are
+   *  due to incomplete backticks. If so, we ensure we get the full prefix
+   *  including the backtick.
+   *
+   * @param content The source content that we'll check the positions for the prefix
+   * @param start The start position we'll start to look for the prefix at
+   * @param end The end position we'll look for the prefix at
+   * @return Either the full prefix including the ` or an empty string
+   */
+  private def checkBacktickPrefix(content: Array[Char], start: Int, end: Int): String =
+    content.lift(start) match
+      case Some(char) if char == '`' =>
+        content.slice(start, end).mkString
+      case _ =>
+        ""
+
+  /**
+   * Inspect `path` to determine the completion prefix. Only symbols whose name start with the
+   * returned prefix should be considered.
+   */
+  def completionPrefix(path: List[untpd.Tree], pos: SourcePosition)(using Context): String =
+    path match
+      case (sel: untpd.ImportSelector) :: _ =>
+        completionPrefix(sel.imported :: Nil, pos)
+
+      case (tree: untpd.ImportOrExport) :: _ =>
+        tree.selectors.find(_.span.contains(pos.span)).map { selector =>
+          completionPrefix(selector :: Nil, pos)
+        }.getOrElse("")
+
+      // Foo.`se<TAB> will result in Select(Ident(Foo), <error>)
+      case (select: untpd.Select) :: _ if select.name == nme.ERROR =>
+        checkBacktickPrefix(select.source.content(), select.nameSpan.start, select.span.end)
+
+      // import scala.util.chaining.`s<TAB> will result in a Ident(<error>)
+      case (ident: untpd.Ident) :: _ if ident.name == nme.ERROR =>
+        checkBacktickPrefix(ident.source.content(), ident.span.start, ident.span.end)
+
+      case (ref: untpd.RefTree) :: _ =>
+        if (ref.name == nme.ERROR) ""
+        else ref.name.toString.take(pos.span.point - ref.span.point)
+
+      case _ =>
+        ""
+  end completionPrefix
+
+  /** Inspect `path` to determine the offset where the completion result should be inserted. */
+  def completionOffset(path: List[Tree]): Int =
+    path match {
+      case (ref: RefTree) :: _ => ref.span.point
+      case _ => 0
+    }
+
+  private def computeCompletions(pos: SourcePosition, path: List[Tree])(using Context): (Int, List[Completion]) = {
+    val mode = completionMode(path, pos)
+    val rawPrefix = completionPrefix(path, pos)
+
+    val hasBackTick = rawPrefix.headOption.contains('`')
+    val prefix = if hasBackTick then rawPrefix.drop(1) else rawPrefix
+
+    val completer = new Completer(mode, prefix, pos)
+
+    val completions = path match {
+        // Ignore synthetic select from `This` because in code it was `Ident`
+        // See example in dotty.tools.languageserver.CompletionTest.syntheticThis
+        case Select(qual @ This(_), _) :: _ if qual.span.isSynthetic  => completer.scopeCompletions
+        case Select(qual, _) :: _           if qual.tpe.hasSimpleKind => completer.selectionCompletions(qual)
+        case Select(qual, _) :: _                                     => Map.empty
+        case (tree: ImportOrExport) :: _                              => completer.directMemberCompletions(tree.expr)
+        case (_: untpd.ImportSelector) :: Import(expr, _) :: _        => completer.directMemberCompletions(expr)
+        case _                                                        => completer.scopeCompletions
+      }
+
+    val describedCompletions = describeCompletions(completions)
+    val backtickedCompletions =
+      describedCompletions.map(completion => backtickCompletions(completion, hasBackTick))
+
+    val offset = completionOffset(path)
+
+    interactiv.println(i"""completion with pos     = $pos,
+                          |                prefix  = ${completer.prefix},
+                          |                term    = ${completer.mode.is(Mode.Term)},
+                          |                type    = ${completer.mode.is(Mode.Type)}
+                          |                results = $backtickedCompletions%, %""")
+    (offset, backtickedCompletions)
+  }
+
+  def backtickCompletions(completion: Completion, hasBackTick: Boolean) =
+    if hasBackTick || needsBacktick(completion.label) then
+      completion.copy(label = s"`${completion.label}`")
+    else
+      completion
+
+  // This borrows from Metals, which itself borrows from Ammonite. This uses
+  // the same approach, but some of the utils that already exist in Dotty.
+  // https://github.com/scalameta/metals/blob/main/mtags/src/main/scala/scala/meta/internal/mtags/KeywordWrapper.scala
+  // https://github.com/com-lihaoyi/Ammonite/blob/73a874173cd337f953a3edc9fb8cb96556638fdd/amm/util/src/main/scala/ammonite/util/Model.scala
+  private def needsBacktick(s: String) =
+    val chunks = s.split("_", -1)
+
+    val validChunks = chunks.zipWithIndex.forall { case (chunk, index) =>
+      chunk.forall(Chars.isIdentifierPart) ||
+      (chunk.forall(Chars.isOperatorPart) &&
+        index == chunks.length - 1 &&
+        !(chunks.lift(index - 1).contains("") && index - 1 == 0))
+    }
+
+    val validStart =
+      Chars.isIdentifierStart(s(0)) || chunks(0).forall(Chars.isOperatorPart)
+
+    val valid = validChunks && validStart && !keywords.contains(s)
+
+    !valid
+  end needsBacktick
+
+  private lazy val keywords = Tokens.keywords.map(Tokens.tokenString)
+
+  /**
+   * Return the list of code completions with descriptions based on a mapping from names to the denotations they refer to.
+   * If several denotations share the same name, each denotation will be transformed into a separate completion item.
+   */
+  def describeCompletions(completions: CompletionMap)(using Context): List[Completion] =
+    for
+      (name, denots) <- completions.toList
+      denot <- denots
+    yield
+      Completion(name.show, description(denot), List(denot.symbol))
+
+  def description(denot: SingleDenotation)(using Context): String =
+    if denot.isType then denot.symbol.showFullName
+    else denot.info.widenTermRefExpr.show
+
+  /** Computes code completions depending on the context in which completion is requested
+   *  @param mode    Should complete names of terms, types or both
+   *  @param prefix  The prefix that all suggested completions should start with
+   *  @param pos     Cursor position where completion was requested
+   *
+   *  For the results of all `xyzCompletions` methods term names and type names are always treated as different keys in the same map
+   *  and they never conflict with each other.
+   */
+  class Completer(val mode: Mode, val prefix: String, pos: SourcePosition) {
+    /** Completions for terms and types that are currently in scope:
+     *  the members of the current class, local definitions and the symbols that have been imported,
+     *  recursively adding completions from outer scopes.
+     *  In case a name is ambiguous, no completions are returned for it.
+     *  This mimics the logic for deciding what is ambiguous used by the compiler.
+     *  In general in case of a name clash symbols introduced in more deeply nested scopes
+     *  have higher priority and shadow previous definitions with the same name although:
+     *  - imports with the same level of nesting cause an ambiguity
+     *  - members and local definitions with the same level of nesting are allowed for overloading
+     *  - an import is ignored if there is a local definition or a member introduced in the same scope
+     *    (even if the import follows it syntactically)
+     *  - a more deeply nested import shadowing a member or a local definition causes an ambiguity
+     */
+    def scopeCompletions(using context: Context): CompletionMap = {
+      val mappings = collection.mutable.Map.empty[Name, List[ScopedDenotations]].withDefaultValue(List.empty)
+      def addMapping(name: Name, denots: ScopedDenotations) =
+        mappings(name) = mappings(name) :+ denots
+
+      ctx.outersIterator.foreach { case ctx @ given Context =>
+        if ctx.isImportContext then
+          importedCompletions.foreach { (name, denots) =>
+            addMapping(name, ScopedDenotations(denots, ctx))
+          }
+        else if ctx.owner.isClass then
+          accessibleMembers(ctx.owner.thisType)
+            .groupByName.foreach { (name, denots) =>
+              addMapping(name, ScopedDenotations(denots, ctx))
+            }
+        else if ctx.scope ne EmptyScope then
+          ctx.scope.toList.filter(symbol => include(symbol, symbol.name))
+            .flatMap(_.alternatives)
+            .groupByName.foreach { (name, denots) =>
+              addMapping(name, ScopedDenotations(denots, ctx))
+            }
+      }
+
+      var resultMappings = Map.empty[Name, Seq[SingleDenotation]]
+
+      mappings.foreach { (name, denotss) =>
+        val first = denotss.head
+
+        // import a.c
+        def isSingleImport =  denotss.length < 2
+        // import a.C
+        // locally {  import b.C }
+        def isImportedInDifferentScope =  first.ctx.scope ne denotss(1).ctx.scope
+        // import a.C
+        // import a.C
+        def isSameSymbolImportedDouble =  denotss.forall(_.denots == first.denots)
+
+        def isScalaPackage(scopedDenots: ScopedDenotations) =
+          scopedDenots.denots.exists(_.info.typeSymbol.owner == defn.ScalaPackageClass)
+
+        def isJavaLangPackage(scopedDenots: ScopedDenotations) =
+          scopedDenots.denots.exists(_.info.typeSymbol.owner == defn.JavaLangPackageClass)
+
+        // For example
+        // import java.lang.annotation
+        //    is shadowed by
+        // import scala.annotation
+        def isJavaLangAndScala =
+          try
+            denotss.forall(denots => isScalaPackage(denots) || isJavaLangPackage(denots))
+          catch
+            case NonFatal(_) => false
+
+        denotss.find(!_.ctx.isImportContext) match {
+          // most deeply nested member or local definition if not shadowed by an import
+          case Some(local) if local.ctx.scope == first.ctx.scope =>
+            resultMappings += name -> local.denots
+
+          case None if isSingleImport || isImportedInDifferentScope || isSameSymbolImportedDouble =>
+            resultMappings += name -> first.denots
+          case None if isJavaLangAndScala =>
+            denotss.foreach{
+              denots =>
+                if isScalaPackage(denots) then
+                  resultMappings += name -> denots.denots
+            }
+
+          case _ =>
+        }
+      }
+
+      resultMappings
+    }
+
+    /** Widen only those types which are applied or are exactly nothing
+     */
+    def widenQualifier(qual: Tree)(using Context): Tree =
+      qual.tpe.widenDealias match
+        case widenedType if widenedType.isExactlyNothing => qual.withType(widenedType)
+        case appliedType: AppliedType => qual.withType(appliedType)
+        case _ => qual
+
+    /** Completions for selections from a term.
+     *  Direct members take priority over members from extensions
+     *  and so do members from extensions over members from implicit conversions
+     */
+    def selectionCompletions(qual: Tree)(using Context): CompletionMap =
+      val adjustedQual = widenQualifier(qual)
+
+      implicitConversionMemberCompletions(adjustedQual) ++
+        extensionCompletions(adjustedQual) ++
+        directMemberCompletions(adjustedQual)
+
+    /** Completions for members of `qual`'s type.
+     *  These include inherited definitions but not members added by extensions or implicit conversions
+     */
+    def directMemberCompletions(qual: Tree)(using Context): CompletionMap =
+      if qual.tpe.isExactlyNothing then
+        Map.empty
+      else
+        accessibleMembers(qual.tpe).groupByName
+
+    /** Completions introduced by imports directly in this context.
+     *  Completions from outer contexts are not included.
+     */
+    private def importedCompletions(using Context): CompletionMap = {
+      val imp = ctx.importInfo
+
+      def fromImport(name: Name, nameInScope: Name): Seq[(Name, SingleDenotation)] =
+        imp.site.member(name).alternatives
+          .collect { case denot if include(denot, nameInScope) => nameInScope -> denot }
+
+      if imp == null then
+        Map.empty
+      else
+        val givenImports = imp.importedImplicits
+          .map { ref => (ref.implicitName: Name, ref.underlyingRef.denot.asSingleDenotation) }
+          .filter((name, denot) => include(denot, name))
+          .groupByName
+
+        val wildcardMembers =
+          if imp.selectors.exists(_.imported.name == nme.WILDCARD) then
+            val denots = accessibleMembers(imp.site)
+              .filter(mbr => !mbr.symbol.is(Given) && !imp.excluded.contains(mbr.name.toTermName))
+            denots.groupByName
+          else
+            Map.empty
+
+        val explicitMembers =
+          val importNamesInScope = imp.forwardMapping.toList.map(_._2)
+          val duplicatedNames = importNamesInScope.diff(importNamesInScope.distinct)
+          val discardedNames = duplicatedNames ++ imp.excluded
+          imp.reverseMapping.toList
+            .filter { (nameInScope, _) => !discardedNames.contains(nameInScope) }
+            .flatMap { (nameInScope, original) =>
+              fromImport(original, nameInScope) ++
+              fromImport(original.toTypeName, nameInScope.toTypeName)
+            }.toSeq.groupByName
+
+        givenImports ++ wildcardMembers ++ explicitMembers
+    }
+
+    /** Completions from implicit conversions including old style extensions using implicit classes */
+    private def implicitConversionMemberCompletions(qual: Tree)(using Context): CompletionMap =
+      if qual.tpe.isExactlyNothing || qual.tpe.isNullType then
+        Map.empty
+      else
+        implicitConversionTargets(qual)(using ctx.fresh.setExploreTyperState())
+          .flatMap(accessibleMembers)
+          .toSeq
+          .groupByName
+
+    /** Completions from extension methods */
+    private def extensionCompletions(qual: Tree)(using Context): CompletionMap =
+      def asDefLikeType(tpe: Type): Type = tpe match
+        case _: MethodOrPoly => tpe
+        case _ => ExprType(tpe)
+
+      def tryApplyingReceiverToExtension(termRef: TermRef): Option[SingleDenotation] =
+        ctx.typer.tryApplyingExtensionMethod(termRef, qual)
+          .map { tree =>
+            val tpe = asDefLikeType(tree.tpe.dealias)
+            termRef.denot.asSingleDenotation.mapInfo(_ => tpe)
+          }
+
+      def extractMemberExtensionMethods(types: Seq[Type]): Seq[(TermRef, TermName)] =
+        object DenotWithMatchingName:
+          def unapply(denot: SingleDenotation): Option[(SingleDenotation, TermName)] =
+            denot.name match
+              case name: TermName if include(denot, name) => Some((denot, name))
+              case _ => None
+
+        types.flatMap { tp =>
+          val tpe = tp.widenExpr
+          tpe.membersBasedOnFlags(required = ExtensionMethod, excluded = EmptyFlags)
+            .collect { case DenotWithMatchingName(denot, name) => TermRef(tpe, denot.symbol) -> name }
+        }
+
+      // There are four possible ways for an extension method to be applicable
+
+      // 1. The extension method is visible under a simple name, by being defined or inherited or imported in a scope enclosing the reference.
+      val termCompleter = new Completer(Mode.Term, prefix, pos)
+      val extMethodsInScope = termCompleter.scopeCompletions.toList.flatMap {
+        case (name, denots) => denots.collect { case d: SymDenotation if d.isTerm => (d.termRef, name.asTermName) }
+      }
+
+      // 2. The extension method is a member of some given instance that is visible at the point of the reference.
+      val givensInScope = ctx.implicits.eligible(defn.AnyType).map(_.implicitRef.underlyingRef)
+      val extMethodsFromGivensInScope = extractMemberExtensionMethods(givensInScope)
+
+      // 3. The reference is of the form r.m and the extension method is defined in the implicit scope of the type of r.
+      val implicitScopeCompanions = ctx.run.nn.implicitScope(qual.tpe).companionRefs.showAsList
+      val extMethodsFromImplicitScope = extractMemberExtensionMethods(implicitScopeCompanions)
+
+      // 4. The reference is of the form r.m and the extension method is defined in some given instance in the implicit scope of the type of r.
+      val givensInImplicitScope = implicitScopeCompanions.flatMap(_.membersBasedOnFlags(required = GivenVal, excluded = EmptyFlags)).map(_.info)
+      val extMethodsFromGivensInImplicitScope = extractMemberExtensionMethods(givensInImplicitScope)
+
+      val availableExtMethods = extMethodsFromGivensInImplicitScope ++ extMethodsFromImplicitScope ++ extMethodsFromGivensInScope ++ extMethodsInScope
+      val extMethodsWithAppliedReceiver = availableExtMethods.flatMap {
+        case (termRef, termName) =>
+          if termRef.symbol.is(ExtensionMethod) && !qual.tpe.isBottomType then
+            tryApplyingReceiverToExtension(termRef)
+              .map(denot => termName -> denot)
+          else None
+      }
+      extMethodsWithAppliedReceiver.groupByName
+
+    /** Include in completion sets only symbols that
+     *   1. start with given name prefix, and
+     *   2. is not absent (info is not NoType)
+     *   3. are not a primary constructor,
+     *   4. have an existing source symbol,
+     *   5. are the module class in case of packages,
+     *   6. are mutable accessors, to exclude setters for `var`,
+     *   7. symbol is not a package object
+     *   8. symbol is not an artifact of the compiler
+     *   9. have same term/type kind as name prefix given so far
+     */
+    private def include(denot: SingleDenotation, nameInScope: Name)(using Context): Boolean =
+      val sym = denot.symbol
+
+
+      nameInScope.startsWith(prefix) &&
+      sym.exists &&
+      completionsFilter(NoType, nameInScope) &&
+      !sym.isAbsent() &&
+      !sym.isPrimaryConstructor &&
+      sym.sourceSymbol.exists &&
+      (!sym.is(Package) || sym.is(ModuleClass)) &&
+      !sym.isAllOf(Mutable | Accessor) &&
+      !sym.isPackageObject &&
+      !sym.is(Artifact) &&
+      (
+           (mode.is(Mode.Term) && (sym.isTerm || sym.is(ModuleClass))
+        || (mode.is(Mode.Type) && (sym.isType || sym.isStableMember)))
+      )
+
+    private def extractRefinements(site: Type)(using Context): Seq[SingleDenotation] =
+      site match
+        case RefinedType(parent, name, info) =>
+          val flags = info match
+            case _: (ExprType | MethodOrPoly) => Method
+            case _ => EmptyFlags
+          val symbol = newSymbol(owner = NoSymbol, name, flags, info)
+          val denot = SymDenotation(symbol, NoSymbol, name, flags, info)
+          denot +: extractRefinements(parent)
+        case tp: TypeProxy => extractRefinements(tp.superType)
+        case _ => List.empty
+
+    /** @param site The type to inspect.
+     *  @return The members of `site` that are accessible and pass the include filter.
+     */
+    private def accessibleMembers(site: Type)(using Context): Seq[SingleDenotation] = {
+      def appendMemberSyms(name: Name, buf: mutable.Buffer[SingleDenotation]): Unit =
+        try
+          val member = site.member(name)
+          if member.symbol.is(ParamAccessor) && !member.symbol.isAccessibleFrom(site) then
+            buf ++= site.nonPrivateMember(name).alternatives
+          else
+            buf ++= member.alternatives
+        catch
+          case ex: TypeError =>
+
+      val members = site.memberDenots(completionsFilter, appendMemberSyms).collect {
+        case mbr if include(mbr, mbr.name)
+                    && mbr.symbol.isAccessibleFrom(site) => mbr
+      }
+      val refinements = extractRefinements(site).filter(mbr => include(mbr, mbr.name))
+
+      members ++ refinements
+    }
+
+    /**
+     * Given `qual` of type T, finds all the types S such that there exists an implicit conversion
+     * from T to S. It then applies conversion method for proper type parameter resolution.
+     *
+     * @param qual The argument to which the implicit conversion should be applied.
+     * @return The set of types after `qual` implicit conversion.
+     */
+    private def implicitConversionTargets(qual: Tree)(using Context): Set[Type] = {
+      val typer = ctx.typer
+      val conversions = new typer.ImplicitSearch(defn.AnyType, qual, pos.span).allImplicits
+      val targets = conversions.map(_.tree.tpe)
+
+      interactiv.println(i"implicit conversion targets considered: ${targets.toList}%, %")
+      targets
+    }
+
+    /** Filter for names that should appear when looking for completions. */
+    private object completionsFilter extends NameFilter {
+      def apply(pre: Type, name: Name)(using Context): Boolean =
+        !name.isConstructorName && name.toTermName.info.kind == SimpleNameKind
+      def isStable = true
+    }
+
+    extension (denotations: Seq[SingleDenotation])
+      def groupByName(using Context): CompletionMap = denotations.groupBy(_.name)
+
+    extension [N <: Name](namedDenotations: Seq[(N, SingleDenotation)])
+      @annotation.targetName("groupByNameTupled")
+      def groupByName: CompletionMap = namedDenotations.groupMap((name, denot) => name)((name, denot) => denot)
+  }
+
+  private type CompletionMap = Map[Name, Seq[SingleDenotation]]
+
+  /** Temporary data structure representing denotations with the same name introduced in a given scope
+   *  as a member of a type, by a local definition or by an import clause
+   */
+  private case class ScopedDenotations(denots: Seq[SingleDenotation], ctx: Context)
+
+  /**
+   * The completion mode: defines what kinds of symbols should be included in the completion
+   * results.
+   */
+  class Mode(val bits: Int) extends AnyVal {
+    def is(other: Mode): Boolean = (bits & other.bits) == other.bits
+    def |(other: Mode): Mode = new Mode(bits | other.bits)
+  }
+  object Mode {
+    /** No symbol should be included */
+    val None: Mode = new Mode(0)
+
+    /** Term symbols are allowed */
+    val Term: Mode = new Mode(1)
+
+    /** Type and stable term symbols are allowed */
+    val Type: Mode = new Mode(2)
+
+    /** Both term and type symbols are allowed */
+    val ImportOrExport: Mode = new Mode(4) | Term | Type
+  }
+}
+
diff --git a/tests/pos-with-compiler-cc/dotc/interactive/Interactive.scala b/tests/pos-with-compiler-cc/dotc/interactive/Interactive.scala
new file mode 100644
index 000000000000..6b2237a09b3f
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/interactive/Interactive.scala
@@ -0,0 +1,445 @@
+package dotty.tools
+package dotc
+package interactive
+
+import scala.language.unsafeNulls
+
+import scala.collection._
+
+import ast.{NavigateAST, Trees, tpd, untpd}
+import core._
+import Decorators._, ContextOps._
+import Contexts._, Flags._, Names._, NameOps._, Symbols._, Trees._, Types._
+import transform.SymUtils._
+import util.Spans._, util.SourceFile, util.SourcePosition
+
+/** High-level API to get information out of typed trees, designed to be used by IDEs.
+ *
+ *  @see `InteractiveDriver` to get typed trees from code.
+ */
+object Interactive {
+  import ast.tpd._
+
+  object Include {
+    case class Set private[Include] (val bits: Int) extends AnyVal {
+      def | (that: Set): Set = Set(bits | that.bits)
+      def except(that: Set): Set = Set(bits & ~that.bits)
+
+      def isEmpty: Boolean = bits == 0
+      def isOverridden: Boolean = (bits & overridden.bits) != 0
+      def isOverriding: Boolean = (bits & overriding.bits) != 0
+      def isReferences: Boolean = (bits & references.bits) != 0
+      def isDefinitions: Boolean = (bits & definitions.bits) != 0
+      def isLinkedClass: Boolean = (bits & linkedClass.bits) != 0
+      def isImports: Boolean = (bits & imports.bits) != 0
+      def isLocal: Boolean = (bits & local.bits) != 0
+    }
+
+    /** The empty set */
+    val empty: Set = Set(0)
+
+    /** Include trees whose symbol is overridden by `sym` */
+    val overridden: Set = Set(1 << 0)
+
+    /** Include trees whose symbol overrides `sym` */
+    val overriding: Set = Set(1 << 1)
+
+    /** Include references */
+    val references: Set = Set(1 << 2)
+
+    /** Include definitions */
+    val definitions: Set = Set(1 << 3)
+
+    /** Include `sym.linkedClass */
+    val linkedClass: Set = Set(1 << 4)
+
+    /** Include imports in the results */
+    val imports: Set = Set(1 << 5)
+
+    /** Include local symbols, inspect local trees */
+    val local: Set = Set(1 << 6)
+
+    /** All the flags */
+    val all: Set = Set(~0)
+  }
+
+  /** Does this tree define a symbol ? */
+  def isDefinition(tree: Tree): Boolean =
+    tree.isInstanceOf[NamedDefTree]
+
+  /** The type of the closest enclosing tree with a type containing position `pos`. */
+  def enclosingType(trees: List[SourceTree], pos: SourcePosition)(using Context): Type = {
+    val path = pathTo(trees, pos)
+    if (path.isEmpty) NoType
+    else path.head.tpe
+  }
+
+  /** The closest enclosing tree with a symbol containing position `pos`, or the `EmptyTree`.
+   */
+  def enclosingTree(trees: List[SourceTree], pos: SourcePosition)(using Context): Tree =
+    enclosingTree(pathTo(trees, pos))
+
+  /** The closest enclosing tree with a symbol, or the `EmptyTree`.
+   */
+  def enclosingTree(path: List[Tree])(using Context): Tree =
+    path.dropWhile(!_.symbol.exists).headOption.getOrElse(tpd.EmptyTree)
+
+  /**
+   * The source symbols that are the closest to `path`.
+   *
+   * If this path ends in an import, then this returns all the symbols that are imported by this
+   * import statement.
+   *
+   * @param path The path to the tree whose symbols to extract.
+   * @return The source symbols that are the closest to `path`.
+   *
+   * @see sourceSymbol
+   */
+  def enclosingSourceSymbols(path: List[Tree], pos: SourcePosition)(using Context): List[Symbol] = {
+    val syms = path match {
+      // For a named arg, find the target `DefDef` and jump to the param
+      case NamedArg(name, _) :: Apply(fn, _) :: _ =>
+        val funSym = fn.symbol
+        if (funSym.name == StdNames.nme.copy
+          && funSym.is(Synthetic)
+          && funSym.owner.is(CaseClass))
+            List(funSym.owner.info.member(name).symbol)
+        else {
+          val classTree = funSym.topLevelClass.asClass.rootTree
+          val paramSymbol =
+            for {
+              case DefDef(_, paramss, _, _) <- tpd.defPath(funSym, classTree).lastOption
+              param <- paramss.flatten.find(_.name == name)
+            }
+            yield param.symbol
+          List(paramSymbol.getOrElse(fn.symbol))
+        }
+
+      // For constructor calls, return the `<init>` that was selected
+      case _ :: (_:  New) :: (select: Select) :: _ =>
+        List(select.symbol)
+
+      case (_: untpd.ImportSelector) :: (imp: Import) :: _ =>
+        importedSymbols(imp, _.span.contains(pos.span))
+
+      case (imp: Import) :: _ =>
+        importedSymbols(imp, _.span.contains(pos.span))
+
+      case _ =>
+        List(enclosingTree(path).symbol)
+    }
+
+    syms.map(_.sourceSymbol).filter(_.exists)
+  }
+
+  /** Check if `tree` matches `sym`.
+   *  This is the case if the symbol defined by `tree` equals `sym`,
+   *  or the source symbol of tree equals sym,
+   *  or `include` is `overridden`, and `tree` is overridden by `sym`,
+   *  or `include` is `overriding`, and `tree` overrides `sym`.
+   */
+  def matchSymbol(tree: Tree, sym: Symbol, include: Include.Set)(using Context): Boolean = {
+
+    def overrides(sym1: Symbol, sym2: Symbol) =
+      sym1.owner.derivesFrom(sym2.owner) && sym1.overriddenSymbol(sym2.owner.asClass) == sym2
+
+    (  sym == tree.symbol
+    || sym.exists && sym == tree.symbol.sourceSymbol
+    || !include.isEmpty && sym.name == tree.symbol.name && sym.maybeOwner != tree.symbol.maybeOwner
+       && (  include.isOverridden && overrides(sym, tree.symbol)
+          || include.isOverriding && overrides(tree.symbol, sym)
+          )
+    )
+  }
+
+  /** Find named trees with a non-empty position whose symbol match `sym` in `trees`.
+   *
+   *  Note that nothing will be found for symbols not defined in source code,
+   *  use `sourceSymbol` to get a symbol related to `sym` that is defined in
+   *  source code.
+   */
+  def namedTrees(trees: List[SourceTree], include: Include.Set, sym: Symbol)
+   (using Context): List[SourceTree] =
+    if (!sym.exists)
+      Nil
+    else
+      namedTrees(trees, include, matchSymbol(_, sym, include))
+
+  /** Find named trees with a non-empty position satisfying `treePredicate` in `trees`.
+   *
+   *  @param trees         The trees to inspect.
+   *  @param include       Whether to include references, definitions, etc.
+   *  @param treePredicate An additional predicate that the trees must match.
+   *  @return The trees with a non-empty position satisfying `treePredicate`.
+   */
+  def namedTrees(trees: List[SourceTree],
+                 include: Include.Set,
+                 treePredicate: NameTree => Boolean = util.common.alwaysTrue
+                )(using Context): List[SourceTree] = safely {
+    val buf = new mutable.ListBuffer[SourceTree]
+
+    def traverser(source: SourceFile) =
+      new untpd.TreeTraverser {
+        private def handle(utree: untpd.NameTree): Unit = {
+          val tree = utree.asInstanceOf[tpd.NameTree]
+          if (tree.symbol.exists
+               && tree.name != StdNames.nme.ERROR
+               && !tree.symbol.is(Synthetic)
+               && !tree.symbol.isPrimaryConstructor
+               && tree.span.exists
+               && !tree.span.isZeroExtent
+               && (include.isReferences || isDefinition(tree))
+               && treePredicate(tree))
+            buf += SourceTree(tree, source)
+        }
+        override def traverse(tree: untpd.Tree)(using Context) =
+          tree match {
+            case imp: untpd.Import if include.isImports && tree.hasType =>
+              val tree = imp.asInstanceOf[tpd.Import]
+              val selections = tpd.importSelections(tree)
+              traverse(imp.expr)
+              selections.foreach(traverse)
+            case utree: untpd.ValOrDefDef if tree.hasType =>
+              handle(utree)
+              if (include.isLocal) traverseChildren(tree)
+            case utree: untpd.NameTree if tree.hasType =>
+              handle(utree)
+              traverseChildren(tree)
+            case tree: untpd.Inlined =>
+              traverse(tree.call)
+            case _ =>
+              traverseChildren(tree)
+          }
+      }
+
+    trees.foreach(t => traverser(t.source).traverse(t.tree))
+
+    buf.toList
+  }
+
+  /**
+   * Find trees that match `symbol` in `trees`.
+   *
+   * @param trees     The trees to inspect.
+   * @param includes  Whether to include references, definitions, etc.
+   * @param symbol    The symbol for which we want to find references.
+   * @param predicate An additional predicate that the trees must match.
+   */
+  def findTreesMatching(trees: List[SourceTree],
+                        includes: Include.Set,
+                        symbol: Symbol,
+                        predicate: NameTree => Boolean = util.common.alwaysTrue
+                       )(using Context): List[SourceTree] = {
+    val linkedSym = symbol.linkedClass
+    val fullPredicate: NameTree => Boolean = tree =>
+      (  (includes.isDefinitions || !Interactive.isDefinition(tree))
+      && (  Interactive.matchSymbol(tree, symbol, includes)
+         || ( includes.isLinkedClass
+            && linkedSym.exists
+            && Interactive.matchSymbol(tree, linkedSym, includes)
+            )
+         )
+      && predicate(tree)
+      )
+    namedTrees(trees, includes, fullPredicate)
+  }
+
+  /** The reverse path to the node that closest encloses position `pos`,
+   *  or `Nil` if no such path exists. If a non-empty path is returned it starts with
+   *  the tree closest enclosing `pos` and ends with an element of `trees`.
+   *
+   *  Note that if the given `pos` points out places for incomplete parses,
+   *  this method returns `errorTermTree` (`Literal(Consotant(null)`).
+   *
+   *  @see https://github.com/lampepfl/dotty/issues/15294
+   */
+  def pathTo(trees: List[SourceTree], pos: SourcePosition)(using Context): List[Tree] =
+    pathTo(trees.map(_.tree), pos.span)
+
+  def pathTo(tree: Tree, span: Span)(using Context): List[Tree] =
+    pathTo(List(tree), span)
+
+  private def pathTo(trees: List[Tree], span: Span)(using Context): List[Tree] =
+    if (trees.exists(_.span.contains(span)))
+      NavigateAST.pathTo(span, trees, skipZeroExtent = true)
+        .collect { case t: untpd.Tree => t }
+        .dropWhile(!_.hasType).asInstanceOf[List[tpd.Tree]]
+    else Nil
+
+  def contextOfStat(stats: List[Tree], stat: Tree, exprOwner: Symbol, ctx: Context): Context = stats match {
+    case Nil =>
+      ctx
+    case first :: _ if first eq stat =>
+      ctx.exprContext(stat, exprOwner)
+    case (imp: Import) :: rest =>
+      contextOfStat(rest, stat, exprOwner, ctx.importContext(imp, inContext(ctx){imp.symbol}))
+    case _ :: rest =>
+      contextOfStat(rest, stat, exprOwner, ctx)
+  }
+
+  def contextOfPath(path: List[Tree])(using Context): Context = path match {
+    case Nil | _ :: Nil =>
+      ctx.fresh
+    case nested :: encl :: rest =>
+      val outer = contextOfPath(encl :: rest)
+      try encl match {
+        case tree @ PackageDef(pkg, stats) =>
+          assert(tree.symbol.exists)
+          if (nested `eq` pkg) outer
+          else contextOfStat(stats, nested, pkg.symbol.moduleClass, outer.packageContext(tree, tree.symbol))
+        case tree: DefDef =>
+          assert(tree.symbol.exists)
+          val localCtx = outer.localContext(tree, tree.symbol).setNewScope
+          for params <- tree.paramss; param <- params do localCtx.enter(param.symbol)
+            // Note: this overapproximates visibility a bit, since value parameters are only visible
+            // in subsequent parameter sections
+          localCtx
+        case tree: MemberDef =>
+          if (tree.symbol.exists)
+            outer.localContext(tree, tree.symbol)
+          else
+            outer
+        case tree @ Block(stats, expr) =>
+          val localCtx = outer.fresh.setNewScope
+          stats.foreach {
+            case stat: MemberDef => localCtx.enter(stat.symbol)
+            case _ =>
+          }
+          contextOfStat(stats, nested, ctx.owner, localCtx)
+        case tree @ CaseDef(pat, _, _) =>
+          val localCtx = outer.fresh.setNewScope
+          pat.foreachSubTree {
+            case bind: Bind => localCtx.enter(bind.symbol)
+            case _ =>
+          }
+          localCtx
+        case tree @ Template(constr, parents, self, _) =>
+          if ((constr :: self :: parents).contains(nested)) outer
+          else contextOfStat(tree.body, nested, tree.symbol, outer.inClassContext(self.symbol))
+        case _ =>
+          outer
+      }
+      catch {
+        case ex: CyclicReference => outer
+      }
+  }
+
+  /** The first tree in the path that is a definition. */
+  def enclosingDefinitionInPath(path: List[Tree])(using Context): Tree =
+    path.find(_.isInstanceOf[DefTree]).getOrElse(EmptyTree)
+
+  /**
+   * Find the definitions of the symbol at the end of `path`. In the case of an import node,
+   * all imported symbols will be considered.
+   *
+   * @param path   The path to the symbol for which we want the definitions.
+   * @param driver The driver responsible for `path`.
+   * @return The definitions for the symbol at the end of `path`.
+   */
+  def findDefinitions(path: List[Tree], pos: SourcePosition, driver: InteractiveDriver): List[SourceTree] = {
+    given Context = driver.currentCtx
+    val enclTree = enclosingTree(path)
+    val includeOverridden = enclTree.isInstanceOf[MemberDef]
+    val symbols = enclosingSourceSymbols(path, pos)
+    val includeExternal = symbols.exists(!_.isLocal)
+    findDefinitions(symbols, driver, includeOverridden, includeExternal)
+  }
+
+  /**
+   * Find the definitions of `symbols`.
+   *
+   * @param symbols           The list of symbols for which to find a definition.
+   * @param driver            The driver responsible for the given symbols.
+   * @param includeOverridden If true, also include the symbols overridden by any of `symbols`.
+   * @param includeExternal   If true, also look for definitions on the classpath.
+   * @return The definitions for the symbols in `symbols`, and if `includeOverridden` is set, the
+   *         definitions for the symbols that they override.
+   */
+  def findDefinitions(symbols: List[Symbol],
+                      driver: InteractiveDriver,
+                      includeOverridden: Boolean,
+                      includeExternal: Boolean): List[SourceTree] = {
+    given Context = driver.currentCtx
+    val include = Include.definitions | Include.overriding |
+      (if (includeOverridden) Include.overridden else Include.empty)
+    symbols.flatMap { sym =>
+      val name = sym.name.sourceModuleName.toString
+      val includeLocal = if (sym.exists && sym.isLocal) Include.local else Include.empty
+      val trees =
+        if (includeExternal) driver.allTreesContaining(name)
+        else driver.sourceTreesContaining(name)
+      findTreesMatching(trees, include | includeLocal, sym)
+    }
+  }
+
+  /**
+   * Given `sym`, originating from `sourceDriver`, find its representation in
+   * `targetDriver`.
+   *
+   * @param symbol The symbol to expression in the new driver.
+   * @param sourceDriver The driver from which `symbol` originates.
+   * @param targetDriver The driver in which we want to get a representation of `symbol`.
+   * @return A representation of `symbol` in `targetDriver`.
+   */
+  def localize(symbol: Symbol, sourceDriver: InteractiveDriver, targetDriver: InteractiveDriver): Symbol = {
+
+    def in[T](driver: InteractiveDriver)(fn: Context ?=> T): T =
+      fn(using driver.currentCtx)
+
+    if (sourceDriver == targetDriver) symbol
+    else {
+      val owners = in(sourceDriver) {
+        symbol.ownersIterator.toList.reverse.map(_.name)
+      }
+      in(targetDriver) {
+        val base: Symbol = defn.RootClass
+        owners.tail.foldLeft(base) { (prefix, symbolName) =>
+          if (prefix.exists) prefix.info.member(symbolName).symbol
+          else NoSymbol
+        }
+      }
+    }
+  }
+
+  /**
+   * Return a predicate function that determines whether a given `NameTree` is an implementation of
+   * `sym`.
+   *
+   * @param sym The symbol whose implementations to find.
+   * @return A function that determines whether a `NameTree` is an implementation of `sym`.
+   */
+  def implementationFilter(sym: Symbol)(using Context): NameTree => Boolean =
+    if (sym.isClass) {
+      case td: TypeDef =>
+        val treeSym = td.symbol
+        (treeSym != sym || !treeSym.isOneOf(AbstractOrTrait)) && treeSym.derivesFrom(sym)
+      case _ =>
+        false
+    }
+    else {
+      case md: MemberDef =>
+        matchSymbol(md, sym, Include.overriding) && !md.symbol.is(Deferred)
+      case _ =>
+        false
+    }
+
+  /**
+   * Is this tree using a renaming introduced by an import statement or an alias for `this`?
+   *
+   * @param tree The tree to inspect
+   * @return True, if this tree's name is different than its symbol's name, indicating that
+   *         it uses a renaming introduced by an import statement or an alias for `this`.
+   */
+  def isRenamed(tree: NameTree)(using Context): Boolean = {
+    val symbol = tree.symbol
+    symbol.exists && !sameName(tree.name, symbol.name)
+  }
+
+  /** Are the two names the same? */
+  def sameName(n0: Name, n1: Name): Boolean =
+    n0.stripModuleClassSuffix.toTermName eq n1.stripModuleClassSuffix.toTermName
+
+  private[interactive] def safely[T](op: => List[T]): List[T] =
+    try op catch { case ex: TypeError => Nil }
+}
+
diff --git a/tests/pos-with-compiler-cc/dotc/interactive/InteractiveCompiler.scala b/tests/pos-with-compiler-cc/dotc/interactive/InteractiveCompiler.scala
new file mode 100644
index 000000000000..38a93125a342
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/interactive/InteractiveCompiler.scala
@@ -0,0 +1,21 @@
+package dotty.tools
+package dotc
+package interactive
+
+import core._
+import Phases._
+import parsing._
+import typer._
+
+class InteractiveCompiler extends Compiler {
+  // TODO: Figure out what phases should be run in IDEs
+  // More phases increase latency but allow us to report more errors.
+  // This could be improved by reporting errors back to the IDE
+  // after each phase group instead of waiting for the pipeline to finish.
+  override def phases: List[List[Phase]] = List(
+    List(new Parser),
+    List(new TyperPhase),
+    List(new transform.SetRootTree),
+    List(new transform.CookComments)
+  )
+}
diff --git a/tests/pos-with-compiler-cc/dotc/interactive/InteractiveDriver.scala b/tests/pos-with-compiler-cc/dotc/interactive/InteractiveDriver.scala
new file mode 100644
index 000000000000..132ff162be61
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/interactive/InteractiveDriver.scala
@@ -0,0 +1,340 @@
+package dotty.tools
+package dotc
+package interactive
+
+import scala.language.unsafeNulls
+
+import java.net.URI
+import java.io._
+import java.nio.file._
+import java.nio.file.attribute.BasicFileAttributes
+import java.nio.charset.StandardCharsets
+import java.util.zip._
+
+import scala.collection._
+import scala.io.Codec
+
+import dotty.tools.io.AbstractFile
+
+import ast.{Trees, tpd}
+import core._, core.Decorators._
+import Contexts._, Names._, NameOps._, Symbols._, SymDenotations._, Trees._, Types._
+import Denotations.staticRef
+import classpath._
+import reporting._
+import util._
+
+/** A Driver subclass designed to be used from IDEs */
+class InteractiveDriver(val settings: List[String]) extends Driver {
+  import tpd._
+
+  override def sourcesRequired: Boolean = false
+
+  private val myInitCtx: Context = {
+    val rootCtx = initCtx.fresh.addMode(Mode.ReadPositions).addMode(Mode.Interactive)
+    rootCtx.setSetting(rootCtx.settings.YretainTrees, true)
+    rootCtx.setSetting(rootCtx.settings.YcookComments, true)
+    rootCtx.setSetting(rootCtx.settings.YreadComments, true)
+    val ctx = setup(settings.toArray, rootCtx) match
+      case Some((_, ctx)) => ctx
+      case None => rootCtx
+    ctx.initialize()(using ctx)
+    ctx
+  }
+
+  private var myCtx: Context = myInitCtx
+  def currentCtx: Context = myCtx
+
+  private val compiler: Compiler = new InteractiveCompiler
+
+  private val myOpenedFiles = new mutable.LinkedHashMap[URI, SourceFile] {
+    override def default(key: URI) = NoSource
+  }
+  def openedFiles: Map[URI, SourceFile] = myOpenedFiles
+
+  private val myOpenedTrees = new mutable.LinkedHashMap[URI, List[SourceTree]] {
+    override def default(key: URI) = Nil
+  }
+  def openedTrees: Map[URI, List[SourceTree]] = myOpenedTrees
+
+  private val myCompilationUnits = new mutable.LinkedHashMap[URI, CompilationUnit]
+  def compilationUnits: Map[URI, CompilationUnit] = myCompilationUnits
+
+  // Presence of a file with one of these suffixes indicates that the
+  // corresponding class has been pickled with TASTY.
+  private val tastySuffix = ".tasty"
+
+  // FIXME: All the code doing classpath handling is very fragile and ugly,
+  // improving this requires changing the dotty classpath APIs to handle our usecases.
+  // We also need something like sbt server-mode to be informed of changes on
+  // the classpath.
+
+  private val (zipClassPaths, dirClassPaths) = currentCtx.platform.classPath(using currentCtx) match {
+    case AggregateClassPath(cps) =>
+      // FIXME: We shouldn't assume that ClassPath doesn't have other
+      // subclasses. For now, the only other subclass is JrtClassPath on Java
+      // 9+, we can safely ignore it for now because it's only used for the
+      // standard Java library, but this will change once we start supporting
+      // adding entries to the modulepath.
+      val zipCps = cps.collect { case cp: ZipArchiveFileLookup[?] => cp }
+      val dirCps = cps.collect { case cp: JFileDirectoryLookup[?] => cp }
+      (zipCps, dirCps)
+    case _ =>
+      (Seq(), Seq())
+  }
+
+  // Like in `ZipArchiveFileLookup` we assume that zips are immutable
+  private val zipClassPathClasses: Seq[TypeName] = {
+    val names = new mutable.ListBuffer[TypeName]
+    for (cp <- zipClassPaths)
+      classesFromZip(cp.zipFile, names)
+    names
+  }
+
+  initialize()
+
+  /**
+   * The trees for all the source files in this project.
+   *
+   * This includes the trees for the buffers that are presently open in the IDE, and the trees
+   * from the target directory.
+   */
+  def sourceTrees(using Context): List[SourceTree] = sourceTreesContaining("")
+
+  /**
+   * The trees for all the source files in this project that contain `id`.
+   *
+   * This includes the trees for the buffers that are presently open in the IDE, and the trees
+   * from the target directory.
+   */
+  def sourceTreesContaining(id: String)(using Context): List[SourceTree] = {
+    val fromBuffers = openedTrees.values.flatten.toList
+    val fromCompilationOutput = {
+      val classNames = new mutable.ListBuffer[TypeName]
+      val output = ctx.settings.outputDir.value
+      if (output.isDirectory)
+        classesFromDir(output.jpath, classNames)
+      else
+        classesFromZip(output.file, classNames)
+      classNames.flatMap { cls =>
+        treesFromClassName(cls, id)
+      }
+    }
+    (fromBuffers ++ fromCompilationOutput).distinct
+  }
+
+  /**
+   * All the trees for this project.
+   *
+   * This includes the trees of the sources of this project, along with the trees that are found
+   * on this project's classpath.
+   */
+  def allTrees(using Context): List[SourceTree] = allTreesContaining("")
+
+  /**
+   * All the trees for this project that contain `id`.
+   *
+   * This includes the trees of the sources of this project, along with the trees that are found
+   * on this project's classpath.
+   */
+  def allTreesContaining(id: String)(using Context): List[SourceTree] = {
+    val fromSource = openedTrees.values.flatten.toList
+    val fromClassPath = (dirClassPathClasses ++ zipClassPathClasses).flatMap { cls =>
+      treesFromClassName(cls, id)
+    }
+    (fromSource ++ fromClassPath).distinct
+  }
+
+  def run(uri: URI, sourceCode: String): List[Diagnostic] = run(uri, toSource(uri, sourceCode))
+
+  def run(uri: URI, source: SourceFile): List[Diagnostic] = {
+    import typer.ImportInfo._
+
+    val previousCtx = myCtx
+    try {
+      val reporter =
+        new StoreReporter(null) with UniqueMessagePositions with HideNonSensicalMessages
+
+      val run = compiler.newRun(using myInitCtx.fresh.setReporter(reporter))
+      myCtx = run.runContext.withRootImports
+
+      given Context = myCtx
+
+      myOpenedFiles(uri) = source
+
+      run.compileSources(List(source))
+      run.printSummary()
+      val ctxRun = ctx.run.nn
+      val unit = if ctxRun.units.nonEmpty then ctxRun.units.head else ctxRun.suspendedUnits.head
+      val t = unit.tpdTree
+      cleanup(t)
+      myOpenedTrees(uri) = topLevelTrees(t, source)
+      myCompilationUnits(uri) = unit
+      myCtx = myCtx.fresh.setPhase(myInitCtx.base.typerPhase)
+
+      reporter.removeBufferedMessages
+    }
+    catch {
+      case ex: FatalError  =>
+        myCtx = previousCtx
+        close(uri)
+        Nil
+    }
+  }
+
+  def close(uri: URI): Unit = {
+    myOpenedFiles.remove(uri)
+    myOpenedTrees.remove(uri)
+    myCompilationUnits.remove(uri)
+  }
+
+  /**
+   * The `SourceTree`s that define the class `className` and/or module `className`.
+   *
+   * @see SourceTree.fromSymbol
+   */
+  private def treesFromClassName(className: TypeName, id: String)(using Context): List[SourceTree] = {
+    def trees(className: TypeName, id: String): List[SourceTree] = {
+      val clsd = staticRef(className)
+      clsd match {
+        case clsd: ClassDenotation =>
+          clsd.ensureCompleted()
+          SourceTree.fromSymbol(clsd.symbol.asClass, id)
+        case _ =>
+          Nil
+      }
+    }
+    trees(className, id) ::: trees(className.moduleClassName, id)
+  }
+
+  // FIXME: classfiles in directories may change at any point, so we retraverse
+  // the directories each time, if we knew when classfiles changed (sbt
+  // server-mode might help here), we could do cache invalidation instead.
+  private def dirClassPathClasses: Seq[TypeName] = {
+    val names = new mutable.ListBuffer[TypeName]
+    dirClassPaths.foreach { dirCp =>
+      val root = dirCp.dir.toPath
+      classesFromDir(root, names)
+    }
+    names
+  }
+
+  /** Adds the names of the classes that are defined in `file` to `buffer`. */
+  private def classesFromZip(file: File, buffer: mutable.ListBuffer[TypeName]): Unit = {
+    val zipFile = new ZipFile(file)
+    try {
+      val entries = zipFile.entries()
+      while (entries.hasMoreElements) {
+        val entry = entries.nextElement()
+        val name = entry.getName
+        if name.endsWith(tastySuffix) then
+          buffer += name.replace("/", ".").stripSuffix(tastySuffix).toTypeName
+      }
+    }
+    finally zipFile.close()
+  }
+
+  /** Adds the names of the classes that are defined in `dir` to `buffer`. */
+  private def classesFromDir(dir: Path, buffer: mutable.ListBuffer[TypeName]): Unit =
+    try
+      Files.walkFileTree(dir, new SimpleFileVisitor[Path] {
+        override def visitFile(path: Path, attrs: BasicFileAttributes) = {
+          if (!attrs.isDirectory) {
+            val name = path.getFileName.toString
+            if name.endsWith(tastySuffix) then
+              buffer += dir.relativize(path).toString.replace("/", ".").stripSuffix(tastySuffix).toTypeName
+          }
+          FileVisitResult.CONTINUE
+        }
+      })
+    catch {
+      case _: NoSuchFileException =>
+    }
+
+  private def topLevelTrees(topTree: Tree, source: SourceFile): List[SourceTree] = {
+    val trees = new mutable.ListBuffer[SourceTree]
+
+    def addTrees(tree: Tree): Unit = tree match {
+      case PackageDef(_, stats) =>
+        stats.foreach(addTrees)
+      case imp: Import =>
+        trees += SourceTree(imp, source)
+      case tree: TypeDef =>
+        trees += SourceTree(tree, source)
+      case _ =>
+    }
+    addTrees(topTree)
+
+    trees.toList
+  }
+
+  /** Remove attachments and error out completers. The goal is to avoid
+   *  having a completer hanging in a typed tree which can capture the context
+   *  of a previous run. Note that typed trees can have untyped or partially
+   *  typed children if the source contains errors.
+   */
+  private def cleanup(tree: tpd.Tree)(using Context): Unit = {
+    val seen = mutable.Set.empty[tpd.Tree]
+    def cleanupTree(tree: tpd.Tree): Unit = {
+      seen += tree
+      tree.foreachSubTree { t =>
+        if (t.symbol.exists && t.hasType) {
+          if (!t.symbol.isCompleted) t.symbol.info = UnspecifiedErrorType
+          t.symbol.annotations.foreach { annot =>
+            /* In some cases annotations are are used on themself (possibly larger cycles).
+            *  This is the case with the java.lang.annotation.Target annotation, would end
+            *  in an infinite loop while cleaning. The `seen` is added to ensure that those
+            *  trees are not cleand twice.
+            *  TODO: Find a less expensive way to check for those cycles.
+            */
+            if (annot.isEvaluated && !seen(annot.tree))
+              cleanupTree(annot.tree)
+          }
+        }
+        t.removeAllAttachments()
+      }
+    }
+    cleanupTree(tree)
+  }
+
+  private def toSource(uri: URI, sourceCode: String): SourceFile =
+    SourceFile.virtual(Paths.get(uri).toString, sourceCode)
+
+  /**
+   * Initialize this driver and compiler.
+   *
+   * This is necessary because an `InteractiveDriver` can be put to work without having
+   * compiled anything (for instance, resolving a symbol coming from a different compiler in
+   * this compiler). In those cases, an un-initialized compiler may crash (for instance if
+   * late-compilation is needed).
+   */
+  private def initialize(): Unit = {
+    val run = compiler.newRun(using myInitCtx.fresh)
+    myCtx = run.runContext
+    run.compileUnits(Nil, myCtx)
+  }
+}
+
+
+object InteractiveDriver {
+  def toUriOption(file: AbstractFile): Option[URI] =
+    if (!file.exists)
+      None
+    else
+      try
+        // We don't use file.file here since it'll be null
+        // for the VirtualFiles created by InteractiveDriver#toSource
+        // TODO: To avoid these round trip conversions, we could add an
+        // AbstractFile#toUri method and implement it by returning a constant
+        // passed as a parameter to a constructor of VirtualFile
+        Some(Paths.get(file.path).toUri)
+      catch {
+        case e: InvalidPathException =>
+          None
+      }
+  def toUriOption(source: SourceFile): Option[URI] =
+    if (!source.exists)
+      None
+    else
+      toUriOption(source.file)
+}
diff --git a/tests/pos-with-compiler-cc/dotc/interactive/SourceTree.scala b/tests/pos-with-compiler-cc/dotc/interactive/SourceTree.scala
new file mode 100644
index 000000000000..60f01396e91e
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/interactive/SourceTree.scala
@@ -0,0 +1,80 @@
+package dotty.tools
+package dotc
+package interactive
+
+
+import ast.tpd
+import core._
+import Contexts._, NameOps._, Symbols._, StdNames._
+import util._, util.Spans._
+
+/**
+ * A `tree` coming from `source`
+ *
+ * `tree` can be either an `Import` or a `NameTree`.
+ */
+case class SourceTree(tree: tpd.Import | tpd.NameTree, source: SourceFile) {
+
+  /** The position of `tree` */
+  final def pos(using Context): SourcePosition = source.atSpan(tree.span)
+
+  /** The position of the name in `tree` */
+  def namePos(using Context): SourcePosition = tree match {
+    case tree: tpd.NameTree =>
+      // FIXME: Merge with NameTree#namePos ?
+      val treeSpan = tree.span
+      if (treeSpan.isZeroExtent || tree.name.toTermName == nme.ERROR)
+        NoSourcePosition
+      else {
+        // Constructors are named `<init>` in the trees, but `this` in the source.
+        val nameLength = tree.name match {
+          case nme.CONSTRUCTOR => nme.this_.toString.length
+          case other => other.stripModuleClassSuffix.show.toString.length
+        }
+        val position = {
+          // FIXME: This is incorrect in some cases, like with backquoted identifiers,
+          //        see https://github.com/lampepfl/dotty/pull/1634#issuecomment-257079436
+          val (start, end) =
+            if (!treeSpan.isSynthetic)
+              (treeSpan.point, treeSpan.point + nameLength)
+            else
+              // If we don't have a point, we need to find it
+              (treeSpan.end - nameLength, treeSpan.end)
+          Span(start, end, start)
+        }
+        source.atSpan(position)
+      }
+    case _ =>
+      NoSourcePosition
+  }
+}
+
+object SourceTree {
+  def fromSymbol(sym: ClassSymbol, id: String = "")(using Context): List[SourceTree] =
+    if (sym == defn.SourceFileAnnot || // FIXME: No SourceFile annotation on SourceFile itself
+        !sym.source.exists) // FIXME: We cannot deal with external projects yet
+      Nil
+    else {
+      import ast.Trees._
+      def sourceTreeOfClass(tree: tpd.Tree): Option[SourceTree] = tree match {
+        case PackageDef(_, stats) =>
+          stats.flatMap(sourceTreeOfClass).headOption
+        case tree: tpd.TypeDef if tree.symbol == sym =>
+          Some(SourceTree(tree, sym.source))
+        case _ =>
+          None
+      }
+
+      def sourceImports(tree: tpd.Tree, sourceFile: SourceFile): List[SourceTree] = tree match {
+        case PackageDef(_, stats) => stats.flatMap(sourceImports(_, sourceFile))
+        case imp: tpd.Import => SourceTree(imp, sourceFile) :: Nil
+        case _ => Nil
+      }
+
+      val tree = sym.rootTreeContaining(id)
+      sourceTreeOfClass(tree) match {
+        case Some(namedTree) => namedTree :: sourceImports(tree, namedTree.source)
+        case None => Nil
+      }
+    }
+}
diff --git a/tests/pos-with-compiler-cc/dotc/parsing/CharArrayReader.scala b/tests/pos-with-compiler-cc/dotc/parsing/CharArrayReader.scala
new file mode 100644
index 000000000000..c63409d0d52b
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/parsing/CharArrayReader.scala
@@ -0,0 +1,128 @@
+package dotty.tools
+package dotc
+package parsing
+
+import util.Chars._
+
+abstract class CharArrayReader { self =>
+
+  val buf: Array[Char]
+  protected def startFrom: Int = 0
+
+  /** Switch whether unicode should be decoded */
+  protected def decodeUni: Boolean = false
+
+  /** An error routine to call on bad unicode escapes \\uxxxx. */
+  protected def error(msg: String, offset: Int): Unit
+
+  /** the last read character */
+  var ch: Char = _
+
+  /** The offset one past the last read character */
+  var charOffset: Int = startFrom
+
+  /** The offset before the last read character */
+  var lastCharOffset: Int = startFrom
+
+  /** The start offset of the current line */
+  var lineStartOffset: Int = startFrom
+
+  private var lastUnicodeOffset = -1
+
+  /** Is last character a unicode escape \\uxxxx? */
+  def isUnicodeEscape: Boolean = charOffset == lastUnicodeOffset
+
+  /** Advance one character; reducing CR;LF pairs to just LF */
+  final def nextChar(): Unit = {
+    val idx = charOffset
+    lastCharOffset = idx
+    charOffset = idx + 1
+    if (idx >= buf.length)
+      ch = SU
+    else {
+      val c = buf(idx)
+      ch = c
+      if (c == '\\') potentialUnicode()
+      else if (c < ' ') { skipCR(); potentialLineEnd() }
+    }
+  }
+
+  def getc(): Char = { nextChar() ; ch }
+
+  /** Advance one character, leaving CR;LF pairs intact.
+   *  This is for use in multi-line strings, so there are no
+   *  "potential line ends" here.
+   */
+  final def nextRawChar(): Unit = {
+    val idx = charOffset
+    lastCharOffset = idx
+    charOffset = idx + 1
+    if (idx >= buf.length)
+      ch = SU
+    else {
+      val c = buf(idx)
+      ch = c
+      if (c == '\\') potentialUnicode()
+    }
+  }
+
+  /** Interpret \\uxxxx escapes */
+  private def potentialUnicode(): Unit = {
+    def evenSlashPrefix: Boolean = {
+      var p = charOffset - 2
+      while (p >= 0 && buf(p) == '\\') p -= 1
+      (charOffset - p) % 2 == 0
+    }
+    def udigit: Int =
+      if (charOffset >= buf.length) {
+        // Since the positioning code is very insistent about throwing exceptions,
+        // we have to decrement the position so our error message can be seen, since
+        // we are one past EOF.  This happens with e.g. val x = \ u 1 <EOF>
+        error("incomplete unicode escape", charOffset - 1)
+        SU
+      }
+      else {
+        val d = digit2int(buf(charOffset), 16)
+        if (d >= 0) charOffset += 1
+        else error("error in unicode escape", charOffset)
+        d
+      }
+    if (charOffset < buf.length && buf(charOffset) == 'u' && decodeUni && evenSlashPrefix) {
+      while ({
+        charOffset += 1
+        charOffset < buf.length && buf(charOffset) == 'u'
+      })
+      ()
+      val code = udigit << 12 | udigit << 8 | udigit << 4 | udigit
+      lastUnicodeOffset = charOffset
+      ch = code.toChar
+    }
+  }
+
+  /** replace CR;LF by LF */
+  private def skipCR(): Unit =
+    if (ch == CR)
+      if (charOffset < buf.length && buf(charOffset) == LF) {
+        charOffset += 1
+        ch = LF
+      }
+
+  /** Handle line ends */
+  private def potentialLineEnd(): Unit =
+    if (ch == LF || ch == FF) lineStartOffset = charOffset
+
+  def isAtEnd: Boolean = charOffset >= buf.length
+
+  /** A new reader that takes off at the current character position */
+  def lookaheadReader(): CharArrayLookaheadReader = new CharArrayLookaheadReader
+
+  def lookaheadChar(): Char = lookaheadReader().getc()
+
+  class CharArrayLookaheadReader extends CharArrayReader {
+    val buf: Array[Char] = self.buf
+    charOffset = self.charOffset
+    ch = self.ch
+    override def decodeUni: Boolean = self.decodeUni
+    def error(msg: String, offset: Int): Unit = self.error(msg, offset)
+  }
+}
diff --git a/tests/pos-with-compiler-cc/dotc/parsing/JavaParsers.scala b/tests/pos-with-compiler-cc/dotc/parsing/JavaParsers.scala
new file mode 100644
index 000000000000..4611554a01a3
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/parsing/JavaParsers.scala
@@ -0,0 +1,1034 @@
+package dotty.tools
+package dotc
+package parsing
+
+import dotty.tools.dotc.core.Constants.Constant
+import dotty.tools.dotc.core.Flags
+import dotty.tools.dotc.core.Flags.FlagSet
+
+import JavaTokens._
+import JavaScanners._
+import Scanners.Offset
+import Parsers._
+import core._
+import Contexts._
+import Names._
+import Types._
+import ast.Trees._
+import Decorators._
+import StdNames._
+import reporting._
+import dotty.tools.dotc.util.SourceFile
+import util.Spans._
+import scala.collection.mutable.ListBuffer
+
+object JavaParsers {
+
+  import ast.untpd._
+
+  class JavaParser(source: SourceFile)(using Context) extends ParserCommon(source) {
+
+    val definitions: Definitions = ctx.definitions
+    import definitions._
+
+    val in: JavaScanner = new JavaScanner(source)
+
+    /** The simple name of the package of the currently parsed file */
+    private var thisPackageName: TypeName = tpnme.EMPTY
+
+    /** This is the general parse entry point.
+     *  Overridden by ScriptParser
+     */
+    def parse(): Tree = {
+      val t = compilationUnit()
+      accept(EOF)
+      t
+    }
+
+    // -------- error handling ---------------------------------------
+
+    protected def skip(): Unit = {
+      var nparens = 0
+      var nbraces = 0
+      while (true) {
+        in.token match {
+          case EOF =>
+            return
+          case SEMI =>
+            if (nparens == 0 && nbraces == 0) return
+          case RPAREN =>
+            nparens -= 1
+          case RBRACE =>
+            if (nbraces == 0) return
+            nbraces -= 1
+          case LPAREN =>
+            nparens += 1
+          case LBRACE =>
+            nbraces += 1
+          case _ =>
+        }
+        in.nextToken()
+      }
+    }
+
+    def syntaxError(msg: String, skipIt: Boolean): Unit =
+      syntaxError(in.offset, msg, skipIt)
+
+    def syntaxError(offset: Int, msg: String, skipIt: Boolean): Unit = {
+      if (offset > lastErrorOffset) {
+        syntaxError(msg, offset)
+        // no more errors on this token.
+        lastErrorOffset = in.offset
+      }
+      if (skipIt)
+        skip()
+    }
+
+    def errorTypeTree: TypeTree = TypeTree().withType(UnspecifiedErrorType).withSpan(Span(in.offset))
+
+    // --------- tree building -----------------------------
+
+    def scalaAnnotationDot(name: Name): Select = Select(scalaDot(nme.annotation), name)
+
+    def javaDot(name: Name): Tree =
+      Select(rootDot(nme.java), name)
+
+    def javaLangDot(name: Name): Tree =
+      Select(javaDot(nme.lang), name)
+
+    def javaLangObject(): Tree = javaLangDot(tpnme.Object)
+
+    def arrayOf(tpt: Tree): AppliedTypeTree =
+      AppliedTypeTree(scalaDot(tpnme.Array), List(tpt))
+
+    def makeTemplate(parents: List[Tree], stats: List[Tree], tparams: List[TypeDef], needsDummyConstr: Boolean): Template = {
+      def pullOutFirstConstr(stats: List[Tree]): (Tree, List[Tree]) = stats match {
+        case (meth: DefDef) :: rest if meth.name == nme.CONSTRUCTOR => (meth, rest)
+        case first :: rest =>
+          val (constr, tail) = pullOutFirstConstr(rest)
+          (constr, first :: tail)
+        case nil => (EmptyTree, nil)
+      }
+      var (constr1, stats1) = pullOutFirstConstr(stats)
+      // A dummy first constructor is needed for Java classes so that the real constructors see the
+      // import of the companion object. The constructor has parameter of type Unit so no Java code
+      // can call it.
+      // This also avoids clashes between the constructor parameter names and member names.
+      if (needsDummyConstr) {
+        if (constr1 == EmptyTree) constr1 = makeConstructor(List(), Nil)
+        stats1 = constr1 :: stats1
+        constr1 = makeConstructor(List(scalaDot(tpnme.Unit)), tparams, Flags.JavaDefined | Flags.PrivateLocal)
+      }
+      else if (constr1 == EmptyTree) {
+        constr1 = makeConstructor(List(), tparams)
+      }
+      Template(constr1.asInstanceOf[DefDef], parents, Nil, EmptyValDef, stats1)
+    }
+
+    def makeSyntheticParam(count: Int, tpt: Tree): ValDef =
+      makeParam(nme.syntheticParamName(count), tpt)
+    def makeParam(name: TermName, tpt: Tree): ValDef =
+      ValDef(name, tpt, EmptyTree).withMods(Modifiers(Flags.JavaDefined | Flags.Param))
+
+    def makeConstructor(formals: List[Tree], tparams: List[TypeDef], flags: FlagSet = Flags.JavaDefined): DefDef = {
+      val vparams = formals.zipWithIndex.map { case (p, i) => makeSyntheticParam(i + 1, p) }
+      DefDef(nme.CONSTRUCTOR, joinParams(tparams, List(vparams)), TypeTree(), EmptyTree).withMods(Modifiers(flags))
+    }
+
+    // ------------- general parsing ---------------------------
+
+    /** skip parent or brace enclosed sequence of things */
+    def skipAhead(): Unit = {
+      var nparens = 0
+      var nbraces = 0
+      while ({
+        in.token match {
+          case LPAREN =>
+            nparens += 1
+          case LBRACE =>
+            nbraces += 1
+          case _ =>
+        }
+        in.nextToken()
+        in.token match {
+          case RPAREN =>
+            nparens -= 1
+          case RBRACE =>
+            nbraces -= 1
+          case _ =>
+        }
+        in.token != EOF && (nparens > 0 || nbraces > 0)
+      })
+      ()
+    }
+
+    def skipTo(tokens: Int*): Unit =
+      while (!(tokens contains in.token) && in.token != EOF)
+        if (in.token == LBRACE) { skipAhead(); accept(RBRACE) }
+        else if (in.token == LPAREN) { skipAhead(); accept(RPAREN) }
+        else in.nextToken()
+
+    /** Consume one token of the specified type, or
+      * signal an error if it is not there.
+      *
+      * @return The offset at the start of the token to accept
+      */
+    def accept(token: Int): Int = {
+      val offset = in.offset
+      if (in.token != token) {
+        val offsetToReport = in.offset
+        val msg =
+          tokenString(token) + " expected but " +
+            tokenString(in.token) + " found."
+
+        syntaxError(offsetToReport, msg, skipIt = true)
+      }
+      if (in.token == token) in.nextToken()
+      offset
+    }
+
+    def acceptClosingAngle(): Unit = {
+      val closers: PartialFunction[Int, Int] = {
+        case GTGTGTEQ => GTGTEQ
+        case GTGTGT   => GTGT
+        case GTGTEQ   => GTEQ
+        case GTGT     => GT
+        case GTEQ     => EQUALS
+      }
+      if (closers isDefinedAt in.token) in.token = closers(in.token)
+      else accept(GT)
+    }
+
+    def identForType(): TypeName = ident().toTypeName
+    def ident(): Name =
+      if (in.token == IDENTIFIER) {
+        val name = in.name
+        in.nextToken()
+        name
+      }
+      else {
+        accept(IDENTIFIER)
+        nme.ERROR
+      }
+
+    def repsep[T <: Tree](p: () => T, sep: Int): List[T] = {
+      val buf = ListBuffer[T](p())
+      while (in.token == sep) {
+        in.nextToken()
+        buf += p()
+      }
+      buf.toList
+    }
+
+    /** Convert (qual)ident to type identifier
+      */
+    def convertToTypeId(tree: Tree): Tree = convertToTypeName(tree) match {
+      case Some(t)  => t.withSpan(tree.span)
+      case _        => tree match {
+        case AppliedTypeTree(_, _) | Select(_, _) =>
+          tree
+        case _ =>
+          syntaxError(IdentifierExpected(tree.show), tree.span)
+          errorTypeTree
+      }
+    }
+
+    /** Translate names in Select/Ident nodes to type names.
+      */
+    def convertToTypeName(tree: Tree): Option[RefTree] = tree match {
+      case Select(qual, name) => Some(Select(qual, name.toTypeName))
+      case Ident(name)        => Some(Ident(name.toTypeName))
+      case _                  => None
+    }
+    // -------------------- specific parsing routines ------------------
+
+    def qualId(): RefTree = {
+      var t: RefTree = atSpan(in.offset) { Ident(ident()) }
+      while (in.token == DOT && in.lookaheadToken == IDENTIFIER) {
+        in.nextToken()
+        t = atSpan(t.span.start, in.offset) { Select(t, ident()) }
+      }
+      t
+    }
+
+    def optArrayBrackets(tpt: Tree): Tree =
+      if (in.token == LBRACKET) {
+        val tpt1 = atSpan(tpt.span.start, in.offset) { arrayOf(tpt) }
+        in.nextToken()
+        accept(RBRACKET)
+        optArrayBrackets(tpt1)
+      }
+      else tpt
+
+    def basicType(): Tree =
+      atSpan(in.offset) {
+        in.token match {
+          case BYTE    => in.nextToken(); TypeTree(ByteType)
+          case SHORT   => in.nextToken(); TypeTree(ShortType)
+          case CHAR    => in.nextToken(); TypeTree(CharType)
+          case INT     => in.nextToken(); TypeTree(IntType)
+          case LONG    => in.nextToken(); TypeTree(LongType)
+          case FLOAT   => in.nextToken(); TypeTree(FloatType)
+          case DOUBLE  => in.nextToken(); TypeTree(DoubleType)
+          case BOOLEAN => in.nextToken(); TypeTree(BooleanType)
+          case _       => syntaxError("illegal start of type", skipIt = true); errorTypeTree
+        }
+      }
+
+    def typ(): Tree =
+      annotations()
+      optArrayBrackets {
+        if (in.token == FINAL) in.nextToken()
+        if (in.token == IDENTIFIER) {
+          var t = typeArgs(atSpan(in.offset)(Ident(ident())))
+          // typeSelect generates Select nodes if the lhs is an Ident or Select,
+          // For other nodes it always assumes that the selected item is a type.
+          def typeSelect(t: Tree, name: Name) = t match {
+            case Ident(_) | Select(_, _) => Select(t, name)
+            case _ => Select(t, name.toTypeName)
+          }
+          while (in.token == DOT) {
+            in.nextToken()
+            t = typeArgs(atSpan(t.span.start, in.offset)(typeSelect(t, ident())))
+          }
+          convertToTypeId(t)
+        }
+        else
+          basicType()
+      }
+
+    def typeArgs(t: Tree): Tree = {
+      var wildnum = 0
+      def typeArg(): Tree =
+        if (in.token == QMARK) {
+          val offset = in.offset
+          in.nextToken()
+          val hi = if (in.token == EXTENDS) { in.nextToken() ; typ() } else javaLangObject()
+          val lo = if (in.token == SUPER)   { in.nextToken() ; typ() } else EmptyTree
+          atSpan(offset) {
+            /*
+            TypeDef(
+              Modifiers(Flags.JavaDefined | Flags.Deferred),
+              typeName("_$" +(wildnum += 1)),
+              List(),
+              TypeBoundsTree(lo, hi))
+              */
+            TypeBoundsTree(lo, hi)
+          }
+        }
+        else
+          typ()
+      if (in.token == LT) {
+        in.nextToken()
+        val t1 = convertToTypeId(t)
+        val args = repsep(() => typeArg(), COMMA)
+        acceptClosingAngle()
+        atSpan(t1.span.start) {
+          AppliedTypeTree(t1, args)
+        }
+      }
+      else t
+    }
+
+    def annotations(): List[Tree] = {
+      var annots = new ListBuffer[Tree]
+      while (in.token == AT) {
+        in.nextToken()
+        annotation() match {
+          case Some(anno) => annots += anno
+          case _ =>
+        }
+      }
+      annots.toList
+    }
+
+    /** Annotation                   ::= TypeName [`(` [AnnotationArgument {`,` AnnotationArgument}] `)`]
+      * AnnotationArgument           ::= ElementValuePair | ELementValue
+      * ElementValuePair             ::= Identifier `=` ElementValue
+      * ElementValue                 ::= ConstExpressionSubset
+      *                                | ElementValueArrayInitializer
+      *                                | Annotation
+      * ElementValueArrayInitializer ::= `{` [ElementValue {`,` ElementValue}] [`,`]  `}`
+      * ConstExpressionSubset        ::= Literal
+      *                                | QualifiedName
+      *                                | ClassLiteral
+      *
+      * We support only subset of const expressions expected in this context by java.
+      * If we encounter expression that we cannot parse, we do not raise parsing error,
+      * but instead we skip entire annotation silently.
+      */
+    def annotation(): Option[Tree] = {
+      def classOrId(): Tree =
+        val id = qualId()
+        if in.lookaheadToken == CLASS then
+          in.nextToken()
+          accept(CLASS)
+          TypeApply(
+            Select(
+              scalaDot(nme.Predef),
+              nme.classOf),
+            convertToTypeId(id) :: Nil
+          )
+        else id
+
+      def array(): Option[Tree] =
+        accept(LBRACE)
+        val buffer = ListBuffer[Option[Tree]]()
+        while in.token != RBRACE do
+          buffer += argValue()
+          if in.token == COMMA then
+            in.nextToken() // using this instead of repsep allows us to handle trailing commas
+        accept(RBRACE)
+        Option.unless(buffer contains None) {
+          Apply(scalaDot(nme.Array), buffer.flatten.toList)
+        }
+
+      def argValue(): Option[Tree] =
+        val tree = tryConstant match {
+          case Some(c) =>
+            Some(atSpan(in.offset)(Literal(c)))
+          case _ => in.token match {
+            case AT =>
+              in.nextToken()
+              annotation()
+            case IDENTIFIER => Some(classOrId())
+            case LBRACE => array()
+            case _ => None
+          }
+        }
+        if in.token == COMMA || in.token == RBRACE || in.token == RPAREN then
+          tree
+        else
+          skipTo(COMMA, RBRACE, RPAREN)
+          None
+
+      def annArg(): Option[Tree] =
+        val name = if (in.token == IDENTIFIER && in.lookaheadToken == EQUALS)
+          val n = ident()
+          accept(EQUALS)
+          n
+        else
+          nme.value
+        argValue().map(NamedArg(name, _))
+
+
+      val id = convertToTypeId(qualId())
+      val args = ListBuffer[Option[Tree]]()
+      if in.token == LPAREN then
+        in.nextToken()
+        if in.token != RPAREN then
+          args += annArg()
+          while in.token == COMMA do
+            in.nextToken()
+            args += annArg()
+        accept(RPAREN)
+
+      Option.unless(args contains None) {
+        Apply(
+          Select(New(id), nme.CONSTRUCTOR),
+          args.flatten.toList
+        )
+      }
+    }
+
+    def modifiers(inInterface: Boolean): Modifiers = {
+      var flags: FlagSet = Flags.JavaDefined
+      // assumed true unless we see public/private/protected
+      var isPackageAccess = true
+      var annots = new ListBuffer[Tree]
+      def addAnnot(tpt: Tree) =
+        annots += atSpan(in.offset) {
+          in.nextToken()
+          New(tpt)
+        }
+
+      while (true)
+        in.token match {
+          case AT if (in.lookaheadToken != INTERFACE) =>
+            in.nextToken()
+            annotation() match {
+              case Some(anno) => annots += anno
+              case _ =>
+            }
+          case PUBLIC =>
+            isPackageAccess = false
+            in.nextToken()
+          case PROTECTED =>
+            flags |= Flags.Protected
+            in.nextToken()
+          case PRIVATE =>
+            isPackageAccess = false
+            flags |= Flags.Private
+            in.nextToken()
+          case STATIC =>
+            flags |= Flags.JavaStatic
+            in.nextToken()
+          case ABSTRACT =>
+            flags |= Flags.Abstract
+            in.nextToken()
+          case FINAL =>
+            flags |= Flags.Final
+            in.nextToken()
+          case DEFAULT =>
+            flags |= Flags.DefaultMethod
+            in.nextToken()
+          case NATIVE =>
+            addAnnot(scalaDot(jtpnme.NATIVEkw))
+          case TRANSIENT =>
+            addAnnot(scalaDot(jtpnme.TRANSIENTkw))
+          case VOLATILE =>
+            addAnnot(scalaDot(jtpnme.VOLATILEkw))
+          case SYNCHRONIZED | STRICTFP =>
+            in.nextToken()
+          case _ =>
+            val privateWithin: TypeName =
+              if (isPackageAccess && !inInterface) thisPackageName
+              else tpnme.EMPTY
+
+            return Modifiers(flags, privateWithin) withAnnotations annots.toList
+        }
+      assert(false, "should not be here")
+      throw new RuntimeException
+    }
+
+    def typeParams(flags: FlagSet = Flags.JavaDefined | Flags.PrivateLocal | Flags.Param): List[TypeDef] =
+      if (in.token == LT) {
+        in.nextToken()
+        val tparams = repsep(() => typeParam(flags), COMMA)
+        acceptClosingAngle()
+        tparams
+      }
+      else List()
+
+    def typeParam(flags: FlagSet): TypeDef =
+      atSpan(in.offset) {
+        annotations()
+        val name = identForType()
+        val hi = if (in.token == EXTENDS) { in.nextToken() ; bound() } else javaLangObject()
+        TypeDef(name, TypeBoundsTree(EmptyTree, hi)).withMods(Modifiers(flags))
+      }
+
+    def bound(): Tree =
+      atSpan(in.offset) {
+        val buf = ListBuffer[Tree](typ())
+        while (in.token == AMP) {
+          in.nextToken()
+          buf += typ()
+        }
+        val ts = buf.toList
+        if (ts.tail.isEmpty) ts.head
+        else ts.reduce(makeAndType(_,_))
+      }
+
+    def formalParams(): List[ValDef] = {
+      accept(LPAREN)
+      val vparams = if (in.token == RPAREN) List() else repsep(() => formalParam(), COMMA)
+      accept(RPAREN)
+      vparams
+    }
+
+    def formalParam(): ValDef = {
+      val start = in.offset
+      if (in.token == FINAL) in.nextToken()
+      annotations()
+      var t = typ()
+      if (in.token == DOTDOTDOT) {
+        in.nextToken()
+        t = atSpan(t.span.start) {
+          PostfixOp(t, Ident(tpnme.raw.STAR))
+        }
+      }
+      atSpan(start, in.offset) {
+        varDecl(Modifiers(Flags.JavaDefined | Flags.Param), t, ident().toTermName)
+      }
+    }
+
+    def optThrows(): Unit =
+      if (in.token == THROWS) {
+        in.nextToken()
+        repsep(() => typ(), COMMA)
+      }
+
+    def methodBody(): Tree = atSpan(in.offset) {
+      skipAhead()
+      accept(RBRACE) // skip block
+      unimplementedExpr
+    }
+
+    def definesInterface(token: Int): Boolean = token == INTERFACE || token == AT
+
+    def termDecl(start: Offset, mods: Modifiers, parentToken: Int, parentTParams: List[TypeDef]): List[Tree] = {
+      val inInterface = definesInterface(parentToken)
+      val tparams = if (in.token == LT) typeParams(Flags.JavaDefined | Flags.Param) else List()
+      val isVoid = in.token == VOID
+      var rtpt =
+        if (isVoid)
+          atSpan(in.offset) {
+            in.nextToken()
+            TypeTree(UnitType)
+          }
+        else typ()
+      var nameOffset = in.offset
+      val rtptName = rtpt match {
+        case Ident(name) => name
+        case _ => nme.EMPTY
+      }
+      if (in.token == LPAREN && rtptName != nme.EMPTY && !inInterface) {
+        // constructor declaration
+        val vparams = formalParams()
+        optThrows()
+        List {
+          atSpan(start) {
+            DefDef(nme.CONSTRUCTOR, joinParams(tparams, List(vparams)),
+                   TypeTree(), methodBody()).withMods(mods)
+          }
+        }
+      }
+      else {
+        var mods1 = mods
+        if (mods.is(Flags.Abstract)) mods1 = mods &~ Flags.Abstract
+        nameOffset = in.offset
+        val name = ident()
+        if (in.token == LPAREN) {
+          // method declaration
+          val vparams = formalParams()
+          if (!isVoid) rtpt = optArrayBrackets(rtpt)
+          optThrows()
+          val bodyOk = !inInterface || mods.isOneOf(Flags.DefaultMethod | Flags.JavaStatic | Flags.Private)
+          val body =
+            if (bodyOk && in.token == LBRACE)
+              methodBody()
+            else
+              if (parentToken == AT && in.token == DEFAULT) {
+                val annot =
+                  atSpan(nameOffset) {
+                    New(Select(Select(scalaDot(nme.annotation), nme.internal), tpnme.AnnotationDefaultATTR), Nil)
+                  }
+                mods1 = mods1 withAddedAnnotation annot
+                val unimplemented = unimplementedExpr
+                skipTo(SEMI)
+                accept(SEMI)
+                unimplemented
+              }
+              else {
+                accept(SEMI)
+                EmptyTree
+              }
+          //if (inInterface) mods1 |= Flags.Deferred
+          List {
+            atSpan(start, nameOffset) {
+              DefDef(name.toTermName, joinParams(tparams, List(vparams)), rtpt, body).withMods(mods1 | Flags.Method)
+            }
+          }
+        }
+        else {
+          if (inInterface) mods1 |= Flags.Final | Flags.JavaStatic
+          val result = fieldDecls(start, nameOffset, mods1, rtpt, name)
+          accept(SEMI)
+          result
+        }
+      }
+    }
+
+    /** Parse a sequence of field declarations, separated by commas.
+      *  This one is tricky because a comma might also appear in an
+      *  initializer. Since we don't parse initializers we don't know
+      *  what the comma signifies.
+      *  We solve this with a second list buffer `maybe` which contains
+      *  potential variable definitions.
+      *  Once we have reached the end of the statement, we know whether
+      *  these potential definitions are real or not.
+      */
+    def fieldDecls(start: Offset, firstNameOffset: Offset, mods: Modifiers, tpt: Tree, name: Name): List[Tree] = {
+      val buf = ListBuffer[Tree](
+          atSpan(start, firstNameOffset) { varDecl(mods, tpt, name.toTermName) })
+      val maybe = new ListBuffer[Tree] // potential variable definitions.
+      while (in.token == COMMA) {
+        in.nextToken()
+        if (in.token == IDENTIFIER) { // if there's an ident after the comma ...
+          val nextNameOffset = in.offset
+          val name = ident()
+          if (in.token == EQUALS || in.token == SEMI) { // ... followed by a `=` or `;`, we know it's a real variable definition
+            buf ++= maybe
+            buf += atSpan(start, nextNameOffset) { varDecl(mods, tpt, name.toTermName) }
+            maybe.clear()
+          }
+          else if (in.token == COMMA) // ... if there's a comma after the ident, it could be a real vardef or not.
+            maybe += atSpan(start, nextNameOffset) { varDecl(mods, tpt, name.toTermName) }
+          else { // ... if there's something else we were still in the initializer of the
+            // previous var def; skip to next comma or semicolon.
+            skipTo(COMMA, SEMI)
+            maybe.clear()
+          }
+        }
+        else { // ... if there's no ident following the comma we were still in the initializer of the
+          // previous var def; skip to next comma or semicolon.
+          skipTo(COMMA, SEMI)
+          maybe.clear()
+        }
+      }
+      if (in.token == SEMI)
+        buf ++= maybe // every potential vardef that survived until here is real.
+      buf.toList
+    }
+
+    def varDecl(mods: Modifiers, tpt: Tree, name: TermName): ValDef = {
+      val tpt1 = optArrayBrackets(tpt)
+      /** Tries to detect final static literals syntactically and returns a constant type replacement */
+      def optConstantTpe(): Tree = {
+        def constantTpe(const: Constant): Tree = TypeTree(ConstantType(const))
+
+        def forConst(const: Constant): Tree = {
+          if (in.token != SEMI) tpt1
+          else {
+            def isStringTyped = tpt1 match {
+              case Ident(n: TypeName) => "String" == n.toString
+              case _ => false
+            }
+            if (const.tag == Constants.StringTag && isStringTyped) constantTpe(const)
+            else tpt1 match {
+              case TypedSplice(tpt2) =>
+                if (const.tag == Constants.BooleanTag || const.isNumeric) {
+                  //for example, literal 'a' is ok for float. 127 is ok for byte, but 128 is not.
+                  val converted = const.convertTo(tpt2.tpe)
+                  if (converted == null) tpt1
+                  else constantTpe(converted)
+                }
+                else tpt1
+              case _ => tpt1
+            }
+          }
+        }
+
+        in.nextToken() // EQUALS
+        if (mods.is(Flags.JavaStatic) && mods.is(Flags.Final)) {
+          tryConstant.map(forConst).getOrElse(tpt1)
+        }
+        else tpt1
+      }
+
+      val tpt2: Tree =
+        if (in.token == EQUALS && !mods.is(Flags.Param)) {
+          val res = optConstantTpe()
+          skipTo(COMMA, SEMI)
+          res
+        }
+        else tpt1
+
+      val mods1 = if (mods.is(Flags.Final)) mods else mods | Flags.Mutable
+      ValDef(name, tpt2, if (mods.is(Flags.Param)) EmptyTree else unimplementedExpr).withMods(mods1)
+    }
+
+    def memberDecl(start: Offset, mods: Modifiers, parentToken: Int, parentTParams: List[TypeDef]): List[Tree] = in.token match {
+      case CLASS | ENUM | INTERFACE | AT =>
+        typeDecl(start, if (definesInterface(parentToken)) mods | Flags.JavaStatic else mods)
+      case _ =>
+        termDecl(start, mods, parentToken, parentTParams)
+    }
+
+    def makeCompanionObject(cdef: TypeDef, statics: List[Tree]): Tree =
+      atSpan(cdef.span) {
+        assert(cdef.span.exists)
+        ModuleDef(cdef.name.toTermName,
+          makeTemplate(List(), statics, List(), false)).withMods((cdef.mods & Flags.RetainedModuleClassFlags).toTermFlags)
+      }
+
+    def addCompanionObject(statics: List[Tree], cdef: TypeDef): List[Tree] =
+      List(makeCompanionObject(cdef, statics), cdef)
+
+    def importDecl(): List[Tree] = {
+      val start = in.offset
+      accept(IMPORT)
+      val buf = new ListBuffer[Name]
+      def collectIdents() : Int =
+        if (in.token == ASTERISK) {
+          val starOffset = in.offset
+          in.nextToken()
+          buf += nme.WILDCARD
+          starOffset
+        }
+        else {
+          val nameOffset = in.offset
+          buf += ident()
+          if (in.token == DOT) {
+            in.nextToken()
+            collectIdents()
+          }
+          else nameOffset
+        }
+      if (in.token == STATIC) in.nextToken()
+      else buf += nme.ROOTPKG
+      val lastnameOffset = collectIdents()
+      accept(SEMI)
+      val names = buf.toList
+      if (names.length < 2) {
+        syntaxError(start, "illegal import", skipIt = false)
+        List()
+      }
+      else {
+        val qual = names.tail.init.foldLeft(Ident(names.head): Tree)(Select(_, _))
+        val lastname = names.last
+        val ident = Ident(lastname).withSpan(Span(lastnameOffset))
+//        val selector = lastname match {
+//          case nme.WILDCARD => Pair(ident, Ident(null) withPos Span(-1))
+//          case _            => Pair(ident, ident)
+//        }
+        val imp = atSpan(start) { Import(qual, ImportSelector(ident) :: Nil) }
+        imp :: Nil
+      }
+    }
+
+    def interfacesOpt(): List[Tree] =
+      if (in.token == IMPLEMENTS) {
+        in.nextToken()
+        repsep(() => typ(), COMMA)
+      }
+      else
+        List()
+
+    def classDecl(start: Offset, mods: Modifiers): List[Tree] = {
+      accept(CLASS)
+      val nameOffset = in.offset
+      val name = identForType()
+      val tparams = typeParams()
+      val superclass =
+        if (in.token == EXTENDS) {
+          in.nextToken()
+          typ()
+        }
+        else
+          javaLangObject()
+      val interfaces = interfacesOpt()
+      val (statics, body) = typeBody(CLASS, name, tparams)
+      val cls = atSpan(start, nameOffset) {
+        TypeDef(name, makeTemplate(superclass :: interfaces, body, tparams, true)).withMods(mods)
+      }
+      addCompanionObject(statics, cls)
+    }
+
+    def interfaceDecl(start: Offset, mods: Modifiers): List[Tree] = {
+      accept(INTERFACE)
+      val nameOffset = in.offset
+      val name = identForType()
+      val tparams = typeParams()
+      val parents =
+        if (in.token == EXTENDS) {
+          in.nextToken()
+          repsep(() => typ(), COMMA)
+        }
+        else
+          List(javaLangObject())
+      val (statics, body) = typeBody(INTERFACE, name, tparams)
+      val iface = atSpan(start, nameOffset) {
+        TypeDef(
+          name,
+          makeTemplate(parents, body, tparams, false)).withMods(mods | Flags.Trait | Flags.JavaInterface | Flags.Abstract)
+      }
+      addCompanionObject(statics, iface)
+    }
+
+    def typeBody(leadingToken: Int, parentName: Name, parentTParams: List[TypeDef]): (List[Tree], List[Tree]) = {
+      accept(LBRACE)
+      val defs = typeBodyDecls(leadingToken, parentName, parentTParams)
+      accept(RBRACE)
+      defs
+    }
+
+    def typeBodyDecls(parentToken: Int, parentName: Name, parentTParams: List[TypeDef]): (List[Tree], List[Tree]) = {
+      val inInterface = definesInterface(parentToken)
+      val statics = new ListBuffer[Tree]
+      val members = new ListBuffer[Tree]
+      while (in.token != RBRACE && in.token != EOF) {
+        val start = in.offset
+        var mods = modifiers(inInterface)
+        if (in.token == LBRACE) {
+          skipAhead() // skip init block, we just assume we have seen only static
+          accept(RBRACE)
+        }
+        else if (in.token == SEMI)
+          in.nextToken()
+        else {
+          if (in.token == ENUM || definesInterface(in.token)) mods |= Flags.JavaStatic
+          val decls = memberDecl(start, mods, parentToken, parentTParams)
+          (if (mods.is(Flags.JavaStatic) || inInterface && !(decls exists (_.isInstanceOf[DefDef])))
+            statics
+          else
+            members) ++= decls
+        }
+      }
+      (statics.toList, members.toList)
+    }
+    def annotationParents: List[Select] = List(
+      scalaAnnotationDot(tpnme.Annotation),
+      Select(javaLangDot(nme.annotation), tpnme.Annotation),
+      scalaAnnotationDot(tpnme.ClassfileAnnotation)
+    )
+    def annotationDecl(start: Offset, mods: Modifiers): List[Tree] = {
+      accept(AT)
+      accept(INTERFACE)
+      val nameOffset = in.offset
+      val name = identForType()
+      val (statics, body) = typeBody(AT, name, List())
+      val constructorParams = body.collect {
+        case dd: DefDef =>
+          makeParam(dd.name, dd.tpt)
+      }
+      val constr = DefDef(nme.CONSTRUCTOR,
+        List(constructorParams), TypeTree(), EmptyTree).withMods(Modifiers(Flags.JavaDefined))
+      val templ = makeTemplate(annotationParents, constr :: body, List(), true)
+      val annot = atSpan(start, nameOffset) {
+        TypeDef(name, templ).withMods(mods | Flags.Abstract)
+      }
+      addCompanionObject(statics, annot)
+    }
+
+    def enumDecl(start: Offset, mods: Modifiers): List[Tree] = {
+      accept(ENUM)
+      val nameOffset = in.offset
+      val name = identForType()
+      def enumType = Ident(name)
+      val interfaces = interfacesOpt()
+      accept(LBRACE)
+      val buf = new ListBuffer[Tree]
+      def parseEnumConsts(): Unit =
+        if (in.token != RBRACE && in.token != SEMI && in.token != EOF) {
+          buf += enumConst(enumType)
+          if (in.token == COMMA) {
+            in.nextToken()
+            parseEnumConsts()
+          }
+        }
+      parseEnumConsts()
+      val consts = buf.toList
+      val (statics, body) =
+        if (in.token == SEMI) {
+          in.nextToken()
+          typeBodyDecls(ENUM, name, List())
+        }
+        else
+          (List(), List())
+      val predefs = List(
+        DefDef(
+          nme.values,
+          ListOfNil,
+          arrayOf(enumType),
+          unimplementedExpr).withMods(Modifiers(Flags.JavaDefined | Flags.JavaStatic | Flags.Method)),
+        DefDef(
+          nme.valueOf,
+          List(List(makeParam("x".toTermName, TypeTree(StringType)))),
+          enumType,
+          unimplementedExpr).withMods(Modifiers(Flags.JavaDefined | Flags.JavaStatic | Flags.Method)))
+      accept(RBRACE)
+      /*
+      val superclazz =
+        AppliedTypeTree(javaLangDot(tpnme.Enum), List(enumType))
+        */
+      val superclazz = Apply(TypeApply(
+        Select(New(javaLangDot(tpnme.Enum)), nme.CONSTRUCTOR), List(enumType)), Nil)
+      val enumclazz = atSpan(start, nameOffset) {
+        TypeDef(name,
+          makeTemplate(superclazz :: interfaces, body, List(), true)).withMods(mods | Flags.JavaEnumTrait)
+      }
+      addCompanionObject(consts ::: statics ::: predefs, enumclazz)
+    }
+
+    def enumConst(enumType: Tree): ValDef = {
+      annotations()
+      atSpan(in.offset) {
+        val name = ident()
+        if (in.token == LPAREN) {
+          // skip arguments
+          skipAhead()
+          accept(RPAREN)
+        }
+        if (in.token == LBRACE) {
+          // skip classbody
+          skipAhead()
+          accept(RBRACE)
+        }
+        ValDef(name.toTermName, enumType, unimplementedExpr).withMods(Modifiers(Flags.JavaEnumTrait | Flags.StableRealizable | Flags.JavaDefined | Flags.JavaStatic))
+      }
+    }
+
+    def typeDecl(start: Offset, mods: Modifiers): List[Tree] = in.token match {
+      case ENUM      => enumDecl(start, mods)
+      case INTERFACE => interfaceDecl(start, mods)
+      case AT        => annotationDecl(start, mods)
+      case CLASS     => classDecl(start, mods)
+      case _         => in.nextToken(); syntaxError("illegal start of type declaration", skipIt = true); List(errorTypeTree)
+    }
+
+    def tryConstant: Option[Constant] = {
+      val negate = in.token match {
+        case MINUS | BANG => in.nextToken(); true
+        case _ => false
+      }
+      val l = in.token match {
+        case TRUE      => !negate
+        case FALSE     => negate
+        case CHARLIT   => in.strVal.charAt(0)
+        case INTLIT    => in.intVal(negate).toInt
+        case LONGLIT   => in.intVal(negate)
+        case FLOATLIT  => in.floatVal(negate).toFloat
+        case DOUBLELIT => in.floatVal(negate)
+        case STRINGLIT => in.strVal
+        case _         => null
+      }
+      if (l == null) None
+      else {
+        in.nextToken()
+        Some(Constant(l))
+      }
+    }
+
+    /** CompilationUnit ::= [package QualId semi] TopStatSeq
+      */
+    def compilationUnit(): Tree = {
+      val start = in.offset
+      val pkg: RefTree =
+        if (in.token == AT || in.token == PACKAGE) {
+          annotations()
+          accept(PACKAGE)
+          val pkg = qualId()
+          accept(SEMI)
+          pkg
+        }
+        else
+          Ident(nme.EMPTY_PACKAGE)
+      thisPackageName = convertToTypeName(pkg) match {
+        case Some(t)  => t.name.toTypeName
+        case _        => tpnme.EMPTY
+      }
+      val buf = new ListBuffer[Tree]
+      while (in.token == IMPORT)
+        buf ++= importDecl()
+      while (in.token != EOF && in.token != RBRACE) {
+        while (in.token == SEMI) in.nextToken()
+        if (in.token != EOF) {
+          val start = in.offset
+          val mods = modifiers(inInterface = false)
+          buf ++= typeDecl(start, mods)
+        }
+      }
+      val unit = atSpan(start) { PackageDef(pkg, buf.toList) }
+      accept(EOF)
+      unit match
+        case PackageDef(Ident(nme.EMPTY_PACKAGE), Nil) => EmptyTree
+        case _ => unit
+    }
+  }
+
+
+  /** OutlineJavaParser parses top-level declarations in `source` to find declared classes, ignoring their bodies (which
+   *  must only have balanced braces). This is used to map class names to defining sources.
+   *  This is necessary even for Java, because the filename defining a non-public classes cannot be determined from the
+   *  classname alone.
+   */
+  class OutlineJavaParser(source: SourceFile)(using Context) extends JavaParser(source) with OutlineParserCommon {
+    override def skipBracesHook(): Option[Tree] = None
+    override def typeBody(leadingToken: Int, parentName: Name, parentTParams: List[TypeDef]): (List[Tree], List[Tree]) = {
+      skipBraces()
+      (List(EmptyValDef), List(EmptyTree))
+    }
+  }
+}
diff --git a/tests/pos-with-compiler-cc/dotc/parsing/JavaScanners.scala b/tests/pos-with-compiler-cc/dotc/parsing/JavaScanners.scala
new file mode 100644
index 000000000000..1be8bdae6bd1
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/parsing/JavaScanners.scala
@@ -0,0 +1,741 @@
+package dotty.tools
+package dotc
+package parsing
+
+import core.Contexts._
+import core.Names.SimpleName
+import Scanners._
+import util.SourceFile
+import JavaTokens._
+import scala.annotation.{switch, tailrec}
+import util.Chars._
+import PartialFunction.cond
+
+object JavaScanners {
+
+  class JavaScanner(source: SourceFile, override val startFrom: Offset = 0)(using Context) extends ScannerCommon(source) {
+
+    override def decodeUni: Boolean = true
+
+    def toToken(name: SimpleName): Token = {
+      val idx = name.start
+      if (idx >= 0 && idx <= lastKeywordStart) kwArray(idx) else IDENTIFIER
+    }
+
+    private class JavaTokenData0 extends TokenData
+
+    /** we need one token lookahead
+      */
+    val next : TokenData = new JavaTokenData0
+    val prev : TokenData = new JavaTokenData0
+
+    // Get next token ------------------------------------------------------------
+
+    def nextToken(): Unit =
+      if next.token == EMPTY then
+        lastOffset = lastCharOffset
+        fetchToken()
+      else
+        this.copyFrom(next)
+        next.token = EMPTY
+
+    def lookaheadToken: Int =
+      lookAhead()
+      val t = token
+      reset()
+      t
+
+    def lookAhead() =
+      prev.copyFrom(this)
+      nextToken()
+
+    def reset() =
+      next.copyFrom(this)
+      this.copyFrom(prev)
+
+    class LookaheadScanner extends JavaScanner(source, startFrom = charOffset - 1):
+      override protected def initialize(): Unit = nextChar()
+
+    /** read next token
+      */
+    private def fetchToken(): Unit = {
+      offset = charOffset - 1
+      ch match {
+        case ' ' | '\t' | CR | LF | FF =>
+          nextChar()
+          fetchToken()
+        case _ =>
+          (ch: @switch) match {
+            case 'A' | 'B' | 'C' | 'D' | 'E' |
+                 'F' | 'G' | 'H' | 'I' | 'J' |
+                 'K' | 'L' | 'M' | 'N' | 'O' |
+                 'P' | 'Q' | 'R' | 'S' | 'T' |
+                 'U' | 'V' | 'W' | 'X' | 'Y' |
+                 'Z' | '$' | '_' |
+                 'a' | 'b' | 'c' | 'd' | 'e' |
+                 'f' | 'g' | 'h' | 'i' | 'j' |
+                 'k' | 'l' | 'm' | 'n' | 'o' |
+                 'p' | 'q' | 'r' | 's' | 't' |
+                 'u' | 'v' | 'w' | 'x' | 'y' |
+                 'z' =>
+              putChar(ch)
+              nextChar()
+              getIdentRest()
+
+            case '0' =>
+              putChar(ch)
+              nextChar()
+              if (ch == 'x' || ch == 'X') {
+                nextChar()
+                base = 16
+              }
+              else
+                base = 8
+              getNumber()
+
+            case '1' | '2' | '3' | '4' |
+                 '5' | '6' | '7' | '8' | '9' =>
+              base = 10
+              getNumber()
+
+            case '\"' =>
+              nextChar()
+              if ch != '\"' then // "..." non-empty string literal
+                while ch != '\"' && (isUnicodeEscape || ch != CR && ch != LF && ch != SU) do
+                  getlitch()
+                if ch == '\"' then
+                  token = STRINGLIT
+                  setStrVal()
+                  nextChar()
+                else
+                  error("unclosed string literal")
+              else
+                nextChar()
+                if ch != '\"' then // "" empty string literal
+                  token = STRINGLIT
+                  setStrVal()
+                else
+                  nextChar()
+                  getTextBlock()
+
+            case '\'' =>
+              nextChar()
+              getlitch()
+              if (ch == '\'') {
+                nextChar()
+                token = CHARLIT
+                setStrVal()
+              }
+              else
+                error("unclosed character literal")
+
+            case '=' =>
+              token = EQUALS
+              nextChar()
+              if (ch == '=') {
+                token = EQEQ
+                nextChar()
+              }
+
+            case '>' =>
+              token = GT
+              nextChar()
+              if (ch == '=') {
+                token = GTEQ
+                nextChar()
+              }
+              else if (ch == '>') {
+                token = GTGT
+                nextChar()
+                if (ch == '=') {
+                  token = GTGTEQ
+                  nextChar()
+                }
+                else if (ch == '>') {
+                  token = GTGTGT
+                  nextChar()
+                  if (ch == '=') {
+                    token = GTGTGTEQ
+                    nextChar()
+                  }
+                }
+              }
+
+            case '<' =>
+              token = LT
+              nextChar()
+              if (ch == '=') {
+                token = LTEQ
+                nextChar()
+              }
+              else if (ch == '<') {
+                token = LTLT
+                nextChar()
+                if (ch == '=') {
+                  token = LTLTEQ
+                  nextChar()
+                }
+              }
+
+            case '!' =>
+              token = BANG
+              nextChar()
+              if (ch == '=') {
+                token = BANGEQ
+                nextChar()
+              }
+
+            case '~' =>
+              token = TILDE
+              nextChar()
+
+            case '?' =>
+              token = QMARK
+              nextChar()
+
+            case ':' =>
+              token = COLONop
+              nextChar()
+
+            case '@' =>
+              token = AT
+              nextChar()
+
+            case '&' =>
+              token = AMP
+              nextChar()
+              if (ch == '&') {
+                token = AMPAMP
+                nextChar()
+              }
+              else if (ch == '=') {
+                token = AMPEQ
+                nextChar()
+              }
+
+            case '|' =>
+              token = BAR
+              nextChar()
+              if (ch == '|') {
+                token = BARBAR
+                nextChar()
+              }
+              else if (ch == '=') {
+                token = BAREQ
+                nextChar()
+              }
+
+            case '+' =>
+              token = PLUS
+              nextChar()
+              if (ch == '+') {
+                token = PLUSPLUS
+                nextChar()
+              }
+              else if (ch == '=') {
+                token = PLUSEQ
+                nextChar()
+              }
+
+            case '-' =>
+              token = MINUS
+              nextChar()
+              if (ch == '-') {
+                token = MINUSMINUS
+                nextChar()
+              }
+              else if (ch == '=') {
+                token = MINUSEQ
+                nextChar()
+              }
+
+            case '*' =>
+              token = ASTERISK
+              nextChar()
+              if (ch == '=') {
+                token = ASTERISKEQ
+                nextChar()
+              }
+
+            case '/' =>
+              nextChar()
+              if (!skipComment()) {
+                token = SLASH
+                nextChar()
+                if (ch == '=') {
+                  token = SLASHEQ
+                  nextChar()
+                }
+              }
+              else fetchToken()
+
+            case '^' =>
+              token = HAT
+              nextChar()
+              if (ch == '=') {
+                token = HATEQ
+                nextChar()
+              }
+
+            case '%' =>
+              token = PERCENT
+              nextChar()
+              if (ch == '=') {
+                token = PERCENTEQ
+                nextChar()
+              }
+
+            case '.' =>
+              token = DOT
+              nextChar()
+              if ('0' <= ch && ch <= '9') {
+                putChar('.');
+                getFraction()
+              }
+              else if (ch == '.') {
+                nextChar()
+                if (ch == '.') {
+                  nextChar()
+                  token = DOTDOTDOT
+                }
+                else error("`.` character expected")
+              }
+
+            case ';' =>
+              token = SEMI
+              nextChar()
+
+            case ',' =>
+              token = COMMA
+              nextChar()
+
+            case '(' =>
+              token = LPAREN
+              nextChar()
+
+            case '{' =>
+              token = LBRACE
+              nextChar()
+
+            case ')' =>
+              token = RPAREN
+              nextChar()
+
+            case '}' =>
+              token = RBRACE
+              nextChar()
+
+            case '[' =>
+              token = LBRACKET
+              nextChar()
+
+            case ']' =>
+              token = RBRACKET
+              nextChar()
+
+            case SU =>
+              if (isAtEnd) token = EOF
+              else {
+                error("illegal character")
+                nextChar()
+              }
+
+            case _ =>
+              if (Character.isUnicodeIdentifierStart(ch)) {
+                putChar(ch)
+                nextChar()
+                getIdentRest()
+              }
+              else {
+                error("illegal character: " + ch.toInt)
+                nextChar()
+              }
+          }
+      }
+    }
+
+    protected def skipComment(): Boolean = {
+      @tailrec def skipLineComment(): Unit = ch match {
+        case CR | LF | SU =>
+        case _ => nextChar(); skipLineComment()
+      }
+      @tailrec def skipJavaComment(): Unit = ch match {
+        case SU => incompleteInputError("unclosed comment")
+        case '*' => nextChar(); if (ch == '/') nextChar() else skipJavaComment()
+        case _ => nextChar(); skipJavaComment()
+      }
+      ch match {
+        case '/' => nextChar(); skipLineComment(); true
+        case '*' => nextChar(); skipJavaComment(); true
+        case _ => false
+      }
+    }
+
+    // Identifiers ---------------------------------------------------------------
+
+    private def getIdentRest(): Unit =
+      while (true)
+        (ch: @switch) match {
+          case 'A' | 'B' | 'C' | 'D' | 'E' |
+               'F' | 'G' | 'H' | 'I' | 'J' |
+               'K' | 'L' | 'M' | 'N' | 'O' |
+               'P' | 'Q' | 'R' | 'S' | 'T' |
+               'U' | 'V' | 'W' | 'X' | 'Y' |
+               'Z' | '$' |
+               'a' | 'b' | 'c' | 'd' | 'e' |
+               'f' | 'g' | 'h' | 'i' | 'j' |
+               'k' | 'l' | 'm' | 'n' | 'o' |
+               'p' | 'q' | 'r' | 's' | 't' |
+               'u' | 'v' | 'w' | 'x' | 'y' |
+               'z' |
+               '0' | '1' | '2' | '3' | '4' |
+               '5' | '6' | '7' | '8' | '9' =>
+            putChar(ch)
+            nextChar()
+
+          case '_' =>
+            putChar(ch)
+            nextChar()
+            getIdentRest()
+            return
+          case SU =>
+            finishNamed()
+            return
+          case _ =>
+            if (Character.isUnicodeIdentifierPart(ch)) {
+              putChar(ch)
+              nextChar()
+            }
+            else {
+              finishNamed()
+              return
+            }
+        }
+
+    // Literals -----------------------------------------------------------------
+
+    /** Read next character in character or string literal.
+      */
+    protected def getlitch(): Unit = getlitch(scanOnly = false, inTextBlock = false)
+
+    /** Read next character in character or string literal.
+     *
+     *  @param scanOnly skip emitting errors or adding to the literal buffer
+     *  @param inTextBlock is this for a text block?
+     */
+    def getlitch(scanOnly: Boolean, inTextBlock: Boolean): Unit =
+      def octal: Char =
+        val leadch: Char = ch
+        var oct: Int = digit2int(ch, 8)
+        nextChar()
+        if ('0' <= ch && ch <= '7') {
+          oct = oct * 8 + digit2int(ch, 8)
+          nextChar()
+          if (leadch <= '3' && '0' <= ch && ch <= '7') {
+            oct = oct * 8 + digit2int(ch, 8)
+            nextChar()
+          }
+        }
+        oct.asInstanceOf[Char]
+      end octal
+      def greatEscape: Char =
+        nextChar()
+        if '0' <= ch && ch <= '7' then octal
+        else
+          val x = ch match
+            case 'b'  => '\b'
+            case 's'  => ' '
+            case 't'  => '\t'
+            case 'n'  => '\n'
+            case 'f'  => '\f'
+            case 'r'  => '\r'
+            case '\"' => '\"'
+            case '\'' => '\''
+            case '\\' => '\\'
+            case CR | LF if inTextBlock =>
+              if !scanOnly then nextChar()
+              0
+            case _    =>
+              if !scanOnly then error("invalid escape character", charOffset - 1)
+              ch
+          if x != 0 then nextChar()
+          x
+      end greatEscape
+
+      // begin getlitch
+      val c: Char =
+        if ch == '\\' then greatEscape
+        else
+          val res = ch
+          nextChar()
+          res
+      if c != 0 && !scanOnly then putChar(c)
+    end getlitch
+
+    /** Read a triple-quote delimited text block, starting after the first three double quotes.
+      */
+    private def getTextBlock(): Unit = {
+      // Open delimiter is followed by optional space, then a newline
+      while (ch == ' ' || ch == '\t' || ch == FF) {
+        nextChar()
+      }
+      if (ch != LF && ch != CR) { // CR-LF is already normalized into LF by `JavaCharArrayReader`
+        error("illegal text block open delimiter sequence, missing line terminator")
+        return
+      }
+      nextChar()
+
+      /* Do a lookahead scan over the full text block to:
+       *   - compute common white space prefix
+       *   - find the offset where the text block ends
+       */
+      var commonWhiteSpacePrefix = Int.MaxValue
+      var blockEndOffset = 0
+      var blockClosed = false
+      var lineWhiteSpacePrefix = 0
+      var lineIsOnlyWhitespace = true
+      val in = LookaheadScanner()
+      while (!blockClosed && (isUnicodeEscape || ch != SU)) {
+        if (in.ch == '\"') { // Potential end of the block
+          in.nextChar()
+          if (in.ch == '\"') {
+            in.nextChar()
+            if (in.ch == '\"') {
+              blockClosed = true
+              commonWhiteSpacePrefix = commonWhiteSpacePrefix min lineWhiteSpacePrefix
+              blockEndOffset = in.charOffset - 2
+            }
+          }
+
+          // Not the end of the block - just a single or double " character
+          if (!blockClosed) {
+            lineIsOnlyWhitespace = false
+          }
+        } else if (in.ch == CR || in.ch == LF) { // new line in the block
+          in.nextChar()
+          if (!lineIsOnlyWhitespace) {
+            commonWhiteSpacePrefix = commonWhiteSpacePrefix min lineWhiteSpacePrefix
+          }
+          lineWhiteSpacePrefix = 0
+          lineIsOnlyWhitespace = true
+        } else if (lineIsOnlyWhitespace && Character.isWhitespace(in.ch)) { // extend white space prefix
+          in.nextChar()
+          lineWhiteSpacePrefix += 1
+        } else {
+          lineIsOnlyWhitespace = false
+          in.getlitch(scanOnly = true, inTextBlock = true)
+        }
+      }
+
+      // Bail out if the block never did have an end
+      if (!blockClosed) {
+        error("unclosed text block")
+        return
+      }
+
+      // Second pass: construct the literal string value this time
+      while (charOffset < blockEndOffset) {
+        // Drop the line's leading whitespace
+        var remainingPrefix = commonWhiteSpacePrefix
+        while (remainingPrefix > 0 && ch != CR && ch != LF && charOffset < blockEndOffset) {
+          nextChar()
+          remainingPrefix -= 1
+        }
+
+        var trailingWhitespaceLength = 0
+        var escapedNewline = false         // Does the line end with `\`?
+        while (ch != CR && ch != LF && charOffset < blockEndOffset && !escapedNewline) {
+          if (Character.isWhitespace(ch)) {
+            trailingWhitespaceLength += 1
+          } else {
+            trailingWhitespaceLength = 0
+          }
+
+          // Detect if the line is about to end with `\`
+          if ch == '\\' && cond(lookaheadChar()) { case CR | LF => true } then
+            escapedNewline = true
+
+          getlitch(scanOnly = false, inTextBlock = true)
+        }
+
+        // Remove the last N characters from the buffer */
+        def popNChars(n: Int): Unit =
+          if n > 0 then
+            val text = litBuf.toString
+            litBuf.clear()
+            val trimmed = text.substring(0, text.length - (n min text.length))
+            trimmed.nn.foreach(litBuf.append)
+
+        // Drop the line's trailing whitespace
+        popNChars(trailingWhitespaceLength)
+
+        // Normalize line terminators
+        if ((ch == CR || ch == LF) && !escapedNewline) {
+          nextChar()
+          putChar('\n')
+        }
+      }
+
+      token = STRINGLIT
+      setStrVal()
+
+      // Trailing """
+      nextChar()
+      nextChar()
+      nextChar()
+    }
+    end getTextBlock
+
+    /** read fractional part and exponent of floating point number
+      * if one is present.
+      */
+    protected def getFraction(): Unit = {
+      token = DOUBLELIT
+      while ('0' <= ch && ch <= '9') {
+        putChar(ch)
+        nextChar()
+      }
+      if (ch == 'e' || ch == 'E') {
+        val lookahead = lookaheadReader()
+        lookahead.nextChar()
+        if (lookahead.ch == '+' || lookahead.ch == '-')
+          lookahead.nextChar()
+        if ('0' <= lookahead.ch && lookahead.ch <= '9') {
+          putChar(ch)
+          nextChar()
+          if (ch == '+' || ch == '-') {
+            putChar(ch)
+            nextChar()
+          }
+          while ('0' <= ch && ch <= '9') {
+            putChar(ch)
+            nextChar()
+          }
+        }
+        token = DOUBLELIT
+      }
+      if (ch == 'd' || ch == 'D') {
+        putChar(ch)
+        nextChar()
+        token = DOUBLELIT
+      }
+      else if (ch == 'f' || ch == 'F') {
+        putChar(ch)
+        nextChar()
+        token = FLOATLIT
+      }
+      setStrVal()
+    }
+
+    /** convert name to long value
+     */
+    def intVal(negated: Boolean): Long =
+      if (token == CHARLIT && !negated)
+        if (strVal.length > 0) strVal.charAt(0).toLong else 0
+      else {
+        var value: Long = 0
+        val divider = if (base == 10) 1 else 2
+        val limit: Long =
+          if (token == LONGLIT) Long.MaxValue else Int.MaxValue
+        var i = 0
+        val len = strVal.length
+        while (i < len) {
+          val d = digit2int(strVal.charAt(i), base)
+          if (d < 0) {
+            error("malformed integer number")
+            return 0
+          }
+          if (value < 0 ||
+              limit / (base / divider) < value ||
+              limit - (d / divider) < value * (base / divider) &&
+              !(negated && limit == value * base - 1 + d)) {
+                error("integer number too large")
+                return 0
+              }
+          value = value * base + d
+          i += 1
+        }
+        if (negated) -value else value
+      }
+
+    /** convert name, base to double value
+     */
+    def floatVal(negated: Boolean): Double = {
+      val limit: Double =
+        if (token == DOUBLELIT) Double.MaxValue else Float.MaxValue
+      try {
+        val value: Double = java.lang.Double.valueOf(strVal.toString).nn.doubleValue()
+        if (value > limit)
+          error("floating point number too large")
+        if (negated) -value else value
+      } catch {
+        case _: NumberFormatException =>
+          error("malformed floating point number")
+          0.0
+      }
+    }
+
+    /** read a number into name and set base
+      */
+    protected def getNumber(): Unit = {
+      while (digit2int(ch, if (base < 10) 10 else base) >= 0) {
+        putChar(ch)
+        nextChar()
+      }
+      token = INTLIT
+      if (base <= 10 && ch == '.') {
+        val lookahead = lookaheadReader()
+        lookahead.nextChar()
+        lookahead.ch match {
+          case '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' |
+               '8' | '9' | 'd' | 'D' | 'e' | 'E' | 'f' | 'F' =>
+            putChar(ch)
+            nextChar()
+            return getFraction()
+          case _ =>
+            if (!isIdentifierStart(lookahead.ch)) {
+              putChar(ch)
+              nextChar()
+              return getFraction()
+            }
+        }
+      }
+      if (base <= 10 &&
+        (ch == 'e' || ch == 'E' ||
+          ch == 'f' || ch == 'F' ||
+          ch == 'd' || ch == 'D'))
+        return getFraction()
+      setStrVal()
+      if (ch == 'l' || ch == 'L') {
+        nextChar()
+        token = LONGLIT
+      }
+    }
+
+    // Errors -----------------------------------------------------------------
+
+    override def toString(): String = token match {
+      case IDENTIFIER => s"id($name)"
+      case CHARLIT => s"char($strVal)"
+      case INTLIT => s"int($strVal, $base)"
+      case LONGLIT => s"long($strVal, $base)"
+      case FLOATLIT => s"float($strVal)"
+      case DOUBLELIT => s"double($strVal)"
+      case STRINGLIT => s"string($strVal)"
+      case SEMI =>
+        ";"
+      case COMMA =>
+        ","
+      case _ =>
+        tokenString(token)
+    }
+
+    /* Initialization: read first char, then first token */
+    protected def initialize(): Unit =
+      nextChar()
+      nextToken()
+    initialize()
+  }
+
+  private val (lastKeywordStart, kwArray) = buildKeywordArray(keywords)
+}
diff --git a/tests/pos-with-compiler-cc/dotc/parsing/JavaTokens.scala b/tests/pos-with-compiler-cc/dotc/parsing/JavaTokens.scala
new file mode 100644
index 000000000000..3e73b6d95adb
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/parsing/JavaTokens.scala
@@ -0,0 +1,92 @@
+package dotty.tools
+package dotc
+package parsing
+
+import collection.immutable.BitSet
+
+object JavaTokens extends TokensCommon {
+  inline val minToken = EMPTY
+  final def maxToken: Int = DOUBLE
+
+  final val javaOnlyKeywords: TokenSet = tokenRange(INSTANCEOF, ASSERT)
+  final val sharedKeywords: BitSet = BitSet( IF, FOR, ELSE, THIS, NULL, NEW, SUPER, ABSTRACT, FINAL, PRIVATE, PROTECTED,
+    EXTENDS, TRUE, FALSE, CLASS, IMPORT, PACKAGE, DO, THROW, TRY, CATCH, FINALLY, WHILE, RETURN )
+  final val primTypes: TokenSet = tokenRange(VOID, DOUBLE)
+  final val keywords: BitSet = sharedKeywords | javaOnlyKeywords | primTypes
+
+  /** keywords */
+  inline val INSTANCEOF = 101;       enter(INSTANCEOF, "instanceof")
+  inline val CONST = 102;            enter(CONST, "const")
+
+  /** templates */
+  inline val INTERFACE = 105;        enter(INTERFACE, "interface")
+  inline val ENUM = 106;             enter(ENUM, "enum")
+  inline val IMPLEMENTS = 107;       enter(IMPLEMENTS, "implements")
+
+  /** modifiers */
+  inline val PUBLIC = 110;           enter(PUBLIC, "public")
+  inline val DEFAULT = 111;          enter(DEFAULT, "default")
+  inline val STATIC = 112;           enter(STATIC, "static")
+  inline val TRANSIENT = 113;        enter(TRANSIENT, "transient")
+  inline val VOLATILE = 114;         enter(VOLATILE, "volatile")
+  inline val SYNCHRONIZED = 115;     enter(SYNCHRONIZED, "synchronized")
+  inline val NATIVE = 116;           enter(NATIVE, "native")
+  inline val STRICTFP = 117;         enter(STRICTFP, "strictfp")
+  inline val THROWS = 118;           enter(THROWS, "throws")
+
+  /** control structures */
+  inline val BREAK = 130;            enter(BREAK, "break")
+  inline val CONTINUE = 131;         enter(CONTINUE, "continue")
+  inline val GOTO = 132;             enter(GOTO, "goto")
+  inline val SWITCH = 133;           enter(SWITCH, "switch")
+  inline val ASSERT = 134;           enter(ASSERT, "assert")
+
+  /** special symbols */
+  inline val EQEQ = 140
+  inline val BANGEQ = 141
+  inline val LT = 142
+  inline val GT = 143
+  inline val LTEQ = 144
+  inline val GTEQ = 145
+  inline val BANG = 146
+  inline val QMARK = 147
+  inline val AMP = 148
+  inline val BAR = 149
+  inline val PLUS = 150
+  inline val MINUS = 151
+  inline val ASTERISK = 152
+  inline val SLASH = 153
+  inline val PERCENT = 154
+  inline val HAT = 155
+  inline val LTLT = 156
+  inline val GTGT = 157
+  inline val GTGTGT = 158
+  inline val AMPAMP = 159
+  inline val BARBAR = 160
+  inline val PLUSPLUS = 161
+  inline val MINUSMINUS = 162
+  inline val TILDE = 163
+  inline val DOTDOTDOT = 164
+  inline val AMPEQ = 165
+  inline val BAREQ = 166
+  inline val PLUSEQ = 167
+  inline val MINUSEQ = 168
+  inline val ASTERISKEQ = 169
+  inline val SLASHEQ = 170
+  inline val PERCENTEQ = 171
+  inline val HATEQ = 172
+  inline val LTLTEQ = 173
+  inline val GTGTEQ = 174
+  inline val GTGTGTEQ = 175
+
+  /** primitive types */
+  inline val VOID = 180;             enter(VOID, "void")
+  inline val BOOLEAN = 181;          enter(BOOLEAN, "boolean")
+  inline val BYTE = 182;             enter(BYTE, "byte")
+  inline val SHORT = 183;            enter(SHORT, "short")
+  inline val CHAR = 184;             enter(CHAR, "char")
+  inline val INT = 185;              enter(INT, "int")
+  inline val LONG = 186;             enter(LONG, "long")
+  inline val FLOAT = 187;            enter(FLOAT, "float")
+  inline val DOUBLE = 188;           enter(DOUBLE, "double")
+}
diff --git a/tests/pos-with-compiler-cc/dotc/parsing/ParserPhase.scala b/tests/pos-with-compiler-cc/dotc/parsing/ParserPhase.scala
new file mode 100644
index 000000000000..a67bca34cae2
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/parsing/ParserPhase.scala
@@ -0,0 +1,60 @@
+package dotty.tools.dotc.parsing
+
+import dotty.tools.dotc.config.Config
+import dotty.tools.dotc.core.Contexts.{ Context, ctx }
+import dotty.tools.dotc.core.Phases.Phase
+import dotty.tools.dotc.typer.ImportInfo.withRootImports
+import dotty.tools.dotc.{ CompilationUnit, ast, report }
+import dotty.tools.dotc.util.{ NoSourcePosition, SourcePosition }
+import dotty.tools.dotc.util.Stats.record
+import dotty.tools.unsupported
+
+class Parser extends Phase {
+
+  override def phaseName: String = Parser.name
+  override def description: String = Parser.description
+
+  // We run TreeChecker only after type checking
+  override def isCheckable: Boolean = false
+
+  /** The position of the first XML literal encountered while parsing,
+   *  NoSourcePosition if there were no XML literals.
+   */
+  private[dotc] var firstXmlPos: SourcePosition = NoSourcePosition
+
+  def parse(using Context) = monitor("parser") {
+    val unit = ctx.compilationUnit
+    unit.untpdTree =
+      if (unit.isJava) new JavaParsers.JavaParser(unit.source).parse()
+      else {
+        val p = new Parsers.Parser(unit.source)
+        //  p.in.debugTokenStream = true
+        val tree = p.parse()
+        if (p.firstXmlPos.exists && !firstXmlPos.exists)
+          firstXmlPos = p.firstXmlPos
+        tree
+      }
+    if (Config.checkPositions)
+      unit.untpdTree.checkPos(nonOverlapping = !unit.isJava && !ctx.reporter.hasErrors)
+  }
+
+
+  override def runOn(units: List[CompilationUnit])(using Context): List[CompilationUnit] = {
+    val unitContexts =
+      for unit <- units yield
+        report.inform(s"parsing ${unit.source}")
+        ctx.fresh.setCompilationUnit(unit).withRootImports
+
+    unitContexts.foreach(parse(using _))
+    record("parsedTrees", ast.Trees.ntrees)
+
+    unitContexts.map(_.compilationUnit)
+  }
+
+  def run(using Context): Unit = unsupported("run")
+}
+
+object Parser{
+  val name: String = "parser"
+  val description: String = "scan and parse sources"
+}
diff --git a/tests/pos-with-compiler-cc/dotc/parsing/Parsers.scala b/tests/pos-with-compiler-cc/dotc/parsing/Parsers.scala
new file mode 100644
index 000000000000..359de5427a04
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/parsing/Parsers.scala
@@ -0,0 +1,4267 @@
+package dotty.tools
+package dotc
+package parsing
+
+import scala.language.unsafeNulls
+
+import scala.annotation.internal.sharable
+import scala.collection.mutable.ListBuffer
+import scala.collection.immutable.BitSet
+import util.{ SourceFile, SourcePosition, NoSourcePosition }
+import Tokens._
+import Scanners._
+import xml.MarkupParsers.MarkupParser
+import core._
+import Flags._
+import Contexts._
+import Names._
+import NameKinds.{WildcardParamName, QualifiedName}
+import NameOps._
+import ast.{Positioned, Trees}
+import ast.Trees._
+import StdNames._
+import util.Spans._
+import Constants._
+import Symbols.NoSymbol
+import ScriptParsers._
+import Decorators._
+import util.Chars
+import scala.annotation.tailrec
+import rewrites.Rewrites.{patch, overlapsPatch}
+import reporting._
+import config.Feature
+import config.Feature.{sourceVersion, migrateTo3, globalOnlyImports}
+import config.SourceVersion._
+import config.SourceVersion
+import language.experimental.pureFunctions
+
+object Parsers {
+
+  import ast.untpd._
+
+  case class OpInfo(operand: Tree, operator: Ident, offset: Offset)
+
+  enum Location(val inParens: Boolean, val inPattern: Boolean, val inArgs: Boolean):
+    case InParens      extends Location(true, false, false)
+    case InArgs        extends Location(true, false, true)
+    case InColonArg    extends Location(false, false, true)
+    case InPattern     extends Location(false, true, false)
+    case InGuard       extends Location(false, false, false)
+    case InPatternArgs extends Location(false, true, true) // InParens not true, since it might be an alternative
+    case InBlock       extends Location(false, false, false)
+    case ElseWhere     extends Location(false, false, false)
+
+  enum ParamOwner:
+    case Class, Type, TypeParam, Def
+
+  enum ParseKind:
+    case Expr, Type, Pattern
+
+  type StageKind = Int
+  object StageKind {
+    val None = 0
+    val Quoted = 1
+    val Spliced = 1 << 1
+    val QuotedPattern = 1 << 2
+  }
+
+  extension (buf: ListBuffer[Tree])
+    def +++=(x: Tree) = x match {
+      case x: Thicket => buf ++= x.trees
+      case x => buf += x
+    }
+
+  /** The parse starting point depends on whether the source file is self-contained:
+   *  if not, the AST will be supplemented.
+   */
+  def parser(source: SourceFile)(using Context): Parser =
+    if source.isSelfContained then new ScriptParser(source)
+    else new Parser(source)
+
+  private val InCase: Region => Region = Scanners.InCase(_)
+  private val InCond: Region => Region = Scanners.InParens(LPAREN, _)
+  private val InFor : Region => Region = Scanners.InBraces(_)
+
+  abstract class ParserCommon(val source: SourceFile)(using Context) {
+
+    val in: ScannerCommon
+
+    /* ------------- POSITIONS ------------------------------------------- */
+
+    /** Positions tree.
+     *  If `t` does not have a span yet, set its span to the given one.
+     */
+    def atSpan[T <: Positioned](span: Span)(t: T): T =
+      if (t.span.isSourceDerived) t else t.withSpan(span.union(t.span))
+
+    def atSpan[T <: Positioned](start: Offset, point: Offset, end: Offset)(t: T): T =
+      atSpan(Span(start, end, point))(t)
+
+    /** If the last read offset is strictly greater than `start`, assign tree
+     *  the span from `start` to last read offset, with given point.
+     *  If the last offset is less than or equal to start, the tree `t` did not
+     *  consume any source for its construction. In this case, don't assign a span yet,
+     *  but wait for its span to be determined by `setChildSpans` when the
+     *  parent node is positioned.
+     */
+    def atSpan[T <: Positioned](start: Offset, point: Offset)(t: T): T =
+      if (in.lastOffset > start) atSpan(start, point, in.lastOffset)(t) else t
+
+    def atSpan[T <: Positioned](start: Offset)(t: T): T =
+      atSpan(start, start)(t)
+
+    def startOffset(t: Positioned): Int =
+      if (t.span.exists) t.span.start else in.offset
+
+    def pointOffset(t: Positioned): Int =
+      if (t.span.exists) t.span.point else in.offset
+
+    def endOffset(t: Positioned): Int =
+      if (t.span.exists) t.span.end else in.lastOffset
+
+    def nameStart: Offset =
+      if (in.token == BACKQUOTED_IDENT) in.offset + 1 else in.offset
+
+    /** in.offset, except if this is at a new line, in which case `lastOffset` is preferred. */
+    def expectedOffset: Int = {
+      val current = in.sourcePos()
+      val last = in.sourcePos(in.lastOffset)
+      if (current.line != last.line) in.lastOffset else in.offset
+    }
+
+    /* ------------- ERROR HANDLING ------------------------------------------- */
+    /** The offset where the last syntax error was reported, or if a skip to a
+     *  safepoint occurred afterwards, the offset of the safe point.
+     */
+    protected var lastErrorOffset : Int = -1
+
+    /** Issue an error at given offset if beyond last error offset
+     *  and update lastErrorOffset.
+     */
+    def syntaxError(msg: Message, offset: Int = in.offset): Unit =
+      if offset > lastErrorOffset then
+        val length = if offset == in.offset && in.name != null then in.name.show.length else 0
+        syntaxError(msg, Span(offset, offset + length))
+        lastErrorOffset = in.offset
+
+    def syntaxError(msg: -> String, offset: Int): Unit =
+      syntaxError(msg.toMessage, offset)
+
+    def syntaxError(msg: -> String): Unit =
+      syntaxError(msg, in.offset)
+
+    /** Unconditionally issue an error at given span, without
+     *  updating lastErrorOffset.
+     */
+    def syntaxError(msg: Message, span: Span): Unit =
+      report.error(msg, source.atSpan(span))
+
+    def syntaxError(msg: -> String, span: Span): Unit =
+      syntaxError(msg.toMessage, span)
+
+    def unimplementedExpr(using Context): Select =
+      Select(scalaDot(nme.Predef), nme.???)
+  }
+
+  trait OutlineParserCommon extends ParserCommon {
+    def accept(token: Int): Int
+
+    def skipBracesHook(): Option[Tree]
+    def skipBraces(): Unit = {
+      accept(if (in.token == INDENT) INDENT else LBRACE)
+      var openBraces = 1
+      while (in.token != EOF && openBraces > 0)
+        skipBracesHook() getOrElse {
+          if (in.token == LBRACE || in.token == INDENT) openBraces += 1
+          else if (in.token == RBRACE || in.token == OUTDENT) openBraces -= 1
+          in.nextToken()
+        }
+    }
+  }
+
+  class Parser(source: SourceFile)(using Context) extends ParserCommon(source) {
+
+    val in: Scanner = new Scanner(source, profile = Profile.current)
+    // in.debugTokenStream = true    // uncomment to see the token stream of the standard scanner, but not syntax highlighting
+
+    /** This is the general parse entry point.
+     *  Overridden by ScriptParser
+     */
+    def parse(): Tree = {
+      val t = compilationUnit()
+      accept(EOF)
+      t
+    }
+
+/* -------------- TOKEN CLASSES ------------------------------------------- */
+
+    def isIdent = in.isIdent
+    def isIdent(name: Name) = in.isIdent(name)
+    def isPureArrow(name: Name): Boolean = isIdent(name) && Feature.pureFunsEnabled
+    def isPureArrow: Boolean = isPureArrow(nme.PUREARROW) || isPureArrow(nme.PURECTXARROW)
+    def isErased = isIdent(nme.erased) && in.erasedEnabled
+    def isSimpleLiteral =
+      simpleLiteralTokens.contains(in.token)
+      || isIdent(nme.raw.MINUS) && numericLitTokens.contains(in.lookahead.token)
+    def isLiteral = literalTokens contains in.token
+    def isNumericLit = numericLitTokens contains in.token
+    def isTemplateIntro = templateIntroTokens contains in.token
+    def isDclIntro = dclIntroTokens contains in.token
+    def isStatSeqEnd = in.isNestedEnd || in.token == EOF || in.token == RPAREN
+    def mustStartStat = mustStartStatTokens contains in.token
+
+    /** Is current token a hard or soft modifier (in modifier position or not)? */
+    def isModifier: Boolean = modifierTokens.contains(in.token) || in.isSoftModifier
+
+    def isBindingIntro: Boolean = {
+      in.token match {
+        case USCORE => true
+        case IDENTIFIER | BACKQUOTED_IDENT =>
+          in.lookahead.isArrow
+        case LPAREN =>
+          val lookahead = in.LookaheadScanner()
+          lookahead.skipParens()
+          lookahead.isArrow
+        case _ => false
+      }
+    } && !in.isSoftModifierInModifierPosition
+
+    def isExprIntro: Boolean =
+      in.canStartExprTokens.contains(in.token)
+      && !in.isSoftModifierInModifierPosition
+      && !(isIdent(nme.extension) && followingIsExtension())
+
+    def isDefIntro(allowedMods: BitSet, excludedSoftModifiers: Set[TermName] = Set.empty): Boolean =
+      in.token == AT
+      || defIntroTokens.contains(in.token)
+      || allowedMods.contains(in.token)
+      || in.isSoftModifierInModifierPosition && !excludedSoftModifiers.contains(in.name)
+
+    def isStatSep: Boolean = in.isStatSep
+
+    /** A '$' identifier is treated as a splice if followed by a `{`.
+     *  A longer identifier starting with `$` is treated as a splice/id combination
+     *  in a quoted block '{...'
+     */
+    def isSplice: Boolean =
+      in.token == IDENTIFIER && in.name(0) == '$' && {
+        if in.name.length == 1 then in.lookahead.token == LBRACE
+        else (staged & StageKind.Quoted) != 0
+      }
+
+/* ------------- ERROR HANDLING ------------------------------------------- */
+
+    /** Is offset1 less or equally indented than offset2?
+     *  This is the case if the characters between the preceding end-of-line and offset1
+     *  are a prefix of the characters between the preceding end-of-line and offset2.
+     */
+    def isLeqIndented(offset1: Int, offset2: Int): Boolean = {
+      def recur(idx1: Int, idx2: Int): Boolean =
+        idx1 == offset1 ||
+        idx2 < offset2 && source(idx1) == source(idx2) && recur(idx1 + 1, idx2 + 1)
+      recur(source.startOfLine(offset1), source.startOfLine(offset2))
+    }
+
+    /** Skip on error to next safe point.
+     */
+    def skip(): Unit =
+      in.skip()
+      lastErrorOffset = in.offset
+
+    def warning(msg: Message, offset: Int = in.offset): Unit =
+      report.warning(msg, source.atSpan(Span(offset)))
+
+    def deprecationWarning(msg: Message, offset: Int = in.offset): Unit =
+      report.deprecationWarning(msg, source.atSpan(Span(offset)))
+
+    /** Issue an error at current offset that input is incomplete */
+    def incompleteInputError(msg: Message): Unit =
+      if in.offset != lastErrorOffset then
+        report.incompleteInputError(msg, source.atSpan(Span(in.offset)))
+
+    /** If at end of file, issue an incompleteInputError.
+     *  Otherwise issue a syntax error and skip to next safe point.
+     */
+    def syntaxErrorOrIncomplete(msg: Message, offset: Int = in.offset): Unit =
+      if in.token == EOF then
+        incompleteInputError(msg)
+      else
+        syntaxError(msg, offset)
+        skip()
+
+    def syntaxErrorOrIncomplete(msg: -> String): Unit =
+      syntaxErrorOrIncomplete(msg.toMessage, in.offset)
+
+    def syntaxErrorOrIncomplete(msg: Message, span: Span): Unit =
+      if in.token == EOF then
+        incompleteInputError(msg)
+      else
+        syntaxError(msg, span)
+        skip()
+
+    /** Consume one token of the specified type, or
+      * signal an error if it is not there.
+      *
+      * @return The offset at the start of the token to accept
+      */
+    def accept(token: Int): Int =
+      val offset = in.offset
+      if in.token != token then
+        syntaxErrorOrIncomplete(ExpectedTokenButFound(token, in.token))
+      if in.token == token then in.nextToken()
+      offset
+
+    def accept(name: Name): Int = {
+      val offset = in.offset
+      if !isIdent(name) then
+        syntaxErrorOrIncomplete(em"`$name` expected")
+      if isIdent(name) then
+        in.nextToken()
+      offset
+    }
+
+    def acceptColon(): Int =
+      val offset = in.offset
+      if in.isColon then { in.nextToken(); offset }
+      else accept(COLONop)
+
+    /** semi = nl {nl} | `;'
+     *  nl  = `\n' // where allowed
+     */
+    def acceptStatSep(): Unit =
+      if in.isNewLine then in.nextToken() else accept(SEMI)
+
+    /** Parse statement separators and end markers. Ensure that there is at least
+     *  one statement separator unless the next token terminates a statement´sequence.
+     *  @param   stats      the statements parsed to far
+     *  @param   noPrevStat true if there was no immediately preceding statement parsed
+     *  @param   what       a string indicating what kind of statement is parsed
+     *  @param   altEnd     a token that is also considered as a terminator of the statement
+     *                      sequence (the default `EOF` already assumes to terminate a statement
+     *                      sequence).
+     *  @return  true if the statement sequence continues, false if it terminates.
+     */
+    def statSepOrEnd[T <: Tree](stats: ListBuffer[T], noPrevStat: Boolean = false, what: String = "statement", altEnd: Token = EOF): Boolean =
+      def recur(sepSeen: Boolean, endSeen: Boolean): Boolean =
+        if isStatSep then
+          in.nextToken()
+          recur(true, endSeen)
+        else if in.token == END then
+          if endSeen then syntaxError("duplicate end marker")
+          checkEndMarker(stats)
+          recur(sepSeen, endSeen = true)
+        else if isStatSeqEnd || in.token == altEnd then
+          false
+        else if sepSeen || endSeen then
+          true
+        else
+          val found = in.token
+          val statFollows = mustStartStatTokens.contains(found)
+          syntaxError(
+            if noPrevStat then IllegalStartOfStatement(what, isModifier, statFollows)
+            else i"end of $what expected but ${showToken(found)} found".toMessage)
+          if mustStartStatTokens.contains(found) then
+            false // it's a statement that might be legal in an outer context
+          else
+            in.nextToken() // needed to ensure progress; otherwise we might cycle forever
+            skip()
+            true
+
+      in.observeOutdented()
+      recur(false, false)
+    end statSepOrEnd
+
+    def rewriteNotice(version: SourceVersion = `3.0-migration`, additionalOption: String = "") =
+      Message.rewriteNotice("This construct", version, additionalOption)
+
+    def syntaxVersionError(option: String, span: Span) =
+      syntaxError(em"""This construct is not allowed under $option.${rewriteNotice(`3.0-migration`, option)}""", span)
+
+    def rewriteToNewSyntax(span: Span = Span(in.offset)): Boolean = {
+      if (in.newSyntax) {
+        if (in.rewrite) return true
+        syntaxVersionError("-new-syntax", span)
+      }
+      false
+    }
+
+    def rewriteToOldSyntax(span: Span = Span(in.offset)): Boolean = {
+      if (in.oldSyntax) {
+        if (in.rewrite) return true
+        syntaxVersionError("-old-syntax", span)
+      }
+      false
+    }
+
+    def errorTermTree(start: Offset): Literal = atSpan(start, in.offset, in.offset) { Literal(Constant(null)) }
+
+    private var inFunReturnType = false
+    private def fromWithinReturnType[T](body: => T): T = {
+      val saved = inFunReturnType
+      try {
+        inFunReturnType = true
+        body
+      }
+      finally inFunReturnType = saved
+    }
+
+    /** A flag indicating we are parsing in the annotations of a primary
+     *  class constructor
+     */
+    private var inClassConstrAnnots = false
+    private def fromWithinClassConstr[T](body: => T): T = {
+      val saved = inClassConstrAnnots
+      inClassConstrAnnots = true
+      try body
+      finally inClassConstrAnnots = saved
+    }
+
+    private var inEnum = false
+    private def withinEnum[T](body: => T): T = {
+      val saved = inEnum
+      inEnum = true
+      try body
+      finally inEnum = saved
+    }
+
+    private var staged = StageKind.None
+    def withinStaged[T](kind: StageKind)(op: => T): T = {
+      val saved = staged
+      staged |= kind
+      try op
+      finally staged = saved
+    }
+
+/* ---------- TREE CONSTRUCTION ------------------------------------------- */
+
+    /** Convert tree to formal parameter list
+    */
+    def convertToParams(tree: Tree): List[ValDef] =
+      val mods =
+        if in.token == CTXARROW || isPureArrow(nme.PURECTXARROW)
+        then Modifiers(Given)
+        else EmptyModifiers
+      tree match
+        case Parens(t) =>
+          convertToParam(t, mods) :: Nil
+        case Tuple(ts) =>
+          ts.map(convertToParam(_, mods))
+        case t @ Typed(Ident(_), _) =>
+          report.errorOrMigrationWarning(
+            em"parentheses are required around the parameter of a lambda${rewriteNotice()}",
+            in.sourcePos(), from = `3.0`)
+          if migrateTo3 then
+            patch(source, t.span.startPos, "(")
+            patch(source, t.span.endPos, ")")
+          convertToParam(t, mods) :: Nil
+        case t =>
+          convertToParam(t, mods) :: Nil
+
+    /** Convert tree to formal parameter
+    */
+    def convertToParam(tree: Tree, mods: Modifiers): ValDef =
+      def fail() =
+        syntaxError(s"not a legal formal parameter for a function literal", tree.span)
+        makeParameter(nme.ERROR, tree, mods)
+      tree match
+        case param: ValDef =>
+          param.withMods(param.mods | mods.flags)
+        case id @ Ident(name) =>
+          makeParameter(name.asTermName, TypeTree(), mods, isBackquoted = isBackquoted(id)).withSpan(tree.span)
+        // the following three cases are needed only for 2.x parameters without enclosing parentheses
+        case Typed(_, tpt: TypeBoundsTree) =>
+          fail()
+        case Typed(id @ Ident(name), tpt) =>
+          makeParameter(name.asTermName, tpt, mods, isBackquoted = isBackquoted(id)).withSpan(tree.span)
+        case _ =>
+          fail()
+
+    /** Convert (qual)ident to type identifier
+     */
+    def convertToTypeId(tree: Tree): Tree = tree match {
+      case id @ Ident(name) =>
+        cpy.Ident(id)(name.toTypeName)
+      case id @ Select(qual, name) =>
+        cpy.Select(id)(qual, name.toTypeName)
+      case _ =>
+        syntaxError(IdentifierExpected(tree.show), tree.span)
+        tree
+    }
+
+/* --------------- PLACEHOLDERS ------------------------------------------- */
+
+    /** The implicit parameters introduced by `_` in the current expression.
+     *  Parameters appear in reverse order.
+     */
+    var placeholderParams: List[ValDef] = Nil
+
+    def checkNoEscapingPlaceholders[T](op: => T): T =
+      val savedPlaceholderParams = placeholderParams
+      val savedLanguageImportContext = in.languageImportContext
+      placeholderParams = Nil
+      try op
+      finally
+        placeholderParams match
+          case vd :: _ => syntaxError(UnboundPlaceholderParameter(), vd.span)
+          case _ =>
+        placeholderParams = savedPlaceholderParams
+        in.languageImportContext = savedLanguageImportContext
+
+    def isWildcard(t: Tree): Boolean = t match {
+      case Ident(name1) => placeholderParams.nonEmpty && name1 == placeholderParams.head.name
+      case Typed(t1, _) => isWildcard(t1)
+      case Annotated(t1, _) => isWildcard(t1)
+      case Parens(t1) => isWildcard(t1)
+      case _ => false
+    }
+
+    def isWildcardType(t: Tree): Boolean = t match {
+      case t: TypeBoundsTree => true
+      case Parens(t1) => isWildcardType(t1)
+      case _ => false
+    }
+
+    def rejectWildcardType(t: Tree, fallbackTree: Tree = scalaAny): Tree =
+      if (isWildcardType(t)) {
+        syntaxError(UnboundWildcardType(), t.span)
+        fallbackTree
+      }
+      else t
+
+/* -------------- XML ---------------------------------------------------- */
+
+    /** The markup parser.
+     *  The first time this lazy val is accessed, we assume we were trying to parse an XML literal.
+     *  The current position is recorded for later error reporting if it turns out
+     *  that we don't have scala-xml on the compilation classpath.
+     */
+    lazy val xmlp: xml.MarkupParsers.MarkupParser = {
+      myFirstXmlPos = source.atSpan(Span(in.offset))
+      new MarkupParser(this, true)
+    }
+
+    /** The position of the first XML literal encountered while parsing,
+     *  NoSourcePosition if there were no XML literals.
+     */
+    def firstXmlPos: SourcePosition = myFirstXmlPos
+    private var myFirstXmlPos: SourcePosition = NoSourcePosition
+
+    object symbXMLBuilder extends xml.SymbolicXMLBuilder(this, true) // DEBUG choices
+
+    def xmlLiteral() : Tree = xmlp.xLiteral
+    def xmlLiteralPattern() : Tree = xmlp.xLiteralPattern
+
+/* -------- COMBINATORS -------------------------------------------------------- */
+
+    def enclosed[T](tok: Token, body: => T): T =
+      accept(tok)
+      try body finally accept(tok + 1)
+
+    def inParens[T](body: => T): T = enclosed(LPAREN, body)
+    def inBraces[T](body: => T): T = enclosed(LBRACE, body)
+    def inBrackets[T](body: => T): T = enclosed(LBRACKET, body)
+
+    def inBracesOrIndented[T](body: => T, rewriteWithColon: Boolean = false): T =
+      if in.token == INDENT then
+        val rewriteToBraces = in.rewriteNoIndent
+          && !testChars(in.lastOffset - 3, " =>") // braces are always optional after `=>` so none should be inserted
+        if rewriteToBraces then indentedToBraces(body)
+        else enclosed(INDENT, body)
+      else
+        if in.rewriteToIndent then bracesToIndented(body, rewriteWithColon)
+        else inBraces(body)
+
+    def inDefScopeBraces[T](body: => T, rewriteWithColon: Boolean = false): T =
+      inBracesOrIndented(body, rewriteWithColon)
+
+    /** <part> {`,` <part>} */
+    def commaSeparated[T](part: () => T): List[T] =
+      in.currentRegion.withCommasExpected {
+        commaSeparatedRest(part(), part)
+      }
+
+    /** {`,` <part>}
+     *
+     *  currentRegion.commasExpected has to be set separately.
+     */
+    def commaSeparatedRest[T](leading: T, part: () => T): List[T] =
+      if in.token == COMMA then
+        val ts = new ListBuffer[T] += leading
+        while in.token == COMMA do
+          in.nextToken()
+          ts += part()
+        ts.toList
+      else leading :: Nil
+
+    def inSepRegion[T](f: Region => Region)(op: => T): T =
+      val cur = in.currentRegion
+      in.currentRegion = f(cur)
+      try op finally in.currentRegion = cur
+
+    /** Parse `body` while checking (under -no-indent) that a `{` is not missing before it.
+     *  This is done as follows:
+     *    If the next token S is indented relative to the current region,
+     *    and the end of `body` is followed by a new line and another statement,
+     *    check that that other statement is indented less than S
+     */
+    def subPart[T](body: () => T): T = in.currentRegion match
+      case r: InBraces if in.isAfterLineEnd =>
+        val startIndentWidth = in.indentWidth(in.offset)
+        if r.indentWidth < startIndentWidth then
+          // Note: we can get here only if indentation is not significant
+          // If indentation is significant, we would see an <indent> as current token
+          // and the indent region would be Indented instead of InBraces.
+          //
+          // If indentation would be significant, an <indent> would be inserted here.
+          val t = body()
+          // Therefore, make sure there would be a matching <outdent>
+          def nextIndentWidth = in.indentWidth(in.next.offset)
+          if in.isNewLine && !(nextIndentWidth < startIndentWidth) then
+            warning(
+              if startIndentWidth <= nextIndentWidth then
+                  i"""Line is indented too far to the right, or a `{` is missing before:
+                   |
+                   |${t.tryToShow}""".toMessage
+              else
+                in.spaceTabMismatchMsg(startIndentWidth, nextIndentWidth).toMessage,
+              in.next.offset
+            )
+          t
+        else body()
+      case _ => body()
+
+    /** Check that this is not the start of a statement that's indented relative to the current region.
+     */
+    def checkNextNotIndented(): Unit =
+      if in.isNewLine then
+        val nextIndentWidth = in.indentWidth(in.next.offset)
+        if in.currentRegion.indentWidth < nextIndentWidth then
+          warning(i"Line is indented too far to the right, or a `{` or `:` is missing".toMessage, in.next.offset)
+
+/* -------- REWRITES ----------------------------------------------------------- */
+
+    /** The last offset where a colon at the end of line would be required if a subsequent { ... }
+     *  block would be converted to an indentation region.
+     */
+    var possibleColonOffset: Int = -1
+
+    def testChar(idx: Int, p: Char => Boolean): Boolean = {
+      val txt = source.content
+      idx < txt.length && p(txt(idx))
+    }
+
+    def testChar(idx: Int, c: Char): Boolean = {
+      val txt = source.content
+      idx < txt.length && txt(idx) == c
+    }
+
+    def testChars(from: Int, str: String): Boolean =
+      str.isEmpty ||
+      testChar(from, str.head) && testChars(from + 1, str.tail)
+
+    def skipBlanks(idx: Int, step: Int = 1): Int =
+      if (testChar(idx, c => c == ' ' || c == '\t' || c == Chars.CR)) skipBlanks(idx + step, step)
+      else idx
+
+    /** Parse indentation region `body` and rewrite it to be in braces instead */
+    def indentedToBraces[T](body: => T): T =
+      val enclRegion   = in.currentRegion.enclosing          // capture on entry
+      def indentWidth  = enclRegion.indentWidth
+      val followsColon = testChar(in.lastOffset - 1, ':')
+
+      /** Is `expr` a tree that lacks a final `else`? Put such trees in `{...}` to make
+       *  sure we don't accidentally merge them with a following `else`.
+       */
+      def isPartialIf(expr: Tree): Boolean = expr match {
+        case If(_, _, EmptyTree) => true
+        case If(_, _, e)         => isPartialIf(e)
+        case _                   => false
+      }
+
+      /** Is `expr` a (possibly curried) function that has a multi-statement block
+       *  as body? Put such trees in `{...}` since we don't enclose statements following
+       *  a `=>` in braces.
+       */
+      def isBlockFunction[T](expr: T): Boolean = expr match {
+        case Function(_, body)  => isBlockFunction(body)
+        case Block(stats, expr) => stats.nonEmpty || isBlockFunction(expr)
+        case _                  => false
+      }
+
+      /** Start of first line after in.lastOffset that does not have a comment
+       *  at indent width greater than the indent width of the closing brace.
+       */
+      def closingOffset(lineStart: Offset): Offset =
+        if in.lineOffset >= 0 && lineStart >= in.lineOffset then in.lineOffset
+        else
+          val commentStart = skipBlanks(lineStart)
+          if testChar(commentStart, '/') && indentWidth < in.indentWidth(commentStart)
+          then closingOffset(source.nextLine(lineStart))
+          else lineStart
+
+      def needsBraces(t: Any): Boolean = t match {
+        case Match(EmptyTree, _) => true
+        case Block(stats, expr)  => stats.nonEmpty || needsBraces(expr)
+        case expr: Tree          => followsColon
+                                 || isPartialIf(expr) && in.token == ELSE
+                                 || isBlockFunction(expr)
+        case _                   => true
+      }
+      // begin indentedToBraces
+      val startOpening =
+        if followsColon then
+          if testChar(in.lastOffset - 2, ' ') then in.lastOffset - 2
+          else in.lastOffset - 1
+        else in.lastOffset
+      val endOpening = in.lastOffset
+      val t = enclosed(INDENT, body)
+      if needsBraces(t) then
+        patch(source, Span(startOpening, endOpening), " {")
+        patch(source, Span(closingOffset(source.nextLine(in.lastOffset))), indentWidth.toPrefix ++ "}\n")
+      t
+    end indentedToBraces
+
+    /** The region to eliminate when replacing an opening `(` or `{` that ends a line.
+     *  The `(` or `{` is at in.offset.
+     */
+    def startingElimRegion(colonRequired: Boolean): (Offset, Offset) = {
+      val skipped = skipBlanks(in.offset + 1)
+      if (in.isAfterLineEnd)
+        if (testChar(skipped, Chars.LF) && !colonRequired)
+          (in.lineOffset, skipped + 1) // skip the whole line
+        else
+          (in.offset, skipped)
+      else if (testChar(in.offset - 1, ' ')) (in.offset - 1, in.offset + 1)
+      else (in.offset, in.offset + 1)
+    }
+
+    /** The region to eliminate when replacing a closing `)` or `}` that starts a new line
+     *  The `)` or `}` precedes in.lastOffset.
+     */
+    def closingElimRegion(): (Offset, Offset) = {
+      val skipped = skipBlanks(in.lastOffset)
+      if (testChar(skipped, Chars.LF))                    // if `)` or `}` is on a line by itself
+        (source.startOfLine(in.lastOffset), skipped + 1)  //   skip the whole line
+      else                                                // else
+        (in.lastOffset - 1, skipped)                      //   move the following text up to where the `)` or `}` was
+    }
+
+    /** Parse brace-enclosed `body` and rewrite it to be an indentation region instead, if possible.
+     *  If possible means:
+     *   1. not inside (...), [...], case ... =>
+     *   2. opening brace `{` is at end of line
+     *   3. closing brace `}` is at start of line
+     *   4. there is at least one token between the braces
+     *   5. the closing brace is also at the end of the line, or it is followed by one of
+     *      `then`, `else`, `do`, `catch`, `finally`, `yield`, or `match`.
+     *   6. the opening brace does not follow a `=>`. The reason for this condition is that
+     *      rewriting back to braces does not work after `=>` (since in most cases braces are omitted
+     *      after a `=>` it would be annoying if braces were inserted).
+     */
+    def bracesToIndented[T](body: => T, rewriteWithColon: Boolean): T = {
+      val underColonSyntax = possibleColonOffset == in.lastOffset
+      val colonRequired = rewriteWithColon || underColonSyntax
+      val (startOpening, endOpening) = startingElimRegion(colonRequired)
+      val isOutermost = in.currentRegion.isOutermost
+      def allBraces(r: Region): Boolean = r match {
+        case r: Indented => r.isOutermost || allBraces(r.enclosing)
+        case r: InBraces => allBraces(r.enclosing)
+        case _ => false
+      }
+      var canRewrite = allBraces(in.currentRegion) && // test (1)
+        !testChars(in.lastOffset - 3, " =>") // test(6)
+      val t = enclosed(LBRACE, {
+        canRewrite &= in.isAfterLineEnd // test (2)
+        val curOffset = in.offset
+        try body
+        finally {
+          canRewrite &= in.isAfterLineEnd && in.offset != curOffset // test (3)(4)
+        }
+      })
+      canRewrite &= (in.isAfterLineEnd || statCtdTokens.contains(in.token)) // test (5)
+      if (canRewrite && (!underColonSyntax || in.fewerBracesEnabled)) {
+        val openingPatchStr =
+          if !colonRequired then ""
+          else if testChar(startOpening - 1, Chars.isOperatorPart(_)) then " :"
+          else ":"
+        val (startClosing, endClosing) = closingElimRegion()
+        patch(source, Span(startOpening, endOpening), openingPatchStr)
+        patch(source, Span(startClosing, endClosing), "")
+      }
+      t
+    }
+
+    /** Drop (...) or { ... }, replacing the closing element with `endStr` */
+    def dropParensOrBraces(start: Offset, endStr: String): Unit = {
+      if (testChar(start + 1, Chars.isLineBreakChar))
+        patch(source, Span(if (testChar(start - 1, ' ')) start - 1 else start, start + 1), "")
+      else
+        patch(source, Span(start, start + 1),
+          if (testChar(start - 1, Chars.isIdentifierPart)) " " else "")
+      val closingStartsLine = testChar(skipBlanks(in.lastOffset - 2, -1), Chars.LF)
+      val preFill = if (closingStartsLine || endStr.isEmpty) "" else " "
+      val postFill = if (in.lastOffset == in.offset) " " else ""
+      val (startClosing, endClosing) =
+        if (closingStartsLine && endStr.isEmpty) closingElimRegion()
+        else (in.lastOffset - 1, in.lastOffset)
+      patch(source, Span(startClosing, endClosing), s"$preFill$endStr$postFill")
+    }
+
+    /** If all other characters on the same line as `span` are blanks, widen to
+     *  the whole line.
+     */
+    def widenIfWholeLine(span: Span): Span = {
+      val start = skipBlanks(span.start - 1, -1)
+      val end = skipBlanks(span.end, 1)
+      if (testChar(start, Chars.LF) && testChar(end, Chars.LF)) Span(start, end)
+      else span
+    }
+
+    /** Drop current token, if it is a `then` or `do`. */
+    def dropTerminator(): Unit =
+      if in.token == THEN || in.token == DO then
+        var startOffset = in.offset
+        var endOffset = in.lastCharOffset
+        if (in.isAfterLineEnd) {
+          if (testChar(endOffset, ' '))
+            endOffset += 1
+        }
+        else
+          if (testChar(startOffset - 1, ' ') &&
+              !overlapsPatch(source, Span(startOffset - 1, endOffset)))
+            startOffset -= 1
+        patch(source, widenIfWholeLine(Span(startOffset, endOffset)), "")
+
+    /** rewrite code with (...) around the source code of `t` */
+    def revertToParens(t: Tree): Unit =
+      if (t.span.exists) {
+        patch(source, t.span.startPos, "(")
+        patch(source, t.span.endPos, ")")
+        dropTerminator()
+      }
+
+/* --------- LOOKAHEAD --------------------------------------- */
+
+    /** In the tokens following the current one, does `query` precede any of the tokens that
+     *   - must start a statement, or
+     *   - separate two statements, or
+     *   - continue a statement (e.g. `else`, catch`), or
+     *   - terminate the current scope?
+     */
+    def followedByToken(query: Token): Boolean = {
+      val lookahead = in.LookaheadScanner()
+      var braces = 0
+      while (true) {
+        val token = lookahead.token
+        if (braces == 0) {
+          if (token == query) return true
+          if (stopScanTokens.contains(token) || lookahead.isNestedEnd) return false
+        }
+        else if (token == EOF)
+          return false
+        else if (lookahead.isNestedEnd)
+          braces -= 1
+        if (lookahead.isNestedStart) braces += 1
+        lookahead.nextToken()
+      }
+      false
+    }
+
+    /** Is the following sequence the generators of a for-expression enclosed in (...)? */
+    def followingIsEnclosedGenerators(): Boolean = {
+      val lookahead = in.LookaheadScanner()
+      var parens = 1
+      lookahead.nextToken()
+      while (parens != 0 && lookahead.token != EOF) {
+        val token = lookahead.token
+        if (token == LPAREN) parens += 1
+        else if (token == RPAREN) parens -= 1
+        lookahead.nextToken()
+      }
+      if (lookahead.token == LARROW)
+        false // it's a pattern
+      else if (lookahead.isIdent)
+        true // it's not a pattern since token cannot be an infix operator
+      else
+        followedByToken(LARROW) // `<-` comes before possible statement starts
+    }
+
+    /** Are the next token the "GivenSig" part of a given definition,
+     *  i.e. an identifier followed by type and value parameters, followed by `:`?
+     *  @pre  The current token is an identifier
+     */
+    def followingIsGivenSig() =
+      val lookahead = in.LookaheadScanner()
+      if lookahead.isIdent then
+        lookahead.nextToken()
+      def skipParams(): Unit =
+        if lookahead.token == LPAREN || lookahead.token == LBRACKET then
+          lookahead.skipParens()
+          skipParams()
+        else if lookahead.isNewLine then
+          lookahead.nextToken()
+          skipParams()
+      skipParams()
+      lookahead.isColon
+
+    def followingIsExtension() =
+      val next = in.lookahead.token
+      next == LBRACKET || next == LPAREN
+
+    def followingIsSelfType() =
+      val lookahead = in.LookaheadScanner(allowIndent = true)
+      lookahead.nextToken()
+      lookahead.token == COLONfollow
+      && {
+        lookahead.observeColonEOL(inTemplate = false)
+        lookahead.nextToken()
+        canStartInfixTypeTokens.contains(lookahead.token)
+      }
+
+    /** Is current ident a `*`, and is it followed by a `)`, `, )`, `,EOF`? The latter two are not
+        syntactically valid, but we need to include them here for error recovery. */
+    def followingIsVararg(): Boolean =
+      in.isIdent(nme.raw.STAR) && {
+        val lookahead = in.LookaheadScanner()
+        lookahead.nextToken()
+        lookahead.token == RPAREN
+        || lookahead.token == COMMA
+           && {
+             lookahead.nextToken()
+             lookahead.token == RPAREN || lookahead.token == EOF
+           }
+      }
+
+    /** When encountering a `:`, is that in the binding of a lambda?
+     *  @pre location of the enclosing expression is `InParens`, so there is an open `(`.
+     */
+    def followingIsLambdaParams() =
+      val lookahead = in.LookaheadScanner()
+      lookahead.nextToken()
+      while lookahead.token != RPAREN && lookahead.token != EOF do
+        if lookahead.token == LPAREN then lookahead.skipParens()
+        else lookahead.nextToken()
+      lookahead.token == RPAREN
+      && {
+        lookahead.nextToken()
+        lookahead.isArrow
+      }
+
+    /** Is the token sequence following the current `:` token classified as a lambda?
+     *  This is the case if the input starts with an identifier, a wildcard, or
+     *  something enclosed in (...) or [...], and this is followed by a `=>` or `?=>`
+     *  and an INDENT.
+     */
+    def followingIsLambdaAfterColon(): Boolean =
+      val lookahead = in.LookaheadScanner(allowIndent = true)
+      def isArrowIndent() =
+        lookahead.isArrow
+        && {
+          lookahead.nextToken()
+          lookahead.token == INDENT
+        }
+      lookahead.nextToken()
+      if lookahead.isIdent || lookahead.token == USCORE then
+        lookahead.nextToken()
+        isArrowIndent()
+      else if lookahead.token == LPAREN || lookahead.token == LBRACKET then
+        lookahead.skipParens()
+        isArrowIndent()
+      else false
+
+    /** Under captureChecking language import: is the following token sequence a
+     *  capture set `{ref1, ..., refN}` followed by a token that can start a type?
+     */
+    def followingIsCaptureSet(): Boolean =
+      Feature.ccEnabled && {
+        val lookahead = in.LookaheadScanner()
+        def followingIsTypeStart() =
+          lookahead.nextToken()
+          canStartInfixTypeTokens.contains(lookahead.token)
+          || lookahead.token == LBRACKET
+        def recur(): Boolean =
+          (lookahead.isIdent || lookahead.token == THIS) && {
+            lookahead.nextToken()
+            if lookahead.token == COMMA then
+              lookahead.nextToken()
+              recur()
+            else
+              lookahead.token == RBRACE && followingIsTypeStart()
+          }
+        lookahead.nextToken()
+        if lookahead.token == RBRACE then followingIsTypeStart() else recur()
+      }
+
+  /* --------- OPERAND/OPERATOR STACK --------------------------------------- */
+
+    var opStack: List[OpInfo] = Nil
+
+    def checkAssoc(offset: Token, op1: Name, op2: Name, op2LeftAssoc: Boolean): Unit =
+      if (op1.isRightAssocOperatorName == op2LeftAssoc)
+        syntaxError(MixedLeftAndRightAssociativeOps(op1, op2, op2LeftAssoc), offset)
+
+    def reduceStack(base: List[OpInfo], top: Tree, prec: Int, leftAssoc: Boolean, op2: Name, isType: Boolean): Tree = {
+      if (opStack != base && precedence(opStack.head.operator.name) == prec)
+        checkAssoc(opStack.head.offset, opStack.head.operator.name, op2, leftAssoc)
+      def recur(top: Tree): Tree =
+        if (opStack == base) top
+        else {
+          val opInfo = opStack.head
+          val opPrec = precedence(opInfo.operator.name)
+          if (prec < opPrec || leftAssoc && prec == opPrec) {
+            opStack = opStack.tail
+            recur {
+              atSpan(opInfo.operator.span union opInfo.operand.span union top.span) {
+                InfixOp(opInfo.operand, opInfo.operator, top)
+              }
+            }
+          }
+          else top
+        }
+      recur(top)
+    }
+
+    /** True if we are seeing a lambda argument after a colon of the form:
+     *    : (params) =>
+     *      body
+     */
+    def isColonLambda =
+      in.fewerBracesEnabled && in.token == COLONfollow && followingIsLambdaAfterColon()
+
+    /**   operand { infixop operand | MatchClause } [postfixop],
+     *
+     *  respecting rules of associativity and precedence.
+     *  @param isOperator    the current token counts as an operator.
+     *  @param maybePostfix  postfix operators are allowed.
+     */
+    def infixOps(
+        first: Tree, canStartOperand: Token => Boolean, operand: Location => Tree,
+        location: Location,
+        kind: ParseKind,
+        isOperator: => Boolean): Tree =
+      val base = opStack
+
+      def recur(top: Tree): Tree =
+        def isType = kind == ParseKind.Type
+        def maybePostfix = kind == ParseKind.Expr && in.postfixOpsEnabled
+        if isIdent && isOperator then
+          val op = if isType then typeIdent() else termIdent()
+          val top1 = reduceStack(base, top, precedence(op.name), !op.name.isRightAssocOperatorName, op.name, isType)
+          opStack = OpInfo(top1, op, in.offset) :: opStack
+          colonAtEOLOpt()
+          newLineOptWhenFollowing(canStartOperand)
+          if isColonLambda then
+            in.nextToken()
+            recur(expr(Location.InColonArg))
+          else if maybePostfix && !canStartOperand(in.token) then
+            val topInfo = opStack.head
+            opStack = opStack.tail
+            val od = reduceStack(base, topInfo.operand, 0, true, in.name, isType)
+            atSpan(startOffset(od), topInfo.offset) {
+              PostfixOp(od, topInfo.operator)
+            }
+          else recur(operand(location))
+        else
+          val t = reduceStack(base, top, minPrec, leftAssoc = true, in.name, isType)
+          if !isType && in.token == MATCH then recurAtMinPrec(matchClause(t))
+          else t
+
+      def recurAtMinPrec(top: Tree): Tree =
+        if isIdent && isOperator && precedence(in.name) == minInfixPrec
+           || in.token == MATCH
+        then recur(top)
+        else top
+
+      recur(first)
+    end infixOps
+
+/* -------- IDENTIFIERS AND LITERALS ------------------------------------------- */
+
+    /** Accept identifier and return its name as a term name. */
+    def ident(): TermName =
+      if (isIdent) {
+        val name = in.name
+        if name == nme.CONSTRUCTOR || name == nme.STATIC_CONSTRUCTOR then
+          report.error(
+            i"""Illegal backquoted identifier: `<init>` and `<clinit>` are forbidden""",
+            in.sourcePos())
+        in.nextToken()
+        name
+      }
+      else {
+        syntaxErrorOrIncomplete(ExpectedTokenButFound(IDENTIFIER, in.token))
+        nme.ERROR
+      }
+
+    /** Accept identifier and return Ident with its name as a term name. */
+    def termIdent(): Ident =
+      makeIdent(in.token, in.offset, ident())
+
+    /** Accept identifier and return Ident with its name as a type name. */
+    def typeIdent(): Ident =
+      makeIdent(in.token, in.offset, ident().toTypeName)
+
+    private def makeIdent(tok: Token, offset: Offset, name: Name) = {
+      val tree = Ident(name)
+      if (tok == BACKQUOTED_IDENT) tree.pushAttachment(Backquoted, ())
+
+      // Make sure that even trees with parsing errors have a offset that is within the offset
+      val errorOffset = offset min (in.lastOffset - 1)
+      if (tree.name == nme.ERROR && tree.span == NoSpan) tree.withSpan(Span(errorOffset, errorOffset))
+      else atSpan(offset)(tree)
+    }
+
+    def wildcardIdent(): Ident =
+      atSpan(accept(USCORE)) { Ident(nme.WILDCARD) }
+
+    /** Accept identifier or match clause acting as a selector on given tree `t` */
+    def selectorOrMatch(t: Tree): Tree =
+      atSpan(startOffset(t), in.offset) {
+        if in.token == MATCH then matchClause(t) else Select(t, ident())
+      }
+
+    def selector(t: Tree): Tree =
+      atSpan(startOffset(t), in.offset) { Select(t, ident()) }
+
+    /** DotSelectors ::= { `.' id } */
+    def dotSelectors(t: Tree): Tree =
+      if (in.token == DOT) { in.nextToken(); dotSelectors(selector(t)) }
+      else t
+
+    private val id: Tree => Tree = x => x
+
+    /** SimpleRef  ::= id
+     *              |  [id ‘.’] ‘this’
+     *              |  [id ‘.’] ‘super’ [ClassQualifier] ‘.’ id
+     */
+    def simpleRef(): Tree =
+      val start = in.offset
+
+      def handleThis(qual: Ident) =
+        in.nextToken()
+        atSpan(start) { This(qual) }
+
+      def handleSuper(qual: Ident) =
+        in.nextToken()
+        val mix = mixinQualifierOpt()
+        val t = atSpan(start) { Super(This(qual), mix) }
+        accept(DOT)
+        selector(t)
+
+      if in.token == THIS then handleThis(EmptyTypeIdent)
+      else if in.token == SUPER then handleSuper(EmptyTypeIdent)
+      else
+        val t = termIdent()
+        if in.token == DOT then
+          def qual = cpy.Ident(t)(t.name.toTypeName)
+          in.lookahead.token match
+            case THIS =>
+              in.nextToken()
+              handleThis(qual)
+            case SUPER =>
+              in.nextToken()
+              handleSuper(qual)
+            case _ => t
+        else t
+    end simpleRef
+
+    /** MixinQualifier ::= `[' id `]'
+    */
+    def mixinQualifierOpt(): Ident =
+      if (in.token == LBRACKET) inBrackets(atSpan(in.offset) { typeIdent() })
+      else EmptyTypeIdent
+
+    /** QualId ::= id {`.' id}
+    */
+    def qualId(): Tree = dotSelectors(termIdent())
+
+    /** Singleton    ::=  SimpleRef
+     *                 |  SimpleLiteral
+     *                 |  Singleton ‘.’ id
+     * -- not yet      |  Singleton ‘(’ Singletons ‘)’
+     * -- not yet      |  Singleton ‘[’ Types ‘]’
+     */
+    def singleton(): Tree =
+      if isSimpleLiteral then simpleLiteral()
+      else dotSelectors(simpleRef())
+
+    /** SimpleLiteral     ::=  [‘-’] integerLiteral
+     *                      |  [‘-’] floatingPointLiteral
+     *                      |  booleanLiteral
+     *                      |  characterLiteral
+     *                      |  stringLiteral
+     */
+    def simpleLiteral(): Tree =
+      if isIdent(nme.raw.MINUS) then
+        val start = in.offset
+        in.nextToken()
+        literal(negOffset = start, inTypeOrSingleton = true)
+      else
+        literal(inTypeOrSingleton = true)
+
+    /** Literal           ::=  SimpleLiteral
+     *                      |  processedStringLiteral
+     *                      |  symbolLiteral
+     *                      |  ‘null’
+     *
+     *  @param negOffset   The offset of a preceding `-' sign, if any.
+     *                     If the literal is not negated, negOffset == in.offset.
+     */
+    def literal(negOffset: Int = in.offset, inPattern: Boolean = false, inTypeOrSingleton: Boolean = false, inStringInterpolation: Boolean = false): Tree = {
+      def literalOf(token: Token): Tree = {
+        val isNegated = negOffset < in.offset
+        def digits0 = in.removeNumberSeparators(in.strVal)
+        def digits = if (isNegated) "-" + digits0 else digits0
+        if !inTypeOrSingleton then
+          token match {
+            case INTLIT  => return Number(digits, NumberKind.Whole(in.base))
+            case DECILIT => return Number(digits, NumberKind.Decimal)
+            case EXPOLIT => return Number(digits, NumberKind.Floating)
+            case _ =>
+          }
+        import scala.util.FromDigits._
+        val value =
+          try token match {
+            case INTLIT                        => intFromDigits(digits, in.base)
+            case LONGLIT                       => longFromDigits(digits, in.base)
+            case FLOATLIT                      => floatFromDigits(digits)
+            case DOUBLELIT | DECILIT | EXPOLIT => doubleFromDigits(digits)
+            case CHARLIT                       => in.strVal.head
+            case STRINGLIT | STRINGPART        => in.strVal
+            case TRUE                          => true
+            case FALSE                         => false
+            case NULL                          => null
+            case _                             =>
+              syntaxErrorOrIncomplete(IllegalLiteral())
+              null
+          }
+          catch {
+            case ex: FromDigitsException => syntaxErrorOrIncomplete(ex.getMessage)
+          }
+        Literal(Constant(value))
+      }
+
+      if (inStringInterpolation) {
+        val t = in.token match {
+          case STRINGLIT | STRINGPART =>
+            val value = in.strVal
+            atSpan(negOffset, negOffset, negOffset + value.length) { Literal(Constant(value)) }
+          case _ =>
+            syntaxErrorOrIncomplete(IllegalLiteral())
+            atSpan(negOffset) { Literal(Constant(null)) }
+        }
+        in.nextToken()
+        t
+      }
+      else atSpan(negOffset) {
+        if (in.token == QUOTEID)
+          if ((staged & StageKind.Spliced) != 0 && Chars.isIdentifierStart(in.name(0))) {
+            val t = atSpan(in.offset + 1) {
+              val tok = in.toToken(in.name)
+              tok match {
+                case TRUE | FALSE | NULL => literalOf(tok)
+                case THIS => This(EmptyTypeIdent)
+                case _ => Ident(in.name)
+              }
+            }
+            in.nextToken()
+            Quote(t)
+          }
+          else
+            if !in.featureEnabled(Feature.symbolLiterals) then
+              val name = in.name // capture name (not `in`) in the warning message closure
+              report.errorOrMigrationWarning(
+                em"""symbol literal '$name is no longer supported,
+                    |use a string literal "$name" or an application Symbol("$name") instead,
+                    |or enclose in braces '{$name} if you want a quoted expression.
+                    |For now, you can also `import language.deprecated.symbolLiterals` to accept
+                    |the idiom, but this possibility might no longer be available in the future.""",
+                in.sourcePos(), from = `3.0`)
+              if migrateTo3 then
+                patch(source, Span(in.offset, in.offset + 1), "Symbol(\"")
+                patch(source, Span(in.charOffset - 1), "\")")
+            atSpan(in.skipToken()) { SymbolLit(in.strVal) }
+        else if (in.token == INTERPOLATIONID) interpolatedString(inPattern)
+        else {
+          val t = literalOf(in.token)
+          in.nextToken()
+          t
+        }
+      }
+    }
+
+    private def interpolatedString(inPattern: Boolean = false): Tree = atSpan(in.offset) {
+      val segmentBuf = new ListBuffer[Tree]
+      val interpolator = in.name
+      val isTripleQuoted =
+        in.charOffset + 1 < in.buf.length &&
+        in.buf(in.charOffset) == '"' &&
+        in.buf(in.charOffset + 1) == '"'
+      in.nextToken()
+      def nextSegment(literalOffset: Offset) =
+        segmentBuf += Thicket(
+            literal(literalOffset, inPattern = inPattern, inStringInterpolation = true),
+            atSpan(in.offset) {
+              if (in.token == IDENTIFIER)
+                termIdent()
+              else if (in.token == USCORE && inPattern) {
+                in.nextToken()
+                Ident(nme.WILDCARD)
+              }
+              else if (in.token == THIS) {
+                in.nextToken()
+                This(EmptyTypeIdent)
+              }
+              else if (in.token == LBRACE)
+                if (inPattern) Block(Nil, inBraces(pattern()))
+                else expr()
+              else {
+                report.error(InterpolatedStringError(), source.atSpan(Span(in.offset)))
+                EmptyTree
+              }
+            })
+
+      var offsetCorrection = if isTripleQuoted then 3 else 1
+      while (in.token == STRINGPART)
+        nextSegment(in.offset + offsetCorrection)
+        offsetCorrection = 0
+      if (in.token == STRINGLIT)
+        segmentBuf += literal(inPattern = inPattern, negOffset = in.offset + offsetCorrection, inStringInterpolation = true)
+
+      InterpolatedString(interpolator, segmentBuf.toList)
+    }
+
+/* ------------- NEW LINES ------------------------------------------------- */
+
+    def newLineOpt(): Unit =
+      if (in.token == NEWLINE) in.nextToken()
+
+    def newLinesOpt(): Unit =
+      if in.isNewLine then in.nextToken()
+
+    def newLineOptWhenFollowedBy(token: Int): Unit =
+      // note: next is defined here because current == NEWLINE
+      if (in.token == NEWLINE && in.next.token == token) in.nextToken()
+
+    def newLinesOptWhenFollowedBy(token: Int): Unit =
+      if in.isNewLine && in.next.token == token then in.nextToken()
+
+    def newLinesOptWhenFollowedBy(name: Name): Unit =
+      if in.isNewLine && in.next.token == IDENTIFIER && in.next.name == name then
+        in.nextToken()
+
+    def newLineOptWhenFollowing(p: Int => Boolean): Unit =
+      // note: next is defined here because current == NEWLINE
+      if (in.token == NEWLINE && p(in.next.token)) newLineOpt()
+
+    def colonAtEOLOpt(): Unit = {
+      possibleColonOffset = in.lastOffset
+      in.observeColonEOL(inTemplate = false)
+      if in.token == COLONeol then in.nextToken()
+    }
+
+    def argumentStart(): Unit =
+      colonAtEOLOpt()
+      if migrateTo3 && in.token == NEWLINE && in.next.token == LBRACE then
+        in.nextToken()
+        if in.indentWidth(in.offset) == in.currentRegion.indentWidth then
+          report.errorOrMigrationWarning(
+            i"""This opening brace will start a new statement in Scala 3.
+               |It needs to be indented to the right to keep being treated as
+               |an argument to the previous expression.${rewriteNotice()}""",
+            in.sourcePos(), from = `3.0`)
+          patch(source, Span(in.offset), "  ")
+
+    def possibleTemplateStart(isNew: Boolean = false): Unit =
+      in.observeColonEOL(inTemplate = true)
+      if in.token == COLONeol then
+        if in.lookahead.token == END then in.token = NEWLINE
+        else
+          in.nextToken()
+          if in.token != INDENT && in.token != LBRACE then
+            syntaxErrorOrIncomplete(i"indented definitions expected, ${in} found")
+      else
+        newLineOptWhenFollowedBy(LBRACE)
+
+    def checkEndMarker[T <: Tree](stats: ListBuffer[T]): Unit =
+
+      def updateSpanOfLast(last: T): Unit =
+        last match
+          case last: WithEndMarker[t] => last.withEndMarker()
+          case _ =>
+        last.span = last.span.withEnd(in.lastCharOffset)
+
+      def matches(stat: T): Boolean = stat match
+        case stat: MemberDef if !stat.name.isEmpty =>
+          if stat.name == nme.CONSTRUCTOR then in.token == THIS
+          else in.isIdent && in.name == stat.name.toTermName
+        case ExtMethods(_, _) =>
+          in.token == IDENTIFIER && in.name == nme.extension
+        case PackageDef(pid: RefTree, _) =>
+          in.isIdent && in.name == pid.name
+        case stat: MemberDef if stat.mods.is(Given) => in.token == GIVEN
+        case _: PatDef => in.token == VAL
+        case _: If => in.token == IF
+        case _: WhileDo => in.token == WHILE
+        case _: ParsedTry => in.token == TRY
+        case _: Match => in.token == MATCH
+        case _: New => in.token == NEW
+        case _: (ForYield | ForDo) => in.token == FOR
+        case _ => false
+
+      def endName = if in.token == IDENTIFIER then in.name.toString else tokenString(in.token)
+
+      def matchesAndSetEnd(last: T): Boolean =
+        val didMatch = matches(last)
+        if didMatch then
+          updateSpanOfLast(last)
+        didMatch
+
+      if in.token == END then
+        val start = in.skipToken()
+        if stats.isEmpty || !matchesAndSetEnd(stats.last) then
+          syntaxError("misaligned end marker", Span(start, in.lastCharOffset))
+        else if overlapsPatch(source, Span(start, start)) then
+          patch(source, Span(start, start), "")
+          patch(source, Span(start, in.lastCharOffset), s"} // end $endName")
+        in.token = IDENTIFIER // Leaving it as the original token can confuse newline insertion
+        in.nextToken()
+    end checkEndMarker
+
+/* ------------- TYPES ------------------------------------------------------ */
+
+    /** Same as [[typ]], but if this results in a wildcard it emits a syntax error and
+     *  returns a tree for type `Any` instead.
+     */
+    def toplevelTyp(): Tree = rejectWildcardType(typ())
+
+    private def isFunction(tree: Tree): Boolean = tree match {
+      case Parens(tree1) => isFunction(tree1)
+      case Block(Nil, tree1) => isFunction(tree1)
+      case _: Function => true
+      case _ => false
+    }
+
+    /** CaptureRef  ::=  ident | `this`
+     */
+    def captureRef(): Tree =
+      if in.token == THIS then simpleRef()
+      else termIdent() match
+        case Ident(nme.CAPTURE_ROOT) => captureRoot
+        case id => id
+
+    /**  CaptureSet ::=  `{` CaptureRef {`,` CaptureRef} `}`    -- under captureChecking
+     */
+    def captureSet(): List[Tree] = inBraces {
+      if in.token == RBRACE then Nil else commaSeparated(captureRef)
+    }
+
+    /** Type           ::=  FunType
+     *                   |  HkTypeParamClause ‘=>>’ Type
+     *                   |  FunParamClause ‘=>>’ Type
+     *                   |  MatchType
+     *                   |  InfixType
+     *                   |  CaptureSet Type                            -- under captureChecking
+     *  FunType        ::=  (MonoFunType | PolyFunType)
+     *  MonoFunType    ::=  FunTypeArgs (‘=>’ | ‘?=>’) Type
+     *                   |  (‘->’ | ‘?->’ ) Type                       -- under pureFunctions
+     *  PolyFunType    ::=  HKTypeParamClause '=>' Type
+     *                   |  HKTypeParamClause ‘->’ Type                -- under pureFunctions
+     *  FunTypeArgs    ::=  InfixType
+     *                   |  `(' [ [ ‘[using]’ ‘['erased']  FunArgType {`,' FunArgType } ] `)'
+     *                   |  '(' [ ‘[using]’ ‘['erased'] TypedFunParam {',' TypedFunParam } ')'
+     */
+    def typ(): Tree =
+      val start = in.offset
+      var imods = Modifiers()
+      def functionRest(params: List[Tree]): Tree =
+        val paramSpan = Span(start, in.lastOffset)
+        atSpan(start, in.offset) {
+          var token = in.token
+          if isPureArrow(nme.PUREARROW) then
+            token = ARROW
+          else if isPureArrow(nme.PURECTXARROW) then
+            token = CTXARROW
+          else if token == TLARROW then
+            if !imods.flags.isEmpty || params.isEmpty then
+              syntaxError(em"illegal parameter list for type lambda", start)
+              token = ARROW
+          else if Feature.pureFunsEnabled then
+            // `=>` means impure function under pureFunctions or captureChecking
+            // language imports, whereas `->` is then a regular function.
+            imods |= Impure
+
+          if token == CTXARROW then
+            in.nextToken()
+            imods |= Given
+          else if token == ARROW || token == TLARROW then
+            in.nextToken()
+          else
+            accept(ARROW)
+
+          val resultType = typ()
+          if token == TLARROW then
+            for case ValDef(_, tpt, _) <- params do
+              if isByNameType(tpt) then
+                syntaxError(em"parameter of type lambda may not be call-by-name", tpt.span)
+            TermLambdaTypeTree(params.asInstanceOf[List[ValDef]], resultType)
+          else if imods.isOneOf(Given | Erased | Impure) then
+            if imods.is(Given) && params.isEmpty then
+              syntaxError("context function types require at least one parameter", paramSpan)
+            FunctionWithMods(params, resultType, imods)
+          else if !ctx.settings.YkindProjector.isDefault then
+            val (newParams :+ newResultType, tparams) = replaceKindProjectorPlaceholders(params :+ resultType): @unchecked
+            lambdaAbstract(tparams, Function(newParams, newResultType))
+          else
+            Function(params, resultType)
+        }
+
+      var isValParamList = false
+
+      val t =
+        if (in.token == LPAREN) {
+          in.nextToken()
+          if (in.token == RPAREN) {
+            in.nextToken()
+            functionRest(Nil)
+          }
+          else {
+            if isErased then imods = addModifier(imods)
+            val paramStart = in.offset
+            val ts = in.currentRegion.withCommasExpected {
+              funArgType() match
+                case Ident(name) if name != tpnme.WILDCARD && in.isColon =>
+                  isValParamList = true
+                  commaSeparatedRest(
+                    typedFunParam(paramStart, name.toTermName, imods),
+                    () => typedFunParam(in.offset, ident(), imods))
+                case t =>
+                  commaSeparatedRest(t, funArgType)
+            }
+            accept(RPAREN)
+            if isValParamList || in.isArrow || isPureArrow then
+              functionRest(ts)
+            else {
+              val ts1 = ts.mapConserve { t =>
+                if isByNameType(t) then
+                  syntaxError(ByNameParameterNotSupported(t), t.span)
+                  stripByNameType(t)
+                else
+                  t
+              }
+              val tuple = atSpan(start) { makeTupleOrParens(ts1) }
+              infixTypeRest(
+                refinedTypeRest(
+                  withTypeRest(
+                    annotTypeRest(
+                      simpleTypeRest(tuple)))))
+            }
+          }
+        }
+        else if (in.token == LBRACKET) {
+          val start = in.offset
+          val tparams = typeParamClause(ParamOwner.TypeParam)
+          if (in.token == TLARROW)
+            atSpan(start, in.skipToken())(LambdaTypeTree(tparams, toplevelTyp()))
+          else if (in.token == ARROW || isPureArrow(nme.PUREARROW)) {
+            val arrowOffset = in.skipToken()
+            val body = toplevelTyp()
+            atSpan(start, arrowOffset) {
+              if (isFunction(body))
+                PolyFunction(tparams, body)
+              else {
+                syntaxError("Implementation restriction: polymorphic function types must have a value parameter", arrowOffset)
+                Ident(nme.ERROR.toTypeName)
+              }
+            }
+          }
+          else { accept(TLARROW); typ() }
+        }
+        else if in.token == LBRACE && followingIsCaptureSet() then
+          CapturingTypeTree(captureSet(), typ())
+        else if (in.token == INDENT) enclosed(INDENT, typ())
+        else infixType()
+
+      in.token match
+        case ARROW | CTXARROW => functionRest(t :: Nil)
+        case MATCH => matchType(t)
+        case FORSOME => syntaxError(ExistentialTypesNoLongerSupported()); t
+        case _ =>
+          if isPureArrow then
+            functionRest(t :: Nil)
+          else
+            if (imods.is(Erased) && !t.isInstanceOf[FunctionWithMods])
+              syntaxError(ErasedTypesCanOnlyBeFunctionTypes(), implicitKwPos(start))
+            t
+    end typ
+
+    private def makeKindProjectorTypeDef(name: TypeName): TypeDef = {
+      val isVarianceAnnotated = name.startsWith("+") || name.startsWith("-")
+      // We remove the variance marker from the name without passing along the specified variance at all
+      // The real variance will be inferred at a later stage but may contradict the variance specified,
+      // This is ok, because `-Ykind-projector` is for cross-compiling existing Scala 2 code, not for writing new code,
+      // we may assume that variance annotations have already been checked by the Scala 2 compiler.
+      val unannotatedName = if (isVarianceAnnotated) name.mapLast(_.drop(1)) else name
+      TypeDef(unannotatedName, WildcardTypeBoundsTree()).withFlags(Param)
+    }
+
+    /** Replaces kind-projector's `*` in a list of types arguments with synthetic names,
+     *  returning the new argument list and the synthetic type definitions.
+     */
+    private def replaceKindProjectorPlaceholders(params: List[Tree]): (List[Tree], List[TypeDef]) = {
+      val tparams = new ListBuffer[TypeDef]
+      def addParam() = {
+        val name = WildcardParamName.fresh().toTypeName
+        tparams += makeKindProjectorTypeDef(name)
+        Ident(name)
+      }
+
+      val uscores = ctx.settings.YkindProjector.value == "underscores"
+      val newParams = params.mapConserve {
+        case param @ Ident(tpnme.raw.STAR | tpnme.raw.MINUS_STAR | tpnme.raw.PLUS_STAR) => addParam()
+        case param @ Ident(tpnme.USCOREkw | tpnme.raw.MINUS_USCORE | tpnme.raw.PLUS_USCORE) if uscores => addParam()
+        case other => other
+      }
+
+      (newParams, tparams.toList)
+    }
+
+    private def implicitKwPos(start: Int): Span =
+      Span(start, start + nme.IMPLICITkw.asSimpleName.length)
+
+    /** TypedFunParam   ::= id ':' Type */
+    def typedFunParam(start: Offset, name: TermName, mods: Modifiers = EmptyModifiers): ValDef =
+      atSpan(start) {
+        acceptColon()
+        makeParameter(name, typ(), mods)
+      }
+
+    /**  FunParamClause ::=  ‘(’ TypedFunParam {‘,’ TypedFunParam } ‘)’
+     */
+    def funParamClause(): List[ValDef] =
+      inParens(commaSeparated(() => typedFunParam(in.offset, ident())))
+
+    def funParamClauses(): List[List[ValDef]] =
+      if in.token == LPAREN then funParamClause() :: funParamClauses() else Nil
+
+    /** InfixType ::= RefinedType {id [nl] RefinedType}
+     */
+    def infixType(): Tree = infixTypeRest(refinedType())
+
+    def infixTypeRest(t: Tree): Tree =
+      infixOps(t, canStartInfixTypeTokens, refinedTypeFn, Location.ElseWhere, ParseKind.Type,
+        isOperator = !followingIsVararg() && !isPureArrow)
+
+    /** RefinedType   ::=  WithType {[nl] Refinement}
+     */
+    val refinedTypeFn: Location => Tree = _ => refinedType()
+
+    def refinedType() = refinedTypeRest(withType())
+
+    def refinedTypeRest(t: Tree): Tree = {
+      argumentStart()
+      if (in.isNestedStart)
+        refinedTypeRest(atSpan(startOffset(t)) {
+          RefinedTypeTree(rejectWildcardType(t), refinement(indentOK = true))
+        })
+      else t
+    }
+
+    /** WithType ::= AnnotType {`with' AnnotType}    (deprecated)
+     */
+    def withType(): Tree = withTypeRest(annotType())
+
+    def withTypeRest(t: Tree): Tree =
+      if in.token == WITH then
+        val withOffset = in.offset
+        in.nextToken()
+        if in.token == LBRACE || in.token == INDENT then
+          t
+        else
+          if sourceVersion.isAtLeast(future) then
+            deprecationWarning(DeprecatedWithOperator(), withOffset)
+          atSpan(startOffset(t)) { makeAndType(t, withType()) }
+      else t
+
+    /** AnnotType ::= SimpleType {Annotation}
+     */
+    def annotType(): Tree = annotTypeRest(simpleType())
+
+    def annotTypeRest(t: Tree): Tree =
+      if (in.token == AT)
+        annotTypeRest(atSpan(startOffset(t)) {
+          Annotated(rejectWildcardType(t), annot())
+        })
+      else t
+
+    /** The block in a quote or splice */
+    def stagedBlock() = inBraces(block(simplify = true))
+
+    /** ExprSplice  ::=  ‘$’ spliceId          --     if inside quoted block
+     *                |  ‘$’ ‘{’ Block ‘}’     -- unless inside quoted pattern
+     *                |  ‘$’ ‘{’ Pattern ‘}’   --   when inside quoted pattern
+     *  TypeSplice  ::=  ‘$’ spliceId          --    if inside quoted type
+     *                |  ‘$’ ‘{’ Block ‘}’     -- unless inside quoted type pattern
+     *                |  ‘$’ ‘{’ Pattern ‘}’   --   when inside quoted type pattern
+     */
+    def splice(isType: Boolean): Tree =
+      val start = in.offset
+      atSpan(in.offset) {
+        val expr =
+          if (in.name.length == 1) {
+            in.nextToken()
+            val inPattern = (staged & StageKind.QuotedPattern) != 0
+            withinStaged(StageKind.Spliced)(if (inPattern) inBraces(pattern()) else stagedBlock())
+          }
+          else atSpan(in.offset + 1) {
+            val id = Ident(in.name.drop(1))
+            in.nextToken()
+            id
+          }
+        if isType then
+          val msg = "Type splicing with `$` in quotes not supported anymore"
+          val inPattern = (staged & StageKind.QuotedPattern) != 0
+          val hint =
+            if inPattern then "Use lower cased variable name without the `$` instead"
+            else "To use a given Type[T] in a quote just write T directly"
+          syntaxError(s"$msg\n\nHint: $hint", Span(start, in.lastOffset))
+          Ident(nme.ERROR.toTypeName)
+        else
+          Splice(expr)
+      }
+
+    /**  SimpleType      ::=  SimpleLiteral
+     *                     |  ‘?’ SubtypeBounds
+     *                     |  SimpleType1
+     *                     |  SimpleType ‘(’ Singletons ‘)’  -- under language.experimental.dependent, checked in Typer
+     *   Singletons      ::=  Singleton {‘,’ Singleton}
+     */
+    def simpleType(): Tree =
+      if isSimpleLiteral then
+        SingletonTypeTree(simpleLiteral())
+      else if in.token == USCORE then
+        if ctx.settings.YkindProjector.value == "underscores" then
+          val start = in.skipToken()
+          Ident(tpnme.USCOREkw).withSpan(Span(start, in.lastOffset, start))
+        else
+          if sourceVersion.isAtLeast(future) then
+            deprecationWarning(em"`_` is deprecated for wildcard arguments of types: use `?` instead".toMessage)
+            patch(source, Span(in.offset, in.offset + 1), "?")
+          val start = in.skipToken()
+          typeBounds().withSpan(Span(start, in.lastOffset, start))
+      // Allow symbols -_ and +_ through for compatibility with code written using kind-projector in Scala 3 underscore mode.
+      // While these signify variant type parameters in Scala 2 + kind-projector, we ignore their variance markers since variance is inferred.
+      else if (isIdent(nme.MINUS) || isIdent(nme.PLUS)) && in.lookahead.token == USCORE && ctx.settings.YkindProjector.value == "underscores" then
+        val identName = in.name.toTypeName ++ nme.USCOREkw
+        val start = in.skipToken()
+        in.nextToken()
+        Ident(identName).withSpan(Span(start, in.lastOffset, start))
+      else if isIdent(nme.?) then
+        val start = in.skipToken()
+        typeBounds().withSpan(Span(start, in.lastOffset, start))
+      else
+        def singletonArgs(t: Tree): Tree =
+          if in.token == LPAREN && in.featureEnabled(Feature.dependent)
+          then singletonArgs(AppliedTypeTree(t, inParens(commaSeparated(singleton))))
+          else t
+        singletonArgs(simpleType1())
+
+    /** SimpleType1      ::=  id
+     *                     |  Singleton `.' id
+     *                     |  Singleton `.' type
+     *                     |  ‘(’ ArgTypes ‘)’
+     *                     |  Refinement
+     *                     |  TypeSplice                -- deprecated syntax (since 3.0.0)
+     *                     |  SimpleType1 TypeArgs
+     *                     |  SimpleType1 `#' id
+     */
+    def simpleType1() = simpleTypeRest {
+      if in.token == LPAREN then
+        atSpan(in.offset) {
+          makeTupleOrParens(inParens(argTypes(namedOK = false, wildOK = true)))
+        }
+      else if in.token == LBRACE then
+        atSpan(in.offset) { RefinedTypeTree(EmptyTree, refinement(indentOK = false)) }
+      else if (isSplice)
+        splice(isType = true)
+      else
+        def singletonCompletion(t: Tree): Tree =
+          if in.token == DOT then
+            in.nextToken()
+            if in.token == TYPE then
+              in.nextToken()
+              atSpan(startOffset(t)) { SingletonTypeTree(t) }
+            else
+              singletonCompletion(selector(t))
+          else convertToTypeId(t)
+        singletonCompletion(simpleRef())
+    }
+
+    private def simpleTypeRest(t: Tree): Tree = in.token match {
+      case HASH => simpleTypeRest(typeProjection(t))
+      case LBRACKET => simpleTypeRest(atSpan(startOffset(t)) {
+        val applied = rejectWildcardType(t)
+        val args = typeArgs(namedOK = false, wildOK = true)
+
+        if (!ctx.settings.YkindProjector.isDefault) {
+          def fail(): Tree = {
+            syntaxError(
+              "λ requires a single argument of the form X => ... or (X, Y) => ...",
+              Span(startOffset(t), in.lastOffset)
+            )
+            AppliedTypeTree(applied, args)
+          }
+
+          applied match {
+            case Ident(tpnme.raw.LAMBDA) =>
+              args match {
+                case List(Function(params, body)) =>
+                  val typeDefs = params.collect {
+                    case param @ Ident(name) => makeKindProjectorTypeDef(name.toTypeName).withSpan(param.span)
+                  }
+                  if (typeDefs.length != params.length) fail()
+                  else LambdaTypeTree(typeDefs, body)
+                case _ =>
+                  fail()
+              }
+            case _ =>
+              val (newArgs, tparams) = replaceKindProjectorPlaceholders(args)
+
+              lambdaAbstract(tparams, AppliedTypeTree(applied, newArgs))
+          }
+
+        } else {
+          AppliedTypeTree(applied, args)
+        }
+      })
+      case _ =>
+        if (!ctx.settings.YkindProjector.isDefault) {
+          t match {
+            case Tuple(params) =>
+              val (newParams, tparams) = replaceKindProjectorPlaceholders(params)
+
+              if (tparams.isEmpty) {
+                t
+              } else {
+                LambdaTypeTree(tparams, Tuple(newParams))
+              }
+            case _ => t
+          }
+        } else {
+          t
+        }
+    }
+
+    private def typeProjection(t: Tree): Tree = {
+      accept(HASH)
+      val id = typeIdent()
+      atSpan(startOffset(t), startOffset(id)) { Select(t, id.name) }
+    }
+
+    /**   ArgTypes          ::=  Type {`,' Type}
+     *                        |  NamedTypeArg {`,' NamedTypeArg}
+     *    NamedTypeArg      ::=  id `=' Type
+     */
+    def argTypes(namedOK: Boolean, wildOK: Boolean): List[Tree] = {
+
+      def argType() = {
+        val t = typ()
+        if (wildOK) t else rejectWildcardType(t)
+      }
+
+      def namedTypeArg() = {
+        val name = ident()
+        accept(EQUALS)
+        NamedArg(name.toTypeName, argType())
+      }
+
+      if (namedOK && in.token == IDENTIFIER)
+        in.currentRegion.withCommasExpected {
+          argType() match {
+            case Ident(name) if in.token == EQUALS =>
+              in.nextToken()
+              commaSeparatedRest(NamedArg(name, argType()), () => namedTypeArg())
+            case firstArg =>
+              commaSeparatedRest(firstArg, () => argType())
+          }
+        }
+      else commaSeparated(() => argType())
+    }
+
+    def paramTypeOf(core: () => Tree): Tree =
+      if in.token == ARROW || isPureArrow(nme.PUREARROW) then
+        val isImpure = in.token == ARROW
+        val tp = atSpan(in.skipToken()) { ByNameTypeTree(core()) }
+        if isImpure && Feature.pureFunsEnabled then ImpureByNameTypeTree(tp) else tp
+      else if in.token == LBRACE && followingIsCaptureSet() then
+        val start = in.offset
+        val cs = captureSet()
+        val endCsOffset = in.lastOffset
+        val startTpOffset = in.offset
+        val tp = paramTypeOf(core)
+        val tp1 = tp match
+          case ImpureByNameTypeTree(tp1) =>
+            syntaxError("explicit captureSet is superfluous for impure call-by-name type", start)
+            tp1
+          case CapturingTypeTree(_, tp1: ByNameTypeTree) =>
+            syntaxError("only one captureSet is allowed here", start)
+            tp1
+          case _: ByNameTypeTree if startTpOffset > endCsOffset =>
+            report.warning(
+              i"""Style: by-name `->` should immediately follow closing `}` of capture set
+                 |to avoid confusion with function type.
+                 |That is, `{c}-> T` instead of `{c} -> T`.""",
+              source.atSpan(Span(startTpOffset, startTpOffset)))
+            tp
+          case _ =>
+            tp
+        CapturingTypeTree(cs, tp1)
+      else
+        core()
+
+    /** FunArgType ::=  Type
+     *               |  `=>' Type
+     *               |  [CaptureSet] `->' Type
+     */
+    val funArgType: () => Tree = () => paramTypeOf(typ)
+
+    /** ParamType  ::=  ParamValueType
+     *               |  `=>' ParamValueType
+     *               |  [CaptureSet] `->' ParamValueType
+     */
+    def paramType(): Tree = paramTypeOf(paramValueType)
+
+    /** ParamValueType ::= Type [`*']
+     */
+    def paramValueType(): Tree = {
+      val t = toplevelTyp()
+      if (isIdent(nme.raw.STAR)) {
+        in.nextToken()
+        atSpan(startOffset(t)) { PostfixOp(t, Ident(tpnme.raw.STAR)) }
+      }
+      else t
+    }
+
+    /** TypeArgs      ::= `[' Type {`,' Type} `]'
+     *  NamedTypeArgs ::= `[' NamedTypeArg {`,' NamedTypeArg} `]'
+     */
+    def typeArgs(namedOK: Boolean, wildOK: Boolean): List[Tree] = inBrackets(argTypes(namedOK, wildOK))
+
+    /** Refinement ::= `{' RefineStatSeq `}'
+     */
+    def refinement(indentOK: Boolean): List[Tree] =
+      if indentOK then
+        inBracesOrIndented(refineStatSeq(), rewriteWithColon = true)
+      else
+        inBraces(refineStatSeq())
+
+    /** TypeBounds ::= [`>:' Type] [`<:' Type]
+     */
+    def typeBounds(): TypeBoundsTree =
+      atSpan(in.offset) { TypeBoundsTree(bound(SUPERTYPE), bound(SUBTYPE)) }
+
+    private def bound(tok: Int): Tree =
+      if (in.token == tok) { in.nextToken(); toplevelTyp() }
+      else EmptyTree
+
+    /** TypeParamBounds   ::=  TypeBounds {`<%' Type} {`:' Type}
+     */
+    def typeParamBounds(pname: TypeName): Tree = {
+      val t = typeBounds()
+      val cbs = contextBounds(pname)
+      if (cbs.isEmpty) t
+      else atSpan((t.span union cbs.head.span).start) { ContextBounds(t, cbs) }
+    }
+
+    def contextBounds(pname: TypeName): List[Tree] =
+      if in.isColon then
+        atSpan(in.skipToken()) {
+          AppliedTypeTree(toplevelTyp(), Ident(pname))
+        } :: contextBounds(pname)
+      else if in.token == VIEWBOUND then
+        report.errorOrMigrationWarning(
+          "view bounds `<%' are no longer supported, use a context bound `:' instead",
+          in.sourcePos(), from = `3.0`)
+        atSpan(in.skipToken()) {
+          Function(Ident(pname) :: Nil, toplevelTyp())
+        } :: contextBounds(pname)
+      else
+        Nil
+
+    def typedOpt(): Tree =
+      if in.isColon then { in.nextToken(); toplevelTyp() }
+      else TypeTree().withSpan(Span(in.lastOffset))
+
+    def typeDependingOn(location: Location): Tree =
+      if location.inParens then typ()
+      else if location.inPattern then rejectWildcardType(refinedType())
+      else if in.token == LBRACE && followingIsCaptureSet() then
+        CapturingTypeTree(captureSet(), infixType())
+      else infixType()
+
+/* ----------- EXPRESSIONS ------------------------------------------------ */
+
+    /** Does the current conditional expression continue after
+     *  the initially parsed (...) region?
+     */
+    def toBeContinued(altToken: Token): Boolean =
+      inline def canContinue =
+        !in.canStartStatTokens.contains(in.token)  // not statement, so take as continued expr
+      || followedByToken(altToken)                 // scan ahead to see whether we find a `then` or `do`
+
+      !in.isNewLine       // a newline token means the expression is finished
+      && !migrateTo3      // old syntax
+      && canContinue
+    end toBeContinued
+
+    def condExpr(altToken: Token): Tree =
+      val t: Tree =
+        if in.token == LPAREN then
+          var t: Tree = atSpan(in.offset) { Parens(inParens(exprInParens())) }
+          if in.token != altToken then
+            if toBeContinued(altToken) then
+              t = inSepRegion(InCond) {
+                expr1Rest(
+                  postfixExprRest(
+                    simpleExprRest(t, Location.ElseWhere),
+                    Location.ElseWhere),
+                  Location.ElseWhere)
+              }
+            else
+              if rewriteToNewSyntax(t.span) then
+                dropParensOrBraces(t.span.start, s"${tokenString(altToken)}")
+              in.observeIndented()
+              return t
+          t
+        else if in.isNestedStart then
+          try expr() finally newLinesOpt()
+        else
+          inSepRegion(InCond)(expr())
+      if rewriteToOldSyntax(t.span.startPos) then revertToParens(t)
+      accept(altToken)
+      t
+
+    /** Expr              ::=  [`implicit'] FunParams (‘=>’ | ‘?=>’) Expr
+     *                      |  HkTypeParamClause ‘=>’ Expr
+     *                      |  Expr1
+     *  FunParams         ::=  Bindings
+     *                      |  id
+     *                      |  `_'
+     *  ExprInParens      ::=  PostfixExpr `:' Type
+     *                      |  Expr
+     *  BlockResult       ::=  [‘implicit’] FunParams (‘=>’ | ‘?=>’) Block
+     *                      |  HkTypeParamClause ‘=>’ Block
+     *                      |  Expr1
+     *  Expr1             ::=  [‘inline’] `if' `(' Expr `)' {nl} Expr [[semi] else Expr]
+     *                      |  [‘inline’] `if' Expr `then' Expr [[semi] else Expr]
+     *                      |  `while' `(' Expr `)' {nl} Expr
+     *                      |  `while' Expr `do' Expr
+     *                      |  `try' Expr Catches [`finally' Expr]
+     *                      |  `try' Expr [`finally' Expr]
+     *                      |  `throw' Expr
+     *                      |  `return' [Expr]
+     *                      |  ForExpr
+     *                      |  [SimpleExpr `.'] id `=' Expr
+     *                      |  PrefixOperator SimpleExpr `=' Expr
+     *                      |  SimpleExpr1 ArgumentExprs `=' Expr
+     *                      |  PostfixExpr [Ascription]
+     *                      |  ‘inline’ InfixExpr MatchClause
+     *  Bindings          ::=  `(' [Binding {`,' Binding}] `)'
+     *  Binding           ::=  (id | `_') [`:' Type]
+     *  Ascription        ::=  `:' [CaptureSet] InfixType
+     *                      |  `:' Annotation {Annotation}
+     *                      |  `:' `_' `*'
+     *  Catches           ::=  ‘catch’ (Expr | ExprCaseClause)
+     */
+    val exprInParens: () => Tree = () => expr(Location.InParens)
+
+    val expr: () => Tree = () => expr(Location.ElseWhere)
+
+    def subExpr() = subPart(expr)
+
+    def expr(location: Location): Tree = {
+      val start = in.offset
+      def isSpecialClosureStart = in.lookahead.isIdent(nme.erased) && in.erasedEnabled
+      in.token match
+        case IMPLICIT =>
+          closure(start, location, modifiers(BitSet(IMPLICIT)))
+        case LPAREN if isSpecialClosureStart =>
+          closure(start, location, Modifiers())
+        case LBRACKET =>
+          val start = in.offset
+          val tparams = typeParamClause(ParamOwner.TypeParam)
+          val arrowOffset = accept(ARROW)
+          val body = expr(location)
+          atSpan(start, arrowOffset) {
+            if (isFunction(body))
+              PolyFunction(tparams, body)
+            else {
+              syntaxError("Implementation restriction: polymorphic function literals must have a value parameter", arrowOffset)
+              errorTermTree(arrowOffset)
+            }
+          }
+        case _ =>
+          val saved = placeholderParams
+          placeholderParams = Nil
+
+          def wrapPlaceholders(t: Tree) = try
+            if (placeholderParams.isEmpty) t
+            else new WildcardFunction(placeholderParams.reverse, t)
+          finally placeholderParams = saved
+
+          val t = expr1(location)
+          if in.isArrow then
+            placeholderParams = Nil // don't interpret `_' to the left of `=>` as placeholder
+            wrapPlaceholders(closureRest(start, location, convertToParams(t)))
+          else if isWildcard(t) then
+            placeholderParams = placeholderParams ::: saved
+            t
+          else wrapPlaceholders(t)
+    }
+
+    def expr1(location: Location = Location.ElseWhere): Tree = in.token match
+      case IF =>
+        ifExpr(in.offset, If)
+      case WHILE =>
+        atSpan(in.skipToken()) {
+          val cond = condExpr(DO)
+          newLinesOpt()
+          val body = subExpr()
+          WhileDo(cond, body)
+        }
+      case DO =>
+        report.errorOrMigrationWarning(
+          i"""`do <body> while <cond>` is no longer supported,
+             |use `while <body> ; <cond> do ()` instead.${rewriteNotice()}""",
+          in.sourcePos(), from = `3.0`)
+        val start = in.skipToken()
+        atSpan(start) {
+          val body = expr()
+          if (isStatSep) in.nextToken()
+          val whileStart = in.offset
+          accept(WHILE)
+          val cond = expr()
+          if migrateTo3 then
+            patch(source, Span(start, start + 2), "while ({")
+            patch(source, Span(whileStart, whileStart + 5), ";")
+            cond match {
+              case Parens(_) =>
+                patch(source, Span(cond.span.start, cond.span.start + 1), "")
+                patch(source, Span(cond.span.end - 1, cond.span.end), "")
+              case _ =>
+            }
+            patch(source, cond.span.endPos, "}) ()")
+          WhileDo(Block(body, cond), Literal(Constant(())))
+        }
+      case TRY =>
+        val tryOffset = in.offset
+        atSpan(in.skipToken()) {
+          val body = expr()
+          val (handler, handlerStart) =
+            if in.token == CATCH then
+              val span = in.offset
+              in.nextToken()
+              (if in.token == CASE then Match(EmptyTree, caseClause(exprOnly = true) :: Nil)
+                else subExpr(),
+                span)
+            else (EmptyTree, -1)
+
+          handler match {
+            case Block(Nil, EmptyTree) =>
+              assert(handlerStart != -1)
+              syntaxErrorOrIncomplete(
+                EmptyCatchBlock(body),
+                Span(handlerStart, endOffset(handler))
+              )
+            case _ =>
+          }
+
+          val finalizer =
+            if (in.token == FINALLY) {
+              in.nextToken();
+              val expr = subExpr()
+              if expr.span.exists then expr
+              else Literal(Constant(())) // finally without an expression
+            }
+            else {
+              if handler.isEmpty then
+                report.warning(
+                  EmptyCatchAndFinallyBlock(body),
+                  source.atSpan(Span(tryOffset, endOffset(body)))
+                )
+              EmptyTree
+            }
+          ParsedTry(body, handler, finalizer)
+        }
+      case THROW =>
+        atSpan(in.skipToken()) { Throw(expr()) }
+      case RETURN =>
+        atSpan(in.skipToken()) {
+          Return(if (isExprIntro) expr() else EmptyTree, EmptyTree)
+        }
+      case FOR =>
+        forExpr()
+      case _ =>
+        if isIdent(nme.inline)
+           && !in.inModifierPosition()
+           && in.canStartExprTokens.contains(in.lookahead.token)
+        then
+          val start = in.skipToken()
+          in.token match
+            case IF =>
+              ifExpr(start, InlineIf)
+            case _ =>
+              postfixExpr() match
+                case t @ Match(scrut, cases) =>
+                  InlineMatch(scrut, cases).withSpan(t.span)
+                case t =>
+                  syntaxError(em"`inline` must be followed by an `if` or a `match`", start)
+                  t
+        else expr1Rest(postfixExpr(location), location)
+    end expr1
+
+    def expr1Rest(t: Tree, location: Location): Tree =
+      if in.token == EQUALS then
+        t match
+          case Ident(_) | Select(_, _) | Apply(_, _) | PrefixOp(_, _) =>
+            atSpan(startOffset(t), in.skipToken()) {
+              val loc = if location.inArgs then location else Location.ElseWhere
+              Assign(t, subPart(() => expr(loc)))
+            }
+          case _ =>
+            t
+      else if in.isColon then
+        in.nextToken()
+        ascription(t, location)
+      else
+        t
+
+    def ascription(t: Tree, location: Location): Tree = atSpan(startOffset(t)) {
+      in.token match {
+        case USCORE if in.lookahead.isIdent(nme.raw.STAR) =>
+          val uscoreStart = in.skipToken()
+          val isVarargSplice = location.inArgs && followingIsVararg()
+          in.nextToken()
+          if isVarargSplice then
+            report.errorOrMigrationWarning(
+              em"The syntax `x: _*` is no longer supported for vararg splices; use `x*` instead${rewriteNotice(`future-migration`)}",
+              in.sourcePos(uscoreStart),
+              future)
+            if sourceVersion == `future-migration` then
+              patch(source, Span(t.span.end, in.lastOffset), " *")
+          else if opStack.nonEmpty then
+            report.errorOrMigrationWarning(
+              em"""`_*` can be used only for last argument of method application.
+                  |It is no longer allowed in operands of infix operations.""",
+              in.sourcePos(uscoreStart), from = `3.0`)
+          else
+            syntaxError(SeqWildcardPatternPos(), uscoreStart)
+          Typed(t, atSpan(uscoreStart) { Ident(tpnme.WILDCARD_STAR) })
+        case AT if !location.inPattern =>
+          annotations().foldLeft(t)(Annotated)
+        case _ =>
+          val tpt = typeDependingOn(location)
+          if (isWildcard(t) && !location.inPattern) {
+            val vd :: rest = placeholderParams: @unchecked
+            placeholderParams =
+              cpy.ValDef(vd)(tpt = tpt).withSpan(vd.span.union(tpt.span)) :: rest
+          }
+          Typed(t, tpt)
+      }
+    }
+
+    /**    `if' `(' Expr `)' {nl} Expr [[semi] else Expr]
+     *     `if' Expr `then' Expr [[semi] else Expr]
+     */
+    def ifExpr(start: Offset, mkIf: (Tree, Tree, Tree) => If): If =
+      atSpan(start, in.skipToken()) {
+        val cond = condExpr(THEN)
+        newLinesOpt()
+        val thenp = subExpr()
+        val elsep = if (in.token == ELSE) { in.nextToken(); subExpr() }
+                    else EmptyTree
+        mkIf(cond, thenp, elsep)
+      }
+
+    /**    MatchClause ::= `match' `{' CaseClauses `}'
+     */
+    def matchClause(t: Tree): Match =
+      atSpan(startOffset(t), in.skipToken()) {
+        Match(t, inBracesOrIndented(caseClauses(() => caseClause())))
+      }
+
+    /**    `match' `{' TypeCaseClauses `}'
+     */
+    def matchType(t: Tree): MatchTypeTree =
+      atSpan(startOffset(t), accept(MATCH)) {
+        MatchTypeTree(EmptyTree, t, inBracesOrIndented(caseClauses(typeCaseClause)))
+      }
+
+    /** FunParams         ::=  Bindings
+     *                     |   id
+     *                     |   `_'
+     *  Bindings          ::=  `(' [[‘erased’] Binding {`,' Binding}] `)'
+     */
+    def funParams(mods: Modifiers, location: Location): List[Tree] =
+      if in.token == LPAREN then
+        in.nextToken()
+        if in.token == RPAREN then
+          Nil
+        else
+          var mods1 = mods
+          if isErased then mods1 = addModifier(mods1)
+          try
+            commaSeparated(() => binding(mods1))
+          finally
+            accept(RPAREN)
+      else {
+        val start = in.offset
+        val name = bindingName()
+        val t =
+          if ((in.token == COLONop || in.token == COLONfollow) && location == Location.InBlock) {
+            report.errorOrMigrationWarning(
+              s"This syntax is no longer supported; parameter needs to be enclosed in (...)${rewriteNotice(`future-migration`)}",
+              source.atSpan(Span(start, in.lastOffset)),
+              from = future)
+            in.nextToken()
+            val t = infixType()
+            if (sourceVersion == `future-migration`) {
+              patch(source, Span(start), "(")
+              patch(source, Span(in.lastOffset), ")")
+            }
+            t
+          }
+          else TypeTree()
+        (atSpan(start) { makeParameter(name, t, mods) }) :: Nil
+      }
+
+    /**  Binding           ::= (id | `_') [`:' Type]
+     */
+    def binding(mods: Modifiers): Tree =
+      atSpan(in.offset) { makeParameter(bindingName(), typedOpt(), mods) }
+
+    def bindingName(): TermName =
+      if (in.token == USCORE) {
+        in.nextToken()
+        WildcardParamName.fresh()
+      }
+      else ident()
+
+    /** Expr         ::= [‘implicit’] FunParams `=>' Expr
+     *  BlockResult  ::= implicit id [`:' InfixType] `=>' Block // Scala2 only
+     */
+    def closure(start: Int, location: Location, implicitMods: Modifiers): Tree =
+      closureRest(start, location, funParams(implicitMods, location))
+
+    def closureRest(start: Int, location: Location, params: List[Tree]): Tree =
+      atSpan(start, in.offset) {
+        if in.token == CTXARROW then
+          if params.isEmpty then
+            syntaxError("context function literals require at least one formal parameter", Span(start, in.lastOffset))
+          in.nextToken()
+        else
+          accept(ARROW)
+        val body =
+          if location == Location.InBlock then block()
+          else if location == Location.InColonArg && in.token == INDENT then blockExpr()
+          else expr()
+        Function(params, body)
+      }
+
+    /** PostfixExpr   ::= InfixExpr [id [nl]]
+     *  InfixExpr     ::= PrefixExpr
+     *                  | InfixExpr id [nl] InfixExpr
+     *                  | InfixExpr id `:` IndentedExpr
+     *                  | InfixExpr MatchClause
+     */
+    def postfixExpr(location: Location = Location.ElseWhere): Tree =
+      val t = postfixExprRest(prefixExpr(location), location)
+      if location.inArgs && followingIsVararg() then
+        Typed(t, atSpan(in.skipToken()) { Ident(tpnme.WILDCARD_STAR) })
+      else
+        t
+
+    def postfixExprRest(t: Tree, location: Location): Tree =
+      infixOps(t, in.canStartExprTokens, prefixExpr, location, ParseKind.Expr,
+        isOperator = !(location.inArgs && followingIsVararg()))
+
+    /** PrefixExpr       ::= [PrefixOperator'] SimpleExpr
+     *  PrefixOperator   ::=  ‘-’ | ‘+’ | ‘~’ | ‘!’ (if not backquoted)
+     */
+    val prefixExpr: Location => Tree = location =>
+      if in.token == IDENTIFIER && nme.raw.isUnary(in.name)
+         && in.canStartExprTokens.contains(in.lookahead.token)
+      then
+        val start = in.offset
+        val op = termIdent()
+        if (op.name == nme.raw.MINUS && isNumericLit)
+          simpleExprRest(literal(start), location, canApply = true)
+        else
+          atSpan(start) { PrefixOp(op, simpleExpr(location)) }
+      else simpleExpr(location)
+
+    /** SimpleExpr    ::= ‘new’ ConstrApp {`with` ConstrApp} [TemplateBody]
+     *                 |  ‘new’ TemplateBody
+     *                 |  BlockExpr
+     *                 |  ExprSplice
+     *                 |  Quoted
+     *                 |  quoteId
+     *                 |  SimpleExpr1 [`_`]
+     *  SimpleExpr1   ::= literal
+     *                 |  xmlLiteral
+     *                 |  SimpleRef
+     *                 |  `(` [ExprsInParens] `)`
+     *                 |  SimpleExpr `.` id
+     *                 |  SimpleExpr `.` MatchClause
+     *                 |  SimpleExpr (TypeArgs | NamedTypeArgs)
+     *                 |  SimpleExpr1 ArgumentExprs
+     *                 |  SimpleExpr1 `:` ColonArgument                   -- under language.experimental.fewerBraces
+     *  ColonArgument ::= indent (CaseClauses | Block) outdent
+     *                 |  FunParams (‘=>’ | ‘?=>’) ColonArgBody
+     *                 |  HkTypeParamClause ‘=>’ ColonArgBody
+     *  ColonArgBody  ::= indent (CaseClauses | Block) outdent
+     *  Quoted        ::= ‘'’ ‘{’ Block ‘}’
+     *                 |  ‘'’ ‘[’ Type ‘]’
+     */
+    def simpleExpr(location: Location): Tree = {
+      var canApply = true
+      val t = in.token match {
+        case XMLSTART =>
+          xmlLiteral()
+        case IDENTIFIER =>
+          if (isSplice) splice(isType = false)
+          else simpleRef()
+        case BACKQUOTED_IDENT | THIS | SUPER =>
+          simpleRef()
+        case USCORE =>
+          val start = in.skipToken()
+          val pname = WildcardParamName.fresh()
+          val param = ValDef(pname, TypeTree(), EmptyTree).withFlags(SyntheticTermParam)
+            .withSpan(Span(start))
+          placeholderParams = param :: placeholderParams
+          atSpan(start) { Ident(pname) }
+        case LPAREN =>
+          atSpan(in.offset) { makeTupleOrParens(inParens(exprsInParensOrBindings())) }
+        case LBRACE | INDENT =>
+          canApply = false
+          blockExpr()
+        case QUOTE =>
+          atSpan(in.skipToken()) {
+            withinStaged(StageKind.Quoted | (if (location.inPattern) StageKind.QuotedPattern else 0)) {
+              Quote {
+                if (in.token == LBRACKET) inBrackets(typ())
+                else stagedBlock()
+              }
+            }
+          }
+        case NEW =>
+          canApply = false
+          newExpr()
+        case MACRO =>
+          val start = in.skipToken()
+          MacroTree(simpleExpr(Location.ElseWhere))
+        case _ =>
+          if isLiteral then
+            literal()
+          else if in.isColon then
+            syntaxError(IllegalStartSimpleExpr(tokenString(in.token)))
+            in.nextToken()
+            simpleExpr(location)
+          else
+            val start = in.lastOffset
+            syntaxErrorOrIncomplete(IllegalStartSimpleExpr(tokenString(in.token)), expectedOffset)
+            errorTermTree(start)
+      }
+      simpleExprRest(t, location, canApply)
+    }
+
+    def simpleExprRest(t: Tree, location: Location, canApply: Boolean = true): Tree =
+      if (canApply) argumentStart()
+      in.token match
+        case DOT =>
+          in.nextToken()
+          simpleExprRest(selectorOrMatch(t), location, canApply = true)
+        case LBRACKET =>
+          val tapp = atSpan(startOffset(t), in.offset) { TypeApply(t, typeArgs(namedOK = true, wildOK = false)) }
+          simpleExprRest(tapp, location, canApply = true)
+        case LPAREN | LBRACE | INDENT if canApply =>
+          val app = atSpan(startOffset(t), in.offset) { mkApply(t, argumentExprs()) }
+          simpleExprRest(app, location, canApply = true)
+        case USCORE =>
+          atSpan(startOffset(t), in.skipToken()) { PostfixOp(t, Ident(nme.WILDCARD)) }
+        case _ =>
+          if in.isColon && location == Location.InParens && followingIsLambdaParams() then
+            t match
+              case id @ Ident(name) =>
+                if name.is(WildcardParamName) then
+                  assert(name == placeholderParams.head.name)
+                  placeholderParams = placeholderParams.tail
+                atSpan(startOffset(id)) {
+                  makeParameter(name.asTermName, typedOpt(), Modifiers(), isBackquoted = isBackquoted(id))
+                }
+              case _ => t
+          else if isColonLambda then
+            val app = atSpan(startOffset(t), in.skipToken()) {
+              Apply(t, expr(Location.InColonArg) :: Nil)
+            }
+            simpleExprRest(app, location, canApply = true)
+          else t
+    end simpleExprRest
+
+    /** SimpleExpr    ::=  ‘new’ ConstrApp {`with` ConstrApp} [TemplateBody]
+     *                  |  ‘new’ TemplateBody
+     */
+    def newExpr(): Tree =
+      val start = in.skipToken()
+      def reposition(t: Tree) = t.withSpan(Span(start, in.lastOffset))
+      possibleTemplateStart()
+      val parents =
+        if in.isNestedStart then Nil
+        else constrApps(exclude = COMMA)
+      possibleTemplateStart(isNew = true)
+      parents match {
+        case parent :: Nil if !in.isNestedStart =>
+          reposition(if (parent.isType) ensureApplied(wrapNew(parent)) else parent)
+        case _ =>
+          New(reposition(templateBodyOpt(emptyConstructor, parents, Nil)))
+      }
+
+    /**   ExprsInParens     ::=  ExprInParens {`,' ExprInParens}
+     *    Bindings          ::=  Binding {`,' Binding}
+     */
+    def exprsInParensOrBindings(): List[Tree] =
+      if in.token == RPAREN then Nil
+      else in.currentRegion.withCommasExpected {
+        var isFormalParams = false
+        def exprOrBinding() =
+          if isFormalParams then binding(Modifiers())
+          else
+            val t = exprInParens()
+            if t.isInstanceOf[ValDef] then isFormalParams = true
+            t
+        commaSeparatedRest(exprOrBinding(), exprOrBinding)
+      }
+
+    /** ParArgumentExprs ::= `(' [‘using’] [ExprsInParens] `)'
+     *                    |  `(' [ExprsInParens `,'] PostfixExpr `*' ')'
+     */
+    def parArgumentExprs(): (List[Tree], Boolean) = inParens {
+      if in.token == RPAREN then
+        (Nil, false)
+      else if isIdent(nme.using) then
+        in.nextToken()
+        (commaSeparated(argumentExpr), true)
+      else
+        (commaSeparated(argumentExpr), false)
+    }
+
+    /** ArgumentExprs ::= ParArgumentExprs
+     *                 |  [nl] BlockExpr
+     */
+    def argumentExprs(): (List[Tree], Boolean) =
+      if (in.isNestedStart) (blockExpr() :: Nil, false) else parArgumentExprs()
+
+    def mkApply(fn: Tree, args: (List[Tree], Boolean)): Tree =
+      val res = Apply(fn, args._1)
+      if args._2 then res.setApplyKind(ApplyKind.Using)
+      res
+
+    val argumentExpr: () => Tree = () => expr(Location.InArgs) match
+      case arg @ Assign(Ident(id), rhs) => cpy.NamedArg(arg)(id, rhs)
+      case arg => arg
+
+    /** ArgumentExprss ::= {ArgumentExprs}
+     */
+    def argumentExprss(fn: Tree): Tree = {
+      argumentStart()
+      if (in.token == LPAREN || in.isNestedStart) argumentExprss(mkApply(fn, argumentExprs()))
+      else fn
+    }
+
+    /** ParArgumentExprss ::= {ParArgumentExprs}
+     *
+     *  Special treatment for arguments to primary constructor annotations.
+     *  (...) is considered an argument only if it does not look like a formal
+     *  parameter list, i.e. does not start with `( <annot>* <mod>* ident : `
+     *  Furthermore, `()` is considered a annotation argument only if it comes first.
+     */
+    def parArgumentExprss(fn: Tree): Tree = {
+      def isLegalAnnotArg: Boolean = {
+        val lookahead = in.LookaheadScanner()
+        (lookahead.token == LPAREN) && {
+          lookahead.nextToken()
+          if (lookahead.token == RPAREN)
+            !fn.isInstanceOf[Trees.Apply[?]] // allow one () as annotation argument
+          else if lookahead.token == IDENTIFIER then
+            lookahead.nextToken()
+            !lookahead.isColon
+          else in.canStartExprTokens.contains(lookahead.token)
+        }
+      }
+      if (in.token == LPAREN && (!inClassConstrAnnots || isLegalAnnotArg))
+        parArgumentExprss(
+          atSpan(startOffset(fn)) { mkApply(fn, parArgumentExprs()) }
+        )
+      else fn
+    }
+
+    /** BlockExpr     ::= <<< (CaseClauses | Block) >>>
+     */
+    def blockExpr(): Tree = atSpan(in.offset) {
+      val simplify = in.token == INDENT
+      inDefScopeBraces {
+        if (in.token == CASE) Match(EmptyTree, caseClauses(() => caseClause()))
+        else block(simplify)
+      }
+    }
+
+    /** Block ::= BlockStatSeq
+     *  @note  Return tree does not have a defined span.
+     */
+    def block(simplify: Boolean = false): Tree = {
+      val stats = blockStatSeq()
+      def isExpr(stat: Tree) = !(stat.isDef || stat.isInstanceOf[Import])
+      if (stats.nonEmpty && isExpr(stats.last)) {
+        val inits = stats.init
+        val last = stats.last
+        if (inits.isEmpty && (simplify || last.isInstanceOf[Block])) last
+        else Block(inits, last)
+      }
+      else Block(stats, EmptyTree)
+    }
+
+    /** Guard ::= if PostfixExpr
+     */
+    def guard(): Tree =
+      if (in.token == IF) { in.nextToken(); postfixExpr(Location.InGuard) }
+      else EmptyTree
+
+    /** Enumerators ::= Generator {semi Enumerator | Guard}
+     */
+    def enumerators(): List[Tree] = generator() :: enumeratorsRest()
+
+    def enumeratorsRest(): List[Tree] =
+      if (isStatSep) {
+        in.nextToken()
+        if (in.token == DO || in.token == YIELD || in.token == RBRACE) Nil
+        else enumerator() :: enumeratorsRest()
+      }
+      else if (in.token == IF)
+        guard() :: enumeratorsRest()
+      else Nil
+
+    /** Enumerator  ::=  Generator
+     *                |  Guard {Guard}
+     *                |  Pattern1 `=' Expr
+     */
+    def enumerator(): Tree =
+      if (in.token == IF) guard()
+      else if (in.token == CASE) generator()
+      else {
+        val pat = pattern1()
+        if (in.token == EQUALS) atSpan(startOffset(pat), in.skipToken()) { GenAlias(pat, subExpr()) }
+        else generatorRest(pat, casePat = false)
+      }
+
+    /** Generator   ::=  [‘case’] Pattern `<-' Expr
+     */
+    def generator(): Tree = {
+      val casePat = if (in.token == CASE) { in.nextToken(); true } else false
+      generatorRest(pattern1(), casePat)
+    }
+
+    def generatorRest(pat: Tree, casePat: Boolean): GenFrom =
+      atSpan(startOffset(pat), accept(LARROW)) {
+        val checkMode =
+          if casePat then GenCheckMode.FilterAlways
+          else if sourceVersion.isAtLeast(`future`) then GenCheckMode.Check
+          else if sourceVersion.isAtLeast(`3.2`) then GenCheckMode.CheckAndFilter
+          else GenCheckMode.FilterNow  // filter on source version < 3.2, for backward compat
+        GenFrom(pat, subExpr(), checkMode)
+      }
+
+    /** ForExpr  ::=  ‘for’ ‘(’ Enumerators ‘)’ {nl} [‘do‘ | ‘yield’] Expr
+     *             |  ‘for’ ‘{’ Enumerators ‘}’ {nl} [‘do‘ | ‘yield’] Expr
+     *             |  ‘for’     Enumerators          (‘do‘ | ‘yield’) Expr
+     */
+    def forExpr(): Tree =
+      atSpan(in.skipToken()) {
+        var wrappedEnums = true
+        val start = in.offset
+        val forEnd = in.lastOffset
+        val leading = in.token
+        val enums =
+          if (leading == LBRACE || leading == LPAREN && followingIsEnclosedGenerators()) {
+            in.nextToken()
+            val res =
+              if (leading == LBRACE || in.token == CASE)
+                enumerators()
+              else {
+                val pats = patternsOpt()
+                val pat =
+                  if (in.token == RPAREN || pats.length > 1) {
+                    wrappedEnums = false
+                    accept(RPAREN)
+                    atSpan(start) { makeTupleOrParens(pats) } // note: alternatives `|' need to be weeded out by typer.
+                  }
+                  else pats.head
+                generatorRest(pat, casePat = false) :: enumeratorsRest()
+              }
+            if (wrappedEnums) {
+              val closingOnNewLine = in.isAfterLineEnd
+              accept(leading + 1)
+              def hasMultiLineEnum =
+                res.exists { t =>
+                  val pos = t.sourcePos
+                  pos.startLine < pos.endLine
+                }
+              if in.newSyntax && in.rewrite && (leading == LBRACE || !hasMultiLineEnum) then
+                // Don't rewrite if that could change meaning of newlines
+                newLinesOpt()
+                dropParensOrBraces(start, if (in.token == YIELD || in.token == DO) "" else "do")
+            }
+            in.observeIndented()
+            res
+          }
+          else {
+            wrappedEnums = false
+
+            if (in.token == INDENT)
+              inBracesOrIndented(enumerators())
+            else {
+              val ts = inSepRegion(InFor)(enumerators())
+              if (rewriteToOldSyntax(Span(start)) && ts.nonEmpty)
+                if (ts.head.sourcePos.startLine != ts.last.sourcePos.startLine) {
+                  patch(source, Span(forEnd), " {")
+                  patch(source, Span(in.offset), "} ")
+                }
+                else {
+                  patch(source, ts.head.span.startPos, "(")
+                  patch(source, ts.last.span.endPos, ")")
+                }
+              ts
+            }
+          }
+        newLinesOpt()
+        if (in.token == YIELD) {
+          in.nextToken()
+          ForYield(enums, subExpr())
+        }
+        else if (in.token == DO) {
+          if (rewriteToOldSyntax()) dropTerminator()
+          in.nextToken()
+          ForDo(enums, subExpr())
+        }
+        else {
+          if (!wrappedEnums) syntaxErrorOrIncomplete(YieldOrDoExpectedInForComprehension())
+          ForDo(enums, expr())
+        }
+      }
+
+    /** CaseClauses         ::= CaseClause {CaseClause}
+     *  TypeCaseClauses     ::= TypeCaseClause {TypeCaseClause}
+     */
+    def caseClauses(clause: () => CaseDef): List[CaseDef] = {
+      val buf = new ListBuffer[CaseDef]
+      buf += clause()
+      while (in.token == CASE) buf += clause()
+      buf.toList
+    }
+
+    /** CaseClause         ::= ‘case’ Pattern [Guard] `=>' Block
+     *  ExprCaseClause    ::=  ‘case’ Pattern [Guard] ‘=>’ Expr
+     */
+    def caseClause(exprOnly: Boolean = false): CaseDef = atSpan(in.offset) {
+      val (pat, grd) = inSepRegion(InCase) {
+        accept(CASE)
+        (pattern(), guard())
+      }
+      CaseDef(pat, grd, atSpan(accept(ARROW)) {
+        if exprOnly then
+          if in.indentSyntax && in.isAfterLineEnd && in.token != INDENT then
+            warning(i"""Misleading indentation: this expression forms part of the preceding catch case.
+                       |If this is intended, it should be indented for clarity.
+                       |Otherwise, if the handler is intended to be empty, use a multi-line catch with
+                       |an indented case.""".toMessage)
+          expr()
+        else block()
+      })
+    }
+
+    /** TypeCaseClause     ::= ‘case’ (InfixType | ‘_’) ‘=>’ Type [semi]
+     */
+    def typeCaseClause(): CaseDef = atSpan(in.offset) {
+      val pat = inSepRegion(InCase) {
+        accept(CASE)
+        in.token match {
+          case USCORE if in.lookahead.isArrow =>
+            val start = in.skipToken()
+            Ident(tpnme.WILDCARD).withSpan(Span(start, in.lastOffset, start))
+          case _ =>
+            rejectWildcardType(infixType())
+        }
+      }
+      CaseDef(pat, EmptyTree, atSpan(accept(ARROW)) {
+        val t = rejectWildcardType(typ())
+        if in.token == SEMI then in.nextToken()
+        newLinesOptWhenFollowedBy(CASE)
+        t
+      })
+    }
+
+    /* -------- PATTERNS ------------------------------------------- */
+
+    /**  Pattern           ::=  Pattern1 { `|' Pattern1 }
+     */
+    def pattern(location: Location = Location.InPattern): Tree =
+      val pat = pattern1(location)
+      if (isIdent(nme.raw.BAR))
+        atSpan(startOffset(pat)) { Alternative(pat :: patternAlts(location)) }
+      else pat
+
+    def patternAlts(location: Location): List[Tree] =
+      if (isIdent(nme.raw.BAR)) { in.nextToken(); pattern1(location) :: patternAlts(location) }
+      else Nil
+
+    /**  Pattern1     ::= Pattern2 [Ascription]
+     */
+    def pattern1(location: Location = Location.InPattern): Tree =
+      val p = pattern2()
+      if in.isColon then
+        in.nextToken()
+        ascription(p, location)
+      else p
+
+    /**  Pattern3    ::=  InfixPattern
+     *                 |  PatVar ‘*’
+     */
+    def pattern3(): Tree =
+      val p = infixPattern()
+      if followingIsVararg() then
+        val start = in.skipToken()
+        p match
+          case p @ Ident(name) if name.isVarPattern =>
+            Typed(p, atSpan(start) { Ident(tpnme.WILDCARD_STAR) })
+          case _ =>
+            syntaxError(em"`*` must follow pattern variable", start)
+            p
+      else p
+
+    /**  Pattern2    ::=  [id `@'] Pattern3
+     */
+    val pattern2: () => Tree = () => pattern3() match
+      case p @ Ident(name) if in.token == AT =>
+        val offset = in.skipToken()
+        pattern3() match {
+          case pt @ Bind(nme.WILDCARD, pt1: Typed) if pt.mods.is(Given) =>
+            atSpan(startOffset(p), 0) { Bind(name, pt1).withMods(pt.mods) }
+          case Typed(Ident(nme.WILDCARD), pt @ Ident(tpnme.WILDCARD_STAR)) =>
+            atSpan(startOffset(p), 0) { Typed(p, pt) }
+          case pt =>
+            atSpan(startOffset(p), 0) { Bind(name, pt) }
+        }
+      case p =>
+        p
+
+    private def warnStarMigration(p: Tree) =
+      report.errorOrMigrationWarning(
+        em"The syntax `x: _*` is no longer supported for vararg splices; use `x*` instead",
+        in.sourcePos(startOffset(p)),
+        from = future)
+
+    /**  InfixPattern ::= SimplePattern {id [nl] SimplePattern}
+     */
+    def infixPattern(): Tree =
+      infixOps(
+        simplePattern(), in.canStartExprTokens, simplePatternFn, Location.InPattern, ParseKind.Pattern,
+        isOperator = in.name != nme.raw.BAR && !followingIsVararg())
+
+    /** SimplePattern    ::= PatVar
+     *                    |  Literal
+     *                    |  Quoted
+     *                    |  XmlPattern
+     *                    |  `(' [Patterns] `)'
+     *                    |  SimplePattern1 [TypeArgs] [ArgumentPatterns]
+     *  SimplePattern1   ::= SimpleRef
+     *                    |  SimplePattern1 `.' id
+     *  PatVar           ::= id
+     *                    |  `_'
+     */
+    def simplePattern(): Tree = in.token match {
+      case IDENTIFIER | BACKQUOTED_IDENT | THIS | SUPER =>
+        simpleRef() match
+          case id @ Ident(nme.raw.MINUS) if isNumericLit => literal(startOffset(id))
+          case t => simplePatternRest(t)
+      case USCORE =>
+        wildcardIdent()
+      case LPAREN =>
+        atSpan(in.offset) { makeTupleOrParens(inParens(patternsOpt())) }
+      case QUOTE =>
+        simpleExpr(Location.InPattern)
+      case XMLSTART =>
+        xmlLiteralPattern()
+      case GIVEN =>
+        atSpan(in.offset) {
+          val givenMod = atSpan(in.skipToken())(Mod.Given())
+          val typed = Typed(Ident(nme.WILDCARD), refinedType())
+          Bind(nme.WILDCARD, typed).withMods(addMod(Modifiers(), givenMod))
+        }
+      case _ =>
+        if (isLiteral) literal(inPattern = true)
+        else {
+          val start = in.lastOffset
+          syntaxErrorOrIncomplete(IllegalStartOfSimplePattern(), expectedOffset)
+          errorTermTree(start)
+        }
+    }
+
+    val simplePatternFn: Location => Tree = _ => simplePattern()
+
+    def simplePatternRest(t: Tree): Tree =
+      if in.token == DOT then
+        in.nextToken()
+        simplePatternRest(selector(t))
+      else
+        var p = t
+        if (in.token == LBRACKET)
+          p = atSpan(startOffset(t), in.offset) { TypeApply(p, typeArgs(namedOK = false, wildOK = false)) }
+        if (in.token == LPAREN)
+          p = atSpan(startOffset(t), in.offset) { Apply(p, argumentPatterns()) }
+        p
+
+    /** Patterns          ::=  Pattern [`,' Pattern]
+     */
+    def patterns(location: Location = Location.InPattern): List[Tree] =
+      commaSeparated(() => pattern(location))
+
+    def patternsOpt(location: Location = Location.InPattern): List[Tree] =
+      if (in.token == RPAREN) Nil else patterns(location)
+
+    /** ArgumentPatterns  ::=  ‘(’ [Patterns] ‘)’
+     *                      |  ‘(’ [Patterns ‘,’] PatVar ‘*’ ‘)’
+     */
+    def argumentPatterns(): List[Tree] =
+      inParens(patternsOpt(Location.InPatternArgs))
+
+/* -------- MODIFIERS and ANNOTATIONS ------------------------------------------- */
+
+    private def modOfToken(tok: Int, name: Name): Mod = tok match {
+      case ABSTRACT    => Mod.Abstract()
+      case FINAL       => Mod.Final()
+      case IMPLICIT    => Mod.Implicit()
+      case GIVEN       => Mod.Given()
+      case LAZY        => Mod.Lazy()
+      case OVERRIDE    => Mod.Override()
+      case PRIVATE     => Mod.Private()
+      case PROTECTED   => Mod.Protected()
+      case SEALED      => Mod.Sealed()
+      case IDENTIFIER =>
+        name match {
+          case nme.erased if in.erasedEnabled => Mod.Erased()
+          case nme.inline => Mod.Inline()
+          case nme.opaque => Mod.Opaque()
+          case nme.open => Mod.Open()
+          case nme.transparent => Mod.Transparent()
+          case nme.infix => Mod.Infix()
+        }
+    }
+
+    /** Drop `private' modifier when followed by a qualifier.
+     *  Contract `abstract' and `override' to ABSOVERRIDE
+     */
+    private def normalize(mods: Modifiers): Modifiers =
+      if (mods.is(Private) && mods.hasPrivateWithin)
+        normalize(mods &~ Private)
+      else if (mods.isAllOf(AbstractOverride))
+        normalize(addFlag(mods &~ AbstractOverride, AbsOverride))
+      else
+        mods
+
+    private def addModifier(mods: Modifiers): Modifiers = {
+      val tok = in.token
+      val name = in.name
+      val mod = atSpan(in.skipToken()) { modOfToken(tok, name) }
+
+      if (mods.isOneOf(mod.flags)) syntaxError(RepeatedModifier(mod.flags.flagsString))
+      addMod(mods, mod)
+    }
+
+    def addFlag(mods: Modifiers, flag: FlagSet): Modifiers =
+      mods.withAddedFlags(flag, Span(in.offset))
+
+    /** Always add the syntactic `mod`, but check and conditionally add semantic `mod.flags`
+     */
+    def addMod(mods: Modifiers, mod: Mod): Modifiers =
+      addFlag(mods, mod.flags).withAddedMod(mod)
+
+    /** AccessQualifier ::= "[" (id | this) "]"
+     */
+    def accessQualifierOpt(mods: Modifiers): Modifiers =
+      if (in.token == LBRACKET) {
+        if (mods.is(Local) || mods.hasPrivateWithin)
+          syntaxError(DuplicatePrivateProtectedQualifier())
+        inBrackets {
+          if in.token == THIS then
+            if sourceVersion.isAtLeast(future) then
+              deprecationWarning(
+                "The [this] qualifier will be deprecated in the future; it should be dropped.".toMessage)
+            in.nextToken()
+            mods | Local
+          else mods.withPrivateWithin(ident().toTypeName)
+        }
+      }
+      else mods
+
+    /** {Annotation} {Modifier}
+     *  Modifiers      ::= {Modifier}
+     *  LocalModifiers ::= {LocalModifier}
+     *  AccessModifier ::= (private | protected) [AccessQualifier]
+     *  Modifier       ::= LocalModifier
+     *                  |  AccessModifier
+     *                  |  override
+     *                  |  opaque
+     *  LocalModifier  ::= abstract | final | sealed | open | implicit | lazy | erased | inline | transparent
+     */
+    def modifiers(allowed: BitSet = modifierTokens, start: Modifiers = Modifiers()): Modifiers = {
+      @tailrec
+      def loop(mods: Modifiers): Modifiers =
+        if allowed.contains(in.token)
+           || in.isSoftModifier
+              && localModifierTokens.subsetOf(allowed) // soft modifiers are admissible everywhere local modifiers are
+              && !in.lookahead.isColon
+        then
+          val isAccessMod = accessModifierTokens contains in.token
+          val mods1 = addModifier(mods)
+          loop(if (isAccessMod) accessQualifierOpt(mods1) else mods1)
+        else if (in.isNewLine && (mods.hasFlags || mods.hasAnnotations)) {
+          in.nextToken()
+          loop(mods)
+        }
+        else
+          mods
+      normalize(loop(start))
+    }
+
+    /** Wrap annotation or constructor in New(...).<init> */
+    def wrapNew(tpt: Tree): Select = Select(New(tpt), nme.CONSTRUCTOR)
+
+    /** Adjust start of annotation or constructor to offset of preceding @ or new */
+    def adjustStart(start: Offset)(tree: Tree): Tree = {
+      val tree1 = tree match {
+        case Apply(fn, args) => cpy.Apply(tree)(adjustStart(start)(fn), args)
+        case Select(qual, name) => cpy.Select(tree)(adjustStart(start)(qual), name)
+        case _ => tree
+      }
+      if (tree1.span.exists && start < tree1.span.start)
+        tree1.withSpan(tree1.span.withStart(start))
+      else tree1
+    }
+
+    /** Annotation        ::=  `@' SimpleType1 {ParArgumentExprs}
+     */
+    def annot(): Tree =
+      adjustStart(accept(AT)) {
+        ensureApplied(parArgumentExprss(wrapNew(simpleType1())))
+      }
+
+    def annotations(skipNewLines: Boolean = false): List[Tree] = {
+      if (skipNewLines) newLinesOptWhenFollowedBy(AT)
+      if (in.token == AT) annot() :: annotations(skipNewLines)
+      else Nil
+    }
+
+    def annotsAsMods(skipNewLines: Boolean = false): Modifiers =
+      Modifiers() withAnnotations annotations(skipNewLines)
+
+    def defAnnotsMods(allowed: BitSet): Modifiers =
+      modifiers(allowed, annotsAsMods(skipNewLines = true))
+
+ /* -------- PARAMETERS ------------------------------------------- */
+
+    /** ClsTypeParamClause::=  ‘[’ ClsTypeParam {‘,’ ClsTypeParam} ‘]’
+     *  ClsTypeParam      ::=  {Annotation} [‘+’ | ‘-’]
+     *                         id [HkTypeParamClause] TypeParamBounds
+     *
+     *  DefTypeParamClause::=  ‘[’ DefTypeParam {‘,’ DefTypeParam} ‘]’
+     *  DefTypeParam      ::=  {Annotation} id [HkTypeParamClause] TypeParamBounds
+     *
+     *  TypTypeParamClause::=  ‘[’ TypTypeParam {‘,’ TypTypeParam} ‘]’
+     *  TypTypeParam      ::=  {Annotation} id [HkTypePamClause] TypeBounds
+     *
+     *  HkTypeParamClause ::=  ‘[’ HkTypeParam {‘,’ HkTypeParam} ‘]’
+     *  HkTypeParam       ::=  {Annotation} [‘+’ | ‘-’] (id [HkTypePamClause] | ‘_’) TypeBounds
+     */
+    def typeParamClause(ownerKind: ParamOwner): List[TypeDef] = inBrackets {
+
+      def variance(vflag: FlagSet): FlagSet =
+        if ownerKind == ParamOwner.Def || ownerKind == ParamOwner.TypeParam then
+          syntaxError(i"no `+/-` variance annotation allowed here")
+          in.nextToken()
+          EmptyFlags
+        else
+          in.nextToken()
+          vflag
+
+      def typeParam(): TypeDef = {
+        val isAbstractOwner = ownerKind == ParamOwner.Type || ownerKind == ParamOwner.TypeParam
+        val start = in.offset
+        val mods =
+          annotsAsMods()
+          | (if (ownerKind == ParamOwner.Class) Param | PrivateLocal else Param)
+          | (if isIdent(nme.raw.PLUS) then variance(Covariant)
+             else if isIdent(nme.raw.MINUS) then variance(Contravariant)
+             else EmptyFlags)
+        atSpan(start, nameStart) {
+          val name =
+            if (isAbstractOwner && in.token == USCORE) {
+              in.nextToken()
+              WildcardParamName.fresh().toTypeName
+            }
+            else ident().toTypeName
+          val hkparams = typeParamClauseOpt(ParamOwner.Type)
+          val bounds = if (isAbstractOwner) typeBounds() else typeParamBounds(name)
+          TypeDef(name, lambdaAbstract(hkparams, bounds)).withMods(mods)
+        }
+      }
+      commaSeparated(() => typeParam())
+    }
+
+    def typeParamClauseOpt(ownerKind: ParamOwner): List[TypeDef] =
+      if (in.token == LBRACKET) typeParamClause(ownerKind) else Nil
+
+    /** ContextTypes   ::=  FunArgType {‘,’ FunArgType}
+     */
+    def contextTypes(ofClass: Boolean, nparams: Int, impliedMods: Modifiers): List[ValDef] =
+      val tps = commaSeparated(funArgType)
+      var counter = nparams
+      def nextIdx = { counter += 1; counter }
+      val paramFlags = if ofClass then LocalParamAccessor else Param
+      tps.map(makeSyntheticParameter(nextIdx, _, paramFlags | Synthetic | impliedMods.flags))
+
+    /** ClsParamClause    ::=  ‘(’ [‘erased’] ClsParams ‘)’ | UsingClsParamClause
+     *  UsingClsParamClause::= ‘(’ ‘using’ [‘erased’] (ClsParams | ContextTypes) ‘)’
+     *  ClsParams         ::=  ClsParam {‘,’ ClsParam}
+     *  ClsParam          ::=  {Annotation}
+     *
+     *  DefParamClause    ::=  ‘(’ [‘erased’] DefParams ‘)’ | UsingParamClause
+     *  UsingParamClause  ::=  ‘(’ ‘using’ [‘erased’] (DefParams | ContextTypes) ‘)’
+     *  DefParams         ::=  DefParam {‘,’ DefParam}
+     *  DefParam          ::=  {Annotation} [‘inline’] Param
+     *
+     *  Param             ::=  id `:' ParamType [`=' Expr]
+     *
+     *  @return   the list of parameter definitions
+     */
+    def paramClause(nparams: Int,                            // number of parameters preceding this clause
+                    ofClass: Boolean = false,                // owner is a class
+                    ofCaseClass: Boolean = false,            // owner is a case class
+                    prefix: Boolean = false,                 // clause precedes name of an extension method
+                    givenOnly: Boolean = false,              // only given parameters allowed
+                    firstClause: Boolean = false             // clause is the first in regular list of clauses
+                   ): List[ValDef] = {
+      var impliedMods: Modifiers = EmptyModifiers
+
+      def addParamMod(mod: () => Mod) = impliedMods = addMod(impliedMods, atSpan(in.skipToken()) { mod() })
+
+      def paramMods() =
+        if in.token == IMPLICIT then
+          addParamMod(() => Mod.Implicit())
+        else
+          if isIdent(nme.using) then
+            addParamMod(() => Mod.Given())
+          if isErased then
+            addParamMod(() => Mod.Erased())
+
+      def param(): ValDef = {
+        val start = in.offset
+        var mods = impliedMods.withAnnotations(annotations())
+        if (ofClass) {
+          mods = addFlag(modifiers(start = mods), ParamAccessor)
+          mods =
+            if in.token == VAL then
+              in.nextToken()
+              mods
+            else if in.token == VAR then
+              val mod = atSpan(in.skipToken()) { Mod.Var() }
+              addMod(mods, mod)
+            else
+              if (!(mods.flags &~ (ParamAccessor | Inline | impliedMods.flags)).isEmpty)
+                syntaxError("`val` or `var` expected")
+              if (firstClause && ofCaseClass) mods
+              else mods | PrivateLocal
+        }
+        else {
+          if (isIdent(nme.inline) && in.isSoftModifierInParamModifierPosition)
+            mods = addModifier(mods)
+          mods |= Param
+        }
+        atSpan(start, nameStart) {
+          val name = ident()
+          acceptColon()
+          if (in.token == ARROW && ofClass && !mods.is(Local))
+            syntaxError(VarValParametersMayNotBeCallByName(name, mods.is(Mutable)))
+              // needed?, it's checked later anyway
+          val tpt = paramType()
+          val default =
+            if (in.token == EQUALS) { in.nextToken(); subExpr() }
+            else EmptyTree
+          if (impliedMods.mods.nonEmpty)
+            impliedMods = impliedMods.withMods(Nil) // keep only flags, so that parameter positions don't overlap
+          ValDef(name, tpt, default).withMods(mods)
+        }
+      }
+
+      def checkVarArgsRules(vparams: List[ValDef]): Unit = vparams match {
+        case Nil =>
+        case _ :: Nil if !prefix =>
+        case vparam :: rest =>
+          vparam.tpt match {
+            case PostfixOp(_, op) if op.name == tpnme.raw.STAR =>
+              syntaxError(VarArgsParamMustComeLast(), vparam.tpt.span)
+            case _ =>
+          }
+          checkVarArgsRules(rest)
+      }
+
+      // begin paramClause
+      inParens {
+        if in.token == RPAREN && !prefix && !impliedMods.is(Given) then Nil
+        else
+          val clause =
+            if prefix && !isIdent(nme.using) && !isIdent(nme.erased) then param() :: Nil
+            else
+              paramMods()
+              if givenOnly && !impliedMods.is(Given) then
+                syntaxError("`using` expected")
+              val isParams =
+                !impliedMods.is(Given)
+                || startParamTokens.contains(in.token)
+                || isIdent && (in.name == nme.inline || in.lookahead.isColon)
+              if isParams then commaSeparated(() => param())
+              else contextTypes(ofClass, nparams, impliedMods)
+          checkVarArgsRules(clause)
+          clause
+      }
+    }
+
+    /** ClsParamClauses   ::=  {ClsParamClause} [[nl] ‘(’ [‘implicit’] ClsParams ‘)’]
+     *  DefParamClauses   ::=  {DefParamClause} [[nl] ‘(’ [‘implicit’] DefParams ‘)’]
+     *
+     *  @return  The parameter definitions
+     */
+    def paramClauses(ofClass: Boolean = false,
+                     ofCaseClass: Boolean = false,
+                     givenOnly: Boolean = false,
+                     numLeadParams: Int = 0): List[List[ValDef]] =
+
+      def recur(firstClause: Boolean, nparams: Int): List[List[ValDef]] =
+        newLineOptWhenFollowedBy(LPAREN)
+        if in.token == LPAREN then
+          val paramsStart = in.offset
+          val params = paramClause(
+              nparams,
+              ofClass = ofClass,
+              ofCaseClass = ofCaseClass,
+              givenOnly = givenOnly,
+              firstClause = firstClause)
+          val lastClause = params.nonEmpty && params.head.mods.flags.is(Implicit)
+          params :: (
+            if lastClause then Nil
+            else recur(firstClause = false, nparams + params.length))
+        else Nil
+      end recur
+
+      recur(firstClause = true, numLeadParams)
+    end paramClauses
+
+/* -------- DEFS ------------------------------------------- */
+
+    def finalizeDef(md: MemberDef, mods: Modifiers, start: Int): md.ThisTree[Untyped] =
+      md.withMods(mods).setComment(in.getDocComment(start))
+
+    type ImportConstr = (Tree, List[ImportSelector]) => Tree
+
+    /** Import  ::= `import' ImportExpr {‘,’ ImportExpr}
+     *  Export  ::= `export' ImportExpr {‘,’ ImportExpr}
+     */
+    def importOrExportClause(leading: Token, mkTree: ImportConstr): List[Tree] = {
+      val offset = accept(leading)
+      commaSeparated(importExpr(mkTree)) match {
+        case t :: rest =>
+          // The first import should start at the start offset of the keyword.
+          val firstPos =
+            if (t.span.exists) t.span.withStart(offset)
+            else Span(offset, in.lastOffset)
+          t.withSpan(firstPos) :: rest
+        case nil => nil
+      }
+    }
+
+    def exportClause() =
+      importOrExportClause(EXPORT, Export(_,_))
+
+    def importClause(outermost: Boolean = false) =
+      importOrExportClause(IMPORT, mkImport(outermost))
+
+    /** Create an import node and handle source version imports */
+    def mkImport(outermost: Boolean = false): ImportConstr = (tree, selectors) =>
+      val imp = Import(tree, selectors)
+      languageImport(tree) match
+        case Some(prefix) =>
+          in.languageImportContext = in.languageImportContext.importContext(imp, NoSymbol)
+          for case ImportSelector(id @ Ident(imported), EmptyTree, _) <- selectors do
+            if Feature.handleGlobalLanguageImport(prefix, imported) && !outermost then
+              syntaxError(i"this language import is only allowed at the toplevel", id.span)
+            if allSourceVersionNames.contains(imported) && prefix.isEmpty then
+              if !outermost then
+                syntaxError(i"source version import is only allowed at the toplevel", id.span)
+              else if ctx.compilationUnit.sourceVersion.isDefined then
+                syntaxError(i"duplicate source version import", id.span)
+              else if illegalSourceVersionNames.contains(imported) then
+                val candidate =
+                  val nonMigration = imported.toString.replace("-migration", "")
+                  validSourceVersionNames.find(_.show == nonMigration)
+                val baseMsg = i"`$imported` is not a valid source version"
+                val msg = candidate match
+                  case Some(member) => i"$baseMsg, did you mean language.`$member`?"
+                  case _ => baseMsg
+                syntaxError(msg, id.span)
+              else
+                ctx.compilationUnit.sourceVersion = Some(SourceVersion.valueOf(imported.toString))
+        case None =>
+      imp
+
+    /** ImportExpr       ::=  SimpleRef {‘.’ id} ‘.’ ImportSpec
+     *                     |  SimpleRef ‘as’ id
+     *  ImportSpec       ::=  NamedSelector
+     *                     |  WildcardSelector
+     *                     | ‘{’ ImportSelectors ‘}’
+     *  ImportSelectors  ::=  NamedSelector [‘,’ ImportSelectors]
+     *                     |  WildCardSelector {‘,’ WildCardSelector}
+     *  NamedSelector    ::=  id [‘as’ (id | ‘_’)]
+     *  WildCardSelector ::=  ‘*' | ‘given’ [InfixType]
+     */
+    def importExpr(mkTree: ImportConstr): () => Tree =
+
+      /** ‘*' | ‘_' */
+      def wildcardSelector() =
+        if in.token == USCORE && sourceVersion.isAtLeast(future) then
+          report.errorOrMigrationWarning(
+            em"`_` is no longer supported for a wildcard import; use `*` instead${rewriteNotice(`future-migration`)}",
+            in.sourcePos(),
+            from = future)
+          patch(source, Span(in.offset, in.offset + 1), "*")
+        ImportSelector(atSpan(in.skipToken()) { Ident(nme.WILDCARD) })
+
+      /** 'given [InfixType]' */
+      def givenSelector() =
+        ImportSelector(
+          atSpan(in.skipToken()) { Ident(nme.EMPTY) },
+          bound =
+            if canStartInfixTypeTokens.contains(in.token) then rejectWildcardType(infixType())
+            else EmptyTree)
+
+      /** id [‘as’ (id | ‘_’) */
+      def namedSelector(from: Ident) =
+        if in.token == ARROW || isIdent(nme.as) then
+          if in.token == ARROW && sourceVersion.isAtLeast(future) then
+            report.errorOrMigrationWarning(
+              em"The import renaming `a => b` is no longer supported ; use `a as b` instead${rewriteNotice(`future-migration`)}",
+              in.sourcePos(),
+              from = future)
+            patch(source, Span(in.offset, in.offset + 2),
+                if testChar(in.offset - 1, ' ') && testChar(in.offset + 2, ' ') then "as"
+                else " as ")
+          atSpan(startOffset(from), in.skipToken()) {
+            val to = if in.token == USCORE then wildcardIdent() else termIdent()
+            ImportSelector(from, if to.name == nme.ERROR then EmptyTree else to)
+          }
+        else ImportSelector(from)
+
+      def importSelector(idOK: Boolean): ImportSelector =
+        atSpan(in.offset) {
+          in.token match
+            case USCORE => wildcardSelector()
+            case GIVEN => givenSelector()
+            case _ =>
+              if isIdent(nme.raw.STAR) then wildcardSelector()
+              else
+                if !idOK then syntaxError(i"named imports cannot follow wildcard imports")
+                namedSelector(termIdent())
+        }
+
+      def importSelectors(): List[ImportSelector] =
+        var idOK = true
+        commaSeparated { () =>
+          val isWildcard = in.token == USCORE || in.token == GIVEN || isIdent(nme.raw.STAR)
+          try importSelector(idOK)
+          finally idOK &= !isWildcard
+        }
+
+      def importSelection(qual: Tree): Tree =
+        if in.isIdent(nme.as) && qual.isInstanceOf[RefTree] then
+          qual match
+            case Select(qual1, name) =>
+              val from = Ident(name).withSpan(Span(qual.span.point, qual.span.end, 0))
+              mkTree(qual1, namedSelector(from) :: Nil)
+            case qual: Ident =>
+              mkTree(EmptyTree, namedSelector(qual) :: Nil)
+        else
+          accept(DOT)
+          in.token match
+            case USCORE =>
+              mkTree(qual, wildcardSelector() :: Nil)
+            case GIVEN =>
+              mkTree(qual, givenSelector() :: Nil)
+            case LBRACE =>
+              mkTree(qual, inBraces(importSelectors()))
+            case _ =>
+              if isIdent(nme.raw.STAR) then
+                mkTree(qual, wildcardSelector() :: Nil)
+              else
+                val start = in.offset
+                val name = ident()
+                if in.token == DOT then
+                  importSelection(atSpan(startOffset(qual), start) { Select(qual, name) })
+                else
+                  mkTree(qual, namedSelector(atSpan(start) { Ident(name) }) :: Nil)
+      end importSelection
+
+      () => atSpan(in.offset) { importSelection(simpleRef()) }
+    end importExpr
+
+    /** Def      ::= val PatDef
+     *             | var VarDef
+     *             | def DefDef
+     *             | type {nl} TypeDcl
+     *             | TmplDef
+     *  Dcl      ::= val ValDcl
+     *             | var ValDcl
+     *             | def DefDcl
+     *             | type {nl} TypeDcl
+     *  EnumCase ::= `case' (id ClassConstr [`extends' ConstrApps]] | ids)
+     */
+    def defOrDcl(start: Int, mods: Modifiers): Tree = in.token match {
+      case VAL =>
+        in.nextToken()
+        patDefOrDcl(start, mods)
+      case VAR =>
+        val mod = atSpan(in.skipToken()) { Mod.Var() }
+        val mod1 = addMod(mods, mod)
+        patDefOrDcl(start, mod1)
+      case DEF =>
+        defDefOrDcl(start, in.skipToken(mods))
+      case TYPE =>
+        typeDefOrDcl(start, in.skipToken(mods))
+      case CASE if inEnum =>
+        enumCase(start, mods)
+      case _ =>
+        tmplDef(start, mods)
+    }
+
+    /** PatDef  ::=  ids [‘:’ Type] ‘=’ Expr
+     *            |  Pattern2 [‘:’ Type] ‘=’ Expr
+     *  VarDef  ::=  PatDef
+     *            | id {`,' id} `:' Type `=' `_' (deprecated in 3.x)
+     *  ValDcl  ::=  id {`,' id} `:' Type
+     *  VarDcl  ::=  id {`,' id} `:' Type
+     */
+    def patDefOrDcl(start: Offset, mods: Modifiers): Tree = atSpan(start, nameStart) {
+      val first = pattern2()
+      var lhs = first match {
+        case id: Ident if in.token == COMMA =>
+          in.nextToken()
+          id :: commaSeparated(() => termIdent())
+        case _ =>
+          first :: Nil
+      }
+      val tpt = typedOpt()
+      val rhs =
+        if tpt.isEmpty || in.token == EQUALS then
+          accept(EQUALS)
+          val rhsOffset = in.offset
+          subExpr() match
+            case rhs0 @ Ident(name) if placeholderParams.nonEmpty && name == placeholderParams.head.name
+                && !tpt.isEmpty && mods.is(Mutable) && lhs.forall(_.isInstanceOf[Ident]) =>
+              if sourceVersion.isAtLeast(future) then
+                deprecationWarning(
+                  em"""`= _` has been deprecated; use `= uninitialized` instead.
+                      |`uninitialized` can be imported with `scala.compiletime.uninitialized`.""".toMessage,
+                  rhsOffset)
+              placeholderParams = placeholderParams.tail
+              atSpan(rhs0.span) { Ident(nme.WILDCARD) }
+            case rhs0 => rhs0
+        else EmptyTree
+      lhs match {
+        case IdPattern(id, t) :: Nil if t.isEmpty =>
+          val vdef = ValDef(id.name.asTermName, tpt, rhs)
+          if (isBackquoted(id)) vdef.pushAttachment(Backquoted, ())
+          finalizeDef(vdef, mods, start)
+        case _ =>
+          def isAllIds = lhs.forall {
+            case IdPattern(id, t) => t.isEmpty
+            case _ => false
+          }
+          val rhs2 =
+            if rhs.isEmpty && !isAllIds then
+              val start = in.lastOffset
+              syntaxError(ExpectedTokenButFound(EQUALS, in.token), Span(in.lastOffset))
+              errorTermTree(start)
+            else
+              rhs
+          PatDef(mods, lhs, tpt, rhs2)
+      }
+    }
+
+    /** DefDef  ::=  DefSig [‘:’ Type] ‘=’ Expr
+     *            |  this ParamClause ParamClauses `=' ConstrExpr
+     *  DefDcl  ::=  DefSig `:' Type
+     *  DefSig  ::=  id [DefTypeParamClause] DefParamClauses
+     *            |  ExtParamClause [nl] [‘.’] id DefParamClauses
+     */
+    def defDefOrDcl(start: Offset, mods: Modifiers, numLeadParams: Int = 0): DefDef = atSpan(start, nameStart) {
+
+      def scala2ProcedureSyntax(resultTypeStr: String) =
+        def toInsert =
+          if in.token == LBRACE then s"$resultTypeStr ="
+          else ": Unit "  // trailing space ensures that `def f()def g()` works.
+        if migrateTo3 then
+          report.errorOrMigrationWarning(
+            s"Procedure syntax no longer supported; `$toInsert` should be inserted here",
+            in.sourcePos(), from = `3.0`)
+          patch(source, Span(in.lastOffset), toInsert)
+          true
+        else
+          false
+
+      if (in.token == THIS) {
+        in.nextToken()
+        val vparamss = paramClauses(numLeadParams = numLeadParams)
+        if (vparamss.isEmpty || vparamss.head.take(1).exists(_.mods.isOneOf(GivenOrImplicit)))
+          in.token match {
+            case LBRACKET   => syntaxError("no type parameters allowed here")
+            case EOF        => incompleteInputError(AuxConstructorNeedsNonImplicitParameter())
+            case _          => syntaxError(AuxConstructorNeedsNonImplicitParameter(), nameStart)
+          }
+        if (migrateTo3) newLineOptWhenFollowedBy(LBRACE)
+        val rhs = {
+          if (!(in.token == LBRACE && scala2ProcedureSyntax(""))) accept(EQUALS)
+          atSpan(in.offset) { subPart(constrExpr) }
+        }
+        makeConstructor(Nil, vparamss, rhs).withMods(mods).setComment(in.getDocComment(start))
+      }
+      else {
+        val mods1 = addFlag(mods, Method)
+        val ident = termIdent()
+        var name = ident.name.asTermName
+        val tparams = typeParamClauseOpt(ParamOwner.Def)
+        val vparamss = paramClauses(numLeadParams = numLeadParams)
+        var tpt = fromWithinReturnType { typedOpt() }
+        if (migrateTo3) newLineOptWhenFollowedBy(LBRACE)
+        val rhs =
+          if in.token == EQUALS then
+            in.nextToken()
+            subExpr()
+          else if !tpt.isEmpty then
+            EmptyTree
+          else if scala2ProcedureSyntax(": Unit") then
+            tpt = scalaUnit
+            if (in.token == LBRACE) expr()
+            else EmptyTree
+          else
+            if (!isExprIntro) syntaxError(MissingReturnType(), in.lastOffset)
+            accept(EQUALS)
+            expr()
+
+        val ddef = DefDef(name, joinParams(tparams, vparamss), tpt, rhs)
+        if (isBackquoted(ident)) ddef.pushAttachment(Backquoted, ())
+        finalizeDef(ddef, mods1, start)
+      }
+    }
+
+    /** ConstrExpr      ::=  SelfInvocation
+     *                    |  `{' SelfInvocation {semi BlockStat} `}'
+     */
+    val constrExpr: () => Tree = () =>
+      if in.isNestedStart then
+        atSpan(in.offset) {
+          inBracesOrIndented {
+            val stats = selfInvocation() :: (
+              if (isStatSep) { in.nextToken(); blockStatSeq() }
+              else Nil)
+            Block(stats, Literal(Constant(())))
+          }
+        }
+      else Block(selfInvocation() :: Nil, Literal(Constant(())))
+
+    /** SelfInvocation  ::= this ArgumentExprs {ArgumentExprs}
+     */
+    def selfInvocation(): Tree =
+      atSpan(accept(THIS)) {
+        argumentStart()
+        argumentExprss(mkApply(Ident(nme.CONSTRUCTOR), argumentExprs()))
+      }
+
+    /** TypeDcl ::=  id [TypeParamClause] {FunParamClause} TypeBounds [‘=’ Type]
+     */
+    def typeDefOrDcl(start: Offset, mods: Modifiers): Tree = {
+      newLinesOpt()
+      atSpan(start, nameStart) {
+        val nameIdent = typeIdent()
+        val tparams = typeParamClauseOpt(ParamOwner.Type)
+        val vparamss = funParamClauses()
+        def makeTypeDef(rhs: Tree): Tree = {
+          val rhs1 = lambdaAbstractAll(tparams :: vparamss, rhs)
+          val tdef = TypeDef(nameIdent.name.toTypeName, rhs1)
+          if (nameIdent.isBackquoted)
+            tdef.pushAttachment(Backquoted, ())
+          finalizeDef(tdef, mods, start)
+        }
+        in.token match {
+          case EQUALS =>
+            in.nextToken()
+            makeTypeDef(toplevelTyp())
+          case SUBTYPE | SUPERTYPE =>
+            val bounds = typeBounds()
+            if (in.token == EQUALS) {
+              val eqOffset = in.skipToken()
+              var rhs = toplevelTyp()
+              rhs match {
+                case mtt: MatchTypeTree =>
+                  bounds match {
+                    case TypeBoundsTree(EmptyTree, upper, _) =>
+                      rhs = MatchTypeTree(upper, mtt.selector, mtt.cases)
+                    case _ =>
+                      syntaxError(i"cannot combine lower bound and match type alias", eqOffset)
+                  }
+                case _ =>
+                  if mods.is(Opaque) then
+                    rhs = TypeBoundsTree(bounds.lo, bounds.hi, rhs)
+                  else
+                    syntaxError(i"cannot combine bound and alias", eqOffset)
+              }
+              makeTypeDef(rhs)
+            }
+            else makeTypeDef(bounds)
+          case SEMI | NEWLINE | NEWLINES | COMMA | RBRACE | OUTDENT | EOF =>
+            makeTypeDef(typeBounds())
+          case _ =>
+            syntaxErrorOrIncomplete(ExpectedTypeBoundOrEquals(in.token))
+            return EmptyTree // return to avoid setting the span to EmptyTree
+        }
+      }
+    }
+
+    /** TmplDef ::=  ([‘case’] ‘class’ | ‘trait’) ClassDef
+     *            |  [‘case’] ‘object’ ObjectDef
+     *            |  ‘enum’ EnumDef
+     *            |  ‘given’ GivenDef
+     */
+    def tmplDef(start: Int, mods: Modifiers): Tree =
+      in.token match {
+        case TRAIT =>
+          classDef(start, in.skipToken(addFlag(mods, Trait)))
+        case CLASS =>
+          classDef(start, in.skipToken(mods))
+        case CASECLASS =>
+          classDef(start, in.skipToken(mods | Case))
+        case OBJECT =>
+          objectDef(start, in.skipToken(mods | Module))
+        case CASEOBJECT =>
+          objectDef(start, in.skipToken(mods | Case | Module))
+        case ENUM =>
+          enumDef(start, in.skipToken(mods | Enum))
+        case GIVEN =>
+          givenDef(start, mods, atSpan(in.skipToken()) { Mod.Given() })
+        case _ =>
+          val start = in.lastOffset
+          syntaxErrorOrIncomplete(ExpectedStartOfTopLevelDefinition())
+          mods.annotations match {
+            case head :: Nil => head
+            case Nil => EmptyTree
+            case all => Block(all, errorTermTree(start))
+          }
+      }
+
+    /** ClassDef ::= id ClassConstr TemplateOpt
+     */
+    def classDef(start: Offset, mods: Modifiers): TypeDef = atSpan(start, nameStart) {
+      classDefRest(start, mods, ident().toTypeName)
+    }
+
+    def classDefRest(start: Offset, mods: Modifiers, name: TypeName): TypeDef =
+      val constr = classConstr(isCaseClass = mods.is(Case))
+      val templ = templateOpt(constr)
+      finalizeDef(TypeDef(name, templ), mods, start)
+
+    /** ClassConstr ::= [ClsTypeParamClause] [ConstrMods] ClsParamClauses
+     */
+    def classConstr(isCaseClass: Boolean = false): DefDef = atSpan(in.lastOffset) {
+      val tparams = typeParamClauseOpt(ParamOwner.Class)
+      val cmods = fromWithinClassConstr(constrModsOpt())
+      val vparamss = paramClauses(ofClass = true, ofCaseClass = isCaseClass)
+      makeConstructor(tparams, vparamss).withMods(cmods)
+    }
+
+    /** ConstrMods        ::=  {Annotation} [AccessModifier]
+     */
+    def constrModsOpt(): Modifiers =
+      modifiers(accessModifierTokens, annotsAsMods())
+
+    /** ObjectDef       ::= id TemplateOpt
+     */
+    def objectDef(start: Offset, mods: Modifiers): ModuleDef = atSpan(start, nameStart) {
+      val name = ident()
+      val templ = templateOpt(emptyConstructor)
+      finalizeDef(ModuleDef(name, templ), mods, start)
+    }
+
+    private def checkAccessOnly(mods: Modifiers, where: String): Modifiers =
+      val mods1 = mods & (AccessFlags | Enum)
+      if mods1 ne mods then
+        syntaxError(s"Only access modifiers are allowed on enum $where")
+      mods1
+
+    /**  EnumDef ::=  id ClassConstr InheritClauses EnumBody
+     */
+    def enumDef(start: Offset, mods: Modifiers): TypeDef = atSpan(start, nameStart) {
+      val mods1 = checkAccessOnly(mods, "definitions")
+      val modulName = ident()
+      val clsName = modulName.toTypeName
+      val constr = classConstr()
+      val templ = template(constr, isEnum = true)
+      finalizeDef(TypeDef(clsName, templ), mods1, start)
+    }
+
+    /** EnumCase = `case' (id ClassConstr [`extends' ConstrApps] | ids)
+     */
+    def enumCase(start: Offset, mods: Modifiers): DefTree = {
+      val mods1 = checkAccessOnly(mods, "cases") | EnumCase
+      accept(CASE)
+
+      atSpan(start, nameStart) {
+        val id = termIdent()
+        if (in.token == COMMA) {
+          in.nextToken()
+          val ids = commaSeparated(() => termIdent())
+          PatDef(mods1, id :: ids, TypeTree(), EmptyTree)
+        }
+        else {
+          val caseDef =
+            if (in.token == LBRACKET || in.token == LPAREN || in.token == AT || isModifier) {
+              val clsName = id.name.toTypeName
+              val constr = classConstr(isCaseClass = true)
+              TypeDef(clsName, caseTemplate(constr))
+            }
+            else
+              ModuleDef(id.name.toTermName, caseTemplate(emptyConstructor))
+          finalizeDef(caseDef, mods1, start)
+        }
+      }
+    }
+
+    /** [`extends' ConstrApps] */
+    def caseTemplate(constr: DefDef): Template = {
+      val parents =
+        if (in.token == EXTENDS) {
+          in.nextToken()
+          constrApps()
+        }
+        else Nil
+      Template(constr, parents, Nil, EmptyValDef, Nil)
+    }
+
+    def checkExtensionMethod(tparams: List[Tree],
+        vparamss: List[List[Tree]], stat: Tree): Unit = stat match {
+      case stat: DefDef =>
+        if stat.mods.is(ExtensionMethod) && vparamss.nonEmpty then
+          syntaxError(i"no extension method allowed here since leading parameter was already given", stat.span)
+        else if !stat.mods.is(ExtensionMethod) && vparamss.isEmpty then
+          syntaxError(i"an extension method is required here", stat.span)
+        else if tparams.nonEmpty && stat.leadingTypeParams.nonEmpty then
+          syntaxError(i"extension method cannot have type parameters since some were already given previously",
+            stat.leadingTypeParams.head.span)
+        else if stat.rhs.isEmpty then
+          syntaxError(i"extension method cannot be abstract", stat.span)
+      case EmptyTree =>
+      case stat =>
+        syntaxError(i"extension clause can only define methods", stat.span)
+    }
+
+    /** GivenDef          ::=  [GivenSig] (AnnotType [‘=’ Expr] | StructuralInstance)
+     *  GivenSig          ::=  [id] [DefTypeParamClause] {UsingParamClauses} ‘:’
+     */
+    def givenDef(start: Offset, mods: Modifiers, givenMod: Mod) = atSpan(start, nameStart) {
+      var mods1 = addMod(mods, givenMod)
+      val nameStart = in.offset
+      val name = if isIdent && followingIsGivenSig() then ident() else EmptyTermName
+
+      val gdef =
+        val tparams = typeParamClauseOpt(ParamOwner.Def)
+        newLineOpt()
+        val vparamss =
+          if in.token == LPAREN && in.lookahead.isIdent(nme.using)
+          then paramClauses(givenOnly = true)
+          else Nil
+        newLinesOpt()
+        val noParams = tparams.isEmpty && vparamss.isEmpty
+        if !(name.isEmpty && noParams) then acceptColon()
+        val parents =
+          if isSimpleLiteral then rejectWildcardType(annotType()) :: Nil
+          else constrApp() :: withConstrApps()
+        val parentsIsType = parents.length == 1 && parents.head.isType
+        if in.token == EQUALS && parentsIsType then
+          accept(EQUALS)
+          mods1 |= Final
+          if noParams && !mods.is(Inline) then
+            mods1 |= Lazy
+            ValDef(name, parents.head, subExpr())
+          else
+            DefDef(name, joinParams(tparams, vparamss), parents.head, subExpr())
+        else if (isStatSep || isStatSeqEnd) && parentsIsType then
+          if name.isEmpty then
+            syntaxError(em"anonymous given cannot be abstract")
+          DefDef(name, joinParams(tparams, vparamss), parents.head, EmptyTree)
+        else
+          val tparams1 = tparams.map(tparam => tparam.withMods(tparam.mods | PrivateLocal))
+          val vparamss1 = vparamss.map(_.map(vparam =>
+            vparam.withMods(vparam.mods &~ Param | ParamAccessor | Protected)))
+          val constr = makeConstructor(tparams1, vparamss1)
+          val templ =
+            if isStatSep || isStatSeqEnd then Template(constr, parents, Nil, EmptyValDef, Nil)
+            else withTemplate(constr, parents)
+          if noParams && !mods.is(Inline) then ModuleDef(name, templ)
+          else TypeDef(name.toTypeName, templ)
+      end gdef
+      finalizeDef(gdef, mods1, start)
+    }
+
+    /** Extension  ::=  ‘extension’ [DefTypeParamClause] {UsingParamClause} ‘(’ DefParam ‘)’
+     *                  {UsingParamClause} ExtMethods
+     */
+    def extension(): ExtMethods =
+      val start = in.skipToken()
+      val tparams = typeParamClauseOpt(ParamOwner.Def)
+      val leadParamss = ListBuffer[List[ValDef]]()
+      def nparams = leadParamss.map(_.length).sum
+      while
+        val extParams = paramClause(nparams, prefix = true)
+        leadParamss += extParams
+        isUsingClause(extParams)
+      do ()
+      leadParamss ++= paramClauses(givenOnly = true, numLeadParams = nparams)
+      if in.isColon then
+        syntaxError("no `:` expected here")
+        in.nextToken()
+      val methods: List[Tree] =
+        if in.token == EXPORT then
+          exportClause()
+        else if isDefIntro(modifierTokens) then
+          extMethod(nparams) :: Nil
+        else
+          in.observeIndented()
+          newLineOptWhenFollowedBy(LBRACE)
+          if in.isNestedStart then inDefScopeBraces(extMethods(nparams))
+          else { syntaxErrorOrIncomplete("Extension without extension methods") ; Nil }
+      val result = atSpan(start)(ExtMethods(joinParams(tparams, leadParamss.toList), methods))
+      val comment = in.getDocComment(start)
+      if comment.isDefined then
+        for case meth: DefDef <- methods do
+          if !meth.rawComment.isDefined then meth.setComment(comment)
+      result
+    end extension
+
+    /**  ExtMethod  ::=  {Annotation [nl]} {Modifier} ‘def’ DefDef
+     *                |  Export
+     */
+    def extMethod(numLeadParams: Int): DefDef =
+      val start = in.offset
+      val mods = defAnnotsMods(modifierTokens)
+      accept(DEF)
+      defDefOrDcl(start, mods, numLeadParams)
+
+    /** ExtMethods ::=  ExtMethod | [nl] ‘{’ ExtMethod {semi ExtMethod ‘}’
+     */
+    def extMethods(numLeadParams: Int): List[Tree] = checkNoEscapingPlaceholders {
+      val meths = new ListBuffer[Tree]
+      while
+        val start = in.offset
+        if in.token == EXPORT then
+          meths ++= exportClause()
+        else
+          val mods = defAnnotsMods(modifierTokens)
+          if in.token != EOF then
+            accept(DEF)
+            meths += defDefOrDcl(start, mods, numLeadParams)
+        in.token != EOF && statSepOrEnd(meths, what = "extension method")
+      do ()
+      if meths.isEmpty then syntaxErrorOrIncomplete("`def` expected")
+      meths.toList
+    }
+
+/* -------- TEMPLATES ------------------------------------------- */
+
+    /** ConstrApp  ::=  SimpleType1 {Annotation} {ParArgumentExprs}
+     */
+    val constrApp: () => Tree = () =>
+      val t = rejectWildcardType(annotTypeRest(simpleType1()),
+        fallbackTree = Ident(tpnme.ERROR))
+        // Using Ident(tpnme.ERROR) to avoid causing cascade errors on non-user-written code
+      if in.token == LPAREN then parArgumentExprss(wrapNew(t)) else t
+
+    /** ConstrApps  ::=  ConstrApp ({‘,’ ConstrApp} | {‘with’ ConstrApp})
+     */
+    def constrApps(exclude: Token = EMPTY): List[Tree] =
+      val t = constrApp()
+      val ts =
+        val tok = in.token
+        if (tok == WITH || tok == COMMA) && tok != exclude then
+          in.nextToken()
+          constrApps(exclude = if tok == WITH then COMMA else WITH)
+        else Nil
+      t :: ts
+
+    /** `{`with` ConstrApp} but no EOL allowed after `with`.
+     */
+    def withConstrApps(): List[Tree] =
+      def isTemplateStart =
+        val la = in.lookahead
+        la.isAfterLineEnd || la.token == LBRACE
+      if in.token == WITH && !isTemplateStart then
+        in.nextToken()
+        constrApp() :: withConstrApps()
+      else Nil
+
+    /** Template          ::=  InheritClauses [TemplateBody]
+     *  InheritClauses    ::=  [‘extends’ ConstrApps] [‘derives’ QualId {‘,’ QualId}]
+     */
+    def template(constr: DefDef, isEnum: Boolean = false): Template = {
+      val parents =
+        if (in.token == EXTENDS) {
+          in.nextToken()
+          if (in.token == LBRACE || in.token == COLONeol) {
+            report.errorOrMigrationWarning(
+              "`extends` must be followed by at least one parent",
+              in.sourcePos(), from = `3.0`)
+            Nil
+          }
+          else constrApps()
+        }
+        else Nil
+      newLinesOptWhenFollowedBy(nme.derives)
+      val derived =
+        if (isIdent(nme.derives)) {
+          in.nextToken()
+          commaSeparated(() => convertToTypeId(qualId()))
+        }
+        else Nil
+      possibleTemplateStart()
+      if isEnum then
+        val (self, stats) = withinEnum(templateBody(parents))
+        Template(constr, parents, derived, self, stats)
+      else
+        templateBodyOpt(constr, parents, derived)
+    }
+
+    /** TemplateOpt = [Template]
+     */
+    def templateOpt(constr: DefDef): Template =
+      newLinesOptWhenFollowedBy(nme.derives)
+      if in.token == EXTENDS || isIdent(nme.derives) then
+        template(constr)
+      else
+        possibleTemplateStart()
+        if in.isNestedStart then
+          template(constr)
+        else
+          checkNextNotIndented()
+          Template(constr, Nil, Nil, EmptyValDef, Nil)
+
+    /** TemplateBody ::=  [nl] `{' TemplateStatSeq `}'
+     *  EnumBody     ::=  [nl] ‘{’ [SelfType] EnumStat {semi EnumStat} ‘}’
+     */
+    def templateBodyOpt(constr: DefDef, parents: List[Tree], derived: List[Tree]): Template =
+      val (self, stats) =
+        if in.isNestedStart then
+          templateBody(parents)
+        else
+          checkNextNotIndented()
+          (EmptyValDef, Nil)
+      Template(constr, parents, derived, self, stats)
+
+    def templateBody(parents: List[Tree], rewriteWithColon: Boolean = true): (ValDef, List[Tree]) =
+      val r = inDefScopeBraces(templateStatSeq(), rewriteWithColon)
+      if in.token == WITH && parents.isEmpty then
+        syntaxError(EarlyDefinitionsNotSupported())
+        in.nextToken()
+        template(emptyConstructor)
+      r
+
+    /** with Template, with EOL <indent> interpreted */
+    def withTemplate(constr: DefDef, parents: List[Tree]): Template =
+      accept(WITH)
+      val (self, stats) = templateBody(parents, rewriteWithColon = false)
+      Template(constr, parents, Nil, self, stats)
+        .withSpan(Span(constr.span.orElse(parents.head.span).start, in.lastOffset))
+
+/* -------- STATSEQS ------------------------------------------- */
+
+    /** Create a tree representing a packaging */
+    def makePackaging(start: Int, pkg: Tree, stats: List[Tree]): PackageDef = pkg match {
+      case x: RefTree => atSpan(start, pointOffset(pkg))(PackageDef(x, stats))
+    }
+
+    /** Packaging ::= package QualId [nl] `{' TopStatSeq `}'
+     */
+    def packaging(start: Int): Tree =
+      val pkg = qualId()
+      possibleTemplateStart()
+      val stats = inDefScopeBraces(topStatSeq(), rewriteWithColon = true)
+      makePackaging(start, pkg, stats)
+
+    /** TopStatSeq ::= TopStat {semi TopStat}
+     *  TopStat ::= Import
+     *            | Export
+     *            | Annotations Modifiers Def
+     *            | Packaging
+     *            | package object objectDef
+     *            | Extension
+     *            |
+     */
+    def topStatSeq(outermost: Boolean = false): List[Tree] = {
+      val stats = new ListBuffer[Tree]
+      while
+        var empty = false
+        if (in.token == PACKAGE) {
+          val start = in.skipToken()
+          if (in.token == OBJECT) {
+            in.nextToken()
+            stats += objectDef(start, Modifiers(Package))
+          }
+          else stats += packaging(start)
+        }
+        else if (in.token == IMPORT)
+          stats ++= importClause(outermost)
+        else if (in.token == EXPORT)
+          stats ++= exportClause()
+        else if isIdent(nme.extension) && followingIsExtension() then
+          stats += extension()
+        else if isDefIntro(modifierTokens) then
+          stats +++= defOrDcl(in.offset, defAnnotsMods(modifierTokens))
+        else
+          empty = true
+        statSepOrEnd(stats, noPrevStat = empty, "toplevel definition")
+      do ()
+      stats.toList
+    }
+
+    /** SelfType ::=  id [‘:’ [CaptureSet] InfixType] ‘=>’
+     *            |  ‘this’ ‘:’ [CaptureSet] InfixType ‘=>’
+     */
+    def selfType(): ValDef =
+      if (in.isIdent || in.token == THIS)
+        && (in.lookahead.isColon && followingIsSelfType()
+            || in.lookahead.token == ARROW)
+      then
+        atSpan(in.offset) {
+          val selfName =
+            if in.token == THIS then
+              in.nextToken()
+              nme.WILDCARD
+            else ident()
+          val selfTpt =
+            if in.isColon then
+              in.nextToken()
+              if in.token == LBRACE && followingIsCaptureSet() then
+                CapturingTypeTree(captureSet(), infixType())
+              else
+                infixType()
+            else
+              if selfName == nme.WILDCARD then accept(COLONfollow)
+              TypeTree()
+          if in.token == ARROW then
+            in.token = SELFARROW // suppresses INDENT insertion after `=>`
+            in.nextToken()
+          else
+            syntaxError("`=>` expected after self type")
+          makeSelfDef(selfName, selfTpt)
+        }
+      else EmptyValDef
+
+    /** TemplateStatSeq  ::= [SelfType] TemplateStat {semi TemplateStat}
+     *  TemplateStat     ::= Import
+     *                     | Export
+     *                     | Annotations Modifiers Def
+     *                     | Annotations Modifiers Dcl
+     *                     | Extension
+     *                     | Expr1
+     *                     |
+     *  EnumStat         ::= TemplateStat
+     *                     | Annotations Modifiers EnumCase
+     */
+    def templateStatSeq(): (ValDef, List[Tree]) = checkNoEscapingPlaceholders {
+      val stats = new ListBuffer[Tree]
+      val self = selfType()
+      while
+        var empty = false
+        if (in.token == IMPORT)
+          stats ++= importClause()
+        else if (in.token == EXPORT)
+          stats ++= exportClause()
+        else if isIdent(nme.extension) && followingIsExtension() then
+          stats += extension()
+        else if (isDefIntro(modifierTokensOrCase))
+          stats +++= defOrDcl(in.offset, defAnnotsMods(modifierTokens))
+        else if (isExprIntro)
+          stats += expr1()
+        else
+          empty = true
+        statSepOrEnd(stats, noPrevStat = empty)
+      do ()
+      (self, if stats.isEmpty then List(EmptyTree) else stats.toList)
+    }
+
+    /** RefineStatSeq    ::=  RefineStat {semi RefineStat}
+     *  RefineStat       ::=  ‘val’ VarDcl
+     *                     |  ‘def’ DefDcl
+     *                     |  ‘type’ {nl} TypeDcl
+     *  (in reality we admit Defs and vars and filter them out afterwards in `checkLegal`)
+     */
+    def refineStatSeq(): List[Tree] = {
+      val stats = new ListBuffer[Tree]
+      def checkLegal(tree: Tree): List[Tree] =
+        val problem = tree match
+          case tree: ValDef if tree.mods.is(Mutable) =>
+            i"""refinement cannot be a mutable var.
+               |You can use an explicit getter ${tree.name} and setter ${tree.name}_= instead"""
+          case tree: MemberDef if !(tree.mods.flags & ModifierFlags).isEmpty =>
+            i"refinement cannot be ${(tree.mods.flags & ModifierFlags).flagStrings().mkString("`", "`, `", "`")}"
+          case tree: DefDef if tree.termParamss.nestedExists(!_.rhs.isEmpty) =>
+            i"refinement cannot have default arguments"
+          case tree: ValOrDefDef =>
+            if tree.rhs.isEmpty then ""
+            else "refinement cannot have a right-hand side"
+          case tree: TypeDef =>
+            if !tree.isClassDef then ""
+            else "refinement cannot be a class or trait"
+          case _ =>
+            "this kind of definition cannot be a refinement"
+        if problem.isEmpty then tree :: Nil
+        else { syntaxError(problem, tree.span); Nil }
+
+      while
+        val dclFound = isDclIntro
+        if dclFound then
+          stats ++= checkLegal(defOrDcl(in.offset, Modifiers()))
+        var what = "declaration"
+        if inFunReturnType then what += " (possible cause: missing `=` in front of current method body)"
+        statSepOrEnd(stats, noPrevStat = !dclFound, what)
+      do ()
+      stats.toList
+    }
+
+    def localDef(start: Int, implicitMods: Modifiers = EmptyModifiers): Tree = {
+      var mods = defAnnotsMods(localModifierTokens)
+      for (imod <- implicitMods.mods) mods = addMod(mods, imod)
+      if (mods.is(Final))
+        // A final modifier means the local definition is "class-like".  // FIXME: Deal with modifiers separately
+        tmplDef(start, mods)
+      else
+        defOrDcl(start, mods)
+    }
+
+    /** BlockStatSeq ::= { BlockStat semi } [Expr]
+     *  BlockStat    ::= Import
+     *                 | Annotations [implicit] [lazy] Def
+     *                 | Annotations LocalModifiers TmplDef
+     *                 | Extension
+     *                 | Expr1
+     *                 |
+     */
+    def blockStatSeq(): List[Tree] = checkNoEscapingPlaceholders {
+      val stats = new ListBuffer[Tree]
+      while
+        var empty = false
+        if (in.token == IMPORT)
+          stats ++= importClause()
+        else if (isExprIntro)
+          stats += expr(Location.InBlock)
+        else if in.token == IMPLICIT && !in.inModifierPosition() then
+          stats += closure(in.offset, Location.InBlock, modifiers(BitSet(IMPLICIT)))
+        else if isIdent(nme.extension) && followingIsExtension() then
+          stats += extension()
+        else if isDefIntro(localModifierTokens, excludedSoftModifiers = Set(nme.`opaque`)) then
+          stats +++= localDef(in.offset)
+        else
+          empty = true
+        statSepOrEnd(stats, noPrevStat = empty, altEnd = CASE)
+      do ()
+      stats.toList
+    }
+
+    /** CompilationUnit ::= {package QualId semi} TopStatSeq
+     */
+    def compilationUnit(): Tree = checkNoEscapingPlaceholders {
+      def topstats(): List[Tree] = {
+        val ts = new ListBuffer[Tree]
+        while (in.token == SEMI) in.nextToken()
+        val start = in.offset
+        if (in.token == PACKAGE) {
+          in.nextToken()
+          if (in.token == OBJECT) {
+            in.nextToken()
+            ts += objectDef(start, Modifiers(Package))
+            if (in.token != EOF) {
+              statSepOrEnd(ts, what = "toplevel definition")
+              ts ++= topStatSeq()
+            }
+          }
+          else
+            val pkg = qualId()
+            var continue = false
+            possibleTemplateStart()
+            if in.token == EOF then
+              ts += makePackaging(start, pkg, List())
+            else if in.isNestedStart then
+              ts += inDefScopeBraces(makePackaging(start, pkg, topStatSeq()), rewriteWithColon = true)
+              continue = true
+            else
+              acceptStatSep()
+              ts += makePackaging(start, pkg, topstats())
+            if continue then
+              statSepOrEnd(ts, what = "toplevel definition")
+              ts ++= topStatSeq()
+        }
+        else
+          ts ++= topStatSeq(outermost = true)
+
+        ts.toList
+      }
+
+      topstats() match {
+        case List(stat @ PackageDef(_, _)) => stat
+        case Nil => EmptyTree  // without this case we'd get package defs without positions
+        case stats => PackageDef(Ident(nme.EMPTY_PACKAGE), stats)
+      }
+    }
+  }
+
+  /** OutlineParser parses top-level declarations in `source` to find declared classes, ignoring their bodies (which
+   *  must only have balanced braces). This is used to map class names to defining sources.
+   */
+  class OutlineParser(source: SourceFile)(using Context) extends Parser(source) with OutlineParserCommon {
+
+    def skipBracesHook(): Option[Tree] =
+      if (in.token == XMLSTART) Some(xmlLiteral()) else None
+
+    override def blockExpr(): Tree = {
+      skipBraces()
+      EmptyTree
+    }
+
+    override def templateBody(parents: List[Tree], rewriteWithColon: Boolean): (ValDef, List[Thicket]) = {
+      skipBraces()
+      (EmptyValDef, List(EmptyTree))
+    }
+  }
+}
diff --git a/tests/pos-with-compiler-cc/dotc/parsing/Scanners.scala b/tests/pos-with-compiler-cc/dotc/parsing/Scanners.scala
new file mode 100644
index 000000000000..c4fe8dc44ddc
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/parsing/Scanners.scala
@@ -0,0 +1,1721 @@
+package dotty.tools
+package dotc
+package parsing
+
+import scala.language.unsafeNulls
+
+import core.Names._, core.Contexts._, core.Decorators._, util.Spans._
+import core.StdNames._, core.Comments._
+import util.SourceFile
+import util.Chars._
+import util.{SourcePosition, CharBuffer}
+import util.Spans.Span
+import config.Config
+import Tokens._
+import scala.annotation.{switch, tailrec}
+import scala.collection.mutable
+import scala.collection.immutable.SortedMap
+import rewrites.Rewrites.patch
+import config.Feature
+import config.Feature.migrateTo3
+import config.SourceVersion.`3.0`
+import reporting.{NoProfile, Profile}
+
+object Scanners {
+
+  /** Offset into source character array */
+  type Offset = Int
+
+  /** An undefined offset */
+  val NoOffset: Offset = -1
+
+  type Token = Int
+
+  private val identity: IndentWidth => IndentWidth = Predef.identity
+
+  trait TokenData {
+
+    /** the next token */
+    var token: Token = EMPTY
+
+    /** the offset of the first character of the current token */
+    var offset: Offset = 0
+
+    /** the offset of the character following the token preceding this one */
+    var lastOffset: Offset = 0
+
+    /** the offset of the newline immediately preceding the token, or -1 if
+     *  token is not preceded by a newline.
+     */
+    var lineOffset: Offset = -1
+
+    /** the name of an identifier */
+    var name: SimpleName = null
+
+    /** the string value of a literal */
+    var strVal: String = null
+
+    /** the base of a number */
+    var base: Int = 0
+
+    def copyFrom(td: TokenData): Unit = {
+      this.token = td.token
+      this.offset = td.offset
+      this.lastOffset = td.lastOffset
+      this.lineOffset = td.lineOffset
+      this.name = td.name
+      this.strVal = td.strVal
+      this.base = td.base
+    }
+
+    def isNewLine = token == NEWLINE || token == NEWLINES
+    def isStatSep = isNewLine || token == SEMI
+    def isIdent = token == IDENTIFIER || token == BACKQUOTED_IDENT
+    def isIdent(name: Name) = token == IDENTIFIER && this.name == name
+
+    def isNestedStart = token == LBRACE || token == INDENT
+    def isNestedEnd = token == RBRACE || token == OUTDENT
+
+    def isColon =
+      token == COLONop || token == COLONfollow || token == COLONeol
+
+    /** Is current token first one after a newline? */
+    def isAfterLineEnd: Boolean = lineOffset >= 0
+
+    def isOperator =
+      token == BACKQUOTED_IDENT
+      || token == IDENTIFIER && isOperatorPart(name(name.length - 1))
+
+    def isArrow =
+      token == ARROW || token == CTXARROW
+  }
+
+  abstract class ScannerCommon(source: SourceFile)(using Context) extends CharArrayReader with TokenData {
+    val buf: Array[Char] = source.content
+    def nextToken(): Unit
+
+    // Errors -----------------------------------------------------------------
+
+    /** the last error offset
+      */
+    var errOffset: Offset = NoOffset
+
+    /** Generate an error at the given offset */
+    def error(msg: String, off: Offset = offset): Unit = {
+      errorButContinue(msg, off)
+      token = ERROR
+      errOffset = off
+    }
+
+    def errorButContinue(msg: String, off: Offset = offset): Unit =
+      report.error(msg, sourcePos(off))
+
+    /** signal an error where the input ended in the middle of a token */
+    def incompleteInputError(msg: String): Unit = {
+      report.incompleteInputError(msg.toMessage, sourcePos())
+      token = EOF
+      errOffset = offset
+    }
+
+    def sourcePos(off: Offset = offset): SourcePosition =
+      source.atSpan(Span(off))
+
+    // Setting token data ----------------------------------------------------
+
+    /** A character buffer for literals
+      */
+    protected val litBuf = CharBuffer()
+
+    /** append Unicode character to "litBuf" buffer
+      */
+    protected def putChar(c: Char): Unit = litBuf.append(c)
+
+    /** Finish an IDENTIFIER with `this.name`. */
+    inline def finishNamed(): Unit = finishNamedToken(IDENTIFIER, this)
+
+    /** Clear buffer and set name and token.
+     *  If `target` is different from `this`, don't treat identifiers as end tokens.
+     */
+    def finishNamedToken(idtoken: Token, target: TokenData): Unit =
+      target.name = termName(litBuf.chars, 0, litBuf.length)
+      litBuf.clear()
+      target.token = idtoken
+      if idtoken == IDENTIFIER then
+        val converted = toToken(target.name)
+        if converted != END || (target eq this) then target.token = converted
+
+    /** The token for given `name`. Either IDENTIFIER or a keyword. */
+    def toToken(name: SimpleName): Token
+
+    /** Clear buffer and set string */
+    def setStrVal(): Unit =
+      strVal = litBuf.toString
+      litBuf.clear()
+
+    @inline def isNumberSeparator(c: Char): Boolean = c == '_'
+
+    @inline def removeNumberSeparators(s: String): String = if (s.indexOf('_') == -1) s else s.replace("_", "")
+
+    // disallow trailing numeric separator char, but continue lexing
+    def checkNoTrailingSeparator(): Unit =
+      if (!litBuf.isEmpty && isNumberSeparator(litBuf.last))
+        errorButContinue("trailing separator is not allowed", offset + litBuf.length - 1)
+  }
+
+  class Scanner(source: SourceFile, override val startFrom: Offset = 0, profile: Profile = NoProfile, allowIndent: Boolean = true)(using Context) extends ScannerCommon(source) {
+    val keepComments = !ctx.settings.YdropComments.value
+
+    /** A switch whether operators at the start of lines can be infix operators */
+    private[Scanners] var allowLeadingInfixOperators = true
+
+    var debugTokenStream = false
+    val showLookAheadOnDebug = false
+
+    val rewrite = ctx.settings.rewrite.value.isDefined
+    val oldSyntax = ctx.settings.oldSyntax.value
+    val newSyntax = ctx.settings.newSyntax.value
+
+    val rewriteToIndent = ctx.settings.indent.value && rewrite
+    val rewriteNoIndent = ctx.settings.noindent.value && rewrite
+
+    val noindentSyntax =
+      ctx.settings.noindent.value
+      || ctx.settings.oldSyntax.value
+      || (migrateTo3 && !ctx.settings.indent.value)
+    val indentSyntax =
+      ((if (Config.defaultIndent) !noindentSyntax else ctx.settings.indent.value)
+       || rewriteNoIndent)
+      && allowIndent
+
+    if (rewrite) {
+      val s = ctx.settings
+      val rewriteTargets = List(s.newSyntax, s.oldSyntax, s.indent, s.noindent)
+      val enabled = rewriteTargets.filter(_.value)
+      if (enabled.length > 1)
+        error(s"illegal combination of -rewrite targets: ${enabled(0).name} and ${enabled(1).name}")
+    }
+
+    private var myLanguageImportContext: Context = ctx
+    def languageImportContext = myLanguageImportContext
+    final def languageImportContext_=(c: Context) = myLanguageImportContext = c
+
+    def featureEnabled(name: TermName) = Feature.enabled(name)(using languageImportContext)
+    def erasedEnabled = featureEnabled(Feature.erasedDefinitions)
+
+    private inline val fewerBracesByDefault = false
+      // turn on to study impact on codebase if `fewerBraces` was the default
+
+    private var fewerBracesEnabledCache = false
+    private var fewerBracesEnabledCtx: Context = NoContext
+
+    def fewerBracesEnabled =
+      if fewerBracesEnabledCtx ne myLanguageImportContext then
+        fewerBracesEnabledCache =
+          featureEnabled(Feature.fewerBraces)
+          || fewerBracesByDefault && indentSyntax && !migrateTo3
+          		// ensure that fewer braces is not the default for 3.0-migration since
+          		//     { x: T =>
+          		//       expr
+          		//     }
+                // would be ambiguous
+        fewerBracesEnabledCtx = myLanguageImportContext
+      fewerBracesEnabledCache
+
+    private var postfixOpsEnabledCache = false
+    private var postfixOpsEnabledCtx: Context = NoContext
+
+    def postfixOpsEnabled =
+      if postfixOpsEnabledCtx ne myLanguageImportContext then
+        postfixOpsEnabledCache = featureEnabled(nme.postfixOps)
+        postfixOpsEnabledCtx = myLanguageImportContext
+      postfixOpsEnabledCache
+
+    /** All doc comments kept by their end position in a `Map`.
+      *
+      * Note: the map is necessary since the comments are looked up after an
+      * entire definition is parsed, and a definition can contain nested
+      * definitions with their own docstrings.
+      */
+    private var docstringMap: SortedMap[Int, Comment] = SortedMap.empty
+
+    /* A Buffer for comment positions */
+    private val commentPosBuf = new mutable.ListBuffer[Span]
+
+    /** Return a list of all the comment positions */
+    def commentSpans: List[Span] = commentPosBuf.toList
+
+    private def addComment(comment: Comment): Unit = {
+      val lookahead = lookaheadReader()
+      def nextPos: Int = (lookahead.getc(): @switch) match {
+        case ' ' | '\t' | CR | LF | FF => nextPos
+        case _ => lookahead.charOffset - 1
+      }
+      docstringMap = docstringMap + (nextPos -> comment)
+    }
+
+    /** Returns the closest docstring preceding the position supplied */
+    def getDocComment(pos: Int): Option[Comment] = docstringMap.get(pos)
+
+    /** A buffer for comments */
+    private val commentBuf = CharBuffer()
+
+    def toToken(identifier: SimpleName): Token =
+      def handleMigration(keyword: Token): Token =
+        if scala3keywords.contains(keyword) && migrateTo3 then
+          val what = tokenString(keyword)
+          report.errorOrMigrationWarning(
+            i"$what is now a keyword, write `$what` instead of $what to keep it as an identifier",
+            sourcePos(),
+            from = `3.0`)
+          patch(source, Span(offset), "`")
+          patch(source, Span(offset + identifier.length), "`")
+          IDENTIFIER
+        else keyword
+      val idx = identifier.start
+      if (idx >= 0 && idx <= lastKeywordStart) handleMigration(kwArray(idx))
+      else IDENTIFIER
+
+    def newTokenData: TokenData = new TokenData {}
+
+    /** We need one token lookahead and one token history
+     */
+    val next = newTokenData
+    private val prev = newTokenData
+
+    /** The current region. This is initially an Indented region with zero indentation width. */
+    var currentRegion: Region = Indented(IndentWidth.Zero, EMPTY, null)
+
+// Error recovery ------------------------------------------------------------
+
+    private def lastKnownIndentWidth: IndentWidth =
+      def recur(r: Region): IndentWidth =
+        if r.knownWidth == null then recur(r.enclosing) else r.knownWidth
+      recur(currentRegion)
+
+    private var skipping = false
+
+    /** Skip on error to next safe point.
+     */
+    def skip(): Unit =
+      val lastRegion = currentRegion
+      skipping = true
+      def atStop =
+        token == EOF
+        || (currentRegion eq lastRegion)
+            && (isStatSep
+                || closingParens.contains(token) && lastRegion.toList.exists(_.closedBy == token)
+                || token == COMMA && lastRegion.toList.exists(_.commasExpected)
+                || token == OUTDENT && indentWidth(offset) < lastKnownIndentWidth)
+          // stop at OUTDENT if the new indentwidth is smaller than the indent width of
+          // currentRegion. This corrects for the problem that sometimes we don't see an INDENT
+          // when skipping and therefore might erroneously end up syncing on a nested OUTDENT.
+      if debugTokenStream then
+        println(s"\nSTART SKIP AT ${sourcePos().line + 1}, $this in $currentRegion")
+      var noProgress = 0
+        // Defensive measure to ensure we always get out of the following while loop
+        // even if source file is weirly formatted (i.e. we never reach EOF
+      while !atStop && noProgress < 3 do
+        val prevOffset = offset
+        nextToken()
+        if offset == prevOffset then noProgress += 1 else noProgress = 0
+      if debugTokenStream then
+        println(s"\nSTOP SKIP AT ${sourcePos().line + 1}, $this in $currentRegion")
+      if token == OUTDENT then dropUntil(_.isInstanceOf[Indented])
+      skipping = false
+
+// Get next token ------------------------------------------------------------
+
+    /** Are we directly in a multiline string interpolation expression?
+     *  @pre inStringInterpolation
+     */
+    private def inMultiLineInterpolation = currentRegion match {
+      case InString(multiLine, _) => multiLine
+      case _ => false
+    }
+
+    /** Are we in a `${ }` block? such that RBRACE exits back into multiline string. */
+    private def inMultiLineInterpolatedExpression =
+      currentRegion match {
+        case InBraces(InString(true, _)) => true
+        case _ => false
+      }
+
+    /** read next token and return last offset
+     */
+    def skipToken(): Offset = {
+      val off = offset
+      nextToken()
+      off
+    }
+
+    def skipToken[T](result: T): T =
+      nextToken()
+      result
+
+    private inline def dropUntil(inline matches: Region => Boolean): Unit =
+      while !matches(currentRegion) && !currentRegion.isOutermost do
+        currentRegion = currentRegion.enclosing
+
+    def adjustSepRegions(lastToken: Token): Unit = (lastToken: @switch) match {
+      case LPAREN | LBRACKET =>
+        currentRegion = InParens(lastToken, currentRegion)
+      case LBRACE =>
+        currentRegion = InBraces(currentRegion)
+      case RBRACE =>
+        dropUntil(_.isInstanceOf[InBraces])
+        if !currentRegion.isOutermost then currentRegion = currentRegion.enclosing
+      case RPAREN | RBRACKET =>
+        currentRegion match {
+          case InParens(prefix, outer) if prefix + 1 == lastToken => currentRegion = outer
+          case _ =>
+        }
+      case OUTDENT =>
+        currentRegion match
+          case r: Indented => currentRegion = r.enclosing
+          case _ =>
+      case STRINGLIT =>
+        currentRegion match {
+          case InString(_, outer) => currentRegion = outer
+          case _ =>
+        }
+      case _ =>
+    }
+
+    /** Read a token or copy it from `next` tokenData */
+    private def getNextToken(lastToken: Token): Unit =
+      if next.token == EMPTY then
+        lastOffset = lastCharOffset
+        currentRegion match
+          case InString(multiLine, _) if lastToken != STRINGPART => fetchStringPart(multiLine)
+          case _ => fetchToken()
+        if token == ERROR then adjustSepRegions(STRINGLIT) // make sure we exit enclosing string literal
+      else
+        this.copyFrom(next)
+        next.token = EMPTY
+
+    /** Produce next token, filling TokenData fields of Scanner.
+     */
+    def nextToken(): Unit =
+      val lastToken = token
+      val lastName = name
+      adjustSepRegions(lastToken)
+      getNextToken(lastToken)
+      if isAfterLineEnd then handleNewLine(lastToken)
+      postProcessToken(lastToken, lastName)
+      profile.recordNewToken()
+      printState()
+
+    final def printState() =
+      if debugTokenStream && (showLookAheadOnDebug || !isInstanceOf[LookaheadScanner]) then
+        print(s"[$show${if isInstanceOf[LookaheadScanner] then "(LA)" else ""}]")
+
+    /** Insert `token` at assumed `offset` in front of current one. */
+    def insert(token: Token, offset: Int) = {
+      assert(next.token == EMPTY, next)
+      next.copyFrom(this)
+      this.offset = offset
+      this.token = token
+    }
+
+    /** A leading symbolic or backquoted identifier is treated as an infix operator if
+      *   - it does not follow a blank line, and
+      *   - it is followed by at least one whitespace character and a
+      *     token that can start an expression.
+      *   - if the operator appears on its own line, the next line must have at least
+      *     the same indentation width as the operator. See pos/i12395 for a test where this matters.
+      *  If a leading infix operator is found and the source version is `3.0-migration`, emit a change warning.
+      */
+    def isLeadingInfixOperator(nextWidth: IndentWidth = indentWidth(offset), inConditional: Boolean = true) =
+      allowLeadingInfixOperators
+      && isOperator
+      && (isWhitespace(ch) || ch == LF)
+      && !pastBlankLine
+      && {
+        // Is current lexeme  assumed to start an expression?
+        // This is the case if the lexime is one of the tokens that
+        // starts an expression or it is a COLONeol. Furthermore, if
+        // the previous token is in backticks, the lexeme may not be a binary operator.
+        // I.e. in
+        //
+        //   a
+        //   `x` += 1
+        //
+        // `+=` is not assumed to start an expression since it follows an identifier
+        // in backticks and is a binary operator. Hence, `x` is not classified as a
+        // leading infix operator.
+        def assumeStartsExpr(lexeme: TokenData) =
+          (canStartExprTokens.contains(lexeme.token) || lexeme.token == COLONeol)
+          && (!lexeme.isOperator || nme.raw.isUnary(lexeme.name))
+        val lookahead = LookaheadScanner()
+        lookahead.allowLeadingInfixOperators = false
+          // force a NEWLINE a after current token if it is on its own line
+        lookahead.nextToken()
+        assumeStartsExpr(lookahead)
+        || lookahead.token == NEWLINE
+           && assumeStartsExpr(lookahead.next)
+           && indentWidth(offset) <= indentWidth(lookahead.next.offset)
+      }
+      && {
+        currentRegion match
+          case r: Indented =>
+            r.width <= nextWidth
+            || {
+              r.outer match
+                case null => true
+                case ro @ Indented(outerWidth, _, _) =>
+                  outerWidth < nextWidth && !ro.otherIndentWidths.contains(nextWidth)
+                case outer =>
+                  outer.indentWidth < nextWidth
+            }
+          case _ => true
+      }
+      && {
+        if migrateTo3 then
+          val (what, previous) =
+            if inConditional then ("Rest of line", "previous expression in parentheses")
+            else ("Line", "expression on the previous line")
+          report.errorOrMigrationWarning(
+            em"""$what starts with an operator;
+                |it is now treated as a continuation of the $previous,
+                |not as a separate statement.""",
+            sourcePos(), from = `3.0`)
+        true
+      }
+
+    /** The indentation width of the given offset. */
+    def indentWidth(offset: Offset): IndentWidth =
+      import IndentWidth.{Run, Conc}
+      def recur(idx: Int, ch: Char, n: Int, k: IndentWidth => IndentWidth): IndentWidth =
+        if (idx < 0) k(Run(ch, n))
+        else {
+          val nextChar = buf(idx)
+          if (nextChar == LF) k(Run(ch, n))
+          else if (nextChar == ' ' || nextChar == '\t')
+            if (nextChar == ch)
+              recur(idx - 1, ch, n + 1, k)
+            else {
+              val k1: IndentWidth => IndentWidth = if (n == 0) k else Conc(_, Run(ch, n))
+              recur(idx - 1, nextChar, 1, k1)
+            }
+          else recur(idx - 1, ' ', 0, identity)
+        }
+      recur(offset - 1, ' ', 0, identity)
+    end indentWidth
+
+    /** Handle newlines, possibly inserting an INDENT, OUTDENT, NEWLINE, or NEWLINES token
+     *  in front of the current token. This depends on whether indentation is significant or not.
+     *
+     *  Indentation is _significant_ if indentSyntax is set, and we are not inside a
+     *  {...}, [...], (...), case ... => pair, nor in a if/while condition
+     *  (i.e. currentRegion is empty).
+     *
+     *  There are three rules:
+     *
+     *   1. Insert NEWLINE or NEWLINES if
+     *
+     *      - the closest enclosing sepRegion is { ... } or for ... do/yield,
+     *         or we are on the toplevel, i.e. currentRegion is empty, and
+     *      - the previous token can end a statement, and
+     *      - the current token can start a statement, and
+     *      - the current token is not a leading infix operator, and
+     *      - if indentation is significant then the current token starts at the current
+     *        indentation width or to the right of it.
+     *
+     *      The inserted token is NEWLINES if the current token is preceded by a
+     *      whitespace line, or NEWLINE otherwise.
+     *
+     *   2. Insert INDENT if
+     *
+     *      - indentation is significant, and
+     *      - the last token can start an indentation region.
+     *      - the indentation of the current token is strictly greater than the previous
+     *        indentation width, or the two widths are the same and the current token is
+     *        one of `:` or `match`.
+     *
+     *      The following tokens can start an indentation region:
+     *
+     *         :  =  =>  <-  if  then  else  while  do  try  catch  finally  for  yield  match
+     *
+     *      Inserting an INDENT starts a new indentation region with the indentation of the current
+     *      token as indentation width.
+     *
+     *   3. Insert OUTDENT if
+     *
+     *      - indentation is significant, and
+     *      - the indentation of the current token is strictly less than the
+     *        previous indentation width,
+     *      - the current token is not a leading infix operator.
+     *
+     *      Inserting an OUTDENT closes an indentation region. In this case, issue an error if
+     *      the indentation of the current token does not match the indentation of some previous
+     *      line in an enclosing indentation region.
+     *
+     *      If a token is inserted and consumed, the original source token is still considered to
+     *      start a new line, so the process that inserts an OUTDENT might repeat several times.
+     *
+     *  Indentation widths are strings consisting of spaces and tabs, ordered by the prefix relation.
+     *  I.e. `a <= b` iff `b.startsWith(a)`. If indentation is significant it is considered an error
+     *  if the current indentation width and the indentation of the current token are incomparable.
+     */
+    def handleNewLine(lastToken: Token) =
+      var indentIsSignificant = false
+      var newlineIsSeparating = false
+      var lastWidth = IndentWidth.Zero
+      var indentPrefix = EMPTY
+      val nextWidth = indentWidth(offset)
+
+      // If nextWidth is an indentation level not yet seen by enclosing indentation
+      // region, invoke `handler`.
+      def handleNewIndentWidth(r: Region, handler: Indented => Unit): Unit = r match
+        case r @ Indented(curWidth, prefix, outer)
+        if curWidth < nextWidth && !r.otherIndentWidths.contains(nextWidth) && nextWidth != lastWidth =>
+          handler(r)
+        case _ =>
+
+      /** Is this line seen as a continuation of last line? We assume that
+       *   - last line ended in a token that can end a statement
+       *   - current line starts with a token that can start a statement
+       *   - current line does not start with a leading infix operator
+       *  The answer is different for Scala-2 and Scala-3.
+       *   - In Scala 2: Only `{` is treated as continuing, irrespective of indentation.
+       *     But this is in fact handled by Parser.argumentStart which skips a NEWLINE,
+       *     so we always assume false here.
+       *   - In Scala 3: Only indented statements are treated as continuing, as long as
+       *     they start with `(`, `[` or `{`, or the last statement ends in a `return`.
+       *   The Scala 2 rules apply under source `3.0-migration` or under `-no-indent`.
+       */
+      def isContinuing =
+        lastWidth < nextWidth
+        && (openParensTokens.contains(token) || lastToken == RETURN)
+        && !pastBlankLine
+        && !migrateTo3
+        && !noindentSyntax
+
+      currentRegion match
+        case r: Indented =>
+          indentIsSignificant = indentSyntax
+          lastWidth = r.width
+          newlineIsSeparating = lastWidth <= nextWidth || r.isOutermost
+          indentPrefix = r.prefix
+        case _: InString => ()
+        case r =>
+          indentIsSignificant = indentSyntax
+          r.proposeKnownWidth(nextWidth, lastToken)
+          lastWidth = r.knownWidth
+          newlineIsSeparating = r.isInstanceOf[InBraces]
+
+      if newlineIsSeparating
+         && canEndStatTokens.contains(lastToken)
+         && canStartStatTokens.contains(token)
+         && !isLeadingInfixOperator(nextWidth)
+         && !isContinuing
+      then
+        insert(if (pastBlankLine) NEWLINES else NEWLINE, lineOffset)
+      else if indentIsSignificant then
+        if nextWidth < lastWidth
+           || nextWidth == lastWidth && (indentPrefix == MATCH || indentPrefix == CATCH) && token != CASE then
+          if currentRegion.isOutermost then
+            if nextWidth < lastWidth then currentRegion = topLevelRegion(nextWidth)
+          else if !isLeadingInfixOperator(nextWidth) && !statCtdTokens.contains(lastToken) && lastToken != INDENT then
+            currentRegion match
+              case r: Indented =>
+                insert(OUTDENT, offset)
+                handleNewIndentWidth(r.enclosing, ir =>
+                  errorButContinue(
+                    i"""The start of this line does not match any of the previous indentation widths.
+                       |Indentation width of current line : $nextWidth
+                       |This falls between previous widths: ${ir.width} and $lastWidth"""))
+              case r =>
+                if skipping then
+                  if r.enclosing.isClosedByUndentAt(nextWidth) then
+                    insert(OUTDENT, offset)
+                else if r.isInstanceOf[InBraces] && !closingRegionTokens.contains(token) then
+                  report.warning("Line is indented too far to the left, or a `}` is missing", sourcePos())
+
+        else if lastWidth < nextWidth
+             || lastWidth == nextWidth && (lastToken == MATCH || lastToken == CATCH) && token == CASE then
+          if canStartIndentTokens.contains(lastToken) then
+            currentRegion = Indented(nextWidth, lastToken, currentRegion)
+            insert(INDENT, offset)
+          else if lastToken == SELFARROW then
+            currentRegion.knownWidth = nextWidth
+        else if (lastWidth != nextWidth)
+          errorButContinue(spaceTabMismatchMsg(lastWidth, nextWidth))
+      if token != OUTDENT then
+        handleNewIndentWidth(currentRegion, _.otherIndentWidths += nextWidth)
+      if next.token == EMPTY then
+        profile.recordNewLine()
+    end handleNewLine
+
+    def spaceTabMismatchMsg(lastWidth: IndentWidth, nextWidth: IndentWidth) =
+      i"""Incompatible combinations of tabs and spaces in indentation prefixes.
+         |Previous indent : $lastWidth
+         |Latest indent   : $nextWidth"""
+
+    def observeColonEOL(inTemplate: Boolean): Unit =
+      val enabled =
+        if token == COLONop && inTemplate then
+          report.deprecationWarning(em"`:` after symbolic operator is deprecated; use backticks around operator instead", sourcePos(offset))
+          true
+        else token == COLONfollow && (inTemplate || fewerBracesEnabled)
+      if enabled then
+        peekAhead()
+        val atEOL = isAfterLineEnd || token == EOF
+        reset()
+        if atEOL then token = COLONeol
+
+    def observeIndented(): Unit =
+      if indentSyntax && isNewLine then
+        val nextWidth = indentWidth(next.offset)
+        val lastWidth = currentRegion.indentWidth
+        if lastWidth < nextWidth then
+          currentRegion = Indented(nextWidth, COLONeol, currentRegion)
+          offset = next.offset
+          token = INDENT
+    end observeIndented
+
+    /** Insert an <outdent> token if next token closes an indentation region.
+     *  Exception: continue if indentation region belongs to a `match` and next token is `case`.
+     */
+    def observeOutdented(): Unit = currentRegion match
+      case r: Indented
+      if !r.isOutermost
+         && closingRegionTokens.contains(token)
+         && !(token == CASE && r.prefix == MATCH)
+         && next.token == EMPTY  // can be violated for ill-formed programs, e.g. neg/i12605.sala
+      =>
+        insert(OUTDENT, offset)
+      case _ =>
+
+    def peekAhead() =
+      prev.copyFrom(this)
+      getNextToken(token)
+      if token == END && !isEndMarker then token = IDENTIFIER
+
+    def reset() =
+      next.copyFrom(this)
+      this.copyFrom(prev)
+
+    def closeIndented() = currentRegion match
+      case r: Indented if !r.isOutermost => insert(OUTDENT, offset)
+      case _ =>
+
+    /** - Join CASE + CLASS => CASECLASS, CASE + OBJECT => CASEOBJECT
+     *         SEMI + ELSE => ELSE, COLON following id/)/] => COLONfollow
+     *  - Insert missing OUTDENTs at EOF
+     */
+    def postProcessToken(lastToken: Token, lastName: SimpleName): Unit = {
+      def fuse(tok: Int) = {
+        token = tok
+        offset = prev.offset
+        lastOffset = prev.lastOffset
+        lineOffset = prev.lineOffset
+      }
+      (token: @switch) match {
+        case CASE =>
+          peekAhead()
+          if (token == CLASS) fuse(CASECLASS)
+          else if (token == OBJECT) fuse(CASEOBJECT)
+          else reset()
+        case SEMI =>
+          peekAhead()
+          if (token != ELSE) reset()
+        case COMMA =>
+          def isEnclosedInParens(r: Region): Boolean = r match
+            case r: Indented => isEnclosedInParens(r.outer)
+            case _: InParens => true
+            case _ => false
+          currentRegion match
+            case r: Indented if isEnclosedInParens(r.outer) =>
+              insert(OUTDENT, offset)
+            case _ =>
+              peekAhead()
+              if isAfterLineEnd
+                 && currentRegion.commasExpected
+                 && (token == RPAREN || token == RBRACKET || token == RBRACE || token == OUTDENT)
+              then
+                () /* skip the trailing comma */
+              else
+                reset()
+        case END =>
+          if !isEndMarker then token = IDENTIFIER
+        case COLONop =>
+          if lastToken == IDENTIFIER && lastName != null && isIdentifierStart(lastName.head)
+              || colonEOLPredecessors.contains(lastToken)
+          then token = COLONfollow
+        case RBRACE | RPAREN | RBRACKET =>
+          closeIndented()
+        case EOF =>
+          if !source.maybeIncomplete then closeIndented()
+        case _ =>
+      }
+    }
+
+    protected def isEndMarker: Boolean =
+      if indentSyntax && isAfterLineEnd then
+        val endLine = source.offsetToLine(offset)
+        val lookahead = new LookaheadScanner():
+          override def isEndMarker = false
+        lookahead.nextToken()
+        if endMarkerTokens.contains(lookahead.token)
+          && source.offsetToLine(lookahead.offset) == endLine
+        then
+          lookahead.nextToken()
+          if lookahead.token == EOF
+          || source.offsetToLine(lookahead.offset) > endLine
+          then return true
+      false
+
+    /** Is there a blank line between the current token and the last one?
+     *  A blank line consists only of characters <= ' '.
+     *  @pre  afterLineEnd().
+     */
+    private def pastBlankLine: Boolean = {
+      val end = offset
+      def recur(idx: Offset, isBlank: Boolean): Boolean =
+        idx < end && {
+          val ch = buf(idx)
+          if (ch == LF || ch == FF) isBlank || recur(idx + 1, true)
+          else recur(idx + 1, isBlank && ch <= ' ')
+        }
+      recur(lastOffset, false)
+    }
+
+    import Character.{isHighSurrogate, isLowSurrogate, isUnicodeIdentifierPart, isUnicodeIdentifierStart, isValidCodePoint, toCodePoint}
+
+    // f"\\u$c%04x" or f"${"\\"}u$c%04x"
+    private def toUnicode(c: Char): String = { val s = c.toInt.toHexString; "\\u" + "0" * (4 - s.length) + s }
+
+    // given char (ch) is high surrogate followed by low, codepoint passes predicate.
+    // true means supplementary chars were put to buffer.
+    // strict to require low surrogate (if not in string literal).
+    private def isSupplementary(high: Char, test: Int => Boolean, strict: Boolean = true): Boolean =
+      isHighSurrogate(high) && {
+        var res = false
+        nextChar()
+        val low = ch
+        if isLowSurrogate(low) then
+          nextChar()
+          val codepoint = toCodePoint(high, low)
+          if isValidCodePoint(codepoint) && test(codepoint) then
+            putChar(high)
+            putChar(low)
+            res = true
+          else
+            error(s"illegal character '${toUnicode(high)}${toUnicode(low)}'")
+        else if !strict then
+          putChar(high)
+          res = true
+        else
+          error(s"illegal character '${toUnicode(high)}' missing low surrogate")
+        res
+      }
+    private def atSupplementary(ch: Char, f: Int => Boolean): Boolean =
+      isHighSurrogate(ch) && {
+        val hi = ch
+        val lo = lookaheadChar()
+        isLowSurrogate(lo) && {
+          val codepoint = toCodePoint(hi, lo)
+          isValidCodePoint(codepoint) && f(codepoint)
+        }
+      }
+
+    /** read next token, filling TokenData fields of Scanner.
+     */
+    protected final def fetchToken(): Unit = {
+      offset = charOffset - 1
+      lineOffset = if (lastOffset < lineStartOffset) lineStartOffset else -1
+      name = null
+      (ch: @switch) match {
+        case ' ' | '\t' | CR | LF | FF =>
+          nextChar()
+          fetchToken()
+        case 'A' | 'B' | 'C' | 'D' | 'E' |
+             'F' | 'G' | 'H' | 'I' | 'J' |
+             'K' | 'L' | 'M' | 'N' | 'O' |
+             'P' | 'Q' | 'R' | 'S' | 'T' |
+             'U' | 'V' | 'W' | 'X' | 'Y' |
+             'Z' | '$' | '_' |
+             'a' | 'b' | 'c' | 'd' | 'e' |
+             'f' | 'g' | 'h' | 'i' | 'j' |
+             'k' | 'l' | 'm' | 'n' | 'o' |
+             'p' | 'q' | 'r' | 's' | 't' |
+             'u' | 'v' | 'w' | 'x' | 'y' |
+             'z' =>
+          putChar(ch)
+          nextChar()
+          getIdentRest()
+          if (ch == '"' && token == IDENTIFIER)
+            token = INTERPOLATIONID
+        case '<' => // is XMLSTART?
+          def fetchLT() = {
+            val last = if (charOffset >= 2) buf(charOffset - 2) else ' '
+            nextChar()
+            last match {
+              case ' ' | '\t' | '\n' | '{' | '(' | '>' if xml.Utility.isNameStart(ch) || ch == '!' || ch == '?' =>
+                token = XMLSTART
+              case _ =>
+                // Console.println("found '<', but last is '" + in.last +"'"); // DEBUG
+                putChar('<')
+                getOperatorRest()
+            }
+          }
+          fetchLT()
+        case '~' | '!' | '@' | '#' | '%' |
+             '^' | '*' | '+' | '-' | /*'<' | */
+             '>' | '?' | ':' | '=' | '&' |
+             '|' | '\\' =>
+          putChar(ch)
+          nextChar()
+          getOperatorRest()
+        case '/' =>
+          if (skipComment())
+            fetchToken()
+          else {
+            putChar('/')
+            getOperatorRest()
+          }
+        case '0' =>
+          def fetchLeadingZero(): Unit = {
+            nextChar()
+            ch match {
+              case 'x' | 'X' => base = 16 ; nextChar()
+              //case 'b' | 'B' => base = 2  ; nextChar()
+              case _         => base = 10 ; putChar('0')
+            }
+            if (base != 10 && !isNumberSeparator(ch) && digit2int(ch, base) < 0)
+              error("invalid literal number")
+          }
+          fetchLeadingZero()
+          getNumber()
+        case '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' =>
+          base = 10
+          getNumber()
+        case '`' =>
+          getBackquotedIdent()
+        case '\"' =>
+          def stringPart(multiLine: Boolean) = {
+            getStringPart(multiLine)
+            currentRegion = InString(multiLine, currentRegion)
+          }
+          def fetchDoubleQuote() =
+            if (token == INTERPOLATIONID) {
+              nextRawChar()
+              if (ch == '\"') {
+                if (lookaheadChar() == '\"') {
+                  nextRawChar()
+                  //offset += 3   // first part is positioned at the quote
+                  nextRawChar()
+                  stringPart(multiLine = true)
+                }
+                else {
+                  nextChar()
+                  token = STRINGLIT
+                  strVal = ""
+                }
+              }
+              else {
+                //offset += 1   // first part is positioned at the quote
+                stringPart(multiLine = false)
+              }
+            }
+            else {
+              nextChar()
+              if (ch == '\"') {
+                nextChar()
+                if (ch == '\"') {
+                  nextRawChar()
+                  getRawStringLit()
+                }
+                else {
+                  token = STRINGLIT
+                  strVal = ""
+                }
+              }
+              else
+                getStringLit()
+            }
+          fetchDoubleQuote()
+        case '\'' =>
+          def fetchSingleQuote(): Unit = {
+            nextChar()
+            if isIdentifierStart(ch) then
+              charLitOr { getIdentRest(); QUOTEID }
+            else if isOperatorPart(ch) && ch != '\\' then
+              charLitOr { getOperatorRest(); QUOTEID }
+            else ch match {
+              case '{' | '[' | ' ' | '\t' if lookaheadChar() != '\'' =>
+                token = QUOTE
+              case _ if !isAtEnd && ch != SU && ch != CR && ch != LF =>
+                val isEmptyCharLit = (ch == '\'')
+                getLitChar()
+                if ch == '\'' then
+                  if isEmptyCharLit then error("empty character literal (use '\\'' for single quote)")
+                  else if litBuf.length != 1 then error("illegal codepoint in Char constant: " + litBuf.toString.map(toUnicode).mkString("'", "", "'"))
+                  else finishCharLit()
+                else if isEmptyCharLit then error("empty character literal")
+                else error("unclosed character literal")
+              case _ =>
+                error("unclosed character literal")
+            }
+          }
+          fetchSingleQuote()
+        case '.' =>
+          nextChar()
+          if ('0' <= ch && ch <= '9') {
+            putChar('.'); getFraction(); setStrVal()
+          }
+          else
+            token = DOT
+        case ';' =>
+          nextChar(); token = SEMI
+        case ',' =>
+          nextChar(); token = COMMA
+        case '(' =>
+          nextChar(); token = LPAREN
+        case '{' =>
+          nextChar(); token = LBRACE
+        case ')' =>
+          nextChar(); token = RPAREN
+        case '}' =>
+          if (inMultiLineInterpolatedExpression) nextRawChar() else nextChar()
+          token = RBRACE
+        case '[' =>
+          nextChar(); token = LBRACKET
+        case ']' =>
+          nextChar(); token = RBRACKET
+        case SU =>
+          if (isAtEnd) token = EOF
+          else {
+            error("illegal character")
+            nextChar()
+          }
+        case _ =>
+          def fetchOther() =
+            if (ch == '\u21D2') {
+              nextChar(); token = ARROW
+              report.deprecationWarning("The unicode arrow `⇒` is deprecated, use `=>` instead. If you still wish to display it as one character, consider using a font with programming ligatures such as Fira Code.", sourcePos(offset))
+            }
+            else if (ch == '\u2190') {
+              nextChar(); token = LARROW
+              report.deprecationWarning("The unicode arrow `←` is deprecated, use `<-` instead. If you still wish to display it as one character, consider using a font with programming ligatures such as Fira Code.", sourcePos(offset))
+            }
+            else if (Character.isUnicodeIdentifierStart(ch)) {
+              putChar(ch)
+              nextChar()
+              getIdentRest()
+            }
+            else if (isSpecial(ch)) {
+              putChar(ch)
+              nextChar()
+              getOperatorRest()
+            }
+            else if isSupplementary(ch, isUnicodeIdentifierStart) then
+              getIdentRest()
+            else {
+              error(s"illegal character '${toUnicode(ch)}'")
+              nextChar()
+            }
+          fetchOther()
+      }
+    }
+
+    private def skipComment(): Boolean = {
+      def appendToComment(ch: Char) =
+        if (keepComments) commentBuf.append(ch)
+      def nextChar() = {
+        appendToComment(ch)
+        Scanner.this.nextChar()
+      }
+      def skipLine(): Unit = {
+        nextChar()
+        if ((ch != CR) && (ch != LF) && (ch != SU)) skipLine()
+      }
+      @tailrec
+      def skipComment(): Unit =
+        if (ch == '/') {
+          nextChar()
+          if (ch == '*') nestedComment()
+          skipComment()
+        }
+        else if (ch == '*') {
+          while ({ nextChar() ; ch == '*' }) ()
+          if (ch == '/') nextChar()
+          else skipComment()
+        }
+        else if (ch == SU) incompleteInputError("unclosed comment")
+        else { nextChar(); skipComment() }
+      def nestedComment() = { nextChar(); skipComment() }
+      val start = lastCharOffset
+      def finishComment(): Boolean = {
+        if (keepComments) {
+          val pos = Span(start, charOffset - 1, start)
+          val comment = Comment(pos, commentBuf.toString)
+          commentBuf.clear()
+          commentPosBuf += pos
+
+          if (comment.isDocComment)
+            addComment(comment)
+          else
+            // "forward" doc comments over normal ones
+            getDocComment(start).foreach(addComment)
+        }
+
+        true
+      }
+      nextChar()
+      if (ch == '/') { skipLine(); finishComment() }
+      else if (ch == '*') { nextChar(); skipComment(); finishComment() }
+      else {
+        // This was not a comment, remove the `/` from the buffer
+        commentBuf.clear()
+        false
+      }
+    }
+
+// Lookahead ---------------------------------------------------------------
+
+    /** The next token after this one.
+     *  The token is computed via fetchToken, so complex two word
+     *  tokens such as CASECLASS are not recognized.
+     *  Newlines and indent/unindent tokens are skipped.
+     *  Restriction: `lookahead` is illegal if the current token is INTERPOLATIONID
+     */
+    def lookahead: TokenData =
+      if next.token == EMPTY then
+        assert(token != INTERPOLATIONID)
+          // INTERPOLATONIDs are followed by a string literal, which can set next
+          // in peekAhead(). In that case, the following reset() would forget that token.
+        peekAhead()
+        reset()
+      next
+
+    class LookaheadScanner(val allowIndent: Boolean = false) extends Scanner(source, offset, allowIndent = allowIndent) {
+      override def languageImportContext = Scanner.this.languageImportContext
+    }
+
+    /** Skip matching pairs of `(...)` or `[...]` parentheses.
+     *  @pre  The current token is `(` or `[`
+     */
+    final def skipParens(multiple: Boolean = true): Unit =
+      val opening = token
+      nextToken()
+      while token != EOF && token != opening + 1 do
+        if token == opening && multiple then skipParens() else nextToken()
+      nextToken()
+
+    /** Is the current token in a position where a modifier is allowed? */
+    def inModifierPosition(): Boolean = {
+      val lookahead = LookaheadScanner()
+      while
+        lookahead.nextToken()
+        lookahead.isNewLine || lookahead.isSoftModifier
+      do ()
+      modifierFollowers.contains(lookahead.token)
+    }
+
+// Identifiers ---------------------------------------------------------------
+
+    private def getBackquotedIdent(): Unit = {
+      nextChar()
+      getLitChars('`')
+      if (ch == '`') {
+        nextChar()
+        finishNamedToken(BACKQUOTED_IDENT, target = this)
+        if (name.length == 0)
+          error("empty quoted identifier")
+        else if (name == nme.WILDCARD)
+          error("wildcard invalid as backquoted identifier")
+      }
+      else error("unclosed quoted identifier")
+    }
+
+    private def getIdentRest(): Unit = (ch: @switch) match {
+      case 'A' | 'B' | 'C' | 'D' | 'E' |
+           'F' | 'G' | 'H' | 'I' | 'J' |
+           'K' | 'L' | 'M' | 'N' | 'O' |
+           'P' | 'Q' | 'R' | 'S' | 'T' |
+           'U' | 'V' | 'W' | 'X' | 'Y' |
+           'Z' | '$' |
+           'a' | 'b' | 'c' | 'd' | 'e' |
+           'f' | 'g' | 'h' | 'i' | 'j' |
+           'k' | 'l' | 'm' | 'n' | 'o' |
+           'p' | 'q' | 'r' | 's' | 't' |
+           'u' | 'v' | 'w' | 'x' | 'y' |
+           'z' |
+           '0' | '1' | '2' | '3' | '4' |
+           '5' | '6' | '7' | '8' | '9' =>
+        putChar(ch)
+        nextChar()
+        getIdentRest()
+      case '_' =>
+        putChar(ch)
+        nextChar()
+        getIdentOrOperatorRest()
+      case SU => // strangely enough, Character.isUnicodeIdentifierPart(SU) returns true!
+        finishNamed()
+      case _ =>
+        if isUnicodeIdentifierPart(ch) then
+          putChar(ch)
+          nextChar()
+          getIdentRest()
+        else if isSupplementary(ch, isUnicodeIdentifierPart) then
+          getIdentRest()
+        else
+          finishNamed()
+    }
+
+    private def getOperatorRest(): Unit = (ch: @switch) match {
+      case '~' | '!' | '@' | '#' | '%' |
+           '^' | '*' | '+' | '-' | '<' |
+           '>' | '?' | ':' | '=' | '&' |
+           '|' | '\\' =>
+        putChar(ch); nextChar(); getOperatorRest()
+      case '/' =>
+        val nxch = lookaheadChar()
+        if nxch == '/' || nxch == '*' then finishNamed()
+        else { putChar(ch); nextChar(); getOperatorRest() }
+      case _ =>
+        if (isSpecial(ch)) { putChar(ch); nextChar(); getOperatorRest() }
+        else finishNamed()
+    }
+
+    private def getIdentOrOperatorRest(): Unit =
+      if (isIdentifierPart(ch))
+        getIdentRest()
+      else ch match {
+        case '~' | '!' | '@' | '#' | '%' |
+             '^' | '*' | '+' | '-' | '<' |
+             '>' | '?' | ':' | '=' | '&' |
+             '|' | '\\' | '/' =>
+          getOperatorRest()
+        case _ =>
+          if (isSpecial(ch)) getOperatorRest()
+          else finishNamed()
+      }
+
+    def isSoftModifier: Boolean =
+      token == IDENTIFIER
+      && (softModifierNames.contains(name) || name == nme.erased && erasedEnabled)
+
+    def isSoftModifierInModifierPosition: Boolean =
+      isSoftModifier && inModifierPosition()
+
+    def isSoftModifierInParamModifierPosition: Boolean =
+      isSoftModifier && !lookahead.isColon
+
+    def isErased: Boolean = isIdent(nme.erased) && erasedEnabled
+
+    def canStartStatTokens =
+      if migrateTo3 then canStartStatTokens2 else canStartStatTokens3
+
+    def canStartExprTokens =
+      if migrateTo3 then canStartExprTokens2 else canStartExprTokens3
+
+// Literals -----------------------------------------------------------------
+
+    private def getStringLit() = {
+      getLitChars('"')
+      if (ch == '"') {
+        setStrVal()
+        nextChar()
+        token = STRINGLIT
+      }
+      else error("unclosed string literal")
+    }
+
+    private def getRawStringLit(): Unit =
+      if (ch == '\"') {
+        nextRawChar()
+        if (isTripleQuote()) {
+          setStrVal()
+          token = STRINGLIT
+        }
+        else
+          getRawStringLit()
+      }
+      else if (ch == SU)
+        incompleteInputError("unclosed multi-line string literal")
+      else {
+        putChar(ch)
+        nextRawChar()
+        getRawStringLit()
+      }
+
+    // for interpolated strings
+    @tailrec private def getStringPart(multiLine: Boolean): Unit =
+      if (ch == '"')
+        if (multiLine) {
+          nextRawChar()
+          if (isTripleQuote()) {
+            setStrVal()
+            token = STRINGLIT
+          }
+          else
+            getStringPart(multiLine)
+        }
+        else {
+          nextChar()
+          setStrVal()
+          token = STRINGLIT
+        }
+      else if (ch == '\\' && !multiLine) {
+        putChar(ch)
+        nextRawChar()
+        if (ch == '"' || ch == '\\')
+          putChar(ch)
+          nextRawChar()
+        getStringPart(multiLine)
+      }
+      else if (ch == '$') {
+        def getInterpolatedIdentRest(hasSupplement: Boolean): Unit =
+          @tailrec def loopRest(): Unit =
+            if ch != SU && isUnicodeIdentifierPart(ch) then
+              putChar(ch) ; nextRawChar()
+              loopRest()
+            else if atSupplementary(ch, isUnicodeIdentifierPart) then
+              putChar(ch) ; nextRawChar()
+              putChar(ch) ; nextRawChar()
+              loopRest()
+            else
+              finishNamedToken(IDENTIFIER, target = next)
+          end loopRest
+          setStrVal()
+          token = STRINGPART
+          next.lastOffset = charOffset - 1
+          next.offset = charOffset - 1
+          putChar(ch) ; nextRawChar()
+          if hasSupplement then
+            putChar(ch) ; nextRawChar()
+          loopRest()
+        end getInterpolatedIdentRest
+
+        nextRawChar()
+        if (ch == '$' || ch == '"') {
+          putChar(ch)
+          nextRawChar()
+          getStringPart(multiLine)
+        }
+        else if (ch == '{') {
+          setStrVal()
+          token = STRINGPART
+        }
+        else if isUnicodeIdentifierStart(ch) || ch == '_' then
+          getInterpolatedIdentRest(hasSupplement = false)
+        else if atSupplementary(ch, isUnicodeIdentifierStart) then
+          getInterpolatedIdentRest(hasSupplement = true)
+        else
+          error("invalid string interpolation: `$$`, `$\"`, `$`ident or `$`BlockExpr expected", off = charOffset - 2)
+          putChar('$')
+          getStringPart(multiLine)
+      }
+      else {
+        val isUnclosedLiteral = !isUnicodeEscape && (ch == SU || (!multiLine && (ch == CR || ch == LF)))
+        if (isUnclosedLiteral)
+          if (multiLine)
+            incompleteInputError("unclosed multi-line string literal")
+          else
+            error("unclosed string literal")
+        else {
+          putChar(ch)
+          nextRawChar()
+          getStringPart(multiLine)
+        }
+      }
+    end getStringPart
+
+    private def fetchStringPart(multiLine: Boolean) = {
+      offset = charOffset - 1
+      getStringPart(multiLine)
+    }
+
+    private def isTripleQuote(): Boolean =
+      if (ch == '"') {
+        nextRawChar()
+        if (ch == '"') {
+          nextChar()
+          while (ch == '"') {
+            putChar('"')
+            nextChar()
+          }
+          true
+        }
+        else {
+          putChar('"')
+          putChar('"')
+          false
+        }
+      }
+      else {
+        putChar('"')
+        false
+      }
+
+    /** Copy current character into cbuf, interpreting any escape sequences,
+     *  and advance to next character. Surrogate pairs are consumed (see check
+     *  at fetchSingleQuote), but orphan surrogate is allowed.
+     */
+    protected def getLitChar(): Unit =
+      if ch == '\\' then
+        nextChar()
+        charEscape()
+      else if !isSupplementary(ch, _ => true, strict = false) then
+        putChar(ch)
+        nextChar()
+
+    private def charEscape(): Unit =
+      var bump = true
+      ch match
+        case 'b'  => putChar('\b')
+        case 't'  => putChar('\t')
+        case 'n'  => putChar('\n')
+        case 'f'  => putChar('\f')
+        case 'r'  => putChar('\r')
+        case '\"' => putChar('\"')
+        case '\'' => putChar('\'')
+        case '\\' => putChar('\\')
+        case 'u' |
+             'U'  => uEscape(); bump = false
+        case x if '0' <= x && x <= '7' => octalEscape(); bump = false
+        case _    => invalidEscape()
+      if bump then nextChar()
+    end charEscape
+
+    private def uEscape(): Unit =
+      while ch == 'u' || ch == 'U' do nextChar()
+      var i  = 0
+      var cp = 0
+      while i < 4 do
+        val digit = digit2int(ch, 16)
+        if digit < 0 then
+          error("invalid character in unicode escape sequence", charOffset - 1)
+          putChar(ch)
+          return
+        val shift = (3 - i) * 4
+        cp += digit << shift
+        nextChar()
+        i += 1
+      end while
+      putChar(cp.asInstanceOf[Char])
+    end uEscape
+
+    private def octalEscape(): Unit =
+      val start = charOffset - 2
+      val leadch: Char = ch
+      var oct: Int = digit2int(ch, 8)
+      nextChar()
+      if '0' <= ch && ch <= '7' then
+        oct = oct * 8 + digit2int(ch, 8)
+        nextChar()
+        if leadch <= '3' && '0' <= ch && ch <= '7' then
+          oct = oct * 8 + digit2int(ch, 8)
+          nextChar()
+      val alt = if oct == LF then raw"\n" else toUnicode(oct.toChar)
+      error(s"octal escape literals are unsupported: use $alt instead", start)
+      putChar(oct.toChar)
+    end octalEscape
+
+    protected def invalidEscape(): Unit =
+      error("invalid escape character", charOffset - 1)
+      putChar(ch)
+
+    private def getLitChars(delimiter: Char) =
+      while (ch != delimiter && !isAtEnd && (ch != SU && ch != CR && ch != LF || isUnicodeEscape))
+        getLitChar()
+
+    /** read fractional part and exponent of floating point number
+     *  if one is present.
+     */
+    protected def getFraction(): Unit = {
+      token = DECILIT
+      while ('0' <= ch && ch <= '9' || isNumberSeparator(ch)) {
+        putChar(ch)
+        nextChar()
+      }
+      checkNoTrailingSeparator()
+      if (ch == 'e' || ch == 'E') {
+        val lookahead = lookaheadReader()
+        lookahead.nextChar()
+        if (lookahead.ch == '+' || lookahead.ch == '-')
+          lookahead.nextChar()
+        if ('0' <= lookahead.ch && lookahead.ch <= '9' || isNumberSeparator(ch)) {
+          putChar(ch)
+          nextChar()
+          if (ch == '+' || ch == '-') {
+            putChar(ch)
+            nextChar()
+          }
+          while ('0' <= ch && ch <= '9' || isNumberSeparator(ch)) {
+            putChar(ch)
+            nextChar()
+          }
+          checkNoTrailingSeparator()
+        }
+        token = EXPOLIT
+      }
+      if (ch == 'd' || ch == 'D') {
+        putChar(ch)
+        nextChar()
+        token = DOUBLELIT
+      }
+      else if (ch == 'f' || ch == 'F') {
+        putChar(ch)
+        nextChar()
+        token = FLOATLIT
+      }
+      checkNoLetter()
+    }
+    def checkNoLetter(): Unit =
+      if (isIdentifierPart(ch) && ch >= ' ')
+        error("Invalid literal number")
+
+    /** Read a number into strVal and set base
+    */
+    protected def getNumber(): Unit = {
+      while (isNumberSeparator(ch) || digit2int(ch, base) >= 0) {
+        putChar(ch)
+        nextChar()
+      }
+      checkNoTrailingSeparator()
+      token = INTLIT
+      if (base == 10 && ch == '.') {
+        val lch = lookaheadChar()
+        if ('0' <= lch && lch <= '9') {
+          putChar('.')
+          nextChar()
+          getFraction()
+        }
+      }
+      else (ch: @switch) match {
+        case 'e' | 'E' | 'f' | 'F' | 'd' | 'D' =>
+          if (base == 10) getFraction()
+        case 'l' | 'L' =>
+          nextChar()
+          token = LONGLIT
+        case _ =>
+      }
+
+      checkNoTrailingSeparator()
+
+      setStrVal()
+    }
+
+    private def finishCharLit(): Unit = {
+      nextChar()
+      token = CHARLIT
+      setStrVal()
+    }
+
+    /** Parse character literal if current character is followed by \',
+     *  or follow with given op and return a symbol literal token
+     */
+    def charLitOr(op: => Token): Unit = {
+      putChar(ch)
+      nextChar()
+      if (ch == '\'') finishCharLit()
+      else {
+        token = op
+        strVal = if (name != null) name.toString else null
+        litBuf.clear()
+      }
+    }
+
+    override def toString: String =
+      showTokenDetailed(token) + {
+        if identifierTokens.contains(token) then s" $name"
+        else if literalTokens.contains(token) then s" $strVal"
+        else ""
+      }
+
+    def show: String = token match {
+      case IDENTIFIER | BACKQUOTED_IDENT => s"id($name)"
+      case CHARLIT => s"char($strVal)"
+      case INTLIT => s"int($strVal, base = $base)"
+      case LONGLIT => s"long($strVal, base = $base)"
+      case FLOATLIT => s"float($strVal)"
+      case DOUBLELIT => s"double($strVal)"
+      case STRINGLIT => s"string($strVal)"
+      case STRINGPART => s"stringpart($strVal)"
+      case INTERPOLATIONID => s"interpolationid($name)"
+      case SEMI => ";"
+      case NEWLINE => ";"
+      case NEWLINES => ";;"
+      case COMMA => ","
+      case COLONfollow | COLONeol => "':'"
+      case _ =>
+        if debugTokenStream then showTokenDetailed(token) else showToken(token)
+    }
+
+    /* Resume normal scanning after XML */
+    def resume(lastTokenData: TokenData): Unit = {
+      this.copyFrom(lastTokenData)
+      if (next.token != EMPTY && !ctx.reporter.hasErrors)
+        error("unexpected end of input: possible missing '}' in XML block")
+
+      nextToken()
+    }
+
+   /* Initialization: read first char, then first token */
+    nextChar()
+    nextToken()
+    currentRegion = topLevelRegion(indentWidth(offset))
+  }
+  end Scanner
+
+  /** A Region indicates what encloses the current token. It can be one of the following
+   *
+   *   InString    a string interpolation
+   *   InParens    a pair of parentheses (...) or brackets [...]
+   *   InBraces    a pair of braces { ... }
+   *   Indented    a pair of <indent> ... <outdent> tokens
+   */
+  abstract class Region(val closedBy: Token) extends caps.Pure:
+
+   /** The region enclosing this one, or `null` for the outermost region */
+    def outer: Region | Null
+
+    /** Is this region the outermost region? */
+    def isOutermost = outer == null
+
+    /** The enclosing region, which is required to exist */
+    def enclosing: Region = outer.asInstanceOf[Region]
+
+    var knownWidth: IndentWidth | Null = null
+
+    /** The indentation width, Zero if not known */
+    final def indentWidth: IndentWidth =
+      if knownWidth == null then IndentWidth.Zero else knownWidth
+
+    def proposeKnownWidth(width: IndentWidth, lastToken: Token) =
+      if knownWidth == null then
+        this match
+          case InParens(_, _) if lastToken != LPAREN =>
+            useOuterWidth()
+          case _ =>
+            knownWidth = width
+
+    private def useOuterWidth(): Unit =
+      if enclosing.knownWidth == null then enclosing.useOuterWidth()
+      knownWidth = enclosing.knownWidth
+
+    /** Does `width` represent an undent of an enclosing indentation region?
+     *  This is the case if there is an indentation region that goes deeper than `width`
+     *  and that is enclosed in a region that contains `width` as an indentation width.
+     */
+    def isClosedByUndentAt(width: IndentWidth): Boolean = this match
+      case _: Indented =>
+        !isOutermost && width <= indentWidth && enclosing.coversIndent(width)
+      case _ =>
+        enclosing.isClosedByUndentAt(width)
+
+    /** A region "covers" an indentation with `width` if it has `width` as known
+     *  indentation width (either as primary, or in case of an Indent region as
+     *  alternate width).
+     */
+    protected def coversIndent(w: IndentWidth): Boolean =
+      knownWidth != null && w == indentWidth
+
+    private var myCommasExpected: Boolean = false
+
+    inline def withCommasExpected[T](inline op: => T): T =
+      val saved = myCommasExpected
+      myCommasExpected = true
+      val res = op
+      myCommasExpected = false
+      res
+
+    def commasExpected = myCommasExpected
+
+    def toList: List[Region] =
+      this :: (if outer == null then Nil else outer.toList)
+
+    private def delimiter = this match
+      case _: InString => "}(in string)"
+      case InParens(LPAREN, _) => ")"
+      case InParens(LBRACKET, _) => "]"
+      case _: InBraces => "}"
+      case _: InCase => "=>"
+      case _: Indented => "UNDENT"
+
+    /** Show open regions as list of lines with decreasing indentations */
+    def visualize: String =
+      toList.map(r => s"${r.indentWidth.toPrefix}${r.delimiter}").mkString("\n")
+
+    override def toString: String =
+      toList.map(r => s"(${r.indentWidth}, ${r.delimiter})").mkString(" in ")
+  end Region
+
+  case class InString(multiLine: Boolean, outer: Region) extends Region(RBRACE)
+  case class InParens(prefix: Token, outer: Region) extends Region(prefix + 1)
+  case class InBraces(outer: Region) extends Region(RBRACE)
+  case class InCase(outer: Region) extends Region(OUTDENT)
+
+  /** A class describing an indentation region.
+   *  @param width   The principal indendation width
+   *  @param prefix  The token before the initial <indent> of the region
+   */
+  case class Indented(width: IndentWidth, prefix: Token, outer: Region | Null) extends Region(OUTDENT):
+    knownWidth = width
+
+    /** Other indendation widths > width of lines in the same region */
+    var otherIndentWidths: Set[IndentWidth] = Set()
+
+    override def coversIndent(w: IndentWidth) = width == w || otherIndentWidths.contains(w)
+  end Indented
+
+  def topLevelRegion(width: IndentWidth) = Indented(width, EMPTY, null)
+
+  enum IndentWidth {
+    case Run(ch: Char, n: Int)
+    case Conc(l: IndentWidth, r: Run)
+
+    def <= (that: IndentWidth): Boolean = this match {
+      case Run(ch1, n1) =>
+        that match {
+          case Run(ch2, n2) => n1 <= n2 && (ch1 == ch2 || n1 == 0)
+          case Conc(l, r) => this <= l
+        }
+      case Conc(l1, r1) =>
+        that match {
+          case Conc(l2, r2) => l1 == l2 && r1 <= r2
+          case _ => false
+        }
+    }
+
+    def < (that: IndentWidth): Boolean = this <= that && !(that <= this)
+
+    def toPrefix: String = this match {
+      case Run(ch, n) => ch.toString * n
+      case Conc(l, r) => l.toPrefix ++ r.toPrefix
+    }
+
+    override def toString: String = {
+      def kind(ch: Char) = ch match {
+        case ' ' => "space"
+        case '\t' => "tab"
+        case _ => s"'$ch'-character"
+      }
+      this match {
+        case Run(ch, n) => s"$n ${kind(ch)}${if (n == 1) "" else "s"}"
+        case Conc(l, r) => s"$l, $r"
+      }
+    }
+  }
+
+  object IndentWidth {
+    private inline val MaxCached = 40
+    private val spaces = Array.tabulate(MaxCached + 1)(new Run(' ', _))
+    private val tabs = Array.tabulate(MaxCached + 1)(new Run('\t', _))
+
+    def Run(ch: Char, n: Int): Run =
+      if (n <= MaxCached && ch == ' ') spaces(n)
+      else if (n <= MaxCached && ch == '\t') tabs(n)
+      else new Run(ch, n)
+
+    val Zero = Run(' ', 0)
+  }
+
+  // ------------- keyword configuration -----------------------------------
+
+  private val (lastKeywordStart, kwArray) = buildKeywordArray(keywords)
+}
diff --git a/tests/pos-with-compiler-cc/dotc/parsing/ScriptParsers.scala b/tests/pos-with-compiler-cc/dotc/parsing/ScriptParsers.scala
new file mode 100644
index 000000000000..d11db73b0455
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/parsing/ScriptParsers.scala
@@ -0,0 +1,147 @@
+package dotty.tools
+package dotc
+package parsing
+
+import util.SourceFile
+import core._
+import Contexts._
+import Parsers._
+
+
+/** <p>Performs the following context-free rewritings:</p>
+ *  <ol>
+ *    <li>
+ *      Places all pattern variables in Bind nodes. In a pattern, for
+ *      identifiers <code>x</code>:<pre>
+ *                 x  => x @ _
+ *               x:T  => x @ (_ : T)</pre>
+ *    </li>
+ *    <li>Removes pattern definitions (PatDef's) as follows:
+ *      If pattern is a simple (typed) identifier:<pre>
+ *        <b>val</b> x = e     ==>  <b>val</b> x = e
+ *        <b>val</b> x: T = e  ==>  <b>val</b> x: T = e</pre>
+ *
+ *      if there are no variables in pattern<pre>
+ *        <b>val</b> p = e  ==>  e match (case p => ())</pre>
+ *
+ *      if there is exactly one variable in pattern<pre>
+ *        <b>val</b> x_1 = e <b>match</b> (case p => (x_1))</pre>
+ *
+ *      if there is more than one variable in pattern<pre>
+ *        <b>val</b> p = e  ==>  <b>private synthetic val</b> t$ = e <b>match</b> (case p => (x_1, ..., x_N))
+ *                        <b>val</b> x_1 = t$._1
+ *                        ...
+ *                        <b>val</b> x_N = t$._N</pre>
+ *    </li>
+ *    <li>
+ *       Removes function types as follows:<pre>
+ *        (argtpes) => restpe   ==>   scala.Function_n[argtpes, restpe]</pre>
+ *    </li>
+ *    <li>
+ *      Wraps naked case definitions in a match as follows:<pre>
+ *        { cases }   ==>   (x => x.match {cases})<span style="font-family:normal;">, except when already argument to match</span></pre>
+ *    </li>
+ *  </ol>
+ */
+object ScriptParsers {
+
+  import ast.untpd._
+
+  class ScriptParser(source: SourceFile)(using Context) extends Parser(source) {
+
+    /** This is the parse entry point for code which is not self-contained, e.g.
+     *  a script which is a series of template statements.  They will be
+     *  swaddled in Trees until the AST is equivalent to the one returned
+     *  by compilationUnit().
+     */
+    override def parse(): Tree = unsupported("parse")
+  }
+}
+
+    /* TODO: reinstantiate
+
+      val stmts = templateStatSeq(false)._2
+      accept(EOF)
+
+      def mainModuleName = ctx.settings.script.value
+
+      /** If there is only a single object template in the file and it has a
+       *  suitable main method, we will use it rather than building another object
+       *  around it.  Since objects are loaded lazily the whole script would have
+       *  been a no-op, so we're not taking much liberty.
+       */
+      def searchForMain(): Option[Tree] = {
+        /** Have to be fairly liberal about what constitutes a main method since
+         *  nothing has been typed yet - for instance we can't assume the parameter
+         *  type will look exactly like "Array[String]" as it could have been renamed
+         *  via import, etc.
+         */
+        def isMainMethod(t: Tree) = t match {
+          case DefDef(_, nme.main, Nil, List(_), _, _)  => true
+          case _                                        => false
+        }
+        /** For now we require there only be one top level object. */
+        var seenModule = false
+        val newStmts = stmts collect {
+          case t @ Import(_, _) => t
+          case md @ ModuleDef(mods, name, template)
+            if !seenModule && (template.body exists isMainMethod) =>
+            seenModule = true
+            /** This slightly hacky situation arises because we have no way to communicate
+             *  back to the scriptrunner what the name of the program is.  Even if we were
+             *  willing to take the sketchy route of settings.script.value = progName, that
+             *  does not work when using fsc.  And to find out in advance would impose a
+             *  whole additional parse.  So instead, if the actual object's name differs from
+             *  what the script is expecting, we transform it to match.
+             */
+            md.derivedModuleDef(mods, mainModuleName.toTermName, template)
+          case _ =>
+            /** If we see anything but the above, fail. */
+            return None
+        }
+        Some(makePackaging(0, emptyPkg, newStmts))
+      }
+
+      if (mainModuleName == ScriptRunner.defaultScriptMain)
+        searchForMain() foreach { return _ }
+
+      /** Here we are building an AST representing the following source fiction,
+       *  where <moduleName> is from -Xscript (defaults to "Main") and <stmts> are
+       *  the result of parsing the script file.
+       *
+       *  object <moduleName> {
+       *    def main(argv: Array[String]): Unit = {
+       *      val args = argv
+       *      new AnyRef {
+       *        <stmts>
+       *      }
+       *    }
+       *  }
+       */
+      import definitions._
+
+      def emptyPkg    = atPos(0, 0, 0) { Ident(nme.EMPTY_PACKAGE_NAME) }
+      def emptyInit   = DefDef(
+        Modifiers(),
+        nme.CONSTRUCTOR,
+        Nil,
+        List(Nil),
+        TypeTree(),
+        Block(List(Apply(Select(Super(This(tpnme.EMPTY), tpnme.EMPTY), nme.CONSTRUCTOR), Nil)), Literal(Constant(())))
+      )
+
+      // def main
+      def mainParamType = AppliedTypeTree(Ident(tpnme.Array), List(Ident(tpnme.String)))
+      def mainParameter = List(ValDef(Modifiers(Param), "argv", mainParamType, EmptyTree))
+      def mainSetArgv   = List(ValDef(Modifiers(), "args", TypeTree(), Ident("argv")))
+      def mainNew       = makeNew(Nil, emptyValDef, stmts, List(Nil), NoPosition, NoPosition)
+      def mainDef       = DefDef(Modifiers(), nme.main, Nil, List(mainParameter), scalaDot(tpnme.Unit), Block(mainSetArgv, mainNew))
+
+      // object Main
+      def moduleName  = ScriptRunner scriptMain settings
+      def moduleBody  = Template(List(scalaScalaObjectConstr), emptyValDef, List(emptyInit, mainDef))
+      def moduleDef   = ModuleDef(Modifiers(), moduleName, moduleBody)
+
+      // package <empty> { ... }
+      makePackaging(0, emptyPkg, List(moduleDef))
+    }*/
diff --git a/tests/pos-with-compiler-cc/dotc/parsing/Tokens.scala b/tests/pos-with-compiler-cc/dotc/parsing/Tokens.scala
new file mode 100644
index 000000000000..7d27b3ca82b9
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/parsing/Tokens.scala
@@ -0,0 +1,298 @@
+package dotty.tools
+package dotc
+package parsing
+
+import scala.language.unsafeNulls
+
+import collection.immutable.BitSet
+import core.Decorators._
+import core.StdNames.nme
+
+abstract class TokensCommon {
+  def maxToken: Int
+
+  type Token = Int
+  type TokenSet = BitSet
+
+  def tokenRange(lo: Int, hi: Int): TokenSet = BitSet(lo to hi: _*)
+
+  val tokenString, debugString: Array[String] = new Array[String](maxToken + 1)
+
+  def enter(token: Int, str: String, debugStr: String = ""): Unit = {
+    assert(tokenString(token) == null)
+    tokenString(token) = str
+    debugString(token) = if (debugStr.isEmpty) str else debugStr
+  }
+
+  /** special tokens */
+  inline val EMPTY = 0;             enter(EMPTY, "<empty>") // a missing token, used in lookahead
+  inline val ERROR = 1;             enter(ERROR, "erroneous token") // an erroneous token
+  inline val EOF = 2;               enter(EOF, "eof")
+
+  /** literals */
+  inline val CHARLIT = 3;           enter(CHARLIT, "character literal")
+  inline val INTLIT = 4;            enter(INTLIT, "integer literal")
+  inline val DECILIT = 5;           enter(DECILIT, "number literal")  // with decimal point
+  inline val EXPOLIT = 6;           enter(EXPOLIT, "number literal with exponent")
+  inline val LONGLIT = 7;           enter(LONGLIT, "long literal")
+  inline val FLOATLIT = 8;          enter(FLOATLIT, "float literal")
+  inline val DOUBLELIT = 9;         enter(DOUBLELIT, "double literal")
+  inline val STRINGLIT = 10;         enter(STRINGLIT, "string literal")
+  inline val STRINGPART = 11;       enter(STRINGPART, "string literal", "string literal part")
+  //inline val INTERPOLATIONID = 12;  enter(INTERPOLATIONID, "string interpolator")
+  //inline val QUOTEID = 13;        enter(QUOTEID, "quoted identifier") // TODO: deprecate
+
+  /** identifiers */
+  inline val IDENTIFIER = 14;       enter(IDENTIFIER, "identifier")
+  //inline val BACKQUOTED_IDENT = 15; enter(BACKQUOTED_IDENT, "identifier", "backquoted ident")
+
+  /** alphabetic keywords */
+  inline val IF = 20;               enter(IF, "if")
+  inline val FOR = 21;              enter(FOR, "for")
+  inline val ELSE = 22;             enter(ELSE, "else")
+  inline val THIS = 23;             enter(THIS, "this")
+  inline val NULL = 24;             enter(NULL, "null")
+  inline val NEW = 25;              enter(NEW, "new")
+  //inline val WITH = 26;             enter(WITH, "with")
+  inline val SUPER = 27;            enter(SUPER, "super")
+  //inline val CASE = 28;             enter(CASE, "case")
+  //inline val CASECLASS = 29;        enter(CASECLASS, "case class")
+  //inline val CASEOBJECT = 30;       enter(CASEOBJECT, "case object")
+  //inline val VAL = 31;              enter(VAL, "val")
+  inline val ABSTRACT = 32;         enter(ABSTRACT, "abstract")
+  inline val FINAL = 33;            enter(FINAL, "final")
+  inline val PRIVATE = 34;          enter(PRIVATE, "private")
+  inline val PROTECTED = 35;        enter(PROTECTED, "protected")
+  inline val OVERRIDE = 36;         enter(OVERRIDE, "override")
+  //inline val IMPLICIT = 37;         enter(IMPLICIT, "implicit")
+  //inline val VAR = 38;              enter(VAR, "var")
+  //inline val DEF = 39;              enter(DEF, "def")
+  //inline val TYPE = 40;             enter(TYPE, "type")
+  inline val EXTENDS = 41;          enter(EXTENDS, "extends")
+  inline val TRUE = 42;             enter(TRUE, "true")
+  inline val FALSE = 43;            enter(FALSE, "false")
+  //inline val OBJECT = 44;           enter(OBJECT, "object")
+  inline val CLASS = 45;            enter(CLASS, "class")
+  inline val IMPORT = 46;           enter(IMPORT, "import")
+  inline val PACKAGE = 47;          enter(PACKAGE, "package")
+  //inline val YIELD = 48;            enter(YIELD, "yield")
+  inline val DO = 49;               enter(DO, "do")
+  //inline val TRAIT = 50;            enter(TRAIT, "trait")
+  //inline val SEALED = 51;           enter(SEALED, "sealed")
+  inline val THROW = 52;            enter(THROW, "throw")
+  inline val TRY = 53;              enter(TRY, "try")
+  inline val CATCH = 54;            enter(CATCH, "catch")
+  inline val FINALLY = 55;          enter(FINALLY, "finally")
+  inline val WHILE = 56;            enter(WHILE, "while")
+  inline val RETURN = 57;           enter(RETURN, "return")
+  //inline val MATCH = 58;            enter(MATCH, "match")
+  //inline val LAZY = 59;             enter(LAZY, "lazy")
+  //inline val THEN = 60;             enter(THEN, "then")
+  //inline val FORSOME = 61;          enter(FORSOME, "forSome") // TODO: deprecate
+  //inline val ENUM = 62;             enter(ENUM, "enum")
+
+  /** special symbols */
+  inline val COMMA = 70;            enter(COMMA, "','")
+  inline val SEMI = 71;             enter(SEMI, "';'")
+  inline val DOT = 72;              enter(DOT, "'.'")
+  //inline val NEWLINE = 78;          enter(NEWLINE, "end of statement", "new line")
+  //inline val NEWLINES = 79;         enter(NEWLINES, "end of statement", "new lines")
+
+  /** special keywords */
+  //inline val USCORE = 73;           enter(USCORE, "_")
+  inline val COLONop = 74;          enter(COLONop, ":")  // a stand-alone `:`, see also COLONfollow
+  inline val EQUALS = 75;           enter(EQUALS, "=")
+  //inline val LARROW = 76;           enter(LARROW, "<-")
+  //inline val ARROW = 77;            enter(ARROW, "=>")
+  //inline val SUBTYPE = 80;          enter(SUBTYPE, "<:")
+  //inline val SUPERTYPE = 81;        enter(SUPERTYPE, ">:")
+  //inline val HASH = 82;             enter(HASH, "#")
+  inline val AT = 83;               enter(AT, "@")
+  //inline val VIEWBOUND = 84;        enter(VIEWBOUND, "<%")
+
+  val keywords: TokenSet
+
+  def isKeyword(token: Token): Boolean = keywords contains token
+
+  /** parentheses */
+  inline val LPAREN = 91;           enter(LPAREN, "'('")
+  inline val RPAREN = 92;           enter(RPAREN, "')'")
+  inline val LBRACKET = 93;         enter(LBRACKET, "'['")
+  inline val RBRACKET = 94;         enter(RBRACKET, "']'")
+  inline val LBRACE = 95;           enter(LBRACE, "'{'")
+  inline val RBRACE = 96;           enter(RBRACE, "'}'")
+  inline val INDENT = 97;           enter(INDENT, "indent")
+  inline val OUTDENT = 98;          enter(OUTDENT, "unindent")
+
+  inline val firstParen = LPAREN
+  inline val lastParen = OUTDENT
+
+  def buildKeywordArray(keywords: TokenSet): (Int, Array[Int]) = {
+    def start(tok: Token) = tokenString(tok).toTermName.asSimpleName.start
+    def sourceKeywords = keywords.toList.filter { (kw: Token) =>
+      val ts = tokenString(kw)
+      (ts != null) && !ts.contains(' ')
+    }
+
+    val lastKeywordStart = sourceKeywords.map(start).max
+
+    val arr = Array.fill(lastKeywordStart + 1)(IDENTIFIER)
+    for (kw <- sourceKeywords) arr(start(kw)) = kw
+    (lastKeywordStart, arr)
+  }
+}
+
+object Tokens extends TokensCommon {
+  inline val minToken = EMPTY
+  final def maxToken: Int = XMLSTART
+
+  inline val INTERPOLATIONID = 12;  enter(INTERPOLATIONID, "string interpolator")
+  inline val QUOTEID = 13;          enter(QUOTEID, "quoted identifier") // TODO: deprecate
+
+  inline val BACKQUOTED_IDENT = 15; enter(BACKQUOTED_IDENT, "identifier", "backquoted ident")
+
+  final val identifierTokens: TokenSet = BitSet(IDENTIFIER, BACKQUOTED_IDENT)
+
+  def isIdentifier(token : Int): Boolean =
+    token >= IDENTIFIER && token <= BACKQUOTED_IDENT
+
+  /** alphabetic keywords */
+  inline val WITH = 26;             enter(WITH, "with")
+  inline val CASE = 28;             enter(CASE, "case")
+  inline val CASECLASS = 29;        enter(CASECLASS, "case class")
+  inline val CASEOBJECT = 30;       enter(CASEOBJECT, "case object")
+  inline val VAL = 31;              enter(VAL, "val")
+  inline val IMPLICIT = 37;         enter(IMPLICIT, "implicit")
+  inline val VAR = 38;              enter(VAR, "var")
+  inline val DEF = 39;              enter(DEF, "def")
+  inline val TYPE = 40;             enter(TYPE, "type")
+  inline val OBJECT = 44;           enter(OBJECT, "object")
+  inline val YIELD = 48;            enter(YIELD, "yield")
+  inline val TRAIT = 50;            enter(TRAIT, "trait")
+  inline val SEALED = 51;           enter(SEALED, "sealed")
+  inline val MATCH = 58;            enter(MATCH, "match")
+  inline val LAZY = 59;             enter(LAZY, "lazy")
+  inline val THEN = 60;             enter(THEN, "then")
+  inline val FORSOME = 61;          enter(FORSOME, "forSome") // TODO: deprecate
+  inline val ENUM = 62;             enter(ENUM, "enum")
+  inline val GIVEN = 63;            enter(GIVEN, "given")
+  inline val EXPORT = 64;           enter(EXPORT, "export")
+  inline val MACRO = 65;            enter(MACRO, "macro") // TODO: remove
+  inline val END = 66;              enter(END, "end")
+
+  /** special symbols */
+  inline val NEWLINE = 78;          enter(NEWLINE, "end of statement", "new line")
+  inline val NEWLINES = 79;         enter(NEWLINES, "end of statement", "new lines")
+
+  /** special keywords */
+  inline val USCORE = 73;           enter(USCORE, "_")
+  inline val LARROW = 76;           enter(LARROW, "<-")
+  inline val ARROW = 77;            enter(ARROW, "=>")
+  inline val SUBTYPE = 80;          enter(SUBTYPE, "<:")
+  inline val SUPERTYPE = 81;        enter(SUPERTYPE, ">:")
+  inline val HASH = 82;             enter(HASH, "#")
+  inline val VIEWBOUND = 84;        enter(VIEWBOUND, "<%")
+  inline val TLARROW = 85;          enter(TLARROW, "=>>")
+  inline val CTXARROW = 86;         enter(CTXARROW, "?=>")
+
+  inline val QUOTE = 87;            enter(QUOTE, "'")
+
+  inline val COLONfollow = 88;      enter(COLONfollow, ":")
+    // A `:` following an alphanumeric identifier or one of the tokens in colonEOLPredecessors
+  inline val COLONeol = 89;         enter(COLONeol, ":", ": at eol")
+    // A `:` recognized as starting an indentation block
+  inline val SELFARROW = 90;        enter(SELFARROW, "=>") // reclassified ARROW following self-type
+
+  /** XML mode */
+  inline val XMLSTART = 99;         enter(XMLSTART, "$XMLSTART$<") // TODO: deprecate
+
+  final val alphaKeywords: TokenSet = tokenRange(IF, END)
+  final val symbolicKeywords: TokenSet = tokenRange(USCORE, CTXARROW)
+  final val keywords: TokenSet = alphaKeywords | symbolicKeywords
+
+  final val allTokens: TokenSet = tokenRange(minToken, maxToken)
+
+  final val simpleLiteralTokens: TokenSet =
+    tokenRange(CHARLIT, STRINGLIT) | BitSet(TRUE, FALSE)
+  final val literalTokens: TokenSet = simpleLiteralTokens | BitSet(INTERPOLATIONID, QUOTEID, NULL)  // TODO: drop QUOTEID when symbol literals are gone
+
+  final val atomicExprTokens: TokenSet = literalTokens | identifierTokens | BitSet(
+    USCORE, NULL, THIS, SUPER, TRUE, FALSE, RETURN, QUOTEID, XMLSTART)
+
+  final val openParensTokens = BitSet(LBRACE, LPAREN, LBRACKET)
+
+  final val canStartExprTokens3: TokenSet =
+      atomicExprTokens
+    | openParensTokens
+    | BitSet(INDENT, QUOTE, IF, WHILE, FOR, NEW, TRY, THROW)
+
+  final val canStartExprTokens2: TokenSet = canStartExprTokens3 | BitSet(DO)
+
+  final val canStartInfixTypeTokens: TokenSet = literalTokens | identifierTokens | BitSet(
+    THIS, SUPER, USCORE, LPAREN, LBRACE, AT)
+
+  final val templateIntroTokens: TokenSet = BitSet(CLASS, TRAIT, OBJECT, ENUM, CASECLASS, CASEOBJECT)
+
+  final val dclIntroTokens: TokenSet = BitSet(DEF, VAL, VAR, TYPE, GIVEN)
+
+  final val defIntroTokens: TokenSet = templateIntroTokens | dclIntroTokens
+
+  final val localModifierTokens: TokenSet = BitSet(ABSTRACT, FINAL, SEALED, IMPLICIT, LAZY)
+
+  final val accessModifierTokens: TokenSet = BitSet(
+    PRIVATE, PROTECTED)
+
+  final val modifierTokens: TokenSet = localModifierTokens | accessModifierTokens | BitSet(
+    OVERRIDE)
+
+  final val modifierTokensOrCase: TokenSet = modifierTokens | BitSet(CASE)
+
+  final val modifierFollowers = modifierTokens | defIntroTokens
+
+  /** Is token only legal as start of statement (eof also included)? */
+  final val mustStartStatTokens: TokenSet = defIntroTokens | modifierTokens | BitSet(IMPORT, EXPORT, PACKAGE)
+
+  final val canStartStatTokens2: TokenSet = canStartExprTokens2 | mustStartStatTokens | BitSet(
+    AT, CASE, END) // END is included since it might be tested before being converted back to IDENTIFIER
+  final val canStartStatTokens3: TokenSet = canStartExprTokens3 | mustStartStatTokens | BitSet(
+    AT, CASE, END)
+
+  final val canEndStatTokens: TokenSet = atomicExprTokens | BitSet(TYPE, GIVEN, RPAREN, RBRACE, RBRACKET, OUTDENT)
+
+  /** Tokens that stop a lookahead scan search for a `<-`, `then`, or `do`.
+   *  Used for disambiguating between old and new syntax.
+   */
+  final val stopScanTokens: BitSet = mustStartStatTokens |
+    BitSet(IF, ELSE, WHILE, DO, FOR, YIELD, NEW, TRY, CATCH, FINALLY, THROW, RETURN, MATCH, SEMI, EOF)
+
+  final val numericLitTokens: TokenSet = BitSet(INTLIT, DECILIT, EXPOLIT, LONGLIT, FLOATLIT, DOUBLELIT)
+
+  final val statCtdTokens: BitSet = BitSet(THEN, ELSE, DO, CATCH, FINALLY, YIELD, MATCH)
+
+  final val closingRegionTokens = BitSet(RBRACE, RPAREN, RBRACKET, CASE) | statCtdTokens
+
+  final val canStartIndentTokens: BitSet =
+    statCtdTokens | BitSet(COLONeol, WITH, EQUALS, ARROW, CTXARROW, LARROW, WHILE, TRY, FOR, IF, THROW, RETURN)
+
+  /** Faced with the choice between a type and a formal parameter, the following
+   *  tokens determine it's a formal parameter.
+   */
+  final val startParamTokens: BitSet = modifierTokens | BitSet(VAL, VAR, AT)
+
+  final val scala3keywords = BitSet(ENUM, GIVEN)
+
+  final val endMarkerTokens = identifierTokens | BitSet(IF, WHILE, FOR, MATCH, TRY, NEW, THROW, GIVEN, VAL, THIS)
+
+  final val colonEOLPredecessors = BitSet(RPAREN, RBRACKET, BACKQUOTED_IDENT, THIS, SUPER, NEW)
+
+  final val closingParens = BitSet(RPAREN, RBRACKET, RBRACE)
+
+  final val softModifierNames = Set(nme.inline, nme.opaque, nme.open, nme.transparent, nme.infix)
+
+  def showTokenDetailed(token: Int): String = debugString(token)
+
+  def showToken(token: Int): String = {
+    val str = tokenString(token)
+    if isKeyword(token) || token == COLONfollow || token == COLONeol then s"'$str'" else str
+  }
+}
diff --git a/tests/pos-with-compiler-cc/dotc/parsing/package.scala b/tests/pos-with-compiler-cc/dotc/parsing/package.scala
new file mode 100644
index 000000000000..a1f9c8d73ad4
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/parsing/package.scala
@@ -0,0 +1,40 @@
+package dotty.tools.dotc
+
+import util.Chars._
+import core.Names.Name
+import core.StdNames.nme
+import core.NameOps._
+
+package object parsing {
+
+  /**
+   * Compute the precedence of infix operator `operator` according to the SLS [§ 6.12.3][SLS].
+   * We implement [SIP-33][SIP-33] and give type operators the same precedence as term operators.
+   *
+   * [SLS]: https://www.scala-lang.org/files/archive/spec/2.13/06-expressions.html#infix-operations
+   * [SIP-33]: https://docs.scala-lang.org/sips/priority-based-infix-type-precedence.html
+   */
+  def precedence(operator: Name): Int =
+    if (operator eq nme.ERROR) -1
+    else {
+      val firstCh = operator.firstPart.head
+      if (isScalaLetter(firstCh)) 1
+      else if (operator.isOpAssignmentName) 0
+      else firstCh match {
+        case '|' => 2
+        case '^' => 3
+        case '&' => 4
+        case '=' | '!' => 5
+        case '<' | '>' => 6
+        case ':' => 7
+        case '+' | '-' => 8
+        case '*' | '/' | '%' => 9
+        case _ => 10
+      }
+    }
+
+  def minPrec: Int = 0
+  def minInfixPrec: Int = 1
+  def maxPrec: Int = 11
+}
+
diff --git a/tests/pos-with-compiler-cc/dotc/parsing/xml/MarkupParserCommon.scala b/tests/pos-with-compiler-cc/dotc/parsing/xml/MarkupParserCommon.scala
new file mode 100644
index 000000000000..2c6c5361e51c
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/parsing/xml/MarkupParserCommon.scala
@@ -0,0 +1,257 @@
+/*                     __                                               *\
+**     ________ ___   / /  ___     Scala API                            **
+**    / __/ __// _ | / /  / _ |    (c) 2003-2013, LAMP/EPFL             **
+**  __\ \/ /__/ __ |/ /__/ __ |    http://scala-lang.org/               **
+** /____/\___/_/ |_/____/_/ | |                                         **
+**                          |/                                          **
+\*                                                                      */
+package dotty.tools.dotc
+package parsing
+package xml
+
+import Utility._
+import util.Chars.SU
+
+
+
+/** This is not a public trait - it contains common code shared
+ *  between the library level XML parser and the compiler's.
+ *  All members should be accessed through those.
+ */
+private[dotty] trait MarkupParserCommon {
+  protected def unreachable: Nothing = scala.sys.error("Cannot be reached.")
+
+  // type HandleType       // MarkupHandler, SymbolicXMLBuilder
+  type InputType        // Source, CharArrayReader
+  type PositionType     // Int, Position
+  type ElementType      // NodeSeq, Tree
+  type NamespaceType    // NamespaceBinding, Any
+  type AttributesType   // (MetaData, NamespaceBinding), mutable.Map[String, Tree]
+
+  def mkAttributes(name: String, pscope: NamespaceType): AttributesType
+  def mkProcInstr(position: PositionType, name: String, text: String): ElementType
+
+  /** parse a start or empty tag.
+   *  [40] STag         ::= '<' Name { S Attribute } [S]
+   *  [44] EmptyElemTag ::= '<' Name { S Attribute } [S]
+   */
+  protected def xTag(pscope: NamespaceType): (String, AttributesType) = {
+    val name = xName
+    xSpaceOpt()
+
+    (name, mkAttributes(name, pscope))
+  }
+
+  /** '<?' ProcInstr ::= Name [S ({Char} - ({Char}'>?' {Char})]'?>'
+   *
+   * see [15]
+   */
+  def xProcInstr: ElementType = {
+    val n = xName
+    xSpaceOpt()
+    xTakeUntil(mkProcInstr(_, n, _), () => tmppos, "?>")
+  }
+
+  /** attribute value, terminated by either `'` or `"`. value may not contain `<`.
+   @param endCh either `'` or `"`
+   */
+  def xAttributeValue(endCh: Char): String = {
+    val buf = new StringBuilder
+    while (ch != endCh) {
+      // well-formedness constraint
+      if (ch == '<') return errorAndResult("'<' not allowed in attrib value", "")
+      else if (ch == SU) truncatedError("")
+      else buf append ch_returning_nextch
+    }
+    ch_returning_nextch
+    // @todo: normalize attribute value
+    buf.toString
+  }
+
+  def xAttributeValue(): String = {
+    val str = xAttributeValue(ch_returning_nextch)
+    // well-formedness constraint
+    normalizeAttributeValue(str)
+  }
+
+  private def takeUntilChar(it: Iterator[Char], end: Char): String = {
+    val buf = new StringBuilder
+    while (it.hasNext) it.next() match {
+      case `end`  => return buf.toString
+      case ch     => buf append ch
+    }
+    scala.sys.error("Expected '%s'".format(end))
+  }
+
+  /** [42]  '<' xmlEndTag ::=  '<' '/' Name S? '>'
+   */
+  def xEndTag(startName: String): Unit = {
+    xToken('/')
+    if (xName != startName)
+      errorNoEnd(startName)
+
+    xSpaceOpt()
+    xToken('>')
+  }
+
+  /** actually, Name ::= (Letter | '_' | ':') (NameChar)*  but starting with ':' cannot happen
+   *  Name ::= (Letter | '_') (NameChar)*
+   *
+   *  see  [5] of XML 1.0 specification
+   *
+   *  pre-condition:  ch != ':' // assured by definition of XMLSTART token
+   *  post-condition: name does neither start, nor end in ':'
+   */
+  def xName: String = {
+    if (ch == SU)
+      truncatedError("")
+    else if (!isNameStart(ch))
+      return errorAndResult("name expected, but char '%s' cannot start a name" format ch, "")
+
+    val buf = new StringBuilder
+
+    while ({ buf append ch_returning_nextch ; isNameChar(ch) }) ()
+
+    if (buf.last == ':') {
+      reportSyntaxError( "name cannot end in ':'" )
+      buf.toString dropRight 1
+    }
+    else buf.toString
+  }
+
+  private def attr_unescape(s: String) = s match {
+    case "lt"     => "<"
+    case "gt"     => ">"
+    case "amp"    => "&"
+    case "apos"   => "'"
+    case "quot"   => "\""
+    case "quote"  => "\""
+    case _        => "&" + s + ";"
+  }
+
+  /** Replaces only character references right now.
+   *  see spec 3.3.3
+   */
+  private def normalizeAttributeValue(attval: String): String = {
+    val buf = new StringBuilder
+    val it = attval.iterator.buffered
+
+    while (it.hasNext) buf append (it.next() match {
+      case ' ' | '\t' | '\n' | '\r' => " "
+      case '&' if it.head == '#'    => it.next() ; xCharRef(it)
+      case '&'                      => attr_unescape(takeUntilChar(it, ';'))
+      case c                        => c
+    })
+
+    buf.toString
+  }
+
+  /** CharRef ::= "&#" '0'..'9' {'0'..'9'} ";"
+   *            | "&#x" '0'..'9'|'A'..'F'|'a'..'f' { hexdigit } ";"
+   *
+   * see [66]
+   */
+  def xCharRef(ch: () => Char, nextch: () => Unit): String =
+    Utility.parseCharRef(ch, nextch, reportSyntaxError _, truncatedError _)
+
+  def xCharRef(it: Iterator[Char]): String = {
+    var c = it.next()
+    Utility.parseCharRef(() => c, () => { c = it.next() }, reportSyntaxError _, truncatedError _)
+  }
+
+  def xCharRef: String = xCharRef(() => ch, () => nextch())
+
+  /** Create a lookahead reader which does not influence the input */
+  def lookahead(): BufferedIterator[Char]
+
+  /** The library and compiler parsers had the interesting distinction of
+   *  different behavior for nextch (a function for which there are a total
+   *  of two plausible behaviors, so we know the design space was fully
+   *  explored.) One of them returned the value of nextch before the increment
+   *  and one of them the new value.  So to unify code we have to at least
+   *  temporarily abstract over the nextchs.
+   */
+  def ch: Char
+  def nextch(): Unit
+  protected def ch_returning_nextch: Char
+  def eof: Boolean
+
+  // def handle: HandleType
+  var tmppos: PositionType
+
+  def xHandleError(that: Char, msg: String): Unit
+  def reportSyntaxError(str: String): Unit
+  def reportSyntaxError(pos: Int, str: String): Unit
+
+  def truncatedError(msg: String): Nothing
+  def errorNoEnd(tag: String): Nothing
+
+  protected def errorAndResult[T](msg: String, x: T): T = {
+    reportSyntaxError(msg)
+    x
+  }
+
+  def xToken(that: Char): Unit = {
+    if (ch == that) nextch()
+    else xHandleError(that, "'%s' expected instead of '%s'".format(that, ch))
+  }
+  def xToken(that: Seq[Char]): Unit = { that foreach xToken }
+
+  /** scan [S] '=' [S]*/
+  def xEQ(): Unit = { xSpaceOpt(); xToken('='); xSpaceOpt() }
+
+  /** skip optional space S? */
+  def xSpaceOpt(): Unit = while (isSpace(ch) && !eof) nextch()
+
+  /** scan [3] S ::= (#x20 | #x9 | #xD | #xA)+ */
+  def xSpace(): Unit =
+    if (isSpace(ch)) { nextch(); xSpaceOpt() }
+    else xHandleError(ch, "whitespace expected")
+
+  /** Apply a function and return the passed value */
+  def returning[T](x: T)(f: T => Unit): T = { f(x); x }
+
+  /** Execute body with a variable saved and restored after execution */
+  def saving[A, B](getter: A, setter: A => Unit)(body: => B): B = {
+    val saved = getter
+    try body
+    finally setter(saved)
+  }
+
+  /** Take characters from input stream until given String "until"
+   *  is seen.  Once seen, the accumulated characters are passed
+   *  along with the current Position to the supplied handler function.
+   */
+  protected def xTakeUntil[T](
+    handler: (PositionType, String) => T,
+    positioner: () => PositionType,
+    until: String): T =
+  {
+    val sb = new StringBuilder
+    val head = until.head
+    val rest = until.tail
+
+    while (true) {
+      if (ch == head && peek(rest))
+        return handler(positioner(), sb.toString)
+      else if (ch == SU)
+        truncatedError("")  // throws TruncatedXMLControl in compiler
+
+      sb append ch
+      nextch()
+    }
+    unreachable
+  }
+
+  /** Create a non-destructive lookahead reader and see if the head
+   *  of the input would match the given String.  If yes, return true
+   *  and drop the entire String from input; if no, return false
+   *  and leave input unchanged.
+   */
+  private def peek(lookingFor: String): Boolean =
+    (lookahead() take lookingFor.length sameElements lookingFor.iterator) && {
+      // drop the chars from the real reader (all lookahead + orig)
+      (0 to lookingFor.length) foreach (_ => nextch())
+      true
+    }
+}
diff --git a/tests/pos-with-compiler-cc/dotc/parsing/xml/MarkupParsers.scala b/tests/pos-with-compiler-cc/dotc/parsing/xml/MarkupParsers.scala
new file mode 100644
index 000000000000..3d9f5fb7ad6d
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/parsing/xml/MarkupParsers.scala
@@ -0,0 +1,483 @@
+package dotty.tools
+package dotc
+package parsing
+package xml
+
+import scala.language.unsafeNulls
+
+import scala.collection.mutable
+import mutable.{ Buffer, ArrayBuffer, ListBuffer }
+import scala.util.control.ControlThrowable
+import util.Chars.SU
+import Parsers._
+import util.Spans._
+import core._
+import Constants._
+import Decorators.toMessage
+import util.SourceFile
+import Utility._
+
+
+// XXX/Note: many/most of the functions in here are almost direct cut and pastes
+// from another file - scala.xml.parsing.MarkupParser, it looks like.
+// (It was like that when I got here.) They used to be commented "[Duplicate]" butx
+// since approximately all of them were, I snipped it as noise.  As far as I can
+// tell this wasn't for any particularly good reason, but slightly different
+// compiler and library parser interfaces meant it would take some setup.
+//
+// I rewrote most of these, but not as yet the library versions: so if you are
+// tempted to touch any of these, please be aware of that situation and try not
+// to let it get any worse.  -- paulp
+
+/** This trait ...
+ *
+ *  @author  Burak Emir
+ *  @version 1.0
+ */
+object MarkupParsers {
+
+  import ast.untpd._
+
+  case object MissingEndTagControl extends ControlThrowable {
+    override def getMessage: String = "start tag was here: "
+  }
+
+  case object ConfusedAboutBracesControl extends ControlThrowable {
+    override def getMessage: String = " I encountered a '}' where I didn't expect one, maybe this tag isn't closed <"
+  }
+
+  case object TruncatedXMLControl extends ControlThrowable {
+    override def getMessage: String = "input ended while parsing XML"
+  }
+
+  class MarkupParser(parser: Parser, final val preserveWS: Boolean)(implicit src: SourceFile) extends MarkupParserCommon {
+
+    import Tokens.{ LBRACE, RBRACE }
+
+    type PositionType = Span
+    type InputType    = CharArrayReader
+    type ElementType  = Tree
+    type AttributesType = mutable.Map[String, Tree]
+    type NamespaceType = Any  // namespaces ignored
+
+    def mkAttributes(name: String, other: NamespaceType): AttributesType = xAttributes
+
+    def eof: Boolean = false
+
+    def truncatedError(msg: String): Nothing = throw TruncatedXMLControl
+    def xHandleError(that: Char, msg: String): Unit =
+      if (ch == SU) throw TruncatedXMLControl
+      else reportSyntaxError(msg)
+
+    var input : CharArrayReader = _
+    def lookahead(): BufferedIterator[Char] =
+      (input.buf drop input.charOffset).iterator.buffered
+
+    import parser.{ symbXMLBuilder => handle }
+
+    def curOffset : Int = input.charOffset - 1
+    var tmppos : Span = NoSpan
+    def ch: Char = input.ch
+    /** this method assign the next character to ch and advances in input */
+    def nextch(): Unit = { input.nextChar() }
+
+    protected def ch_returning_nextch: Char = {
+      val result = ch; input.nextChar(); result
+    }
+
+    def mkProcInstr(position: Span, name: String, text: String): ElementType =
+      parser.symbXMLBuilder.procInstr(position, name, text)
+
+    var xEmbeddedBlock: Boolean = false
+
+    private var debugLastStartElement = List.empty[(Int, String)]
+    private def debugLastPos = debugLastStartElement.head._1
+    private def debugLastElem = debugLastStartElement.head._2
+
+    private def errorBraces() = {
+      reportSyntaxError("in XML content, please use '}}' to express '}'")
+      throw ConfusedAboutBracesControl
+    }
+    def errorNoEnd(tag: String): Nothing = {
+      reportSyntaxError("expected closing tag of " + tag)
+      throw MissingEndTagControl
+    }
+
+    /** checks whether next character starts a Scala block, if yes, skip it.
+     * @return true if next character starts a scala block
+     */
+    def xCheckEmbeddedBlock: Boolean = {
+      // attentions, side-effect, used in xText
+      xEmbeddedBlock = (ch == '{') && { nextch(); (ch != '{') }
+      xEmbeddedBlock
+    }
+
+    /** parse attribute and add it to listmap
+     *  [41] Attributes   ::= { S Name Eq AttValue }
+     *       AttValue     ::= `'` { _  } `'`
+     *                      | `"` { _ } `"`
+     *                      | `{` scalablock `}`
+     */
+    def xAttributes: mutable.LinkedHashMap[String, Tree] = {
+      val aMap = mutable.LinkedHashMap[String, Tree]()
+
+      while (isNameStart(ch)) {
+        val start = curOffset
+        val key = xName
+        xEQ()
+        val delim = ch
+        val mid = curOffset
+        val value: Tree = ch match {
+          case '"' | '\'' =>
+            val tmp = xAttributeValue(ch_returning_nextch)
+
+            try handle.parseAttribute(Span(start, curOffset, mid), tmp)
+            catch {
+              case e: RuntimeException =>
+                errorAndResult("error parsing attribute value", parser.errorTermTree(parser.in.offset))
+            }
+
+          case '{'  =>
+            nextch()
+            xEmbeddedExpr
+          case SU =>
+            throw TruncatedXMLControl
+          case _ =>
+            errorAndResult("' or \" delimited attribute value or '{' scala-expr '}' expected", Literal(Constant("<syntax-error>")))
+        }
+        // well-formedness constraint: unique attribute names
+        if (aMap contains key)
+          reportSyntaxError("attribute %s may only be defined once" format key)
+
+        aMap(key) = value
+        if (ch != '/' && ch != '>')
+          xSpace()
+      }
+      aMap
+    }
+
+    /** '<! CharData ::= [CDATA[ ( {char} - {char}"]]>"{char} ) ']]>'
+     *
+     * see [15]
+     */
+    def xCharData: Tree = {
+      val start = curOffset
+      xToken("[CDATA[")
+      val mid = curOffset
+      xTakeUntil(handle.charData, () => Span(start, curOffset, mid), "]]>")
+    }
+
+    def xUnparsed: Tree = {
+      val start = curOffset
+      xTakeUntil(handle.unparsed, () => Span(start, curOffset, start), "</xml:unparsed>")
+    }
+
+    /** Comment ::= '<!--' ((Char - '-') | ('-' (Char - '-')))* '-->'
+     *
+     * see [15]
+     */
+    def xComment: Tree = {
+      val start = curOffset - 2   // Rewinding to include "<!"
+      xToken("--")
+      xTakeUntil(handle.comment, () => Span(start, curOffset, start), "-->")
+    }
+
+    def appendText(span: Span, ts: Buffer[Tree], txt: String): Unit = {
+      def append(t: String) = ts append handle.text(span, t)
+
+      if (preserveWS) append(txt)
+      else {
+        val sb = new StringBuilder()
+
+        txt foreach { c =>
+          if (!isSpace(c)) sb append c
+          else if (sb.isEmpty || !isSpace(sb.last)) sb append ' '
+        }
+
+        val trimmed = sb.toString.trim
+        if (!trimmed.isEmpty) append(trimmed)
+      }
+    }
+
+    /** adds entity/character to ts as side-effect
+     *  @precond ch == '&'
+     */
+    def content_AMP(ts: ArrayBuffer[Tree]): Unit = {
+      nextch()
+      val toAppend = ch match {
+        case '#' => // CharacterRef
+          nextch()
+          val theChar = handle.text(tmppos, xCharRef)
+          xToken(';')
+          theChar
+        case _ =>   // EntityRef
+          val n = xName
+          xToken(';')
+          handle.entityRef(tmppos, n)
+      }
+
+      ts append toAppend
+    }
+
+    /**
+     *  @precond ch == '{'
+     *  @postcond: xEmbeddedBlock == false!
+     */
+    def content_BRACE(p: Span, ts: ArrayBuffer[Tree]): Unit =
+      if (xCheckEmbeddedBlock) ts append xEmbeddedExpr
+      else appendText(p, ts, xText)
+
+    /** Returns true if it encounters an end tag (without consuming it),
+     *  appends trees to ts as side-effect.
+     *
+     *  @param ts ...
+     *  @return   ...
+     */
+    private def content_LT(ts: ArrayBuffer[Tree]): Boolean = {
+      if (ch == '/')
+        return true   // end tag
+
+      val toAppend = ch match {
+        case '!'    => nextch() ; if (ch =='[') xCharData else xComment // CDATA or Comment
+        case '?'    => nextch() ; xProcInstr                            // PI
+        case _      => element                                          // child node
+      }
+
+      ts append toAppend
+      false
+    }
+
+    def content: Buffer[Tree] = {
+      val ts = new ArrayBuffer[Tree]
+      while (true) {
+        if (xEmbeddedBlock)
+          ts append xEmbeddedExpr
+        else {
+          tmppos = Span(curOffset)
+          ch match {
+            // end tag, cdata, comment, pi or child node
+            case '<'  => nextch() ; if (content_LT(ts)) return ts
+            // either the character '{' or an embedded scala block }
+            case '{'  => content_BRACE(tmppos, ts)  // }
+            // EntityRef or CharRef
+            case '&'  => content_AMP(ts)
+            case SU   => return ts
+            // text content - here xEmbeddedBlock might be true
+            case _    => appendText(tmppos, ts, xText)
+          }
+        }
+      }
+      unreachable
+    }
+
+    /** '<' element ::= xmlTag1 '>'  { xmlExpr | '{' simpleExpr '}' } ETag
+     *                | xmlTag1 '/' '>'
+     */
+    def element: Tree = {
+      val start = curOffset
+      val (qname, attrMap) = xTag(())
+      if (ch == '/') { // empty element
+        xToken("/>")
+        handle.element(Span(start, curOffset, start), qname, attrMap, true, new ListBuffer[Tree])
+      }
+      else { // handle content
+        xToken('>')
+        if (qname == "xml:unparsed")
+          return xUnparsed
+
+        debugLastStartElement = (start, qname) :: debugLastStartElement
+        val ts = content
+        xEndTag(qname)
+        debugLastStartElement = debugLastStartElement.tail
+        val span = Span(start, curOffset, start)
+        qname match {
+          case "xml:group" => handle.group(span, ts)
+          case _ => handle.element(span, qname, attrMap, false, ts)
+        }
+      }
+    }
+
+    /** parse character data.
+     *  precondition: xEmbeddedBlock == false (we are not in a scala block)
+     */
+    private def xText: String = {
+      assert(!xEmbeddedBlock, "internal error: encountered embedded block")
+      val buf = new StringBuilder
+      def done = buf.toString
+
+      while (ch != SU) {
+        if (ch == '}') {
+          if (charComingAfter(nextch()) == '}') nextch()
+          else errorBraces()
+        }
+
+        buf append ch
+        nextch()
+        if (xCheckEmbeddedBlock || ch == '<' ||  ch == '&')
+          return done
+      }
+      done
+    }
+
+    /** Some try/catch/finally logic used by xLiteral and xLiteralPattern.  */
+    inline private def xLiteralCommon(f: () => Tree, ifTruncated: String => Unit): Tree = {
+      assert(parser.in.token == Tokens.XMLSTART)
+      val saved = parser.in.newTokenData
+      saved.copyFrom(parser.in)
+      var output: Tree = null.asInstanceOf[Tree]
+      try output = f()
+      catch {
+        case c @ TruncatedXMLControl  =>
+          ifTruncated(c.getMessage)
+        case c @ (MissingEndTagControl | ConfusedAboutBracesControl) =>
+          parser.syntaxError(c.getMessage + debugLastElem + ">", debugLastPos)
+        case _: ArrayIndexOutOfBoundsException =>
+          parser.syntaxError("missing end tag in XML literal for <%s>" format debugLastElem, debugLastPos)
+      }
+      finally parser.in.resume(saved)
+
+      if (output == null)
+        parser.errorTermTree(parser.in.offset)
+      else
+        output
+    }
+
+    /** Use a lookahead parser to run speculative body, and return the first char afterward. */
+    private def charComingAfter(body: => Unit): Char = {
+      try {
+        input = input.lookaheadReader()
+        body
+        ch
+      }
+      finally input = parser.in
+    }
+
+    /** xLiteral = element { element }
+     *  @return Scala representation of this xml literal
+     */
+    def xLiteral: Tree = xLiteralCommon(
+      () => {
+        input = parser.in
+        handle.isPattern = false
+
+        val ts = new ArrayBuffer[Tree]
+        val start = curOffset
+        tmppos = Span(curOffset)    // Iuli: added this line, as it seems content_LT uses tmppos when creating trees
+        content_LT(ts)
+
+        // parse more XML?
+        if (charComingAfter(xSpaceOpt()) == '<') {
+          while {
+            xSpaceOpt()
+            nextch()
+            ts.append(element)
+            charComingAfter(xSpaceOpt()) == '<'
+          } do ()
+          handle.makeXMLseq(Span(start, curOffset, start), ts)
+        }
+        else {
+          assert(ts.length == 1, "Require one tree")
+          ts(0)
+        }
+      },
+      msg => parser.incompleteInputError(msg.toMessage)
+    )
+
+    /** @see xmlPattern. resynchronizes after successful parse
+     *  @return this xml pattern
+     */
+    def xLiteralPattern: Tree = xLiteralCommon(
+      () => {
+        input = parser.in
+        saving[Boolean, Tree](handle.isPattern, handle.isPattern = _) {
+          handle.isPattern = true
+          val tree = xPattern
+          xSpaceOpt()
+          tree
+        }
+      },
+      msg => parser.syntaxError(msg, curOffset)
+    )
+
+    def escapeToScala[A](op: => A, kind: String): A = {
+      xEmbeddedBlock = false
+      val res = saving(parser.in.currentRegion, parser.in.currentRegion = _) {
+        val lbrace = parser.in.newTokenData
+        lbrace.token = LBRACE
+        lbrace.offset = parser.in.charOffset - 1
+        lbrace.lastOffset = parser.in.lastOffset
+        lbrace.lineOffset = parser.in.lineOffset
+        parser.in.resume(lbrace)
+        op
+      }
+      if (parser.in.token != RBRACE)
+        reportSyntaxError(" expected end of Scala " + kind)
+
+      res
+    }
+
+    def xEmbeddedExpr: Tree = escapeToScala(parser.block(), "block")
+
+    /** xScalaPatterns  ::= patterns
+     */
+    def xScalaPatterns: List[Tree] = escapeToScala(parser.patterns(), "pattern")
+
+    def reportSyntaxError(offset: Int, str: String): Unit = parser.syntaxError(str, offset)
+    def reportSyntaxError(str: String): Unit = {
+      reportSyntaxError(curOffset, "in XML literal: " + str)
+      nextch()
+    }
+
+    /** '<' xPattern  ::= Name [S] { xmlPattern | '{' pattern3 '}' } ETag
+     *                  | Name [S] '/' '>'
+     */
+    def xPattern: Tree = {
+      var start = curOffset
+      val qname = xName
+      debugLastStartElement = (start, qname) :: debugLastStartElement
+      xSpaceOpt()
+
+      val ts = new ArrayBuffer[Tree]
+
+      val isEmptyTag = ch == '/'
+      if (isEmptyTag) nextch()
+      xToken('>')
+
+      if (!isEmptyTag) {
+        // recurses until it hits a termination condition, then returns
+        def doPattern: Boolean = {
+          val start1 = curOffset
+          if (xEmbeddedBlock) ts ++= xScalaPatterns
+          else ch match {
+            case '<'  => // tag
+              nextch()
+              if (ch != '/') ts append xPattern   // child
+              else return false                   // terminate
+
+            case '{'  => // embedded Scala patterns
+              while (ch == '{') {
+                nextch()
+                ts ++= xScalaPatterns
+              }
+              assert(!xEmbeddedBlock, "problem with embedded block")
+
+            case SU   =>
+              throw TruncatedXMLControl
+
+            case _    => // text
+              appendText(Span(start1, curOffset, start1), ts, xText)
+              // here xEmbeddedBlock might be true:
+              // if (xEmbeddedBlock) throw new ApplicationError("after:" + text); // assert
+          }
+          true
+        }
+
+        while (doPattern) { }  // call until false
+        xEndTag(qname)
+        debugLastStartElement = debugLastStartElement.tail
+      }
+
+      handle.makeXMLpat(Span(start, curOffset, start), qname, ts)
+    }
+  } /* class MarkupParser */
+}
diff --git a/tests/pos-with-compiler-cc/dotc/parsing/xml/SymbolicXMLBuilder.scala b/tests/pos-with-compiler-cc/dotc/parsing/xml/SymbolicXMLBuilder.scala
new file mode 100644
index 000000000000..0e70cc077fa4
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/parsing/xml/SymbolicXMLBuilder.scala
@@ -0,0 +1,261 @@
+package dotty.tools
+package dotc
+package parsing
+package xml
+
+import scala.language.unsafeNulls
+
+import scala.collection.mutable
+import core._
+import Decorators._
+import Flags.Mutable
+import Names._, StdNames._, ast.Trees._, ast.{tpd, untpd}
+import Symbols._, Contexts._
+import util.Spans._
+import Parsers.Parser
+
+/** This class builds instance of `Tree` that represent XML.
+ *
+ *  Note from martin: This needs to have its position info reworked. I don't
+ *  understand exactly what's done here. To make validation pass, I set many
+ *  positions to be transparent. Not sure this is a good idea for navigating
+ *  XML trees in the IDE but it's the best I can do right now. If someone
+ *  who understands this part better wants to give it a shot, please do!
+ *
+ *  @author  Burak Emir
+ *  @version 1.0
+ */
+class SymbolicXMLBuilder(parser: Parser, preserveWS: Boolean)(using Context) {
+
+  import Constants.Constant
+  import untpd._
+
+  import parser.atSpan
+
+  private[parsing] var isPattern: Boolean = _
+
+  private object xmltypes extends ScalaTypeNames {
+    val _Comment: TypeName             = "Comment"
+    val _Elem: TypeName                = "Elem"
+    val _EntityRef: TypeName           = "EntityRef"
+    val _Group: TypeName               = "Group"
+    val _MetaData: TypeName            = "MetaData"
+    val _NamespaceBinding: TypeName    = "NamespaceBinding"
+    val _NodeBuffer: TypeName          = "NodeBuffer"
+    val _PrefixedAttribute: TypeName   = "PrefixedAttribute"
+    val _ProcInstr: TypeName           = "ProcInstr"
+    val _Text: TypeName                = "Text"
+    val _Unparsed: TypeName            = "Unparsed"
+    val _UnprefixedAttribute: TypeName = "UnprefixedAttribute"
+  }
+
+  private object xmlterms extends ScalaTermNames {
+    val _Null: TermName     = "Null"
+    val __Elem: TermName    = "Elem"
+    val __Text: TermName    = "Text"
+    val _buf: TermName      = "$buf"
+    val _md: TermName       = "$md"
+    val _plus: TermName     = "&+"
+    val _tmpscope: TermName = "$tmpscope"
+    val _xml: TermName      = "xml"
+  }
+
+  import xmltypes.{_Comment, _Elem, _EntityRef, _Group, _MetaData, _NamespaceBinding, _NodeBuffer,
+    _PrefixedAttribute, _ProcInstr, _Text, _Unparsed, _UnprefixedAttribute}
+
+  import xmlterms.{_Null, __Elem, __Text, _buf, _md, _plus, _scope, _tmpscope, _xml}
+
+  // convenience methods
+  private def LL[A](x: A*): List[List[A]] = List(List(x:_*))
+  private def const(x: Any) = Literal(Constant(x))
+  private def wild                          = Ident(nme.WILDCARD)
+  private def wildStar                      = Ident(tpnme.WILDCARD_STAR)
+  private def _scala(name: Name)            = scalaDot(name)
+  private def _scala_xml(name: Name)        = Select(_scala(_xml), name)
+
+  private def _scala_xml_Comment            = _scala_xml(_Comment)
+  private def _scala_xml_Elem               = _scala_xml(_Elem)
+  private def _scala_xml_EntityRef          = _scala_xml(_EntityRef)
+  private def _scala_xml_Group              = _scala_xml(_Group)
+  private def _scala_xml_MetaData           = _scala_xml(_MetaData)
+  private def _scala_xml_NamespaceBinding   = _scala_xml(_NamespaceBinding)
+  private def _scala_xml_NodeBuffer         = _scala_xml(_NodeBuffer)
+  private def _scala_xml_Null               = _scala_xml(_Null)
+  private def _scala_xml_PrefixedAttribute  = _scala_xml(_PrefixedAttribute)
+  private def _scala_xml_ProcInstr          = _scala_xml(_ProcInstr)
+  private def _scala_xml_Text               = _scala_xml(_Text)
+  private def _scala_xml_Unparsed           = _scala_xml(_Unparsed)
+  private def _scala_xml_UnprefixedAttribute= _scala_xml(_UnprefixedAttribute)
+  private def _scala_xml__Elem              = _scala_xml(__Elem)
+  private def _scala_xml__Text              = _scala_xml(__Text)
+
+  /** Wildly wrong documentation deleted in favor of "self-documenting code." */
+  protected def mkXML(
+    span: Span,
+    isPattern: Boolean,
+    pre: Tree,
+    label: Tree,
+    attrs: Tree,
+    scope: Tree,
+    empty: Boolean,
+    children: collection.Seq[Tree]): Tree =
+  {
+    def starArgs =
+      if (children.isEmpty) Nil
+      else List(Typed(makeXMLseq(span, children), wildStar))
+
+    def pat    = Apply(_scala_xml__Elem, List(pre, label, wild, wild) ::: convertToTextPat(children))
+    def nonpat = New(_scala_xml_Elem, List(List(pre, label, attrs, scope, if (empty) Literal(Constant(true)) else Literal(Constant(false))) ::: starArgs))
+
+    atSpan(span) { if (isPattern) pat else nonpat }
+  }
+
+  final def entityRef(span: Span, n: String): Tree =
+    atSpan(span)( New(_scala_xml_EntityRef, LL(const(n))) )
+
+  // create scala.xml.Text here <: scala.xml.Node
+  final def text(span: Span, txt: String): Tree = atSpan(span) {
+    if (isPattern) makeTextPat(const(txt))
+    else makeText1(const(txt))
+  }
+
+  def makeTextPat(txt: Tree): Apply               = Apply(_scala_xml__Text, List(txt))
+  def makeText1(txt: Tree): Tree                  = New(_scala_xml_Text, LL(txt))
+  def comment(span: Span, text: String): Tree  = atSpan(span)( Comment(const(text)) )
+  def charData(span: Span, txt: String): Tree  = atSpan(span)( makeText1(const(txt)) )
+
+  def procInstr(span: Span, target: String, txt: String): Tree =
+    atSpan(span)( ProcInstr(const(target), const(txt)) )
+
+  protected def Comment(txt: Tree): Tree                  = New(_scala_xml_Comment, LL(txt))
+  protected def ProcInstr(target: Tree, txt: Tree): Tree  = New(_scala_xml_ProcInstr, LL(target, txt))
+
+  /** @todo: attributes */
+  def makeXMLpat(span: Span, n: String, args: collection.Seq[Tree]): Tree = {
+    val (prepat, labpat) = splitPrefix(n) match {
+      case (Some(pre), rest)  => (const(pre), const(rest))
+      case _                  => (wild, const(n))
+    }
+    mkXML(span, true, prepat, labpat, null, null, false, args)
+  }
+
+  protected def convertToTextPat(t: Tree): Tree = t match {
+    case _: Literal => makeTextPat(t)
+    case _          => t
+  }
+  protected def convertToTextPat(buf: collection.Seq[Tree]): List[Tree] =
+    (buf map convertToTextPat).toList
+
+  def parseAttribute(span: Span, s: String): Tree = {
+    val ts = Utility.parseAttributeValue(s, text(span, _), entityRef(span, _))
+    ts match {
+      case Nil      => TypedSplice(tpd.ref(defn.NilModule).withSpan(span))
+      case t :: Nil => t
+      case _        => makeXMLseq(span, ts)
+    }
+  }
+
+  def isEmptyText(t: Tree): Boolean = t match {
+    case Literal(Constant("")) => true
+    case _ => false
+  }
+
+  /** could optimize if args.length == 0, args.length == 1 AND args(0) is <: Node. */
+  def makeXMLseq(span: Span, args: collection.Seq[Tree]): Block = {
+    val buffer = ValDef(_buf, TypeTree(), New(_scala_xml_NodeBuffer, ListOfNil))
+    val applies = args filterNot isEmptyText map (t => Apply(Select(Ident(_buf), _plus), List(t)))
+
+    atSpan(span)(new XMLBlock(buffer :: applies.toList, Ident(_buf)) )
+  }
+
+  /** Returns (Some(prefix) | None, rest) based on position of ':' */
+  def splitPrefix(name: String): (Option[String], String) = name.splitWhere(_ == ':', doDropIndex = true) match {
+    case Some((pre, rest))  => (Some(pre), rest)
+    case _                  => (None, name)
+  }
+
+  /** Various node constructions. */
+  def group(span: Span, args: collection.Seq[Tree]): Tree =
+    atSpan(span)( New(_scala_xml_Group, LL(makeXMLseq(span, args))) )
+
+  def unparsed(span: Span, str: String): Tree =
+    atSpan(span)( New(_scala_xml_Unparsed, LL(const(str))) )
+
+  def element(span: Span, qname: String, attrMap: mutable.Map[String, Tree], empty: Boolean, args: collection.Seq[Tree]): Tree = {
+    def handleNamespaceBinding(pre: String, z: String): Tree = {
+      def mkAssign(t: Tree): Tree = Assign(
+        Ident(_tmpscope),
+        New(_scala_xml_NamespaceBinding, LL(const(pre), t, Ident(_tmpscope)))
+      )
+
+      val uri1 = attrMap(z) match {
+        case Apply(_, List(uri @ Literal(Constant(_)))) => mkAssign(uri)
+        case Select(_, nme.Nil)                         => mkAssign(const(null))  // allow for xmlns="" -- bug #1626
+        case x                                          => mkAssign(x)
+      }
+      attrMap -= z
+      uri1
+    }
+
+    /** Extract all the namespaces from the attribute map. */
+    val namespaces: List[Tree] =
+      for (z <- attrMap.keys.toList ; if z startsWith "xmlns") yield {
+        val ns = splitPrefix(z) match {
+          case (Some(_), rest)  => rest
+          case _                => null
+        }
+        handleNamespaceBinding(ns, z)
+      }
+
+    val (pre, newlabel) = splitPrefix(qname) match {
+      case (Some(p), x) => (p, x)
+      case (None, x)    => (null, x)
+    }
+
+    def mkAttributeTree(pre: String, key: String, value: Tree) = atSpan(span.toSynthetic) {
+      // XXX this is where we'd like to put Select(value, nme.toString_) for #1787
+      // after we resolve the Some(foo) situation.
+      val baseArgs = List(const(key), value, Ident(_md))
+      val (clazz, attrArgs) =
+        if (pre == null) (_scala_xml_UnprefixedAttribute, baseArgs)
+                    else (_scala_xml_PrefixedAttribute  , const(pre) :: baseArgs)
+
+      Assign(Ident(_md), New(clazz, LL(attrArgs: _*)))
+    }
+
+    def handlePrefixedAttribute(pre: String, key: String, value: Tree)  = mkAttributeTree(pre, key, value)
+    def handleUnprefixedAttribute(key: String, value: Tree)             = mkAttributeTree(null, key, value)
+
+    val attributes: List[Tree] =
+      for ((k, v) <- attrMap.toList.reverse) yield splitPrefix(k) match {
+        case (Some(pre), rest)  => handlePrefixedAttribute(pre, rest, v)
+        case _                  => handleUnprefixedAttribute(k, v)
+      }
+
+    lazy val scopeDef     = ValDef(_scope, _scala_xml_NamespaceBinding, Ident(_tmpscope))
+    lazy val tmpScopeDef  = ValDef(_tmpscope, _scala_xml_NamespaceBinding, Ident(_scope)).withFlags(Mutable)
+    lazy val metadataDef  = ValDef(_md, _scala_xml_MetaData, _scala_xml_Null).withFlags(Mutable)
+    val makeSymbolicAttrs = if (!attributes.isEmpty) Ident(_md) else _scala_xml_Null
+
+    val (attrResult, nsResult) =
+      (attributes.isEmpty, namespaces.isEmpty) match {
+        case (true ,  true)   => (Nil, Nil)
+        case (true , false)   => (scopeDef :: Nil, tmpScopeDef :: namespaces)
+        case (false,  true)   => (metadataDef :: attributes, Nil)
+        case (false, false)   => (scopeDef :: metadataDef :: attributes, tmpScopeDef :: namespaces)
+      }
+
+    val body = mkXML(
+      span.toSynthetic,
+      false,
+      const(pre),
+      const(newlabel),
+      makeSymbolicAttrs,
+      Ident(_scope),
+      empty,
+      args
+    )
+
+    atSpan(span.toSynthetic)(new XMLBlock(nsResult, new XMLBlock(attrResult, body)))
+  }
+}
diff --git a/tests/pos-with-compiler-cc/dotc/parsing/xml/Utility.scala b/tests/pos-with-compiler-cc/dotc/parsing/xml/Utility.scala
new file mode 100644
index 000000000000..87412cf6d69c
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/parsing/xml/Utility.scala
@@ -0,0 +1,173 @@
+package dotty.tools.dotc
+package parsing
+package xml
+
+import scala.language.unsafeNulls
+
+import scala.collection.mutable
+
+/**
+ * The `Utility` object provides utility functions for processing instances
+ * of bound and not bound XML classes, as well as escaping text nodes.
+ *
+ * @author Burak Emir
+ */
+object Utility {
+  import util.Chars.SU
+
+  private val unescMap = Map(
+    "lt"    -> '<',
+    "gt"    -> '>',
+    "amp"   -> '&',
+    "quot"  -> '"',
+    "apos"  -> '\''
+  )
+
+  /**
+   * Appends unescaped string to `s`, `amp` becomes `&amp;`,
+   * `lt` becomes `&lt;` etc..
+   *
+   * @return    `'''null'''` if `ref` was not a predefined entity.
+   */
+  private final def unescape(ref: String, s: StringBuilder): StringBuilder =
+    ((unescMap get ref) map (s append _)).orNull
+
+  def parseAttributeValue[T](value: String, text: String => T, entityRef: String => T): List[T] = {
+    val sb  = new StringBuilder
+    var rfb: StringBuilder = null
+    val nb = new mutable.ListBuffer[T]()
+
+    val it = value.iterator
+    while (it.hasNext) {
+      var c = it.next()
+      // entity! flush buffer into text node
+      if (c == '&') {
+        c = it.next()
+        if (c == '#') {
+          c = it.next()
+          val theChar = parseCharRef ({ ()=> c },{ () => c = it.next() },{s => throw new RuntimeException(s)}, {s => throw new RuntimeException(s)})
+          sb.append(theChar)
+        }
+        else {
+          if (rfb eq null) rfb = new StringBuilder()
+          rfb append c
+          c = it.next()
+          while (c != ';') {
+            rfb.append(c)
+            c = it.next()
+          }
+          val ref = rfb.toString()
+          rfb.clear()
+          unescape(ref,sb) match {
+            case null =>
+              if (!sb.isEmpty) {  // flush buffer
+                nb += text(sb.toString())
+                sb.clear()
+              }
+              nb += entityRef(ref) // add entityref
+            case _ =>
+          }
+        }
+      }
+      else sb append c
+    }
+
+    if (!sb.isEmpty) // flush buffer
+      nb += text(sb.toString())
+
+    nb.toList
+  }
+
+  /**
+   * {{{
+   *   CharRef ::= "&amp;#" '0'..'9' {'0'..'9'} ";"
+   *             | "&amp;#x" '0'..'9'|'A'..'F'|'a'..'f' { hexdigit } ";"
+   * }}}
+   * See [66]
+   */
+  def parseCharRef(ch: () => Char, nextch: () => Unit, reportSyntaxError: String => Unit, reportTruncatedError: String => Unit): String = {
+    val hex  = ch() == 'x'
+    if (hex) nextch()
+    val base = if (hex) 16 else 10
+    var i = 0
+    while (ch() != ';') {
+      ch() match {
+        case '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' =>
+          i = i * base + ch().asDigit
+        case 'a' | 'b' | 'c' | 'd' | 'e' | 'f'
+           | 'A' | 'B' | 'C' | 'D' | 'E' | 'F' =>
+          if (! hex)
+            reportSyntaxError("hex char not allowed in decimal char ref\n" +
+                              "Did you mean to write &#x ?")
+          else
+            i = i * base + ch().asDigit
+        case SU =>
+          reportTruncatedError("")
+        case _ =>
+          reportSyntaxError("character '" + ch() + "' not allowed in char ref\n")
+      }
+      nextch()
+    }
+    new String(Array(i), 0, 1)
+  }
+
+  /** {{{
+   *  (#x20 | #x9 | #xD | #xA)
+   *  }}} */
+  final def isSpace(ch: Char): Boolean = ch match {
+    case '\u0009' | '\u000A' | '\u000D' | '\u0020' => true
+    case _                                         => false
+  }
+  /** {{{
+   *  (#x20 | #x9 | #xD | #xA)+
+   *  }}} */
+  final def isSpace(cs: Seq[Char]): Boolean = cs.nonEmpty && (cs forall isSpace)
+
+  /** {{{
+   *  NameChar ::= Letter | Digit | '.' | '-' | '_' | ':'
+   *             | CombiningChar | Extender
+   *  }}}
+   *  See [4] and Appendix B of XML 1.0 specification.
+  */
+  def isNameChar(ch: Char): Boolean = {
+    import java.lang.Character._
+    // The constants represent groups Mc, Me, Mn, Lm, and Nd.
+
+    isNameStart(ch) || (getType(ch).toByte match {
+      case COMBINING_SPACING_MARK |
+              ENCLOSING_MARK | NON_SPACING_MARK |
+              MODIFIER_LETTER | DECIMAL_DIGIT_NUMBER => true
+      case _                                         => ".-:" contains ch
+    })
+  }
+
+  /** {{{
+   *  NameStart ::= ( Letter | '_' )
+   *  }}}
+   *  where Letter means in one of the Unicode general
+   *  categories `{ Ll, Lu, Lo, Lt, Nl }`.
+   *
+   *  We do not allow a name to start with `:`.
+   *  See [3] and Appendix B of XML 1.0 specification
+   */
+  def isNameStart(ch: Char): Boolean = {
+    import java.lang.Character._
+
+    getType(ch).toByte match {
+      case LOWERCASE_LETTER |
+              UPPERCASE_LETTER | OTHER_LETTER |
+              TITLECASE_LETTER | LETTER_NUMBER => true
+      case _                                   => ch == '_'
+    }
+  }
+
+  /** {{{
+   *  Name ::= ( Letter | '_' ) (NameChar)*
+   *  }}}
+   *  See [5] of XML 1.0 specification.
+   */
+  def isName(s: String): Boolean =
+    s.nonEmpty && isNameStart(s.head) && (s.tail forall isNameChar)
+
+}
+
diff --git a/tests/pos-with-compiler-cc/dotc/plugins/Plugin.scala b/tests/pos-with-compiler-cc/dotc/plugins/Plugin.scala
new file mode 100644
index 000000000000..21bb0fa2be54
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/plugins/Plugin.scala
@@ -0,0 +1,196 @@
+package dotty.tools.dotc
+package plugins
+
+import scala.language.unsafeNulls
+
+import core._
+import Contexts._
+import Phases._
+import dotty.tools.io._
+import transform.MegaPhase.MiniPhase
+
+import java.io.InputStream
+import java.util.Properties
+
+import scala.util.{ Try, Success, Failure }
+
+trait PluginPhase extends MiniPhase {
+  def runsBefore: Set[String] = Set.empty
+}
+
+sealed trait Plugin {
+  /** The name of this plugin */
+  def name: String
+
+  /** A one-line description of the plugin */
+  def description: String
+
+  /** Is this plugin a research plugin?
+   *
+   *  Research plugin receives a phase plan and return a new phase plan, while
+   *  non-research plugin returns a list of phases to be inserted.
+   *
+   */
+  def isResearch: Boolean = isInstanceOf[ResearchPlugin]
+
+  /** A description of this plugin's options, suitable as a response
+   *  to the -help command-line option.  Conventionally, the options
+   *  should be listed with the `-P:plugname:` part included.
+   */
+  val optionsHelp: Option[String] = None
+}
+
+/** A standard plugin can be inserted into the normal compilation pipeline */
+trait StandardPlugin extends Plugin {
+  /** Non-research plugins should override this method to return the phases
+   *
+   *  @param options: commandline options to the plugin, `-P:plugname:opt1,opt2` becomes List(opt1, opt2)
+   *  @return a list of phases to be added to the phase plan
+   */
+  def init(options: List[String]): List[PluginPhase]
+}
+
+/** A research plugin may customize the compilation pipeline freely
+ *
+ *  @note Research plugins are only supported by nightly or snapshot build of the compiler.
+ */
+trait ResearchPlugin extends Plugin {
+  /** Research plugins should override this method to return the new phase plan
+   *
+   *  @param options: commandline options to the plugin, `-P:plugname:opt1,opt2` becomes List(opt1, opt2)
+   *  @param plan: the given phase plan
+   *  @return the new phase plan
+   */
+  def init(options: List[String], plan: List[List[Phase]])(using Context): List[List[Phase]]
+}
+
+object Plugin {
+
+  private val PluginFile = "plugin.properties"
+
+  /** Create a class loader with the specified locations plus
+   *  the loader that loaded the Scala compiler.
+   */
+  private def loaderFor(locations: Seq[Path]): ClassLoader = {
+    val compilerLoader = classOf[Plugin].getClassLoader
+    val urls = locations map (_.toURL)
+
+    new java.net.URLClassLoader(urls.toArray, compilerLoader)
+  }
+
+  type AnyClass = Class[?]
+
+  /** Use a class loader to load the plugin class.
+   */
+  def load(classname: String, loader: ClassLoader): Try[AnyClass] = {
+    import scala.util.control.NonFatal
+    try
+      Success[AnyClass](loader loadClass classname)
+    catch {
+      case NonFatal(e) =>
+        Failure(new PluginLoadException(classname, s"Error: unable to load class $classname: ${e.getMessage}"))
+      case e: NoClassDefFoundError =>
+        Failure(new PluginLoadException(classname, s"Error: class not found: ${e.getMessage} required by $classname"))
+    }
+  }
+
+  /** Load all plugins specified by the arguments.
+   *  Each location of `paths` must be a valid plugin archive or exploded archive.
+   *  Each of `paths` must define one plugin.
+   *  Each of `dirs` may be a directory containing arbitrary plugin archives.
+   *  Skips all plugins named in `ignoring`.
+   *  A classloader is created to load each plugin.
+   */
+  def loadAllFrom(
+    paths: List[List[Path]],
+    dirs: List[Path],
+    ignoring: List[String]): List[Try[Plugin]] = {
+
+    def fromFile(inputStream: InputStream, path: Path): String = {
+      val props = new Properties
+      props.load(inputStream)
+      inputStream.close()
+
+      val pluginClass = props.getProperty("pluginClass")
+
+      if (pluginClass == null) throw new RuntimeException("Bad plugin descriptor: " + path)
+      else pluginClass
+    }
+
+    def loadDescriptionFromDir(f: Path): Try[String] = {
+      val path = f / PluginFile
+      Try(fromFile(new java.io.FileInputStream(path.jpath.toFile), path))
+    }
+
+    def loadDescriptionFromJar(jarp: Path): Try[String] = {
+      // XXX Return to this once we have more ARM support
+      def read(is: InputStream) =
+        if (is == null) throw new PluginLoadException(jarp.path, s"Missing $PluginFile in $jarp")
+        else fromFile(is, jarp)
+
+      val fileEntry = new java.util.jar.JarEntry(PluginFile)
+      Try(read(new Jar(jarp.jpath.toFile).getEntryStream(fileEntry)))
+    }
+
+    // List[(jar, Try(descriptor))] in dir
+    def scan(d: Directory) =
+      d.files.toList sortBy (_.name) filter (Jar isJarOrZip _) map (j => (j, loadDescriptionFromJar(j)))
+
+    type PDResults = List[Try[(String, ClassLoader)]]
+
+    // scan plugin dirs for jars containing plugins, ignoring dirs with none and other jars
+    val fromDirs: PDResults = dirs filter (_.isDirectory) flatMap { d =>
+      scan(d.toDirectory) collect {
+        case (j, Success(pd)) => Success((pd, loaderFor(Seq(j))))
+      }
+    }
+
+    // scan jar paths for plugins, taking the first plugin you find.
+    // a path element can be either a plugin.jar or an exploded dir.
+    def findDescriptor(ps: List[Path]) = {
+      def loop(qs: List[Path]): Try[String] = qs match {
+        case Nil       => Failure(new MissingPluginException(ps))
+        case p :: rest =>
+          if (p.isDirectory) loadDescriptionFromDir(p.toDirectory) orElse loop(rest)
+          else if (p.isFile) loadDescriptionFromJar(p.toFile) orElse loop(rest)
+          else loop(rest)
+      }
+      loop(ps)
+    }
+
+    val fromPaths: PDResults = paths map (p => findDescriptor(p) match {
+      case Success(classname) => Success((classname, loaderFor(p)))
+      case Failure(e)  => Failure(e)
+    })
+
+    val seen = util.HashSet[String]()
+    val enabled = (fromPaths ::: fromDirs) map(_.flatMap {
+      case (classname, loader) =>
+        Plugin.load(classname, loader).flatMap {  clazz =>
+          val plugin = instantiate(clazz)
+          if (seen.contains(classname))   // a nod to scala/bug#7494, take the plugin classes distinctly
+            Failure(new PluginLoadException(plugin.name, s"Ignoring duplicate plugin ${plugin.name} (${classname})"))
+          else if (ignoring contains plugin.name)
+            Failure(new PluginLoadException(plugin.name, s"Disabling plugin ${plugin.name}"))
+          else {
+            seen += classname
+            Success(plugin)
+          }
+        }
+    })
+    enabled   // distinct and not disabled
+  }
+
+  /** Instantiate a plugin class, given the class and
+   *  the compiler it is to be used in.
+   */
+  def instantiate(clazz: AnyClass): Plugin = clazz.getConstructor().newInstance().asInstanceOf[Plugin]
+}
+
+class PluginLoadException(val path: String, message: String, cause: Exception) extends Exception(message, cause) {
+  def this(path: String, message: String) = this(path, message, null)
+}
+
+class MissingPluginException(path: String) extends PluginLoadException(path, s"No plugin in path $path") {
+  def this(paths: List[Path]) = this(paths mkString File.pathSeparator)
+}
diff --git a/tests/pos-with-compiler-cc/dotc/plugins/Plugins.scala b/tests/pos-with-compiler-cc/dotc/plugins/Plugins.scala
new file mode 100644
index 000000000000..3093a1c0460f
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/plugins/Plugins.scala
@@ -0,0 +1,276 @@
+package dotty.tools.dotc
+package plugins
+
+import scala.language.unsafeNulls
+
+import core._
+import Contexts._
+import config.{ PathResolver, Feature }
+import dotty.tools.io._
+import Phases._
+import config.Printers.plugins.{ println => debug }
+
+/** Support for run-time loading of compiler plugins.
+ *
+ *  @author Lex Spoon
+ *  @version 1.1, 2009/1/2
+ *  Updated 2009/1/2 by Anders Bach Nielsen: Added features to implement SIP 00002
+ */
+trait Plugins {
+  self: ContextBase =>
+
+  /** Load a rough list of the plugins.  For speed, it
+   *  does not instantiate a compiler run.  Therefore it cannot
+   *  test for same-named phases or other problems that are
+   *  filtered from the final list of plugins.
+   */
+  protected def loadRoughPluginsList(using Context): List[Plugin] = {
+    def asPath(p: String) = ClassPath split p
+    val paths  = ctx.settings.plugin.value filter (_ != "") map (s => asPath(s) map Path.apply)
+    val dirs   = {
+      def injectDefault(s: String) = if (s.isEmpty) PathResolver.Defaults.scalaPluginPath else s
+      asPath(ctx.settings.pluginsDir.value) map injectDefault map Path.apply
+    }
+    val maybes = Plugin.loadAllFrom(paths, dirs, ctx.settings.disable.value)
+    val (goods, errors) = maybes partition (_.isSuccess)
+    // Explicit parameterization of recover to avoid -Xlint warning about inferred Any
+    errors foreach (_.recover[Any] {
+      // legacy behavior ignores altogether, so at least warn devs
+      case e: MissingPluginException => report.warning(e.getMessage.nn)
+      case e: Exception              => report.inform(e.getMessage.nn)
+    })
+
+    goods map (_.get)
+  }
+
+  private var _roughPluginsList: List[Plugin] = _
+  protected def roughPluginsList(using Context): List[Plugin] =
+    if (_roughPluginsList == null) {
+      _roughPluginsList = loadRoughPluginsList
+      _roughPluginsList
+    }
+    else _roughPluginsList
+
+  /** Load all available plugins. Skips plugins that
+   *  either have the same name as another one, or which
+   *  define a phase name that another one does.
+   */
+  protected def loadPlugins(using Context): List[Plugin] = {
+    // remove any with conflicting names or subcomponent names
+    def pick(
+      plugins: List[Plugin],
+      plugNames: Set[String]): List[Plugin] = {
+      if (plugins.isEmpty) return Nil // early return
+
+      val plug :: tail      = plugins: @unchecked
+      def withoutPlug       = pick(tail, plugNames)
+      def withPlug          = plug :: pick(tail, plugNames + plug.name)
+
+      def note(msg: String): Unit = if (ctx.settings.verbose.value) report.inform(msg format plug.name)
+      def fail(msg: String)       = { note(msg) ; withoutPlug }
+
+      if (plugNames contains plug.name)
+        fail("[skipping a repeated plugin: %s]")
+      else if (ctx.settings.disable.value contains plug.name)
+        fail("[disabling plugin: %s]")
+      else {
+        note("[loaded plugin %s]")
+        withPlug
+      }
+    }
+
+    val plugs = pick(roughPluginsList, ctx.base.phasePlan.flatten.map(_.phaseName).toSet)
+
+    // Verify required plugins are present.
+    for (req <- ctx.settings.require.value ; if !(plugs exists (_.name == req)))
+      report.error("Missing required plugin: " + req)
+
+    // Verify no non-existent plugin given with -P
+    for {
+      opt <- ctx.settings.pluginOptions.value
+      if !(plugs exists (opt startsWith _.name + ":"))
+    }
+    report.error("bad option: -P:" + opt)
+
+    plugs
+  }
+
+  private var _plugins: List[Plugin] = _
+  def plugins(using Context): List[Plugin] =
+    if (_plugins == null) {
+      _plugins = loadPlugins
+      _plugins
+    }
+    else _plugins
+
+  /** A description of all the plugins that are loaded */
+  def pluginDescriptions(using Context): String =
+    roughPluginsList map (x => "%s - %s".format(x.name, x.description)) mkString "\n"
+
+  /** Summary of the options for all loaded plugins */
+  def pluginOptionsHelp(using Context): String =
+    (for (plug <- roughPluginsList ; help <- plug.optionsHelp) yield {
+      "\nOptions for plugin '%s':\n%s\n".format(plug.name, help)
+    }).mkString
+
+  /** Add plugin phases to phase plan */
+  def addPluginPhases(plan: List[List[Phase]])(using Context): List[List[Phase]] = {
+    // plugin-specific options.
+    // The user writes `-P:plugname:opt1,opt2`, but the plugin sees `List(opt1, opt2)`.
+    def options(plugin: Plugin): List[String] = {
+      def namec = plugin.name + ":"
+      ctx.settings.pluginOptions.value filter (_ startsWith namec) map (_ stripPrefix namec)
+    }
+
+    // schedule plugins according to ordering constraints
+    val pluginPhases = plugins.collect { case p: StandardPlugin => p }.flatMap { plug => plug.init(options(plug)) }
+    val updatedPlan = Plugins.schedule(plan, pluginPhases)
+
+    // add research plugins
+    if (Feature.isExperimentalEnabled)
+      plugins.collect { case p: ResearchPlugin => p }.foldRight(updatedPlan) {
+        (plug, plan) => plug.init(options(plug), plan)
+      }
+    else
+      updatedPlan
+  }
+}
+
+object Plugins {
+  /** Insert plugin phases in the right place of the phase plan
+   *
+   *  The scheduling makes sure the ordering constraints of plugin phases are satisfied.
+   *  If the ordering constraints are unsatisfiable, an exception is thrown.
+   *
+   *  Note: this algorithm is factored out for unit test.
+   */
+  def schedule(plan: List[List[Phase]], pluginPhases: List[PluginPhase]): List[List[Phase]] = {
+    import scala.collection.mutable.{ Map => MMap }
+    type OrderingReq = (Set[String], Set[String])
+
+    val orderRequirements = MMap[String, OrderingReq]()
+
+    // 1. already inserted phases don't need constraints themselves.
+    // 2. no need to propagate beyond boundary of inserted phases, as the information
+    //    beyond boundary is less useful than the boundary.
+    // 3. unsatisfiable constraints will still be exposed by the first plugin in a loop
+    //    due to its conflicting `runAfter` and `runBefore` after propagation. The ordering
+    //    of primitive phases (`plan`) are used to check `runAfter` and `runBefore`, thus
+    //    there is no need to propagate the primitive phases.
+
+    var insertedPhase   = plan.flatMap(ps => ps.map(_.phaseName)).toSet
+    def isInserted(phase: String): Boolean = insertedPhase.contains(phase)
+
+    var updatedPlan = plan
+
+    def constraintConflict(phase: Phase): String = {
+      val (runsAfter, runsBefore) = orderRequirements(phase.phaseName)
+      s"""
+         |Ordering conflict for phase ${phase.phaseName}
+         |after: ${runsAfter.mkString("[", ", ", "]")}
+         |before: ${runsBefore.mkString("[", ", ", "]")}
+       """.stripMargin
+    }
+
+    // init ordering map, no propagation
+    pluginPhases.foreach { phase =>
+      val runsAfter  = phase.runsAfter
+      val runsBefore = phase.runsBefore
+
+      orderRequirements.update(phase.phaseName, (runsAfter, runsBefore))
+    }
+
+    // propagate ordering constraint : reflexivity
+    pluginPhases.foreach { phase =>
+
+      var (runsAfter, runsBefore) = orderRequirements(phase.phaseName)
+
+      // propagate transitive constraints to related phases
+      runsAfter.filter(!isInserted(_)).foreach { phaseName =>
+        val (runsAfter1, runsBefore1) = orderRequirements(phaseName)
+        orderRequirements.update(phaseName, (runsAfter1, runsBefore1 + phase.phaseName))
+      }
+
+      runsBefore.filter(!isInserted(_)).foreach { phaseName =>
+        val (runsAfter1, runsBefore1) = orderRequirements(phaseName)
+        orderRequirements.update(phaseName, (runsAfter1 + phase.phaseName, runsBefore1))
+      }
+
+    }
+
+    debug(
+      s""" reflexive constraints:
+         | ${orderRequirements.mkString("\n")}
+       """.stripMargin
+    )
+
+    // propagate constraints from related phases to current phase: transitivity
+    def propagate(phase: Phase): OrderingReq = {
+      def propagateRunsBefore(beforePhase: String): Set[String] =
+        if (beforePhase == phase.phaseName)
+          throw new Exception(constraintConflict(phase))
+        else if (isInserted(beforePhase))
+          Set(beforePhase)
+        else {
+          val (_, runsBefore) = orderRequirements(beforePhase)
+          runsBefore.flatMap(propagateRunsBefore) + beforePhase
+        }
+
+      def propagateRunsAfter(afterPhase: String): Set[String] =
+        if (afterPhase == phase.phaseName)
+          throw new Exception(constraintConflict(phase))
+        else if (isInserted(afterPhase))
+          Set(afterPhase)
+        else {
+          val (runsAfter, _) = orderRequirements(afterPhase)
+          runsAfter.flatMap(propagateRunsAfter) + afterPhase
+        }
+
+      var (runsAfter, runsBefore) = orderRequirements(phase.phaseName)
+
+      runsAfter  = runsAfter.flatMap(propagateRunsAfter)
+      runsBefore = runsBefore.flatMap(propagateRunsBefore)
+
+      (runsAfter, runsBefore)
+    }
+
+    pluginPhases.sortBy(_.phaseName).foreach { phase =>
+      var (runsAfter1, runsBefore1) = propagate(phase)
+
+      debug(
+        s"""propagated constraints for ${phase}:
+           |after: ${runsAfter1.mkString("[", ", ", "]")}
+           |before: ${runsBefore1.mkString("[", ", ", "]")}
+         """.stripMargin
+      )
+
+      var runsAfter  = runsAfter1 & insertedPhase
+      val runsBefore = runsBefore1 & insertedPhase
+
+      // runsBefore met after the split
+      val (before, after) = updatedPlan.span { ps =>
+        val phases = ps.map(_.phaseName)
+        val runsAfterSat = runsAfter.isEmpty
+        runsAfter = runsAfter -- phases
+        // Prefer the point immediately before the first runsBefore.
+        // If runsBefore not specified, insert at the point immediately
+        // after the last afterPhases.
+        !phases.exists(runsBefore.contains) &&
+          !(runsBefore.isEmpty && runsAfterSat)
+      }
+
+      // check runsAfter
+      // error can occur if: a < b, b < c, c < a
+      after.foreach { ps =>
+        val phases = ps.map(_.phaseName)
+        if (phases.exists(runsAfter)) // afterReq satisfied
+          throw new Exception(s"Ordering conflict for phase ${phase.phaseName}")
+      }
+
+      insertedPhase = insertedPhase + phase.phaseName
+      updatedPlan = before ++ (List(phase) :: after)
+    }
+
+    updatedPlan
+  }
+}
diff --git a/tests/pos-with-compiler-cc/dotc/printing/Formatting.scala b/tests/pos-with-compiler-cc/dotc/printing/Formatting.scala
new file mode 100644
index 000000000000..f85845517d8c
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/printing/Formatting.scala
@@ -0,0 +1,400 @@
+package dotty.tools
+package dotc
+package printing
+
+import scala.language.unsafeNulls
+
+import scala.collection.mutable
+
+import core._
+import Texts._, Types._, Flags._, Symbols._, Contexts._
+import Decorators._
+import reporting.Message
+import util.DiffUtil
+import Highlighting._
+
+object Formatting {
+
+  object ShownDef:
+    /** Represents a value that has been "shown" and can be consumed by StringFormatter.
+     *  Not just a string because it may be a Seq that StringFormatter will intersperse with the trailing separator.
+     *  It may also be a CtxShow, which allows the Show instance to finish showing the value with the string
+     *  interpolator's correct context, that is with non-sensical tagging, message limiting, explanations, etc. */
+    opaque type Shown = Any
+    object Shown:
+      given [A: Show]: Conversion[A, Shown] = Show[A].show(_)
+
+    sealed abstract class Show[-T]:
+      /** Show a value T by returning a "shown" result. */
+      def show(x: T): Shown
+
+    trait CtxShow:
+      def run(using Context): Shown
+
+    extension (s: Shown)
+      def ctxShow(using Context): Shown = s match
+        case cs: CtxShow => cs.run
+        case _           => s
+
+    /** The base implementation, passing the argument to StringFormatter which will try to `.show` it. */
+    object ShowAny extends Show[Any]:
+      def show(x: Any): Shown = x
+
+    class ShowImplicits3:
+      given Show[Product] = ShowAny
+
+    class ShowImplicits2 extends ShowImplicits3:
+      given Show[ParamInfo] = ShowAny
+
+    class ShowImplicits1 extends ShowImplicits2:
+      given Show[ImplicitRef]      = ShowAny
+      given Show[Names.Designator] = ShowAny
+      given Show[util.SrcPos]      = ShowAny
+
+    object Show extends ShowImplicits1:
+      inline def apply[A](using inline z: Show[A]): Show[A] = z
+
+      given [X: Show]: Show[Seq[X]] with
+        def show(x: Seq[X]) = new CtxShow:
+          def run(using Context) = x.map(show1)
+
+      given [H: Show, T <: Tuple: Show]: Show[H *: T] with
+        def show(x: H *: T) = new CtxShow:
+          def run(using Context) = show1(x.head) *: Show[T].show(x.tail).ctxShow.asInstanceOf[Tuple]
+
+      given [X: Show]: Show[X | Null] with
+        def show(x: X | Null) = if x == null then "null" else Show[X].show(x.nn)
+
+      given Show[FlagSet] with
+        def show(x: FlagSet) = x.flagsString
+
+      given Show[TypeComparer.ApproxState] with
+        def show(x: TypeComparer.ApproxState) = TypeComparer.ApproxState.Repr.show(x)
+
+      given Show[Showable]                            = ShowAny
+      given Show[Shown]                               = ShowAny
+      given Show[Int]                                 = ShowAny
+      given Show[Char]                                = ShowAny
+      given Show[Boolean]                             = ShowAny
+      given Show[Integer]                             = ShowAny
+      given Show[String]                              = ShowAny
+      given Show[Class[?]]                            = ShowAny
+      given Show[Throwable]                           = ShowAny
+      given Show[StringBuffer]                        = ShowAny
+      given Show[CompilationUnit]                     = ShowAny
+      given Show[Phases.Phase]                        = ShowAny
+      given Show[TyperState]                          = ShowAny
+      given Show[config.ScalaVersion]                 = ShowAny
+      given Show[io.AbstractFile]                     = ShowAny
+      given Show[parsing.Scanners.Scanner]            = ShowAny
+      given Show[util.SourceFile]                     = ShowAny
+      given Show[util.Spans.Span]                     = ShowAny
+      given Show[tasty.TreeUnpickler#OwnerTree]       = ShowAny
+
+      private def show1[A: Show](x: A)(using Context) = show2(Show[A].show(x).ctxShow)
+      private def show2(x: Shown)(using Context): String = x match
+        case seq: Seq[?] => seq.map(show2).mkString("[", ", ", "]")
+        case res         => res.tryToShow
+    end Show
+  end ShownDef
+  export ShownDef.{ Show, Shown }
+
+  /** General purpose string formatter, with the following features:
+   *
+   *  1. Invokes the `show` extension method on the interpolated arguments.
+   *  2. Sequences can be formatted using the desired separator between two `%` signs,
+   *     eg `i"myList = (${myList}%, %)"`
+   *  3. Safe handling of multi-line margins. Left margins are stripped on the parts
+   *     of the string context *before* inserting the arguments. That way, we guard
+   *     against accidentally treating an interpolated value as a margin.
+   */
+  class StringFormatter(protected val sc: StringContext) {
+    protected def showArg(arg: Any)(using Context): String = arg.tryToShow
+
+    private def treatArg(arg: Shown, suffix: String)(using Context): (String, String) = arg.ctxShow match {
+      case arg: Seq[?] if suffix.indexOf('%') == 0 && suffix.indexOf('%', 1) != -1 =>
+        val end = suffix.indexOf('%', 1)
+        val sep = StringContext.processEscapes(suffix.substring(1, end))
+        (arg.mkString(sep), suffix.substring(end + 1))
+      case arg: Seq[?] =>
+        (arg.map(showArg).mkString("[", ", ", "]"), suffix)
+      case arg =>
+        (showArg(arg), suffix)
+    }
+
+    def assemble(args: Seq[Shown])(using Context): String = {
+      def isLineBreak(c: Char) = c == '\n' || c == '\f' // compatible with StringLike#isLineBreak
+      def stripTrailingPart(s: String) = {
+        val (pre, post) = s.span(c => !isLineBreak(c))
+        pre ++ post.stripMargin
+      }
+      val (prefix, suffixes) = sc.parts.toList match {
+        case head :: tail => (head.stripMargin, tail map stripTrailingPart)
+        case Nil => ("", Nil)
+      }
+      val (args1, suffixes1) = args.lazyZip(suffixes).map(treatArg(_, _)).unzip
+      new StringContext(prefix :: suffixes1.toList: _*).s(args1: _*)
+    }
+  }
+
+  /** The `em` string interpolator works like the `i` string interpolator, but marks nonsensical errors
+   *  using `<nonsensical>...</nonsensical>` tags.
+   *  Note: Instead of these tags, it would be nicer to return a data structure containing the message string
+   *  and a boolean indicating whether the message is sensical, but then we cannot use string operations
+   *  like concatenation, stripMargin etc on the values returned by em"...", and in the current error
+   *  message composition methods, this is crucial.
+   */
+  def forErrorMessages(op: Context ?=> String)(using Context): String = op(using errorMessageCtx)
+
+  private class ErrorMessagePrinter(_ctx: Context) extends RefinedPrinter(_ctx):
+    override def toText(tp: Type): Text    = wrapNonSensical(tp, super.toText(tp))
+    override def toText(sym: Symbol): Text = wrapNonSensical(sym, super.toText(sym))
+
+  private def wrapNonSensical(arg: Any, text: Text)(using Context): Text = {
+    import Message._
+    def isSensical(arg: Any): Boolean = arg match {
+      case tpe: Type =>
+        tpe.exists && !tpe.isErroneous
+      case sym: Symbol if sym.isCompleted =>
+        sym.info match {
+          case _: ErrorType | TypeAlias(_: ErrorType) | NoType => false
+          case _ => true
+        }
+      case _ => true
+    }
+
+    if (isSensical(arg)) text
+    else nonSensicalStartTag ~ text ~ nonSensicalEndTag
+  }
+
+  private type Recorded = Symbol | ParamRef | SkolemType
+
+  private case class SeenKey(str: String, isType: Boolean)
+  private class Seen extends mutable.HashMap[SeenKey, List[Recorded]] {
+
+    override def default(key: SeenKey) = Nil
+
+    def record(str: String, isType: Boolean, entry: Recorded)(using Context): String = {
+
+      /** If `e1` is an alias of another class of the same name, return the other
+       *  class symbol instead. This normalization avoids recording e.g. scala.List
+       *  and scala.collection.immutable.List as two different types
+       */
+      def followAlias(e1: Recorded): Recorded = e1 match {
+        case e1: Symbol if e1.isAliasType =>
+          val underlying = e1.typeRef.underlyingClassRef(refinementOK = false).typeSymbol
+          if (underlying.name == e1.name) underlying else e1
+        case _ => e1
+      }
+      val key = SeenKey(str, isType)
+      val existing = apply(key)
+      lazy val dealiased = followAlias(entry)
+
+      // alts: The alternatives in `existing` that are equal, or follow (an alias of) `entry`
+      var alts = existing.dropWhile(alt => dealiased ne followAlias(alt))
+      if (alts.isEmpty) {
+        alts = entry :: existing
+        update(key, alts)
+      }
+      val suffix = alts.length match {
+        case 1 => ""
+        case n => n.toString.toCharArray.map {
+          case '0' => '⁰'
+          case '1' => '¹'
+          case '2' => '²'
+          case '3' => '³'
+          case '4' => '⁴'
+          case '5' => '⁵'
+          case '6' => '⁶'
+          case '7' => '⁷'
+          case '8' => '⁸'
+          case '9' => '⁹'
+        }.mkString
+      }
+      str + suffix
+    }
+  }
+
+  private class ExplainingPrinter(seen: Seen)(_ctx: Context) extends ErrorMessagePrinter(_ctx) {
+
+    /** True if printer should a source module instead of its module class */
+    private def useSourceModule(sym: Symbol): Boolean =
+      sym.is(ModuleClass, butNot = Package) && sym.sourceModule.exists && !_ctx.settings.YdebugNames.value
+
+    override def simpleNameString(sym: Symbol): String =
+      if (useSourceModule(sym)) simpleNameString(sym.sourceModule)
+      else seen.record(super.simpleNameString(sym), sym.isType, sym)
+
+    override def ParamRefNameString(param: ParamRef): String =
+      seen.record(super.ParamRefNameString(param), param.isInstanceOf[TypeParamRef], param)
+
+    override def toTextRef(tp: SingletonType): Text = tp match {
+      case tp: SkolemType => seen.record(tp.repr.toString, isType = true, tp)
+      case _ => super.toTextRef(tp)
+    }
+
+    override def toText(tp: Type): Text = tp match {
+      case tp: TypeRef if useSourceModule(tp.symbol) => Str("object ") ~ super.toText(tp)
+      case _ => super.toText(tp)
+    }
+  }
+
+  /** Create explanation for single `Recorded` type or symbol */
+  def explanation(entry: AnyRef)(using Context): String = {
+    def boundStr(bound: Type, default: ClassSymbol, cmp: String) =
+      if (bound.isRef(default)) "" else i"$cmp $bound"
+
+    def boundsStr(bounds: TypeBounds): String = {
+      val lo = boundStr(bounds.lo, defn.NothingClass, ">:")
+      val hi = boundStr(bounds.hi, defn.AnyClass, "<:")
+      if (lo.isEmpty) hi
+      else if (hi.isEmpty) lo
+      else s"$lo and $hi"
+    }
+
+    def addendum(cat: String, info: Type): String = info match {
+      case bounds @ TypeBounds(lo, hi) if bounds ne TypeBounds.empty =>
+        if (lo eq hi) i" which is an alias of $lo"
+        else i" with $cat ${boundsStr(bounds)}"
+      case _ =>
+        ""
+    }
+
+    entry match {
+      case param: TypeParamRef =>
+        s"is a type variable${addendum("constraint", TypeComparer.bounds(param))}"
+      case param: TermParamRef =>
+        s"is a reference to a value parameter"
+      case sym: Symbol =>
+        val info =
+          if (ctx.gadt.contains(sym))
+            sym.info & ctx.gadt.fullBounds(sym)
+          else
+            sym.info
+        s"is a ${ctx.printer.kindString(sym)}${sym.showExtendedLocation}${addendum("bounds", info)}"
+      case tp: SkolemType =>
+        s"is an unknown value of type ${tp.widen.show}"
+    }
+  }
+
+  /** Turns a `Seen` into a `String` to produce an explanation for types on the
+    * form `where: T is...`
+    *
+    * @return string disambiguating types
+    */
+  private def explanations(seen: Seen)(using Context): String = {
+    def needsExplanation(entry: Recorded) = entry match {
+      case param: TypeParamRef => ctx.typerState.constraint.contains(param)
+      case param: ParamRef     => false
+      case skolem: SkolemType => true
+      case sym: Symbol =>
+        ctx.gadt.contains(sym) && ctx.gadt.fullBounds(sym) != TypeBounds.empty
+    }
+
+    val toExplain: List[(String, Recorded)] = seen.toList.flatMap { kvs =>
+      val res: List[(String, Recorded)] = kvs match {
+        case (key, entry :: Nil) =>
+          if (needsExplanation(entry)) (key.str, entry) :: Nil else Nil
+        case (key, entries) =>
+          for (alt <- entries) yield {
+            val tickedString = seen.record(key.str, key.isType, alt)
+            (tickedString, alt)
+          }
+      }
+      res // help the inferrencer out
+    }.sortBy(_._1)
+
+    def columnar(parts: List[(String, String)]): List[String] = {
+      lazy val maxLen = parts.map(_._1.length).max
+      parts.map {
+        case (leader, trailer) =>
+          val variable = hl(leader)
+          s"""$variable${" " * (maxLen - leader.length)} $trailer"""
+      }
+    }
+
+    val explainParts = toExplain.map { case (str, entry) => (str, explanation(entry)) }
+    val explainLines = columnar(explainParts)
+    if (explainLines.isEmpty) "" else i"where:    $explainLines%\n          %\n"
+  }
+
+  private def errorMessageCtx(using Context): Context =
+    val ctx1 = ctx.property(MessageLimiter) match
+      case Some(_: ErrorMessageLimiter) => ctx
+      case _ => ctx.fresh.setProperty(MessageLimiter, ErrorMessageLimiter())
+    ctx1.printer match
+      case _: ErrorMessagePrinter => ctx1
+      case _ => ctx1.fresh.setPrinterFn(ctx => ErrorMessagePrinter(ctx))
+
+  /** Context with correct printer set for explanations */
+  private def explainCtx(seen: Seen)(using Context): Context =
+    val ectx = errorMessageCtx
+    ectx.printer match
+      case dp: ExplainingPrinter =>
+        ectx // re-use outer printer and defer explanation to it
+      case _ =>
+        ectx.fresh.setPrinterFn(ctx => new ExplainingPrinter(seen)(ctx))
+
+  /** Entrypoint for explanation string interpolator:
+    *
+    * ```
+    * ex"disambiguate $tpe1 and $tpe2"
+    * ```
+    */
+  def explained(op: Context ?=> String)(using Context): String = {
+    val seen = new Seen
+    val msg = op(using explainCtx(seen))
+    val addendum = explanations(seen)
+    if (addendum.isEmpty) msg else msg ++ "\n\n" ++ addendum
+  }
+
+  /** When getting a type mismatch it is useful to disambiguate placeholders like:
+    *
+    * ```
+    * found:    List[Int]
+    * required: List[T]
+    * where:    T is a type in the initializer of value s which is an alias of
+    *           String
+    * ```
+    *
+    * @return the `where` section as well as the printing context for the
+    *         placeholders - `("T is a...", printCtx)`
+    */
+  def disambiguateTypes(args: Type*)(using Context): (String, Context) = {
+    val seen = new Seen
+    val printCtx = explainCtx(seen)
+    args.foreach(_.show(using printCtx)) // showing each member will put it into `seen`
+    (explanations(seen), printCtx)
+  }
+
+  /** This method will produce a colored type diff from the given arguments.
+    * The idea is to do this for known cases that are useful and then fall back
+    * on regular syntax highlighting for the cases which are unhandled.
+    *
+    * Please not that if used in combination with `disambiguateTypes` the
+    * correct `Context` for printing should also be passed when calling the
+    * method.
+    *
+    * @return the (found, expected, changePercentage) with coloring to
+    *         highlight the difference
+    */
+  def typeDiff(found: Type, expected: Type)(using Context): (String, String) = {
+    val fnd = wrapNonSensical(found, found.toText(ctx.printer)).show
+    val exp = wrapNonSensical(expected, expected.toText(ctx.printer)).show
+
+    DiffUtil.mkColoredTypeDiff(fnd, exp) match {
+      case _ if ctx.settings.color.value == "never" => (fnd, exp)
+      case (fnd, exp, change) if change < 0.5 => (fnd, exp)
+      case _ => (fnd, exp)
+    }
+  }
+
+  /** Explicit syntax highlighting */
+  def hl(s: String)(using Context): String =
+    SyntaxHighlighting.highlight(s)
+
+  /** Explicitly highlight a string with the same formatting as used for keywords */
+  def hlAsKeyword(str: String)(using Context): String =
+    if str.isEmpty || ctx.settings.color.value == "never" then str
+    else s"${SyntaxHighlighting.KeywordColor}$str${SyntaxHighlighting.NoColor}"
+}
diff --git a/tests/pos-with-compiler-cc/dotc/printing/Highlighting.scala b/tests/pos-with-compiler-cc/dotc/printing/Highlighting.scala
new file mode 100644
index 000000000000..091f8bfb5c16
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/printing/Highlighting.scala
@@ -0,0 +1,72 @@
+package dotty.tools
+package dotc
+package printing
+
+import scala.collection.mutable
+import core.Contexts._
+
+object Highlighting {
+
+  sealed abstract class Highlight(private val highlight: String) {
+    def text: String
+
+    def show(using Context): String = if ctx.useColors then highlight + text + Console.RESET else text
+
+    override def toString: String =
+      highlight + text + Console.RESET
+
+    def +(other: Highlight)(using Context): HighlightBuffer =
+      new HighlightBuffer(this) + other
+
+    def +(other: String)(using Context): HighlightBuffer =
+      new HighlightBuffer(this) + other
+  }
+
+  abstract class Modifier(private val mod: String, text: String) extends Highlight(Console.RESET) {
+    override def show(using Context): String =
+      if (ctx.settings.color.value == "never") ""
+      else mod + super.show
+  }
+
+  case class HighlightBuffer(hl: Highlight)(using Context) {
+    private val buffer = new mutable.ListBuffer[String]
+
+    buffer += hl.show
+
+    def +(other: Highlight): HighlightBuffer = {
+      buffer += other.show
+      this
+    }
+
+    def +(other: String): HighlightBuffer = {
+      buffer += other
+      this
+    }
+
+    override def toString: String =
+      buffer.mkString
+  }
+
+  case class NoColor(text: String) extends Highlight(Console.RESET)
+
+  case class Red(text: String) extends Highlight(Console.RED)
+  case class Blue(text: String) extends Highlight(Console.BLUE)
+  case class Cyan(text: String) extends Highlight(Console.CYAN)
+  case class Black(text: String) extends Highlight(Console.BLACK)
+  case class Green(text: String) extends Highlight(Console.GREEN)
+  case class White(text: String) extends Highlight(Console.WHITE)
+  case class Yellow(text: String) extends Highlight(Console.YELLOW)
+  case class Magenta(text: String) extends Highlight(Console.MAGENTA)
+
+  case class RedB(text: String) extends Highlight(Console.RED_B)
+  case class BlueB(text: String) extends Highlight(Console.BLUE_B)
+  case class CyanB(text: String) extends Highlight(Console.CYAN_B)
+  case class BlackB(text: String) extends Highlight(Console.BLACK_B)
+  case class GreenB(text: String) extends Highlight(Console.GREEN_B)
+  case class WhiteB(text: String) extends Highlight(Console.WHITE_B)
+  case class YellowB(text: String) extends Highlight(Console.YELLOW_B)
+  case class MagentaB(text: String) extends Highlight(Console.MAGENTA_B)
+
+  case class Bold(text: String) extends Modifier(Console.BOLD, text)
+  case class Underlined(text: String) extends Modifier(Console.UNDERLINED, text)
+}
diff --git a/tests/pos-with-compiler-cc/dotc/printing/MessageLimiter.scala b/tests/pos-with-compiler-cc/dotc/printing/MessageLimiter.scala
new file mode 100644
index 000000000000..c9ac4a5af4ce
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/printing/MessageLimiter.scala
@@ -0,0 +1,61 @@
+package dotty.tools
+package dotc
+package printing
+
+import core._
+import Contexts._
+import util.Property
+import Texts.Text
+
+abstract class MessageLimiter:
+
+  protected def recurseLimit = 100
+  protected var recurseCount: Int = 0
+
+  def register(str: String): Unit = ()
+
+  protected def recursionLimitExceeded()(using Context): Unit = ()
+
+  final def controlled(op: => Text)(using Context): Text =
+    if recurseCount < recurseLimit then
+      try
+        recurseCount += 1
+        op
+      finally
+        recurseCount -= 1
+    else
+      recursionLimitExceeded()
+      "..."
+
+object MessageLimiter extends Property.Key[MessageLimiter]
+
+class DefaultMessageLimiter extends MessageLimiter:
+  override def recursionLimitExceeded()(using Context): Unit =
+    if ctx.debug then
+      report.warning("Exceeded recursion depth attempting to print.")
+      Thread.dumpStack()
+
+class SummarizeMessageLimiter(depth: Int) extends MessageLimiter:
+  override val recurseLimit = recurseCount + depth
+  override def recursionLimitExceeded()(using Context): Unit = ()
+
+class ErrorMessageLimiter extends MessageLimiter:
+  private val initialRecurseLimit = 50
+  private val sizeLimit = 10000
+
+  private var textLength: Int = 0
+
+  override def register(str: String): Unit =
+    textLength += str.length
+
+  override def recurseLimit =
+    val freeFraction: Double = ((sizeLimit - textLength) max 0).toDouble / sizeLimit
+    // 10'000 -     0 / 10'0000 = 100% free
+    // 10'000 -   200 / 10'0000 =  98% free * 50 = 49
+    // 10'000 - 1'000 / 10'0000 =  90% free * 50 = 45
+    // 10'000 - 2'000 / 10'0000 =  80% free * 50 = 40
+    // every 200 characters consumes a "recurseCount"
+    // which, additionally, is lowered from 100 to 50 here
+    (initialRecurseLimit * freeFraction).toInt
+
+
diff --git a/tests/pos-with-compiler-cc/dotc/printing/PlainPrinter.scala b/tests/pos-with-compiler-cc/dotc/printing/PlainPrinter.scala
new file mode 100644
index 000000000000..95b268f0b07a
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/printing/PlainPrinter.scala
@@ -0,0 +1,719 @@
+package dotty.tools.dotc
+package printing
+
+import core._
+import Texts._, Types._, Flags._, Names._, Symbols._, NameOps._, Constants._, Denotations._
+import StdNames._
+import Contexts._
+import Scopes.Scope, Denotations.Denotation, Annotations.Annotation
+import StdNames.nme
+import ast.Trees._
+import typer.Implicits._
+import typer.ImportInfo
+import Variances.varianceSign
+import util.SourcePosition
+import scala.util.control.NonFatal
+import scala.annotation.switch
+import config.{Config, Feature}
+import cc.{CapturingType, EventuallyCapturingType, CaptureSet, isBoxed}
+
+class PlainPrinter(_ctx: Context) extends Printer {
+
+  /** The context of all public methods in Printer and subclasses.
+   *  Overridden in RefinedPrinter.
+   */
+  def printerContext: Context = _ctx.addMode(Mode.Printing)
+  protected given [DummyToEnforceDef]: Context = printerContext
+
+  protected def printDebug = ctx.settings.YprintDebug.value
+
+  private var openRecs: List[RecType] = Nil
+
+  protected def maxToTextRecursions: Int = 100
+
+  protected def showUniqueIds = ctx.settings.uniqid.value || Printer.debugPrintUnique
+  protected def showNestingLevel = ctx.settings.YprintLevel.value
+
+  protected final def limiter: MessageLimiter = ctx.property(MessageLimiter).get
+
+  protected def controlled(op: => Text): Text = limiter.controlled(op)
+
+  def Str(str: String, lineRange: LineRange = EmptyLineRange): Str =
+    limiter.register(str)
+    Texts.Str(str, lineRange)
+
+  given stringToText: Conversion[String, Text] = Str(_)
+
+  /** If true, tweak output so it is the same before and after pickling */
+  protected def homogenizedView: Boolean = ctx.settings.YtestPickler.value
+  protected def debugPos: Boolean = ctx.settings.YdebugPos.value
+
+  def homogenize(tp: Type): Type =
+    if (homogenizedView)
+      tp match {
+        case tp: ThisType if tp.cls.is(Package) && !tp.cls.isEffectiveRoot =>
+          requiredPackage(tp.cls.fullName).termRef
+        case tp: TypeVar if tp.isInstantiated =>
+          homogenize(tp.instanceOpt)
+        case AndType(tp1, tp2) =>
+          homogenize(tp1) & homogenize(tp2)
+        case OrType(tp1, tp2) =>
+          homogenize(tp1) | homogenize(tp2)
+        case AnnotatedType(parent, annot)
+        if !ctx.mode.is(Mode.Type) && annot.symbol == defn.UncheckedVarianceAnnot =>
+          homogenize(parent)
+        case tp: SkolemType =>
+          homogenize(tp.info)
+        case tp: LazyRef =>
+          homogenize(tp.ref)
+        case tp @ AppliedType(tycon, args) =>
+          if (defn.isCompiletimeAppliedType(tycon.typeSymbol)) tp.tryCompiletimeConstantFold
+          else tycon.dealias.appliedTo(args)
+        case tp: NamedType =>
+          tp.reduceProjection
+        case _ =>
+          tp
+      }
+    else tp
+
+  private def sameBound(lo: Type, hi: Type): Boolean =
+    try lo frozen_=:= hi catch { case NonFatal(ex) => false }
+
+  private def homogenizeArg(tp: Type) = tp match {
+    case TypeBounds(lo, hi) if homogenizedView && sameBound(lo, hi) => homogenize(hi)
+    case _ => tp
+  }
+
+  private def selfRecName(n: Int) = s"z$n"
+
+  /** If the name of the symbol's owner should be used when you care about
+   *  seeing an interesting name: in such cases this symbol is e.g. a method
+   *  parameter with a synthetic name, a constructor named "this", an object
+   *  "package", etc.  The kind string, if non-empty, will be phrased relative
+   *  to the name of the owner.
+   */
+  protected def hasMeaninglessName(sym: Symbol): Boolean = (
+       sym.is(Param) && sym.owner.isSetter    // x$1
+    || sym.isClassConstructor                  // this
+    || (sym.name == nme.PACKAGE)               // package
+  )
+
+  def nameString(name: Name): String =
+    if (name eq tpnme.FromJavaObject) && !printDebug
+    then nameString(tpnme.Object)
+    else name.toString
+
+  def toText(name: Name): Text = Str(nameString(name))
+
+  /** String representation of a name used in a refinement
+   *  In refined printing this undoes type parameter expansion
+   */
+  protected def refinementNameString(tp: RefinedType): String = nameString(tp.refinedName)
+
+  /** String representation of a refinement */
+  protected def toTextRefinement(rt: RefinedType): Closed =
+    (refinementNameString(rt) ~ toTextRHS(rt.refinedInfo)).close
+
+  protected def argText(arg: Type): Text = homogenizeArg(arg) match {
+    case arg: TypeBounds => "?" ~ toText(arg)
+    case arg => toText(arg)
+  }
+
+  /** Pretty-print comma-separated type arguments for a constructor to be inserted among parentheses or brackets
+    * (hence with `GlobalPrec` precedence).
+    */
+  protected def argsText(args: List[Type]): Text =
+    atPrec(GlobalPrec) { Text(args.map(arg => argText(arg) ), ", ") }
+
+  /** The longest sequence of refinement types, starting at given type
+   *  and following parents.
+   */
+  private def refinementChain(tp: Type): List[Type] =
+    tp :: (tp match {
+      case tp: RefinedType => refinementChain(tp.parent.stripTypeVar)
+      case _ => Nil
+    })
+
+  /** Direct references to these symbols are printed without their prefix for convenience.
+   *  They are either aliased in scala.Predef or in the scala package object, as well as `Object`
+   */
+  private lazy val printWithoutPrefix: Set[Symbol] =
+    (defn.ScalaPredefModule.termRef.typeAliasMembers
+      ++ defn.ScalaPackageObject.termRef.typeAliasMembers).map(_.info.classSymbol).toSet
+    + defn.ObjectClass
+    + defn.FromJavaObjectSymbol
+
+  def toText(cs: CaptureSet): Text =
+    "{" ~ Text(cs.elems.toList.map(toTextCaptureRef), ", ") ~ "}"
+
+  def toText(tp: Type): Text = controlled {
+    homogenize(tp) match {
+      case tp: TypeType =>
+        toTextRHS(tp)
+      case tp: TermRef
+      if !tp.denotationIsCurrent && !homogenizedView || // always print underlying when testing picklers
+         tp.symbol.is(Module) || tp.symbol.name == nme.IMPORT =>
+        toTextRef(tp) ~ ".type"
+      case tp: TermRef if tp.denot.isOverloaded =>
+        "<overloaded " ~ toTextRef(tp) ~ ">"
+      case tp: TypeRef =>
+        if (printWithoutPrefix.contains(tp.symbol))
+          toText(tp.name)
+        else
+          toTextPrefix(tp.prefix) ~ selectionString(tp)
+      case tp: TermParamRef =>
+        ParamRefNameString(tp) ~ lambdaHash(tp.binder) ~ ".type"
+      case tp: TypeParamRef =>
+        val suffix =
+          if showNestingLevel then
+            val tvar = ctx.typerState.constraint.typeVarOfParam(tp)
+            if tvar.exists then s"#${tvar.asInstanceOf[TypeVar].nestingLevel.toString}" else ""
+          else ""
+        ParamRefNameString(tp) ~ lambdaHash(tp.binder) ~ suffix
+      case tp: SingletonType =>
+        toTextSingleton(tp)
+      case AppliedType(tycon, args) =>
+        (toTextLocal(tycon) ~ "[" ~ argsText(args) ~ "]").close
+      case tp: RefinedType =>
+        val parent :: (refined: List[RefinedType @unchecked]) =
+          refinementChain(tp).reverse: @unchecked
+        toTextLocal(parent) ~ "{" ~ Text(refined map toTextRefinement, "; ").close ~ "}"
+      case tp: RecType =>
+        try {
+          openRecs = tp :: openRecs
+          "{" ~ selfRecName(openRecs.length) ~ " => " ~ toTextGlobal(tp.parent) ~ "}"
+        }
+        finally openRecs = openRecs.tail
+      case AndType(tp1, tp2) =>
+        changePrec(AndTypePrec) { toText(tp1) ~ " & " ~ atPrec(AndTypePrec + 1) { toText(tp2) } }
+      case OrType(tp1, tp2) =>
+        changePrec(OrTypePrec) { toText(tp1) ~ " | " ~ atPrec(OrTypePrec + 1) { toText(tp2) } }
+      case MatchType(bound, scrutinee, cases) =>
+        changePrec(GlobalPrec) {
+          def caseText(tp: Type): Text = tp match {
+            case tp: HKTypeLambda => caseText(tp.resultType)
+            case defn.MatchCase(pat, body) => "case " ~ toText(pat) ~ " => " ~ toText(body)
+            case _ => "case " ~ toText(tp)
+          }
+          def casesText = Text(cases.map(caseText), "\n")
+          atPrec(InfixPrec) { toText(scrutinee) } ~
+          keywordStr(" match ") ~ "{" ~ casesText ~ "}" ~
+          (" <: " ~ toText(bound) provided !bound.isAny)
+        }.close
+      case tp @ EventuallyCapturingType(parent, refs) =>
+        def box =
+          Str("box ") provided tp.isBoxed //&& ctx.settings.YccDebug.value
+        def printRegular(refsText: Text) =
+          changePrec(GlobalPrec)(box ~ refsText ~ " " ~ toText(parent))
+        if printDebug && !refs.isConst then
+          printRegular(refs.toString)
+        else if ctx.settings.YccDebug.value then
+          printRegular(refs.show)
+        else if !refs.isConst && refs.elems.isEmpty then
+          printRegular("?")
+        else if Config.printCaptureSetsAsPrefix then
+          printRegular(toText(refs))
+        else
+          changePrec(InfixPrec)(box ~ toText(parent) ~ " @retains(" ~ toText(refs.elems.toList, ",") ~ ")")
+      case tp: PreviousErrorType if ctx.settings.XprintTypes.value =>
+        "<error>" // do not print previously reported error message because they may try to print this error type again recuresevely
+      case tp: ErrorType =>
+        s"<error ${tp.msg.rawMessage}>"
+      case tp: WildcardType =>
+        if (tp.optBounds.exists) "<?" ~ toTextRHS(tp.bounds) ~ ">" else "<?>"
+      case NoType =>
+        "<notype>"
+      case NoPrefix =>
+        "<noprefix>"
+      case tp: MethodType =>
+        changePrec(GlobalPrec) {
+          "("
+          ~ keywordText("using ").provided(tp.isContextualMethod)
+          ~ keywordText("erased ").provided(tp.isErasedMethod)
+          ~ keywordText("implicit ").provided(tp.isImplicitMethod && !tp.isContextualMethod)
+          ~ paramsText(tp)
+          ~ ")"
+          ~ (Str(": ") provided !tp.resultType.isInstanceOf[MethodOrPoly])
+          ~ toText(tp.resultType)
+        }
+      case ExprType(ct @ EventuallyCapturingType(parent, refs))
+      if ct.annot.symbol == defn.RetainsByNameAnnot =>
+        if refs.isUniversal then changePrec(GlobalPrec) { "=> " ~ toText(parent) }
+        else toText(CapturingType(ExprType(parent), refs))
+      case ExprType(restp) =>
+        changePrec(GlobalPrec) {
+          (if Feature.pureFunsEnabled then "-> " else "=> ") ~ toText(restp)
+        }
+      case tp: HKTypeLambda =>
+        changePrec(GlobalPrec) {
+          "[" ~ paramsText(tp) ~ "]" ~ lambdaHash(tp) ~ Str(" =>> ") ~ toTextGlobal(tp.resultType)
+        }
+      case tp: PolyType =>
+        changePrec(GlobalPrec) {
+          "[" ~ paramsText(tp) ~ "]" ~ lambdaHash(tp) ~
+          (Str(": ") provided !tp.resultType.isInstanceOf[MethodOrPoly]) ~
+          toTextGlobal(tp.resultType)
+        }
+      case AnnotatedType(tpe, annot) =>
+        if annot.symbol == defn.InlineParamAnnot || annot.symbol == defn.ErasedParamAnnot then toText(tpe)
+        else toTextLocal(tpe) ~ " " ~ toText(annot)
+      case tp: TypeVar =>
+        if (tp.isInstantiated)
+          toTextLocal(tp.instanceOpt) ~ (Str("^") provided printDebug)
+        else {
+          val constr = ctx.typerState.constraint
+          val bounds =
+            if constr.contains(tp) then
+              withMode(Mode.Printing)(TypeComparer.fullBounds(tp.origin))
+            else
+              TypeBounds.empty
+          if (bounds.isTypeAlias) toText(bounds.lo) ~ (Str("^") provided printDebug)
+          else if (ctx.settings.YshowVarBounds.value) "(" ~ toText(tp.origin) ~ "?" ~ toText(bounds) ~ ")"
+          else toText(tp.origin)
+        }
+      case tp: LazyRef =>
+        def refTxt =
+          try toTextGlobal(tp.ref)
+          catch {
+            case ex: Throwable => Str("...")
+          }
+        "LazyRef(" ~ refTxt ~ ")"
+      case Range(lo, hi) =>
+        toText(lo) ~ " .. " ~ toText(hi)
+      case _ =>
+        tp.fallbackToText(this)
+    }
+  }.close
+
+  def toTextSingleton(tp: SingletonType): Text =
+    "(" ~ toTextRef(tp) ~ " : " ~ toTextGlobal(tp.underlying) ~ ")"
+
+  protected def paramsText(lam: LambdaType): Text = {
+    def paramText(name: Name, tp: Type) =
+      toText(name) ~ lambdaHash(lam) ~ toTextRHS(tp, isParameter = true)
+    Text(lam.paramNames.lazyZip(lam.paramInfos).map(paramText), ", ")
+  }
+
+  protected def ParamRefNameString(name: Name): String = nameString(name)
+
+  protected def ParamRefNameString(param: ParamRef): String =
+    ParamRefNameString(param.binder.paramNames(param.paramNum))
+
+  /** The name of the symbol without a unique id. */
+  protected def simpleNameString(sym: Symbol): String = nameString(sym.name)
+
+  /** If -uniqid is set, the hashcode of the lambda type, after a # */
+  protected def lambdaHash(pt: LambdaType): Text =
+    if (showUniqueIds)
+      try "#" + pt.hashCode
+      catch { case ex: NullPointerException => "" }
+    else ""
+
+  /** A string to append to a symbol composed of:
+   *  - if -uniqid is set, its unique id after a #.
+   *  - if -Yprint-level, its nesting level after a %.
+   */
+  protected def idString(sym: Symbol): String =
+    (if (showUniqueIds || Printer.debugPrintUnique) "#" + sym.id else "") +
+    (if (showNestingLevel) "%" + sym.nestingLevel else "")
+
+  def nameString(sym: Symbol): String =
+    simpleNameString(sym) + idString(sym) // + "<" + (if (sym.exists) sym.owner else "") + ">"
+
+  def fullNameString(sym: Symbol): String =
+    if (sym eq defn.FromJavaObjectSymbol) && !printDebug then
+      fullNameString(defn.ObjectClass)
+    else if sym.isRoot || sym == NoSymbol || sym.owner.isEffectiveRoot then
+      nameString(sym)
+    else
+      fullNameString(fullNameOwner(sym)) + "." + nameString(sym)
+
+  protected def fullNameOwner(sym: Symbol): Symbol = sym.effectiveOwner.enclosingClass
+
+  protected def objectPrefix: String = "object "
+  protected def packagePrefix: String = "package "
+
+  protected def trimPrefix(text: Text): Text =
+    text.stripPrefix(objectPrefix).stripPrefix(packagePrefix)
+
+  protected def selectionString(tp: NamedType): String = {
+    val sym = if (homogenizedView) tp.symbol else tp.currentSymbol
+    if (sym.exists) nameString(sym) else nameString(tp.name)
+  }
+
+  /** The string representation of this type used as a prefix */
+  def toTextRef(tp: SingletonType): Text = controlled {
+    tp match {
+      case tp: TermRef =>
+        toTextPrefix(tp.prefix) ~ selectionString(tp)
+      case tp: ThisType =>
+        nameString(tp.cls) + ".this"
+      case SuperType(thistpe: SingletonType, _) =>
+        toTextRef(thistpe).map(_.replaceAll("""\bthis$""", "super").nn)
+      case SuperType(thistpe, _) =>
+        "Super(" ~ toTextGlobal(thistpe) ~ ")"
+      case tp @ ConstantType(value) =>
+        toText(value)
+      case pref: TermParamRef =>
+        nameString(pref.binder.paramNames(pref.paramNum)) ~ lambdaHash(pref.binder)
+      case tp: RecThis =>
+        val idx = openRecs.reverse.indexOf(tp.binder)
+        if (idx >= 0) selfRecName(idx + 1)
+        else "{...}.this" // TODO move underlying type to an addendum, e.g. ... z3 ... where z3: ...
+      case tp: SkolemType =>
+        if (homogenizedView) toText(tp.info)
+        else if (ctx.settings.XprintTypes.value) "<" ~ toText(tp.repr) ~ ":" ~ toText(tp.info) ~ ">"
+        else toText(tp.repr)
+    }
+  }
+
+  /** The string representation of this type used as a prefix, including separator */
+  def toTextPrefix(tp: Type): Text = controlled {
+    homogenize(tp) match {
+      case NoPrefix => ""
+      case tp: SingletonType => toTextRef(tp) ~ "."
+      case tp => trimPrefix(toTextLocal(tp)) ~ "#"
+    }
+  }
+
+  def toTextCaptureRef(tp: Type): Text =
+    homogenize(tp) match
+      case tp: TermRef if tp.symbol == defn.captureRoot => Str("*")
+      case tp: SingletonType => toTextRef(tp)
+      case _ => toText(tp)
+
+  protected def isOmittablePrefix(sym: Symbol): Boolean =
+    defn.unqualifiedOwnerTypes.exists(_.symbol == sym) || isEmptyPrefix(sym)
+
+  protected def isEmptyPrefix(sym: Symbol): Boolean =
+    sym.isEffectiveRoot || sym.isAnonymousClass || sym.name.isReplWrapperName
+
+  /** String representation of a definition's type following its name,
+   *  if symbol is completed, "?" otherwise.
+   */
+  protected def toTextRHS(optType: Option[Type]): Text = optType match {
+    case Some(tp) => toTextRHS(tp)
+    case None => "?"
+  }
+
+  protected def decomposeLambdas(bounds: TypeBounds): (Text, TypeBounds) =
+    def decompose(tp: Type): (Text, Type) = tp.stripTypeVar match
+      case lam: HKTypeLambda =>
+        val names =
+          if lam.isDeclaredVarianceLambda then
+            lam.paramNames.lazyZip(lam.declaredVariances).map((name, v) =>
+              varianceSign(v) + name)
+          else lam.paramNames.map(_.toString)
+        val infos = lam.paramInfos.map(toText)
+        val tparams = names.zip(infos).map(_ ~ _)
+        ("[" ~ Text(tparams, ",") ~ "]", lam.resType)
+      case _ =>
+        ("", tp)
+    bounds match
+      case bounds: AliasingBounds =>
+        val (tparamStr, aliasRhs) = decompose(bounds.alias)
+        (tparamStr, bounds.derivedAlias(aliasRhs))
+      case TypeBounds(lo, hi) =>
+        val (_, loRhs) = decompose(lo)
+        val (tparamStr, hiRhs) = decompose(hi)
+        (tparamStr, bounds.derivedTypeBounds(loRhs, hiRhs))
+  end decomposeLambdas
+
+  /** String representation of a definition's type following its name */
+  protected def toTextRHS(tp: Type, isParameter: Boolean = false): Text = controlled {
+    homogenize(tp) match {
+      case tp: TypeBounds =>
+        val (tparamStr, rhs) = decomposeLambdas(tp)
+        val binder = rhs match
+          case tp: AliasingBounds =>
+            " = " ~ toText(tp.alias)
+          case TypeBounds(lo, hi) =>
+            (if lo.isExactlyNothing then Text() else " >: " ~ toText(lo))
+            ~ (if hi.isExactlyAny || (!printDebug && hi.isFromJavaObject) then Text() else " <: " ~ toText(hi))
+        tparamStr ~ binder
+      case tp @ ClassInfo(pre, cls, cparents, decls, selfInfo) =>
+        val preText = toTextLocal(pre)
+        val (tparams, otherDecls) = decls.toList partition treatAsTypeParam
+        val tparamsText =
+          if (tparams.isEmpty) Text() else ("[" ~ dclsText(tparams) ~ "]").close
+        val selfText: Text = selfInfo match {
+          case NoType => Text()
+          case sym: Symbol if !sym.isCompleted => "this: ? =>"
+          case _ => "this: " ~ atPrec(InfixPrec) { toText(tp.selfType) } ~ " =>"
+        }
+        val trueDecls = otherDecls.filterNot(treatAsTypeArg)
+        val declsText =
+          if (trueDecls.isEmpty || !ctx.settings.Ydebug.value) Text()
+          else dclsText(trueDecls)
+        tparamsText ~ " extends " ~ toTextParents(tp.parents) ~~ "{" ~ selfText ~ declsText ~
+          "} at " ~ preText
+      case mt: MethodType =>
+        toTextGlobal(mt)
+      case tp: ExprType =>
+        // parameterless methods require special treatment, see #11201
+        (if (isParameter) ": => " else ": ") ~ toTextGlobal(tp.widenExpr)
+      case tp: PolyType =>
+        "[" ~ paramsText(tp) ~ "]"
+        ~ (Str(": ") provided !tp.resultType.isInstanceOf[MethodOrPoly])
+        ~ toTextGlobal(tp.resultType)
+      case tp =>
+        ": " ~ toTextGlobal(tp)
+    }
+  }
+
+  protected def toTextParents(parents: List[Type]): Text = Text(parents.map(toTextLocal), " with ")
+
+  protected def treatAsTypeParam(sym: Symbol): Boolean = false
+  protected def treatAsTypeArg(sym: Symbol): Boolean = false
+
+  /** String representation of symbol's kind. */
+  def kindString(sym: Symbol): String = {
+    val flags = sym.flagsUNSAFE
+    if (flags.is(PackageClass)) "package class"
+    else if (flags.is(PackageVal)) "package"
+    else if (sym.isPackageObject)
+      if (sym.isClass) "package object class"
+      else "package object"
+    else if (sym.isAnonymousClass) "anonymous class"
+    else if (flags.is(ModuleClass)) "object class"
+    else if (flags.is(ModuleVal)) "object"
+    else if (flags.is(Trait)) "trait"
+    else if (sym.isClass) "class"
+    else if (sym.isType) "type"
+    else if (sym.isGetter) "getter"
+    else if (sym.isSetter) "setter"
+    else if sym.is(Param) then "parameter"
+    else if sym.is(Given) then "given instance"
+    else if (flags.is(Lazy)) "lazy value"
+    else if (flags.is(Mutable)) "variable"
+    else if (sym.isClassConstructor && sym.isPrimaryConstructor) "primary constructor"
+    else if (sym.isClassConstructor) "constructor"
+    else if (sym.is(Method)) "method"
+    else if (sym.isTerm) "value"
+    else ""
+  }
+
+  /** String representation of symbol's definition keyword */
+  protected def keyString(sym: Symbol): String = {
+    val flags = sym.flagsUNSAFE
+    if (flags.isAllOf(JavaInterface)) "interface"
+    else if (flags.is(Trait)) "trait"
+    else if (flags.is(Module)) "object"
+    else if (sym.isClass) "class"
+    else if (sym.isType) "type"
+    else if (flags.is(Mutable)) "var"
+    else if (flags.is(Package)) "package"
+    else if (sym.is(Method)) "def"
+    else if (sym.isTerm && !flags.is(Param)) "val"
+    else ""
+  }
+
+  protected def privateWithinString(sym: Symbol): String =
+    if (sym.exists && sym.privateWithin.exists)
+      nameString(sym.privateWithin.name.stripModuleClassSuffix)
+    else ""
+
+  /** String representation of symbol's flags */
+  protected def toTextFlags(sym: Symbol): Text = toTextFlags(sym, sym.flagsUNSAFE)
+
+  protected def toTextFlags(sym: Symbol, flags: FlagSet): Text =
+    Text(flags.flagStrings(privateWithinString(sym)).map(flag => stringToText(keywordStr(flag))), " ")
+
+  def annotsText(sym: Symbol): Text = Text(sym.annotations.map(toText))
+
+  def dclText(sym: Symbol): Text = dclTextWithInfo(sym, sym.unforcedInfo)
+
+  def dclText(d: SingleDenotation): Text = dclTextWithInfo(d.symbol, Some(d.info))
+
+  private def dclTextWithInfo(sym: Symbol, info: Option[Type]): Text =
+    (toTextFlags(sym) ~~ keyString(sym) ~~
+      (varianceSign(sym.variance) ~ nameString(sym)) ~ toTextRHS(info)).close
+
+  def toText(sym: Symbol): Text =
+    (kindString(sym) ~~ {
+      if (sym.isAnonymousClass) toTextParents(sym.info.parents) ~~ "{...}"
+      else if (hasMeaninglessName(sym) && !printDebug) simpleNameString(sym.owner) + idString(sym)
+      else if sym.is(Package) then fullNameString(sym)
+      else nameString(sym)
+    }).close
+
+  def locationText(sym: Symbol): Text =
+    if (!sym.exists) ""
+    else {
+      val ownr = sym.effectiveOwner
+      if (ownr.isClass && !isEmptyPrefix(ownr)) " in " ~ toText(ownr) else Text()
+    }
+
+  def locatedText(sym: Symbol): Text =
+    (toText(sym) ~ locationText(sym)).close
+
+  def extendedLocationText(sym: Symbol): Text =
+    if (!sym.exists) ""
+    else {
+      def recur(ownr: Symbol, innerLocation: String): Text = {
+        def nextOuter(innerKind: String): Text =
+          recur(ownr.effectiveOwner,
+            if (!innerLocation.isEmpty) innerLocation
+            else s" in an anonymous $innerKind")
+        def showLocation(ownr: Symbol, where: String): Text =
+          innerLocation ~ " " ~ where ~ " " ~ toText(ownr)
+        if (ownr.isAnonymousClass) nextOuter("class")
+        else if (ownr.isAnonymousFunction) nextOuter("function")
+        else if (isEmptyPrefix(ownr)) ""
+        else if (ownr.isLocalDummy) showLocation(ownr.owner, "locally defined in")
+        else if (ownr.isTerm && !ownr.isOneOf(Module | Method)) showLocation(ownr, "in the initializer of")
+        else showLocation(ownr, "in")
+      }
+      recur(sym.owner, "")
+    }
+
+  def toText(denot: Denotation): Text = toText(denot.symbol) ~ "/D"
+
+  private def escapedChar(ch: Char): String = (ch: @switch) match {
+    case '\b' => "\\b"
+    case '\t' => "\\t"
+    case '\n' => "\\n"
+    case '\f' => "\\f"
+    case '\r' => "\\r"
+    case '"' => "\\\""
+    case '\'' => "\\\'"
+    case '\\' => "\\\\"
+    case _ => if ch.isControl then f"${"\\"}u${ch.toInt}%04x" else String.valueOf(ch).nn
+  }
+
+  def toText(const: Constant): Text = const.tag match {
+    case StringTag => stringText("\"" + escapedString(const.value.toString) + "\"")
+    case ClazzTag => "classOf[" ~ toText(const.typeValue) ~ "]"
+    case CharTag => literalText(s"'${escapedChar(const.charValue)}'")
+    case LongTag => literalText(const.longValue.toString + "L")
+    case DoubleTag => literalText(const.doubleValue.toString + "d")
+    case FloatTag => literalText(const.floatValue.toString + "f")
+    case _ => literalText(String.valueOf(const.value).nn)
+  }
+
+  /** Usual target for `Annotation#toText`, overridden in RefinedPrinter */
+  def annotText(annot: Annotation): Text = s"@${annot.symbol.name}"
+
+  def toText(annot: Annotation): Text = annot.toText(this)
+
+  def toText(param: LambdaParam): Text =
+    varianceSign(param.paramVariance)
+    ~ toText(param.paramName)
+    ~ (if param.isTypeParam then "" else ": ")
+    ~ toText(param.paramInfo)
+
+  protected def escapedString(str: String): String = str flatMap escapedChar
+
+  def dclsText(syms: List[Symbol], sep: String): Text = Text(syms map dclText, sep)
+
+  def toText(sc: Scope): Text =
+    ("Scope{" ~ dclsText(sc.toList) ~ "}").close
+
+  def toText[T >: Untyped](tree: Tree[T]): Text = {
+    def toTextElem(elem: Any): Text = elem match {
+      case elem: Showable => elem.toText(this)
+      case elem: List[?] => "List(" ~ Text(elem map toTextElem, ",") ~ ")"
+      case elem => elem.toString
+    }
+    val nodeName = tree.productPrefix
+    val elems =
+      Text(tree.productIterator.map(toTextElem).toList, ", ")
+    val tpSuffix =
+      if (ctx.settings.XprintTypes.value && tree.hasType)
+        " | " ~ toText(tree.typeOpt)
+      else
+        Text()
+
+    nodeName ~ "(" ~ elems ~ tpSuffix ~ ")" ~ (Str(tree.sourcePos.toString) provided printDebug)
+  }.close
+
+  def toText(pos: SourcePosition): Text =
+    if (!pos.exists) "<no position>"
+    else if (pos.source.exists) s"${pos.source.file.name}:${pos.line + 1}"
+    else s"(no source file, offset = ${pos.span.point})"
+
+  def toText(result: SearchResult): Text = result match {
+    case result: SearchSuccess =>
+      "SearchSuccess: " ~ toText(result.ref) ~ " via " ~ toText(result.tree)
+    case result: SearchFailure =>
+      result.reason match {
+        case _: NoMatchingImplicits => "No Matching Implicit"
+        case _: DivergingImplicit => "Diverging Implicit"
+        case result: AmbiguousImplicits =>
+          "Ambiguous Implicit: " ~ toText(result.alt1.ref) ~ " and " ~ toText(result.alt2.ref)
+        case _ =>
+          "Search Failure: " ~ toText(result.tree)
+      }
+  }
+
+  def toText(importInfo: ImportInfo): Text =
+    val siteStr = importInfo.site.show
+    val exprStr = if siteStr.endsWith(".type") then siteStr.dropRight(5) else siteStr
+    val selectorStr = importInfo.selectors match
+      case sel :: Nil if sel.renamed.isEmpty && sel.bound.isEmpty =>
+        if sel.isGiven then "given" else sel.name.show
+      case _ => "{...}"
+    s"import $exprStr.$selectorStr"
+
+  def toText(c: OrderingConstraint): Text =
+    val savedConstraint = ctx.typerState.constraint
+    try
+      // The current TyperState constraint determines how type variables are printed
+      ctx.typerState.constraint = c
+      def entryText(tp: Type) = tp match {
+        case tp: TypeBounds =>
+          toText(tp)
+        case _ =>
+          " := " ~ toText(tp)
+      }
+      val indent = 3
+      val uninstVarsText = " uninstantiated variables: " ~
+        Text(c.uninstVars.map(toText), ", ")
+      val constrainedText =
+        " constrained types: " ~ Text(c.domainLambdas.map(toText), ", ")
+      val boundsText =
+        " bounds: " ~ {
+          val assocs =
+            for (param <- c.domainParams)
+            yield (" " * indent) ~ toText(param) ~ entryText(c.entry(param))
+          Text(assocs, "\n")
+        }
+      val orderingText =
+        " ordering: " ~ {
+          val deps =
+            for {
+              param <- c.domainParams
+              ups = c.minUpper(param)
+              if ups.nonEmpty
+            }
+            yield
+              (" " * indent) ~ toText(param) ~ " <: " ~
+                Text(ups.map(toText), ", ")
+          Text(deps, "\n")
+        }
+      //Printer.debugPrintUnique = false
+      Text.lines(List(uninstVarsText, constrainedText, boundsText, orderingText))
+    finally
+      ctx.typerState.constraint = savedConstraint
+
+  def toText(g: GadtConstraint): Text =
+    val deps = for sym <- g.symbols yield
+      val bound = g.fullBounds(sym).nn
+      (typeText(toText(sym.typeRef)) ~ toText(bound)).close
+    ("GadtConstraint(" ~ Text(deps, ", ") ~ ")").close
+
+  def plain: PlainPrinter = this
+
+  protected def keywordStr(text: String): String = coloredStr(text, SyntaxHighlighting.KeywordColor)
+  protected def keywordText(text: String): Text = coloredStr(text, SyntaxHighlighting.KeywordColor)
+  protected def valDefText(text: Text): Text = coloredText(text, SyntaxHighlighting.ValDefColor)
+  protected def typeText(text: Text): Text = coloredText(text, SyntaxHighlighting.TypeColor)
+  protected def literalText(text: Text): Text = coloredText(text, SyntaxHighlighting.LiteralColor)
+  protected def stringText(text: Text): Text = coloredText(text, SyntaxHighlighting.StringColor)
+
+  protected def coloredStr(text: String, color: String): String =
+    if (ctx.useColors) color + text + SyntaxHighlighting.NoColor else text
+  protected def coloredText(text: Text, color: String): Text =
+    if (ctx.useColors) color ~ text ~ SyntaxHighlighting.NoColor else text
+}
+
diff --git a/tests/pos-with-compiler-cc/dotc/printing/Printer.scala b/tests/pos-with-compiler-cc/dotc/printing/Printer.scala
new file mode 100644
index 000000000000..812351e8cec0
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/printing/Printer.scala
@@ -0,0 +1,201 @@
+package dotty.tools
+package dotc
+package printing
+
+import core._
+import Texts._, ast.Trees._
+import Types.{Type, SingletonType, LambdaParam},
+       Symbols.Symbol, Scopes.Scope, Constants.Constant,
+       Names.Name, Denotations._, Annotations.Annotation, Contexts.Context
+import typer.Implicits.SearchResult
+import util.SourcePosition
+import typer.ImportInfo
+
+import scala.annotation.internal.sharable
+
+/** The base class of all printers
+ */
+abstract class Printer extends caps.Pure {
+
+  private var prec: Precedence = GlobalPrec
+
+  /** The current precedence level.
+   *  When pretty-printing arguments of operator `op`, `currentPrecedence` must equal `op`'s precedence level,
+   *  so that pretty-printing expressions using lower-precedence operators can insert parentheses automatically
+   *  by calling `changePrec`.
+   */
+  def currentPrecedence: Precedence = prec
+
+  /** Generate text using `op`, assuming a given precedence level `prec`.
+   *
+   *  ### `atPrec` vs `changePrec`
+   *
+   *  This is to be used when changing precedence inside some sort of parentheses:
+   *  for instance, to print T[A]` use
+   *  `toText(T) ~ '[' ~ atPrec(GlobalPrec) { toText(A) } ~ ']'`.
+   *
+   *  If the presence of the parentheses depends on precedence, inserting them manually is most certainly a bug.
+   *  Use `changePrec` instead to generate them exactly when needed.
+   */
+  def atPrec(prec: Precedence)(op: => Text): Text = {
+    val outerPrec = this.prec
+    this.prec = prec
+    try op
+    finally this.prec = outerPrec
+  }
+
+  /** Generate text using `op`, assuming a given precedence level `prec`.
+   *  If new level `prec` is lower than previous level, put text in parentheses.
+   *
+   *  ### `atPrec` vs `changePrec`
+   *
+   *  To pretty-print `A op B`, you need something like
+   *  `changePrec(parsing.precedence(op, isType)) { toText(a) ~ op ~ toText(b) }` // BUGGY
+   *  that will insert parentheses around `A op B` if, for instance, the
+   *  preceding operator has higher precedence.
+   *
+   *  But that does not handle infix operators with left- or right- associativity.
+   *
+   *  If op and op' have the same precedence and associativity,
+   *  A op B op' C parses as (A op B) op' C if op and op' are left-associative, and as
+   *  A op (B op' C) if they're right-associative, so we need respectively
+   *  ```scala
+   *  val isType = ??? // is this a term or type operator?
+   *  val prec = parsing.precedence(op, isType)
+   *  // either:
+   *  changePrec(prec) { toText(a) ~ op ~ atPrec(prec + 1) { toText(b) } } // for left-associative op and op'
+   *  // or:
+   *  changePrec(prec) { atPrec(prec + 1) { toText(a) } ~ op ~ toText(b) } // for right-associative op and op'
+   *  ```
+   */
+  def changePrec(prec: Precedence)(op: => Text): Text =
+    if (prec < this.prec) atPrec(prec) ("(" ~ op ~ ")") else atPrec(prec)(op)
+
+  /** The name, possibly with with namespace suffix if debugNames is set:
+   *  /L for local names, /V for other term names, /T for type names
+   */
+  def nameString(name: Name): String
+
+  /** The name of the given symbol.
+   *  If !settings.debug, the original name where
+   *  expansions of operators are translated back to operator symbol.
+   *  E.g. $eq => =.
+   *  If settings.uniqid, adds id.
+   */
+  def nameString(sym: Symbol): String
+
+  /** The fully qualified name of the symbol */
+  def fullNameString(sym: Symbol): String
+
+  /** The kind of the symbol */
+  def kindString(sym: Symbol): String
+
+  /** The name as a text */
+  def toText(name: Name): Text
+
+  /** Textual representation, including symbol's kind e.g., "class Foo", "method Bar".
+   *  If hasMeaninglessName is true, uses the owner's name to disambiguate identity.
+   */
+  def toText(sym: Symbol): Text
+
+  /** Textual representation of singleton type reference */
+  def toTextRef(tp: SingletonType): Text
+
+  /** Textual representation of a prefix of some reference, ending in `.` or `#` */
+  def toTextPrefix(tp: Type): Text
+
+  /** Textual representation of a reference in a capture set */
+  def toTextCaptureRef(tp: Type): Text
+
+  /** Textual representation of symbol's declaration */
+  def dclText(sym: Symbol): Text
+
+  /** Textual representation of single denotation's declaration */
+  def dclText(sd: SingleDenotation): Text
+
+  /** If symbol's owner is a printable class C, the text "in C", otherwise "" */
+  def locationText(sym: Symbol): Text
+
+  /** Textual representation of symbol and its location */
+  def locatedText(sym: Symbol): Text
+
+  /** A description of sym's location */
+  def extendedLocationText(sym: Symbol): Text
+
+  /** Textual description of regular annotation in terms of its tree */
+  def annotText(annot: Annotation): Text
+
+  /** Textual representation of denotation */
+  def toText(denot: Denotation): Text
+
+  /** Textual representation of constant */
+  def toText(const: Constant): Text
+
+  /** Textual representation of annotation */
+  def toText(annot: Annotation): Text
+
+  /** Textual representation of type */
+  def toText(tp: Type): Text
+
+  /** Textual representation of lambda param */
+  def toText(tree: LambdaParam): Text
+
+  /** Textual representation of all symbols in given list,
+   *  using `dclText` for displaying each.
+   */
+  def dclsText(syms: List[Symbol], sep: String = "\n"): Text
+
+  /** Textual representation of all definitions in a scope using `dclText` for each */
+  def toText(sc: Scope): Text
+
+  /** Textual representation of tree */
+  def toText[T >: Untyped](tree: Tree[T]): Text
+
+  /** Textual representation of source position */
+  def toText(pos: SourcePosition): Text
+
+  /** Textual representation of implicit search result */
+  def toText(result: SearchResult): Text
+
+  /** Textual representation of info relating to an import clause */
+  def toText(result: ImportInfo): Text
+
+  /** Textual representation of a constraint */
+  def toText(c: OrderingConstraint): Text
+
+  /** Textual representation of a GADT constraint */
+  def toText(c: GadtConstraint): Text
+
+  /** Render element within highest precedence */
+  def toTextLocal(elem: Showable): Text =
+    atPrec(DotPrec) { elem.toText(this) }
+
+  /** Render element within lowest precedence */
+  def toTextGlobal(elem: Showable): Text =
+    atPrec(GlobalPrec) { elem.toText(this) }
+
+  /** Render elements alternating with `sep` string */
+  def toText(elems: Traversable[Showable], sep: String): Text =
+    Text(elems map (_ toText this), sep)
+
+  /** Render elements within highest precedence */
+  def toTextLocal(elems: Traversable[Showable], sep: String): Text =
+    atPrec(DotPrec) { toText(elems, sep) }
+
+  /** Render elements within lowest precedence */
+  def toTextGlobal(elems: Traversable[Showable], sep: String): Text =
+    atPrec(GlobalPrec) { toText(elems, sep) }
+
+  /** A plain printer without any embellishments */
+  def plain: Printer
+
+  /** The context in which this printer operates */
+  def printerContext: Context
+}
+object Printer {
+
+  /** Debug hook; set to true if you want to see unique ids but cannot run with option
+   *  -uniqid. A typical use case is for further exploration after a -Ytest-pickler failure.
+   */
+  @sharable var debugPrintUnique: Boolean = false
+}
diff --git a/tests/pos-with-compiler-cc/dotc/printing/RefinedPrinter.scala b/tests/pos-with-compiler-cc/dotc/printing/RefinedPrinter.scala
new file mode 100644
index 000000000000..2a87ec9b4bbe
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/printing/RefinedPrinter.scala
@@ -0,0 +1,1132 @@
+package dotty.tools
+package dotc
+package printing
+
+import core._
+import Texts._
+import Types._
+import Flags._
+import Names._
+import Symbols._
+import NameOps._
+import TypeErasure.ErasedValueType
+import Contexts._
+import Annotations.Annotation
+import Denotations._
+import SymDenotations._
+import StdNames.{nme, tpnme}
+import ast.{Trees, tpd, untpd}
+import typer.{Implicits, Namer, Applications}
+import typer.ProtoTypes._
+import Trees._
+import TypeApplications._
+import NameKinds.{WildcardParamName, DefaultGetterName}
+import util.Chars.isOperatorPart
+import transform.TypeUtils._
+import transform.SymUtils._
+import config.{Config, Feature}
+
+import dotty.tools.dotc.util.SourcePosition
+import dotty.tools.dotc.ast.untpd.{MemberDef, Modifiers, PackageDef, RefTree, Template, TypeDef, ValOrDefDef}
+import cc.{CaptureSet, toCaptureSet, IllegalCaptureRef}
+
+class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
+
+  /** A stack of enclosing DefDef, TypeDef, or ClassDef, or ModuleDefs nodes */
+  private var enclosingDef: untpd.Tree = untpd.EmptyTree
+  private var myCtx: Context = super.printerContext
+  private var printPos = ctx.settings.YprintPos.value
+  private val printLines = ctx.settings.printLines.value
+
+  override def printerContext: Context = myCtx
+
+  def withEnclosingDef(enclDef: Tree[? >: Untyped])(op: => Text): Text = {
+    val savedCtx = myCtx
+    if (enclDef.hasType && enclDef.symbol.exists)
+      myCtx = ctx.withOwner(enclDef.symbol)
+    val savedDef = enclosingDef
+    enclosingDef = enclDef
+    try op finally {
+      myCtx = savedCtx
+      enclosingDef = savedDef
+    }
+  }
+
+  def inPattern(op: => Text): Text = {
+    val savedCtx = myCtx
+    myCtx = ctx.addMode(Mode.Pattern)
+    try op finally myCtx = savedCtx
+  }
+
+  inline def inContextBracket(inline op: Text): Text =
+    val savedCtx = myCtx
+    try op finally myCtx = savedCtx
+
+  def withoutPos(op: => Text): Text = {
+    val savedPrintPos = printPos
+    printPos = false
+    try op finally printPos = savedPrintPos
+  }
+
+  protected def enclDefIsClass: Boolean = enclosingDef match {
+    case owner: TypeDef => owner.isClassDef
+    case owner: untpd.ModuleDef => true
+    case _ => false
+  }
+
+  protected def PrintableFlags(isType: Boolean): FlagSet = {
+    val fs =
+      if (isType) TypeSourceModifierFlags | Module | Local  // DOTTY problem: cannot merge these two statements
+      else TermSourceModifierFlags | Module | Local
+    fs.toCommonFlags
+  }
+
+  override def nameString(name: Name): String =
+    def strippedName = if printDebug then name else name.stripModuleClassSuffix
+    if ctx.settings.YdebugNames.value then strippedName.debugString
+    else if name.isTypeName && name.is(WildcardParamName) && !printDebug then "_"
+    else super.nameString(strippedName)
+
+  override protected def simpleNameString(sym: Symbol): String =
+    nameString(if (ctx.property(XprintMode).isEmpty) sym.initial.name else sym.name)
+
+  override def fullNameString(sym: Symbol): String =
+    if !sym.exists || isEmptyPrefix(sym.effectiveOwner) then nameString(sym)
+    else super.fullNameString(sym)
+
+  override protected def fullNameOwner(sym: Symbol): Symbol = {
+    val owner = super.fullNameOwner(sym)
+    if (owner.is(ModuleClass)) owner.sourceModule else owner
+  }
+
+  override def toTextRef(tp: SingletonType): Text = controlled {
+    tp match {
+      case tp: ThisType if !printDebug =>
+        if (tp.cls.isAnonymousClass) keywordStr("this")
+        if (tp.cls.is(ModuleClass)) fullNameString(tp.cls.sourceModule)
+        else super.toTextRef(tp)
+      case _ =>
+        super.toTextRef(tp)
+    }
+  }
+
+  override def toTextPrefix(tp: Type): Text = controlled {
+    def isOmittable(sym: Symbol) =
+      if printDebug then false
+      else if homogenizedView then isEmptyPrefix(sym) // drop <root> and anonymous classes, but not scala, Predef.
+      else if sym.isPackageObject then isOmittablePrefix(sym.owner)
+      else isOmittablePrefix(sym)
+    tp match {
+      case tp: ThisType if isOmittable(tp.cls) =>
+        ""
+      case tp @ TermRef(pre, _) =>
+        val sym = tp.symbol
+        if sym.isPackageObject && !homogenizedView && !printDebug then toTextPrefix(pre)
+        else if (isOmittable(sym)) ""
+        else super.toTextPrefix(tp)
+      case _ => super.toTextPrefix(tp)
+    }
+  }
+
+  override protected def toTextParents(parents: List[Type]): Text =
+    Text(parents.map(toTextLocal).map(typeText), keywordStr(" with "))
+
+  override protected def refinementNameString(tp: RefinedType): String =
+    if (tp.parent.isInstanceOf[WildcardType] || tp.refinedName == nme.WILDCARD)
+      super.refinementNameString(tp)
+    else {
+      val tsym = tp.parent.member(tp.refinedName).symbol
+      if (!tsym.exists) super.refinementNameString(tp)
+      else simpleNameString(tsym)
+    }
+
+  private def arrow(isGiven: Boolean, isPure: Boolean): String =
+    (if isGiven then "?" else "") + (if isPure then "->" else "=>")
+
+  override def toText(tp: Type): Text = controlled {
+    def toTextTuple(args: List[Type]): Text =
+      "(" ~ argsText(args) ~ ")"
+
+    def toTextFunction(args: List[Type], isGiven: Boolean, isErased: Boolean, isPure: Boolean): Text =
+      changePrec(GlobalPrec) {
+        val argStr: Text =
+          if args.length == 2
+             && !defn.isTupleNType(args.head)
+             && !isGiven && !isErased
+          then
+            atPrec(InfixPrec) { argText(args.head) }
+          else
+            "("
+            ~ keywordText("erased ").provided(isErased)
+            ~ argsText(args.init)
+            ~ ")"
+        argStr ~ " " ~ arrow(isGiven, isPure) ~ " " ~ argText(args.last)
+      }
+
+    def toTextMethodAsFunction(info: Type, isPure: Boolean): Text = info match
+      case info: MethodType =>
+        changePrec(GlobalPrec) {
+          "("
+          ~ keywordText("erased ").provided(info.isErasedMethod)
+          ~ paramsText(info)
+          ~ ") "
+          ~ arrow(info.isImplicitMethod, isPure)
+          ~ " "
+          ~ toTextMethodAsFunction(info.resultType, isPure)
+        }
+      case info: PolyType =>
+        changePrec(GlobalPrec) {
+          "["
+          ~ paramsText(info)
+          ~ "] => "
+          ~ toTextMethodAsFunction(info.resultType, isPure)
+        }
+      case _ =>
+        toText(info)
+
+    def isInfixType(tp: Type): Boolean = tp match
+      case AppliedType(tycon, args) =>
+        args.length == 2
+        && {
+          val sym = tycon.typeSymbol
+          sym.is(Infix)
+          || sym.getAnnotation(defn.ShowAsInfixAnnot)
+              .exists(_.argumentConstant(0).forall(_.booleanValue))
+          || !Character.isUnicodeIdentifierStart(tycon.typeSymbol.name.toString.head)
+        }
+      case _ => false
+
+    def tyconName(tp: Type): Name = tp.typeSymbol.name
+    def checkAssocMismatch(tp: Type, isRightAssoc: Boolean) = tp match {
+      case AppliedType(tycon, _) => isInfixType(tp) && tyconName(tycon).endsWith(":") != isRightAssoc
+      case AndType(_, _) => isRightAssoc
+      case OrType(_, _) => isRightAssoc
+      case _ => false
+    }
+
+    def toTextInfixType(opName: Name, l: Type, r: Type)(op: => Text): Text = {
+      val isRightAssoc = opName.endsWith(":")
+      val opPrec = parsing.precedence(opName)
+
+      changePrec(opPrec) {
+        val leftPrec = if (isRightAssoc || checkAssocMismatch(l, isRightAssoc)) opPrec + 1 else opPrec
+        val rightPrec = if (!isRightAssoc || checkAssocMismatch(r, isRightAssoc)) opPrec + 1 else opPrec
+
+        atPrec(leftPrec) { argText(l) }  ~ " " ~ op ~ " " ~ atPrec(rightPrec) { argText(r) }
+      }
+    }
+
+    def appliedText(tp: Type): Text = tp match
+      case tp @ AppliedType(tycon, args) =>
+        tp.tupleElementTypes match
+          case Some(types) if types.size >= 2 && !printDebug => toTextTuple(types)
+          case _ =>
+            val tsym = tycon.typeSymbol
+            if tycon.isRepeatedParam then toTextLocal(args.head) ~ "*"
+            else if defn.isFunctionSymbol(tsym) then
+              toTextFunction(args, tsym.name.isContextFunction, tsym.name.isErasedFunction,
+                isPure = Feature.pureFunsEnabled && !tsym.name.isImpureFunction)
+            else if isInfixType(tp) then
+              val l :: r :: Nil = args: @unchecked
+              val opName = tyconName(tycon)
+              toTextInfixType(tyconName(tycon), l, r) { simpleNameString(tycon.typeSymbol) }
+            else Str("")
+      case _ =>
+        Str("")
+
+    homogenize(tp) match {
+      case tp: AppliedType =>
+        val refined = appliedText(tp)
+        if refined.isEmpty then super.toText(tp) else refined
+      // Since RefinedPrinter, unlike PlainPrinter, can output right-associative type-operators, we must override handling
+      // of AndType and OrType to account for associativity
+      case AndType(tp1, tp2) =>
+        toTextInfixType(tpnme.raw.AMP, tp1, tp2) { toText(tpnme.raw.AMP) }
+      case tp @ OrType(tp1, tp2) =>
+        toTextInfixType(tpnme.raw.BAR, tp1, tp2) {
+          if tp.isSoft && printDebug then toText(tpnme.ZOR) else toText(tpnme.raw.BAR)
+        }
+      case tp @ EtaExpansion(tycon)
+      if !printDebug && appliedText(tp.asInstanceOf[HKLambda].resType).isEmpty =>
+        // don't eta contract if the application would be printed specially
+        toText(tycon)
+      case tp: RefinedType if defn.isFunctionOrPolyType(tp) && !printDebug =>
+        toTextMethodAsFunction(tp.refinedInfo,
+          isPure = Feature.pureFunsEnabled && !tp.typeSymbol.name.isImpureFunction)
+      case tp: TypeRef =>
+        if (tp.symbol.isAnonymousClass && !showUniqueIds)
+          toText(tp.info)
+        else if (tp.symbol.is(Param))
+          tp.prefix match {
+            case pre: ThisType if pre.cls == tp.symbol.owner =>
+              nameString(tp.symbol)
+            case _ => super.toText(tp)
+          }
+        else super.toText(tp)
+      case ErasedValueType(tycon, underlying) =>
+        "ErasedValueType(" ~ toText(tycon) ~ ", " ~ toText(underlying) ~ ")"
+      case tp: ClassInfo =>
+        if tp.cls.derivesFrom(defn.PolyFunctionClass) then
+          tp.member(nme.apply).info match
+            case info: PolyType => toTextMethodAsFunction(info, isPure = false)
+            case _ => toTextParents(tp.parents) ~~ "{...}"
+        else toTextParents(tp.parents) ~~ "{...}"
+      case JavaArrayType(elemtp) =>
+        toText(elemtp) ~ "[]"
+      case tp: LazyRef if !printDebug =>
+        try toText(tp.ref)
+        catch case ex: Throwable => "..."
+      case AnySelectionProto =>
+        "a type that can be selected or applied"
+      case tp: SelectionProto =>
+        "?{ " ~ toText(tp.name) ~
+           (Str(" ") provided !tp.name.toSimpleName.last.isLetterOrDigit) ~
+           ": " ~ toText(tp.memberProto) ~ " }"
+      case tp: ViewProto =>
+        toText(tp.argType) ~ " ?=>? " ~ toText(tp.resultType)
+      case tp @ FunProto(args, resultType) =>
+        val argsText = args match {
+          case dummyTreeOfType(tp) :: Nil if !(tp isRef defn.NullClass) => "null: " ~ toText(tp)
+          case _ => toTextGlobal(args, ", ")
+        }
+        "[applied to ("
+        ~ keywordText("using ").provided(tp.isContextualMethod)
+        ~ keywordText("erased ").provided(tp.isErasedMethod)
+        ~ argsText
+        ~ ") returning "
+        ~ toText(resultType)
+        ~ "]"
+      case IgnoredProto(ignored) =>
+        "?" ~ (("(ignored: " ~ toText(ignored) ~ ")") provided printDebug)
+      case tp @ PolyProto(targs, resType) =>
+        "[applied to [" ~ toTextGlobal(targs, ", ") ~ "] returning " ~ toText(resType)
+      case _ =>
+        super.toText(tp)
+    }
+  }
+
+  protected def exprToText(tp: ExprType): Text =
+    "=> " ~ toText(tp.resType)
+
+  protected def blockToText[T >: Untyped](block: Block[T]): Text =
+    blockText(block.stats :+ block.expr)
+
+  protected def blockText[T >: Untyped](trees: List[Tree[T]]): Text =
+    inContextBracket {
+      ("{" ~ toText(trees, "\n") ~ "}").close
+    }
+
+  protected def typeApplyText[T >: Untyped](tree: TypeApply[T]): Text = {
+    val funText = toTextLocal(tree.fun)
+    tree.fun match {
+      case Select(New(tpt), nme.CONSTRUCTOR) if tpt.typeOpt.dealias.isInstanceOf[AppliedType] =>
+        funText  // type was already printed by toText(new)
+      case _ =>
+        funText ~ "[" ~ toTextGlobal(tree.args, ", ") ~ "]"
+    }
+  }
+
+  protected def toTextCore[T >: Untyped](tree: Tree[T]): Text = {
+    import untpd._
+
+    def isLocalThis(tree: Tree) = tree.typeOpt match {
+      case tp: ThisType => tp.cls == ctx.owner.enclosingClass
+      case _ => false
+    }
+
+    def optDotPrefix(tree: This) = optText(tree.qual)(_ ~ ".") provided !isLocalThis(tree)
+
+    def caseBlockText(tree: Tree): Text = tree match {
+      case Block(stats, expr) => toText(stats :+ expr, "\n")
+      case expr => toText(expr)
+    }
+
+    // Dotty deviation: called with an untpd.Tree, so cannot be a untpd.Tree[T] (seems to be a Scala2 problem to allow this)
+    // More deviations marked below as // DD
+    def enumText(tree: untpd.Tree) = tree match { // DD
+      case _: untpd.GenFrom | _: untpd.GenAlias => toText(tree)
+      case _ => keywordStr("if ") ~ toText(tree)
+    }
+
+    def forText(enums: List[untpd.Tree], expr: untpd.Tree, sep: String): Text = // DD
+      changePrec(GlobalPrec) { keywordStr("for ") ~ Text(enums map enumText, "; ") ~ sep ~ toText(expr) }
+
+    def cxBoundToText(bound: untpd.Tree): Text = bound match { // DD
+      case AppliedTypeTree(tpt, _) => " : " ~ toText(tpt)
+      case untpd.Function(_, tpt) => " <% " ~ toText(tpt)
+    }
+
+    def varianceText(mods: untpd.Modifiers) =
+      if (mods.is(Covariant)) "+"
+      else if (mods.is(Contravariant)) "-"
+      else ""
+
+    def argText(arg: Tree): Text = arg match {
+      case arg: TypeBoundsTree => "?" ~ toTextGlobal(arg)
+      case arg: TypeTree =>
+        arg.typeOpt match {
+          case tp: TypeBounds => "?" ~ toTextGlobal(arg)
+          case _ => toTextGlobal(arg)
+        }
+      case _ => toTextGlobal(arg)
+    }
+
+    def dropBlock(tree: Tree): Tree = tree match {
+      case Block(Nil, expr) => expr
+      case _ => tree
+    }
+
+    def importText(expr: Tree, selectors: List[untpd.ImportSelector]) =
+
+      def selectorText(sel: untpd.ImportSelector): Text =
+        val id: Text =
+          if sel.isGiven then keywordText("given")
+          else sel.imported.name match
+            case nme.WILDCARD => "*"
+            case nme.raw.STAR => "`*`"
+            case name => toText(name)
+        val rename: Text =
+          if sel.renamed.isEmpty then "" else Str(" as ") ~ toText(sel.renamed)
+        val bound: Text =
+          if sel.bound.isEmpty then ""
+          else if sel.isGiven then Str(" ") ~ toText(sel.bound)
+          else Str(" : ") ~ toText(sel.bound)
+        id ~ rename ~ bound
+
+      val selectorsText: Text = selectors match
+        case (sel @ untpd.ImportSelector(name, EmptyTree, EmptyTree)) :: Nil =>
+          selectorText(sel)
+        case _ =>
+          "{" ~ Text(selectors.map(selectorText), ", ") ~ "}"
+
+      toTextLocal(expr) ~ "." ~ selectorsText
+
+    tree match {
+      case id: Trees.SearchFailureIdent[?] =>
+        tree.typeOpt match {
+          case reason: Implicits.SearchFailureType =>
+            Str(id.explanation)
+            ~ ("summon[" ~ toText(reason.clarify(reason.expectedType)) ~ "]").close
+          case _ =>
+            Str(id.explanation)
+        }
+      case id @ Ident(name) =>
+        val txt = tree.typeOpt match {
+          case tp: NamedType if name != nme.WILDCARD =>
+            val pre = if (tp.symbol.is(JavaStatic)) tp.prefix.widen else tp.prefix
+            toTextPrefix(pre) ~ withPos(selectionString(tp), tree.sourcePos)
+          case _ =>
+            toText(name)
+        }
+        if (isBackquoted(tree) && !homogenizedView) "`" ~ toText(name) ~ "`"
+        else if (name.isTypeName) typeText(txt)
+        else txt
+      case tree @ Select(qual, name) =>
+        if (qual.isType) toTextLocal(qual) ~ "#" ~ typeText(toText(name))
+        else toTextLocal(qual) ~ ("." ~ nameIdText(tree) provided (name != nme.CONSTRUCTOR || printDebug))
+      case tree: This =>
+        optDotPrefix(tree) ~ keywordStr("this") ~ idText(tree)
+      case Super(qual: This, mix) =>
+        optDotPrefix(qual) ~ keywordStr("super") ~ optText(mix)("[" ~ _ ~ "]")
+      case app @ Apply(fun, args) =>
+        if (fun.hasType && fun.symbol == defn.throwMethod)
+          changePrec (GlobalPrec) {
+            keywordStr("throw ") ~ toText(args.head)
+          }
+        else if (!printDebug && fun.hasType && fun.symbol == defn.QuotedRuntime_exprQuote)
+          keywordStr("'{") ~ toTextGlobal(args, ", ") ~ keywordStr("}")
+        else if (!printDebug && fun.hasType && fun.symbol.isExprSplice)
+          keywordStr("${") ~ toTextGlobal(args, ", ") ~ keywordStr("}")
+        else
+          toTextLocal(fun)
+          ~ "("
+          ~ Str("using ").provided(app.applyKind == ApplyKind.Using && !homogenizedView)
+          ~ toTextGlobal(args, ", ")
+          ~ ")"
+      case tree: TypeApply =>
+        typeApplyText(tree)
+      case Literal(c) =>
+        tree.typeOpt match {
+          case ConstantType(tc) => withPos(toText(tc), tree.sourcePos)
+          case _ => withPos(toText(c), tree.sourcePos)
+        }
+      case New(tpt) =>
+        keywordStr("new ") ~ {
+          tpt match {
+            case tpt: Template => toTextTemplate(tpt, ofNew = true)
+            case _ => toTextLocal(tpt)
+          }
+        }
+      case Typed(expr, tpt) =>
+        changePrec(InfixPrec) {
+          if isWildcardStarArg(tree) then
+            expr match
+              case Ident(nme.WILDCARD_STAR) =>
+              	// `_*` is used as a wildcard name to indicate a vararg splice pattern;
+              	// avoid the double `*` in this case.
+              	toText(expr)
+              case _ =>
+                toText(expr) ~ "*"
+          else
+            val exprText = toText(expr)
+            val line = exprText.lastLine
+            val colon = if !line.isEmpty && isOperatorPart(line.last) then " :" else ":"
+            exprText ~ colon ~ toText(tpt)
+        }
+      case NamedArg(name, arg) =>
+        toText(name) ~ " = " ~ toText(arg)
+      case Assign(lhs, rhs) =>
+        changePrec(GlobalPrec) { toTextLocal(lhs) ~ " = " ~ toText(rhs) }
+      case block: Block =>
+        blockToText(block)
+      case If(cond, thenp, elsep) =>
+        val isInline = tree.isInstanceOf[Trees.InlineIf[?]]
+        changePrec(GlobalPrec) {
+          keywordStr(if (isInline) "inline if " else "if ") ~
+          toText(cond) ~ (keywordText(" then") provided !cond.isInstanceOf[Parens]) ~~
+          toText(thenp) ~ optText(elsep)(keywordStr(" else ") ~ _)
+        }
+      case Closure(env, ref, target) =>
+        "closure(" ~ (toTextGlobal(env, ", ") ~ " | " provided env.nonEmpty) ~
+        toTextGlobal(ref) ~ (":" ~ toText(target) provided !target.isEmpty) ~ ")"
+      case Match(sel, cases) =>
+        val isInline = tree.isInstanceOf[Trees.InlineMatch[?]]
+        if (sel.isEmpty && !isInline) blockText(cases)
+        else changePrec(GlobalPrec) {
+          val selTxt: Text =
+            if (isInline)
+              if (sel.isEmpty) keywordStr("implicit")
+              else keywordStr("inline ") ~ toText(sel)
+            else toText(sel)
+          selTxt ~ keywordStr(" match ") ~ blockText(cases)
+        }
+      case CaseDef(pat, guard, body) =>
+        keywordStr("case ") ~ inPattern(toText(pat)) ~ optText(guard)(keywordStr(" if ") ~ _) ~ " => " ~ caseBlockText(body)
+      case Labeled(bind, expr) =>
+        changePrec(GlobalPrec) { toText(bind.name) ~ keywordStr("[") ~ toText(bind.symbol.info) ~ keywordStr("]: ") ~ toText(expr) }
+      case Return(expr, from) =>
+        val sym = from.symbol
+        if (sym.is(Label))
+          changePrec(GlobalPrec) { keywordStr("return[") ~ toText(sym.name) ~ keywordStr("]") ~ optText(expr)(" " ~ _) }
+        else
+          changePrec(GlobalPrec) { keywordStr("return") ~ optText(expr)(" " ~ _) }
+      case WhileDo(cond, body) =>
+        changePrec(GlobalPrec) { keywordStr("while ") ~ toText(cond) ~ keywordStr(" do ") ~ toText(body) }
+      case Try(expr, cases, finalizer) =>
+        changePrec(GlobalPrec) {
+          keywordStr("try ") ~ toText(expr) ~ optText(cases)(keywordStr(" catch ") ~ _) ~ optText(finalizer)(keywordStr(" finally ") ~ _)
+        }
+      case Throw(expr) =>
+        changePrec(GlobalPrec) {
+          keywordStr("throw ") ~ toText(expr)
+        }
+      case SeqLiteral(elems, elemtpt) =>
+        "[" ~ toTextGlobal(elems, ",") ~ " : " ~ toText(elemtpt) ~ "]"
+      case tree @ Inlined(call, bindings, body) =>
+        (("/* inlined from " ~ (if (call.isEmpty) "outside" else toText(call)) ~ " */ ") `provided`
+          !homogenizedView && ctx.settings.XprintInline.value) ~
+          (if bindings.isEmpty then toText(body) else blockText(bindings :+ body))
+      case tpt: untpd.DerivedTypeTree =>
+        "<derived typetree watching " ~ tpt.watched.showSummary() ~ ">"
+      case TypeTree() =>
+        typeText(toText(tree.typeOpt))
+        ~ Str("(inf)").provided(tree.isInstanceOf[InferredTypeTree] && printDebug)
+      case SingletonTypeTree(ref) =>
+        toTextLocal(ref) ~ "." ~ keywordStr("type")
+      case RefinedTypeTree(tpt, refines) =>
+        toTextLocal(tpt) ~ " " ~ blockText(refines)
+      case AppliedTypeTree(tpt, args) =>
+        if (tpt.symbol == defn.orType && args.length == 2)
+          changePrec(OrTypePrec) { toText(args(0)) ~ " | " ~ atPrec(OrTypePrec + 1) { toText(args(1)) } }
+        else if (tpt.symbol == defn.andType && args.length == 2)
+          changePrec(AndTypePrec) { toText(args(0)) ~ " & " ~ atPrec(AndTypePrec + 1) { toText(args(1)) } }
+        else if defn.isFunctionSymbol(tpt.symbol)
+            && tpt.isInstanceOf[TypeTree] && tree.hasType && !printDebug
+        then changePrec(GlobalPrec) { toText(tree.typeOpt) }
+        else args match
+          case arg :: _ if arg.isTerm =>
+            toTextLocal(tpt) ~ "(" ~ Text(args.map(argText), ", ") ~ ")"
+          case _ =>
+            toTextLocal(tpt) ~ "[" ~ Text(args.map(argText), ", ") ~ "]"
+      case LambdaTypeTree(tparams, body) =>
+        changePrec(GlobalPrec) {
+          paramsText(tparams) ~ " =>> " ~ toText(body)
+        }
+      case TermLambdaTypeTree(params, body) =>
+        changePrec(GlobalPrec) {
+          paramsText(params) ~ " =>> " ~ toText(body)
+        }
+      case MatchTypeTree(bound, sel, cases) =>
+        changePrec(GlobalPrec) {
+          toText(sel) ~ keywordStr(" match ") ~ blockText(cases) ~
+          (" <: " ~ toText(bound) provided !bound.isEmpty)
+        }
+      case ByNameTypeTree(tpt) =>
+        (if Feature.pureFunsEnabled then "-> " else "=> ")
+        ~ toTextLocal(tpt)
+      case TypeBoundsTree(lo, hi, alias) =>
+        if (lo eq hi) && alias.isEmpty then optText(lo)(" = " ~ _)
+        else optText(lo)(" >: " ~ _) ~ optText(hi)(" <: " ~ _) ~ optText(alias)(" = " ~ _)
+      case bind @ Bind(name, body) =>
+        keywordText("given ").provided(tree.symbol.isOneOf(GivenOrImplicit) && !homogenizedView) ~ // Used for scala.quoted.Type in quote patterns (not pickled)
+        changePrec(InfixPrec) { nameIdText(bind) ~ " @ " ~ toText(body) }
+      case Alternative(trees) =>
+        changePrec(OrPrec) { toText(trees, " | ") }
+      case UnApply(fun, implicits, patterns) =>
+        val extractor = fun match {
+          case Select(extractor, name) if name.isUnapplyName => extractor
+          case _ => fun
+        }
+        toTextLocal(extractor) ~
+        "(" ~ toTextGlobal(patterns, ", ") ~ ")" ~
+        ("(" ~ toTextGlobal(implicits, ", ") ~ ")" provided implicits.nonEmpty)
+      case tree @ ValDef(_, _, _) =>
+        valDefToText(tree)
+      case tree @ DefDef(_, _, _, _) =>
+        defDefToText(tree)
+      case tree @ TypeDef(name, rhs) =>
+        def typeDefText(tparamsText: => Text, rhsText: => Text) =
+          dclTextOr(tree) {
+            modText(tree.mods, tree.symbol, keywordStr("type"), isType = true) ~~
+            (varianceText(tree.mods) ~ typeText(nameIdText(tree))) ~
+            withEnclosingDef(tree) { tparamsText ~ rhsText }
+          }
+        def recur(rhs: Tree, tparamsTxt: => Text, printMemberArgs: Boolean): Text = rhs match {
+          case impl: Template =>
+            templateText(tree, impl)
+          case rhs: TypeBoundsTree =>
+            typeDefText(tparamsTxt, toText(rhs))
+          case LambdaTypeTree(tparams, body) if printMemberArgs =>
+            recur(body, paramsText(tparams), false)
+          case rhs: TypeTree if isBounds(rhs.typeOpt) =>
+            typeDefText(tparamsTxt, toText(rhs))
+          case rhs =>
+            typeDefText(tparamsTxt, optText(rhs)(" = " ~ _))
+        }
+        recur(rhs, "", true)
+      case tree @ Import(expr, selectors) =>
+        myCtx = myCtx.importContext(tree, tree.symbol)
+        keywordText("import ") ~ importText(expr, selectors)
+      case Export(expr, selectors) =>
+        keywordText("export ") ~ importText(expr, selectors)
+      case ExtMethods(paramss, mdefs) =>
+        addParamssText(keywordText("extension "), paramss)
+        ~ " " ~ (if mdefs.length == 1 then toText(mdefs.head) else blockText(mdefs))
+      case packageDef: PackageDef =>
+        packageDefText(packageDef)
+      case tree: Template =>
+        toTextTemplate(tree)
+      case Annotated(arg, annot) =>
+        def captureSet =
+          annot.asInstanceOf[tpd.Tree].toCaptureSet
+        def toTextAnnot =
+          toTextLocal(arg) ~~ annotText(annot.symbol.enclosingClass, annot)
+        def toTextRetainsAnnot =
+          try changePrec(GlobalPrec)(toText(captureSet) ~ " " ~ toText(arg))
+          catch case ex: IllegalCaptureRef => toTextAnnot
+        if annot.symbol.maybeOwner == defn.RetainsAnnot
+            && Feature.ccEnabled && Config.printCaptureSetsAsPrefix && !printDebug
+        then toTextRetainsAnnot
+        else toTextAnnot
+      case EmptyTree =>
+        "<empty>"
+      case TypedSplice(t) =>
+        if (printDebug) "[" ~ toText(t) ~ "]#TS#"
+        else toText(t)
+      case tree @ ModuleDef(name, impl) =>
+        withEnclosingDef(tree) {
+          modText(tree.mods, NoSymbol, keywordStr("object"), isType = false) ~~
+          nameIdText(tree) ~ toTextTemplate(impl)
+        }
+      case SymbolLit(str) =>
+        "'" + str
+      case InterpolatedString(id, segments) =>
+        def strText(str: Literal) = withPos(escapedString(str.const.stringValue), tree.sourcePos)
+        def segmentText(segment: Tree) = segment match {
+          case Thicket(List(str: Literal, expr)) => strText(str) ~ "{" ~ toTextGlobal(expr) ~ "}"
+          case str: Literal => strText(str)
+        }
+        toText(id) ~ "\"" ~ Text(segments map segmentText, "") ~ "\""
+      case Function(args, body) =>
+        var implicitSeen: Boolean = false
+        var isGiven: Boolean = false
+        var isErased: Boolean = false
+        def argToText(arg: Tree) = arg match {
+          case arg @ ValDef(name, tpt, _) =>
+            val implicitText =
+              if ((arg.mods.is(Given))) { isGiven = true; "" }
+              else if ((arg.mods.is(Erased))) { isErased = true; "" }
+              else if ((arg.mods.is(Implicit)) && !implicitSeen) { implicitSeen = true; keywordStr("implicit ") }
+              else ""
+            implicitText ~ toText(name) ~ optAscription(tpt)
+          case _ =>
+            toText(arg)
+        }
+        val argsText = args match {
+          case (arg @ ValDef(_, tpt, _)) :: Nil if tpt.isEmpty => argToText(arg)
+          case _ =>
+            "("
+            ~ keywordText("erased ").provided(isErased)
+            ~ Text(args.map(argToText), ", ")
+            ~ ")"
+        }
+        val isPure =
+          Feature.pureFunsEnabled
+          && tree.match
+            case tree: FunctionWithMods => !tree.mods.is(Impure)
+            case _ => true
+        argsText ~ " " ~ arrow(isGiven, isPure) ~ " " ~ toText(body)
+      case PolyFunction(targs, body) =>
+        val targsText = "[" ~ Text(targs.map((arg: Tree) => toText(arg)), ", ") ~ "]"
+        changePrec(GlobalPrec) {
+          targsText ~ " => " ~ toText(body)
+        }
+      case InfixOp(l, op, r) =>
+        val opPrec = parsing.precedence(op.name)
+        changePrec(opPrec) { toText(l) ~ " " ~ toText(op) ~ " " ~ toText(r) }
+      case PostfixOp(l, op) =>
+        changePrec(InfixPrec) { toText(l) ~ " " ~ toText(op) }
+      case PrefixOp(op, r) =>
+        changePrec(DotPrec) { toText(op) ~ " " ~ toText(r) }
+      case Parens(t) =>
+        "(" ~ toTextGlobal(t) ~ ")"
+      case Tuple(ts) =>
+        "(" ~ toTextGlobal(ts, ", ") ~ ")"
+      case ForYield(enums, expr) =>
+        forText(enums, expr, keywordStr(" yield "))
+      case ForDo(enums, expr) =>
+        forText(enums, expr, keywordStr(" do "))
+      case GenFrom(pat, expr, checkMode) =>
+        (Str("case ") provided checkMode == untpd.GenCheckMode.FilterAlways) ~
+        toText(pat) ~ " <- " ~ toText(expr)
+      case GenAlias(pat, expr) =>
+        toText(pat) ~ " = " ~ toText(expr)
+      case ContextBounds(bounds, cxBounds) =>
+        cxBounds.foldLeft(toText(bounds)) {(t, cxb) =>
+          t ~ cxBoundToText(cxb)
+        }
+      case PatDef(mods, pats, tpt, rhs) =>
+        modText(mods, NoSymbol, keywordStr("val"), isType = false) ~~
+        toText(pats, ", ") ~ optAscription(tpt) ~ optText(rhs)(" = " ~ _)
+      case ParsedTry(expr, handler, finalizer) =>
+        changePrec(GlobalPrec) {
+          keywordStr("try ") ~ toText(expr) ~ " " ~ keywordStr("catch") ~ " {" ~ toText(handler) ~ "}" ~ optText(finalizer)(keywordStr(" finally ") ~ _)
+        }
+      case Number(digits, kind) =>
+        digits
+      case Quote(tree) if tree.isTerm =>
+        keywordStr("'{") ~ toTextGlobal(dropBlock(tree)) ~ keywordStr("}")
+      case Splice(tree) =>
+        keywordStr("${") ~ toTextGlobal(dropBlock(tree)) ~ keywordStr("}")
+      case Thicket(trees) =>
+        "Thicket {" ~~ toTextGlobal(trees, "\n") ~~ "}"
+      case MacroTree(call) =>
+        keywordStr("macro ") ~ toTextGlobal(call)
+      case Hole(isTermHole, idx, args, content, tpt) =>
+        val (prefix, postfix) = if isTermHole then ("{{{", "}}}") else ("[[[", "]]]")
+        val argsText = toTextGlobal(args, ", ")
+        val contentText = toTextGlobal(content)
+        val tptText = toTextGlobal(tpt)
+        prefix ~~ idx.toString ~~ "|" ~~ tptText ~~ "|" ~~ argsText ~~ "|" ~~ contentText ~~ postfix
+      case CapturingTypeTree(refs, parent) =>
+        parent match
+          case ImpureByNameTypeTree(bntpt) =>
+            "=> " ~ toTextLocal(bntpt)
+          case _ =>
+            changePrec(GlobalPrec)("{" ~ Text(refs.map(toText), ", ") ~ "} " ~ toText(parent))
+      case _ =>
+        tree.fallbackToText(this)
+    }
+  }
+
+  override def toText[T >: Untyped](tree: Tree[T]): Text = controlled {
+    import untpd._
+
+    var txt = toTextCore(tree)
+
+    def suppressTypes =
+      tree.isType || tree.isDef || // don't print types of types or defs
+      homogenizedView && ctx.mode.is(Mode.Pattern)
+        // When comparing pickled info, disregard types of patterns.
+        // The reason is that GADT matching can rewrite types of pattern trees
+        // without changing the trees themselves. (see Typer.typedCase.indexPatterns.transform).
+        // But then pickling and unpickling the original trees will yield trees
+        // with the original types before they are rewritten, which causes a discrepancy.
+
+    def suppressPositions = tree match {
+      case _: WithoutTypeOrPos[?] | _: TypeTree => true // TypeTrees never have an interesting position
+      case _ => false
+    }
+
+    if (ctx.settings.XprintTypes.value && tree.hasType) {
+      // add type to term nodes; replace type nodes with their types unless -Yprint-pos is also set.
+      val tp1 = tree.typeOpt match {
+        case tp: TermRef if tree.isInstanceOf[RefTree] && !tp.denot.isOverloaded => tp.underlying
+        case tp => tp
+      }
+      val tp2 = {
+        val tp = tp1.tryNormalize
+        if (tp != NoType) tp else tp1
+      }
+      val tp3 =
+        if (homogenizedView && tree.isInstanceOf[If | Match | Annotated | Block | CaseDef]) {
+          // Types of non-leaf trees are not pickled but reconstructed when
+          // unpickled using the TypeAssigner. Sometimes, this requires choosing
+          // arbitrarily between two =:= types (e.g., when typing an `if`, where
+          // one branch is typed with a type alias and the other with a
+          // dealiased version of the same type) and we cannot guarantee that
+          // the same choice was made by the original Typer (e.g., because the
+          // original choice involved type variables). So we need to get rid of
+          // any alias in these types to make -Ytest-pickler work (the list of
+          // types in the isInstanceOf check above is conservative and might
+          // need to be expanded).
+          val dealiasMap = new TypeMap {
+            def apply(tp: Type) = mapOver(tp.dealias)
+          }
+          dealiasMap(tp2)
+        }
+        else tp2
+
+      if (!suppressTypes)
+        txt = ("<" ~ txt ~ ":" ~ toText(tp3) ~ ">").close
+      else if (tree.isType && !homogenizedView)
+        txt = toText(tp3)
+    }
+    if (!suppressPositions) {
+      if (printPos) {
+        val posStr =
+          if (homogenizedView || debugPos)
+            if (tree.isInstanceOf[MemberDef]) Str(s"${tree.source}${tree.span}")
+            else Str(s"${tree.source}${tree.span.toSynthetic}")
+          else
+            "<" ~ toText(tree.sourcePos) ~ ">"
+        val clsStr = ""//if (tree.isType) tree.getClass.toString else ""
+        txt = (txt ~ "@" ~ posStr ~ clsStr).close
+      }
+      if (ctx.settings.YprintPosSyms.value && tree.isDef)
+        txt = (txt ~
+          s"@@(${tree.symbol.name}=" ~ tree.symbol.sourcePos.toString ~ ")").close
+    }
+    if (ctx.settings.YshowTreeIds.value)
+      txt = (txt ~ "#" ~ tree.uniqueId.toString).close
+    tree match {
+      case Block(_, _) | Template(_, _, _, _) => txt
+      case _ => txt.close
+    }
+  }
+
+  /** Print modifiers from symbols if tree has type, overriding the behavior in Trees. */
+  extension (mdef: untpd.DefTree) def mods: untpd.Modifiers =
+    if mdef.hasType then Modifiers(mdef.symbol) else mdef.rawMods
+
+  private def Modifiers(sym: Symbol): Modifiers = untpd.Modifiers(
+    sym.flagsUNSAFE & (if (sym.isType) ModifierFlags | VarianceFlags else ModifierFlags),
+    if (sym.privateWithin.exists) sym.privateWithin.asType.name else tpnme.EMPTY,
+    sym.annotationsUNSAFE.filterNot(ann => dropAnnotForModText(ann.symbol)).map(_.tree))
+
+  protected def dropAnnotForModText(sym: Symbol): Boolean = sym == defn.BodyAnnot
+
+  protected def optAscription[T >: Untyped](tpt: Tree[T]): Text = optText(tpt)(": " ~ _)
+
+  private def idText(tree: untpd.Tree): Text =
+    (if showUniqueIds && tree.hasType && tree.symbol.exists then s"#${tree.symbol.id}" else "") ~
+    (if showNestingLevel then tree.typeOpt match
+      case tp: NamedType if !tp.symbol.isStatic => s"%${tp.symbol.nestingLevel}"
+      case tp: TypeVar => s"%${tp.nestingLevel}"
+      case tp: TypeParamRef => ctx.typerState.constraint.typeVarOfParam(tp) match
+        case tvar: TypeVar => s"%${tvar.nestingLevel}"
+        case _ => ""
+      case _ => ""
+     else "")
+
+  private def useSymbol(tree: untpd.Tree) =
+    tree.hasType && tree.symbol.exists && ctx.settings.YprintSyms.value
+
+  protected def nameIdText[T >: Untyped](tree: NameTree[T]): Text =
+    if (tree.hasType && tree.symbol.exists) {
+      val str = nameString(tree.symbol)
+      tree match {
+        case tree: RefTree => withPos(str, tree.sourcePos)
+        case tree: MemberDef => withPos(str, tree.sourcePos.withSpan(tree.nameSpan))
+        case _ => str
+      }
+    }
+    else toText(tree.name) ~ idText(tree)
+
+  private def toTextOwner(tree: Tree[?]) =
+    "[owner = " ~ tree.symbol.maybeOwner.show ~ "]" provided ctx.settings.YprintDebugOwners.value
+
+  protected def dclTextOr[T >: Untyped](tree: Tree[T])(treeText: => Text): Text =
+    toTextOwner(tree) ~ {
+      if (useSymbol(tree)) annotsText(tree.symbol) ~~ dclText(tree.symbol)
+      else treeText
+    }
+
+  def paramsText[T>: Untyped](params: ParamClause[T]): Text = (params: @unchecked) match
+    case Nil =>
+      "()"
+    case untpd.ValDefs(vparams @ (vparam :: _)) =>
+      "(" ~ keywordText("using ").provided(vparam.mods.is(Given))
+          ~ keywordText("erased ").provided(vparam.mods.is(Erased))
+          ~ toText(vparams, ", ") ~ ")"
+    case untpd.TypeDefs(tparams) =>
+      "[" ~ toText(tparams, ", ") ~ "]"
+
+  def addParamssText[T >: Untyped](leading: Text, paramss: List[ParamClause[T]]): Text =
+    paramss.foldLeft(leading)((txt, params) => txt ~ paramsText(params))
+
+  protected def valDefToText[T >: Untyped](tree: ValDef[T]): Text = {
+    dclTextOr(tree) {
+      modText(tree.mods, tree.symbol, keywordStr(if (tree.mods.is(Mutable)) "var" else "val"), isType = false) ~~
+        valDefText(nameIdText(tree)) ~ optAscription(tree.tpt) ~
+        withEnclosingDef(tree) { optText(tree.rhs)(" = " ~ _) }
+    }
+  }
+
+  protected def defDefToText[T >: Untyped](tree: DefDef[T]): Text = {
+    import untpd._
+    dclTextOr(tree) {
+      val defKeyword = modText(tree.mods, tree.symbol, keywordStr("def"), isType = false)
+      val isExtension = tree.hasType && tree.symbol.is(ExtensionMethod)
+      withEnclosingDef(tree) {
+        val coreSig =
+          if isExtension then
+            val paramss =
+              if tree.name.isRightAssocOperatorName then
+                // we have the following encoding of tree.paramss:
+                //   (leadingTyParamss ++ leadingUsing
+                //      ++ rightTyParamss ++ rightParamss
+                //      ++ leftParamss ++ trailingUsing ++ rest)
+                //   e.g.
+                //     extension [A](using B)(c: C)(using D)
+                //       def %:[E](f: F)(g: G)(using H): Res = ???
+                //   will have the following values:
+                //   - leadingTyParamss = List(`[A]`)
+                //   - leadingUsing = List(`(using B)`)
+                //   - rightTyParamss = List(`[E]`)
+                //   - rightParamss = List(`(f: F)`)
+                //   - leftParamss = List(`(c: C)`)
+                //   - trailingUsing = List(`(using D)`)
+                //   - rest = List(`(g: G)`, `(using H)`)
+                // we need to swap (rightTyParams ++ rightParamss) with (leftParamss ++ trailingUsing)
+                val (leadingTyParamss, rest1) = tree.paramss.span(isTypeParamClause)
+                val (leadingUsing, rest2) = rest1.span(isUsingClause)
+                val (rightTyParamss, rest3) = rest2.span(isTypeParamClause)
+                val (rightParamss, rest4) = rest3.splitAt(1)
+                val (leftParamss, rest5) = rest4.splitAt(1)
+                val (trailingUsing, rest6) = rest5.span(isUsingClause)
+                if leftParamss.nonEmpty then
+                  leadingTyParamss ::: leadingUsing ::: leftParamss ::: trailingUsing ::: rightTyParamss ::: rightParamss ::: rest6
+                else
+                  tree.paramss // it wasn't a binary operator, after all.
+              else
+                tree.paramss
+            val trailingParamss = paramss
+              .dropWhile(isUsingOrTypeParamClause)
+              .drop(1)
+              .dropWhile(isUsingClause)
+            val leadingParamss = paramss.take(paramss.length - trailingParamss.length)
+            addParamssText(
+              addParamssText(keywordStr("extension "), leadingParamss)
+              ~~ (defKeyword ~~ valDefText(nameIdText(tree))).close,
+             trailingParamss)
+          else
+            addParamssText(defKeyword ~~ valDefText(nameIdText(tree)), tree.paramss)
+
+        coreSig
+        ~ optAscription(tree.tpt)
+        ~ optText(tree.rhs)(" = " ~ keywordText("macro ").provided(tree.symbol.isScala2Macro) ~ _)
+      }
+    }
+  }
+
+  protected def toTextTemplate(impl: Template, ofNew: Boolean = false): Text = {
+    val Template(constr @ DefDef(_, paramss, _, _), _, self, _) = impl
+    val tparamsTxt = withEnclosingDef(constr) {
+      paramsText(constr.leadingTypeParams) provided constr.leadingTypeParams.nonEmpty
+    }
+    val primaryConstrs = if (constr.rhs.isEmpty) Nil else constr :: Nil
+    val prefix: Text =
+      if (constr.trailingParamss.isEmpty || primaryConstrs.nonEmpty) tparamsTxt
+      else {
+        var modsText = modText(constr.mods, constr.symbol, "", isType = false)
+        if (!modsText.isEmpty) modsText = " " ~ modsText
+        if (constr.mods.hasAnnotations && !constr.mods.hasFlags) modsText = modsText ~~ " this"
+        withEnclosingDef(constr) { addParamssText(tparamsTxt ~~ modsText, constr.trailingParamss) }
+      }
+    val parentsText = Text(impl.parents.map(constrText), if (ofNew) keywordStr(" with ") else ", ")
+    val derivedText = Text(impl.derived.map(toText(_)), ", ")
+    val selfText = {
+      val selfName = if (self.name == nme.WILDCARD) keywordStr("this") else self.name.toString
+      (selfName ~ optText(self.tpt)(": " ~ _) ~ " =>").close
+    }.provided(!self.isEmpty)
+    val body = if (ctx.settings.YtestPickler.value) {
+      // Pickling/unpickling reorders the body members, so we need to homogenize
+      val (params, rest) = impl.body partition {
+        case stat: TypeDef => stat.symbol.is(Param)
+        case stat: ValOrDefDef =>
+          stat.symbol.is(ParamAccessor) && !stat.symbol.isSetter
+        case _ => false
+      }
+      params ::: rest
+    }
+    else impl.body
+
+    val bodyText = inContextBracket(
+      " {" ~~ selfText ~ toTextGlobal(primaryConstrs ::: body, "\n") ~ "}")
+
+    prefix ~
+    keywordText(" extends").provided(!ofNew && impl.parents.nonEmpty) ~~ parentsText ~
+    keywordText(" derives").provided(impl.derived.nonEmpty) ~~ derivedText ~
+    bodyText
+  }
+
+  protected def templateText(tree: TypeDef, impl: Template): Text = {
+    val kw = if tree.mods.is(Trait) then "trait" else "class"
+    val decl = modText(tree.mods, tree.symbol, keywordStr(kw), isType = true)
+    ( decl ~~ typeText(nameIdText(tree)) ~ withEnclosingDef(tree) { toTextTemplate(impl) }
+    // ~ (if (tree.hasType && printDebug) i"[decls = ${tree.symbol.info.decls}]" else "") // uncomment to enable
+    )
+  }
+
+  protected def toTextPackageId[T >: Untyped](pid: Tree[T]): Text =
+    if (homogenizedView && pid.hasType) toTextLocal(pid.tpe.asInstanceOf[Showable])
+    else toTextLocal(pid)
+
+  protected def packageDefText(tree: PackageDef): Text = {
+    val statsText = tree.stats match {
+      case (pdef: PackageDef) :: Nil => toText(pdef)
+      case _ => inContextBracket(toTextGlobal(tree.stats, "\n"))
+    }
+    val bodyText =
+      if (currentPrecedence == TopLevelPrec) "\n" ~ statsText else " {" ~ statsText ~ "}"
+    keywordStr("package ") ~ toTextPackageId(tree.pid) ~ bodyText
+  }
+
+  /** Textual representation of an instance creation expression without the leading `new` */
+  protected def constrText(tree: untpd.Tree): Text = toTextLocal(tree).stripPrefix(keywordStr("new ")) // DD
+
+  protected def annotText(sym: Symbol, tree: untpd.Tree): Text =
+    def recur(t: untpd.Tree): Text = t match
+      case Apply(fn, Nil) => recur(fn)
+      case Apply(fn, args) =>
+        val explicitArgs = args.filterNot(_.symbol.name.is(DefaultGetterName))
+        recur(fn) ~ "(" ~ toTextGlobal(explicitArgs, ", ") ~ ")"
+      case TypeApply(fn, args) => recur(fn) ~ "[" ~ toTextGlobal(args, ", ") ~ "]"
+      case Select(qual, nme.CONSTRUCTOR) => recur(qual)
+      case New(tpt) => recur(tpt)
+      case _ =>
+        val annotSym = sym.orElse(tree.symbol.enclosingClass)
+        s"@${if annotSym.exists then annotSym.name.toString else t.show}"
+    recur(tree)
+
+  protected def modText(mods: untpd.Modifiers, sym: Symbol, kw: String, isType: Boolean): Text = { // DD
+    val suppressKw = if (enclDefIsClass) mods.isAllOf(LocalParam) else mods.is(Param)
+    var flagMask =
+      if (ctx.settings.YdebugFlags.value) AnyFlags
+      else if (suppressKw) PrintableFlags(isType) &~ Private
+      else PrintableFlags(isType)
+    if (homogenizedView && mods.flags.isTypeFlags) flagMask &~= GivenOrImplicit // drop implicit/given from classes
+    val rawFlags = if (sym.exists) sym.flagsUNSAFE else mods.flags
+    if (rawFlags.is(Param)) flagMask = flagMask &~ Given &~ Erased
+    val flags = rawFlags & flagMask
+    var flagsText = toTextFlags(sym, flags)
+    val annotTexts =
+      if sym.exists then
+        sym.annotationsUNSAFE.filterNot(ann => dropAnnotForModText(ann.symbol)).map(toText)
+      else
+        mods.annotations.filterNot(tree => dropAnnotForModText(tree.symbol)).map(annotText(NoSymbol, _))
+    Text(annotTexts, " ") ~~ flagsText ~~ (Str(kw) provided !suppressKw)
+  }
+
+  override def annotText(annot: Annotation): Text = annotText(annot.symbol, annot.tree)
+
+  def optText(name: Name)(encl: Text => Text): Text =
+    if (name.isEmpty) "" else encl(toText(name))
+
+  def optText[T >: Untyped](tree: Tree[T])(encl: Text => Text): Text =
+    if (tree.isEmpty) "" else encl(toText(tree))
+
+  def optText[T >: Untyped](tree: List[Tree[T]])(encl: Text => Text): Text =
+    if (tree.exists(!_.isEmpty)) encl(blockText(tree)) else ""
+
+  override protected def treatAsTypeParam(sym: Symbol): Boolean = sym.is(TypeParam)
+
+  override protected def treatAsTypeArg(sym: Symbol): Boolean =
+    sym.isType && (sym.isAllOf(ProtectedLocal)) &&
+      (sym.allOverriddenSymbols exists (_.is(TypeParam)))
+
+  override def toText(sym: Symbol): Text = {
+    if (sym.isImport)
+      sym.infoOrCompleter match {
+        case info: Namer#Completer => return info.original.show
+        case info: ImportType => return s"import $info.expr.show"
+        case _ =>
+      }
+    def name =
+      if (printDebug)
+        nameString(sym)
+      else if sym.is(Package) then
+        fullNameString(sym)
+      else if (sym.is(ModuleClass) && sym.isPackageObject && sym.name.stripModuleClassSuffix == tpnme.PACKAGE)
+        nameString(sym.owner.name)
+      else if (sym.is(ModuleClass))
+        nameString(sym.name.stripModuleClassSuffix) + idString(sym)
+      else if (hasMeaninglessName(sym))
+        simpleNameString(sym.owner) + idString(sym)
+      else
+        nameString(sym)
+    (keywordText(kindString(sym)) ~~ {
+      if (sym.isAnonymousClass)
+        toTextParents(sym.info.parents) ~~ "{...}"
+      else
+        typeText(name)
+    }).close
+  }
+
+  /** String representation of symbol's kind. */
+  override def kindString(sym: Symbol): String = {
+    val flags = sym.flagsUNSAFE
+    if (flags.is(Package)) "package"
+    else if (sym.isPackageObject) "package object"
+    else if (flags.is(Module)) "object"
+    else if (sym.isClassConstructor) "constructor"
+    else super.kindString(sym)
+  }
+
+  /** String representation of symbol's definition keyword */
+  override protected def keyString(sym: Symbol): String = {
+    val flags = sym.flagsUNSAFE
+    if (sym.isType && sym.owner.isTerm) ""
+    else if (sym.isPackageObject) "package object"
+    else if (flags.is(Module) && flags.is(Case)) "case object"
+    else if (sym.isClass && flags.is(Case)) "case class"
+    else super.keyString(sym)
+  }
+
+  override def toTextFlags(sym: Symbol): Text =
+    if (ctx.settings.YdebugFlags.value)
+      super.toTextFlags(sym)
+    else {
+      var flags = sym.flagsUNSAFE
+      if (flags.is(TypeParam)) flags = flags &~ Protected
+      toTextFlags(sym, flags & PrintableFlags(sym.isType))
+    }
+
+  override def toText(denot: Denotation): Text = denot match {
+    case denot: MultiDenotation => Text(denot.alternatives.map(dclText), " <and> ")
+    case NoDenotation => "NoDenotation"
+    case _ =>
+      if (denot.symbol.exists) toText(denot.symbol)
+      else "some " ~ toText(denot.info)
+  }
+
+  override def plain: PlainPrinter = new PlainPrinter(_ctx)
+
+  private def withPos(txt: Text, pos: SourcePosition): Text =
+    if (!printLines || !pos.exists) txt
+    else txt match {
+      case Str(s, _) => Str(s, LineRange(pos.line, pos.endLine))
+      case _ => txt
+    }
+}
diff --git a/tests/pos-with-compiler-cc/dotc/printing/ReplPrinter.scala b/tests/pos-with-compiler-cc/dotc/printing/ReplPrinter.scala
new file mode 100644
index 000000000000..ea3afef27fae
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/printing/ReplPrinter.scala
@@ -0,0 +1,61 @@
+package dotty.tools.dotc.printing
+
+import dotty.tools.dotc.core.Constants
+import dotty.tools.dotc.core.Constants.Constant
+import dotty.tools.dotc.core.Contexts._
+import dotty.tools.dotc.core.Flags._
+import dotty.tools.dotc.core.NameOps._
+import dotty.tools.dotc.core.Names.Name
+import dotty.tools.dotc.core.Symbols._
+import dotty.tools.dotc.core.Types._
+import dotty.tools.dotc.printing.Texts._
+
+
+class ReplPrinter(_ctx: Context) extends RefinedPrinter(_ctx) {
+
+  val debugPrint = _ctx.settings.YprintDebug.value
+
+  override def nameString(name: Name): String =
+    if (name.isReplAssignName) name.decode.toString.takeWhile(_ != '$')
+    else super.nameString(name)
+
+  override def toText(sym: Symbol): Text =
+    if (sym.name.isReplAssignName) nameString(sym.name)
+    else if (debugPrint) super.toText(sym)
+    else keyString(sym) ~~ nameString(sym.name.stripModuleClassSuffix)
+
+  inline private val qSc = '"';
+
+  override def toText(const: Constant): Text =
+    if (debugPrint) super.toText(const)
+    else if (const.tag == Constants.StringTag) Str(s"${qSc}${const.value}$qSc")
+    else Str(const.value.toString)
+
+  override def dclText(sym: Symbol): Text = if (debugPrint) super.dclText(sym) else
+    ("lazy": Text).provided(sym.is(Lazy)) ~~
+    toText(sym) ~ {
+      if (sym.is(Method)) {
+        sym.info match {
+          case tp: ExprType => ":" ~~ toText(tp.resType)
+          case info => toText(info)
+        }
+      }
+      else if (sym.isType && sym.info.isTypeAlias) toText(sym.info)
+      else if (sym.isType || sym.isClass) ""
+      else ":" ~~ toText(sym.info)
+    }
+
+  override def toTextSingleton(tp: SingletonType): Text =
+    if (debugPrint)
+      super.toTextSingleton(tp)
+    else
+      tp match {
+        case ConstantType(const) => toText(const)
+        case _                   => toTextRef(tp) ~ ".type"
+      }
+
+  // We don't want the colors coming from RefinedPrinter as the REPL uses its
+  // own syntax coloring mechanism.
+  override def coloredStr(text: String, color: String): String = text
+  override def coloredText(text: Text, color: String): Text = text
+}
diff --git a/tests/pos-with-compiler-cc/dotc/printing/Showable.scala b/tests/pos-with-compiler-cc/dotc/printing/Showable.scala
new file mode 100644
index 000000000000..4a0e68861a1a
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/printing/Showable.scala
@@ -0,0 +1,36 @@
+package dotty.tools.dotc
+package printing
+
+import core._
+
+import Contexts._, Texts._, Decorators._
+import config.Config.summarizeDepth
+
+trait Showable extends Any {
+
+  /** The text representation of this showable element.
+   *  This normally dispatches to a pattern matching
+   *  method in Printers.
+   */
+  def toText(printer: Printer): Text
+
+  /** A fallback text representation, if the pattern matching
+   *  in Printers does not have a case for this showable element
+   */
+  def fallbackToText(printer: Printer): Text = toString
+
+  /** The string representation of this showable element. */
+  def show(using Context): String = toText(ctx.printer).show
+
+  /** The string representation with each line after the first one indented
+   *  by the given given margin (in spaces).
+   */
+  def showIndented(margin: Int)(using Context): String = show.replace("\n", "\n" + " " * margin).nn
+
+  /** The summarized string representation of this showable element.
+   *  Recursion depth is limited to some smallish value. Default is
+   *  Config.summarizeDepth.
+   */
+  def showSummary(depth: Int = summarizeDepth)(using Context): String =
+    show(using ctx.fresh.setProperty(MessageLimiter, SummarizeMessageLimiter(depth)))
+}
diff --git a/tests/pos-with-compiler-cc/dotc/printing/SyntaxHighlighting.scala b/tests/pos-with-compiler-cc/dotc/printing/SyntaxHighlighting.scala
new file mode 100644
index 000000000000..53e6b9472f5e
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/printing/SyntaxHighlighting.scala
@@ -0,0 +1,147 @@
+package dotty.tools.dotc
+package printing
+
+import scala.language.unsafeNulls
+
+import dotty.tools.dotc.ast.untpd
+import dotty.tools.dotc.core.Contexts._
+import dotty.tools.dotc.core.StdNames._
+import dotty.tools.dotc.parsing.Parsers.Parser
+import dotty.tools.dotc.parsing.Scanners.Scanner
+import dotty.tools.dotc.parsing.Tokens._
+import dotty.tools.dotc.reporting.Reporter
+import dotty.tools.dotc.util.Spans.Span
+import dotty.tools.dotc.util.SourceFile
+
+import java.util.Arrays
+
+/** This object provides functions for syntax highlighting in the REPL */
+object SyntaxHighlighting {
+
+  /** if true, log erroneous positions being highlighted */
+  private inline val debug = true
+
+  // Keep in sync with SyntaxHighlightingTests
+  val NoColor: String         = Console.RESET
+  val CommentColor: String    = Console.BLUE
+  val KeywordColor: String    = Console.YELLOW
+  val ValDefColor: String     = Console.CYAN
+  val LiteralColor: String    = Console.RED
+  val StringColor: String     = Console.GREEN
+  val TypeColor: String       = Console.MAGENTA
+  val AnnotationColor: String = Console.MAGENTA
+
+  def highlight(in: String)(using Context): String = {
+    def freshCtx = ctx.fresh.setReporter(Reporter.NoReporter)
+    if (in.isEmpty || ctx.settings.color.value == "never") in
+    else {
+      val source = SourceFile.virtual("<highlighting>", in)
+
+      given Context = freshCtx
+        .setCompilationUnit(CompilationUnit(source, mustExist = false)(using freshCtx))
+
+      val colorAt = Array.fill(in.length)(NoColor)
+
+      def highlightRange(from: Int, to: Int, color: String) =
+        Arrays.fill(colorAt.asInstanceOf[Array[AnyRef]], from, to, color)
+
+      def highlightPosition(span: Span, color: String) = if (span.exists)
+        if (span.start < 0 || span.end > in.length) {
+          if (debug)
+            println(s"Trying to highlight erroneous position $span. Input size: ${in.length}")
+        }
+        else
+          highlightRange(span.start, span.end, color)
+
+      val scanner = new Scanner(source)
+      while (scanner.token != EOF) {
+        val start = scanner.offset
+        val token = scanner.token
+        val name = scanner.name
+        val isSoftModifier = scanner.isSoftModifierInModifierPosition
+        scanner.nextToken()
+        val end = scanner.lastOffset
+
+        // Branch order is important. For example,
+        // `true` is at the same time a keyword and a literal
+        token match {
+          case _ if literalTokens.contains(token) =>
+            highlightRange(start, end, LiteralColor)
+
+          case STRINGPART =>
+            // String interpolation parts include `$` but
+            // we don't highlight it, hence the `-1`
+            highlightRange(start, end - 1, LiteralColor)
+
+          case _ if alphaKeywords.contains(token) || isSoftModifier =>
+            highlightRange(start, end, KeywordColor)
+
+          case IDENTIFIER if name == nme.??? =>
+            highlightRange(start, end, Console.RED_B)
+
+          case _ =>
+        }
+      }
+
+      for (span <- scanner.commentSpans)
+        highlightPosition(span, CommentColor)
+
+      object TreeHighlighter extends untpd.UntypedTreeTraverser {
+        import untpd._
+
+        def ignored(tree: NameTree) = {
+          val name = tree.name.toTermName
+          // trees named <error> and <init> have weird positions
+          name == nme.ERROR || name == nme.CONSTRUCTOR
+        }
+
+        def highlightAnnotations(tree: MemberDef): Unit =
+          for (annotation <- tree.rawMods.annotations)
+            highlightPosition(annotation.span, AnnotationColor)
+
+        def highlight(trees: List[Tree])(using Context): Unit =
+          trees.foreach(traverse)
+
+        def traverse(tree: Tree)(using Context): Unit = {
+          tree match {
+            case tree: NameTree if ignored(tree) =>
+              ()
+            case tree: ValOrDefDef =>
+              highlightAnnotations(tree)
+              highlightPosition(tree.nameSpan, ValDefColor)
+              highlightPosition(tree.endSpan, ValDefColor)
+            case tree: MemberDef /* ModuleDef | TypeDef */ =>
+              highlightAnnotations(tree)
+              highlightPosition(tree.nameSpan, TypeColor)
+              highlightPosition(tree.endSpan, TypeColor)
+            case tree: Ident if tree.isType =>
+              highlightPosition(tree.span, TypeColor)
+            case _: TypeTree =>
+              highlightPosition(tree.span, TypeColor)
+            case _ =>
+          }
+          traverseChildren(tree)
+        }
+      }
+
+      val parser = new Parser(source)
+      val trees = parser.blockStatSeq()
+      TreeHighlighter.highlight(trees)
+
+      val highlighted = new StringBuilder()
+
+      for (idx <- colorAt.indices) {
+        val prev = if (idx == 0) NoColor else colorAt(idx - 1)
+        val curr = colorAt(idx)
+        if (curr != prev)
+          highlighted.append(curr)
+        highlighted.append(in(idx))
+      }
+
+      if (colorAt.last != NoColor)
+        highlighted.append(NoColor)
+
+      highlighted.toString
+    }
+  }
+}
diff --git a/tests/pos-with-compiler-cc/dotc/printing/Texts.scala b/tests/pos-with-compiler-cc/dotc/printing/Texts.scala
new file mode 100644
index 000000000000..17f86e766869
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/printing/Texts.scala
@@ -0,0 +1,198 @@
+package dotty.tools.dotc
+package printing
+
+object Texts {
+
+  sealed abstract class Text {
+
+    protected def indentMargin: Int = 2
+
+    def relems: List[Text]
+
+    def isEmpty: Boolean = this match {
+      case Str(s, _) => s.isEmpty
+      case Fluid(relems) => relems forall (_.isEmpty)
+      case Vertical(relems) => relems.isEmpty
+    }
+
+    def isVertical: Boolean = isInstanceOf[Vertical]
+    def isClosed: Boolean = isVertical || isInstanceOf[Closed]
+    def isFluid: Boolean = isInstanceOf[Fluid]
+    def isSplittable: Boolean = isFluid && !isClosed
+
+    def close: Closed = new Closed(relems)
+
+    def remaining(width: Int): Int = this match {
+      case Str(s, _) =>
+        width - lengthWithoutAnsi(s)
+      case Fluid(Nil) =>
+        width
+      case Fluid(last :: prevs) =>
+        val r = last remaining width
+        if (r < 0) r else Fluid(prevs) remaining r
+      case Vertical(_) =>
+        -1
+    }
+
+    def lastLine: String = this match {
+      case Str(s, _) => s
+      case _ => relems.head.lastLine
+    }
+
+    def appendToLastLine(that: Text): Text = that match {
+      case Str(s2, lines1) =>
+        this match {
+          case Str(s1, lines2) => Str(s1 + s2, lines1 union lines2)
+          case Fluid(Str(s1, lines2) :: prev) => Fluid(Str(s1 + s2, lines1 union lines2) :: prev)
+          case Fluid(relems) => Fluid(that :: relems)
+          case Vertical(_) => throw new IllegalArgumentException("Unexpected Vertical.appendToLastLine")
+        }
+      case Fluid(relems) =>
+        relems.reverse.foldLeft(this)(_ appendToLastLine _)
+      case Vertical(_) => throw new IllegalArgumentException("Unexpected Text.appendToLastLine(Vertical(...))")
+    }
+
+    private def appendIndented(that: Text)(width: Int): Text =
+      Vertical(that.layout(width - indentMargin).indented :: this.relems)
+
+    private def append(width: Int)(that: Text): Text =
+      if (this.isEmpty) that.layout(width)
+      else if (that.isEmpty) this
+      else if (that.isVertical) appendIndented(that)(width)
+      else if (this.isVertical) Fluid(that.layout(width) :: this.relems)
+      else if (that.remaining(width - lengthWithoutAnsi(lastLine)) >= 0) appendToLastLine(that)
+      else if (that.isSplittable) that.relems.reverse.foldLeft(this)(_.append(width)(_))
+      else appendIndented(that)(width)
+
+    private def lengthWithoutAnsi(str: String): Int =
+      str.replaceAll("\u001b\\[\\d+m", "").nn.length
+
+    def layout(width: Int): Text = this match {
+      case Str(s, _) =>
+        this
+      case Fluid(relems) =>
+        relems.reverse.foldLeft(Str(""): Text)(_.append(width)(_))
+      case Vertical(relems) =>
+        Vertical(relems map (_ layout width))
+    }
+
+    def map(f: String => String): Text = this match {
+      case Str(s, lines) => Str(f(s), lines)
+      case Fluid(relems) => Fluid(relems map (_ map f))
+      case Vertical(relems) => Vertical(relems map (_ map f))
+    }
+
+    def stripPrefix(pre: String): Text = this match {
+      case Str(s, _) =>
+        if (s.startsWith(pre)) s drop pre.length else s
+      case Fluid(relems) =>
+        val elems = relems.reverse
+        val head = elems.head.stripPrefix(pre)
+        if (head eq elems.head) this else Fluid((head :: elems.tail).reverse)
+      case Vertical(relems) =>
+        val elems = relems.reverse
+        val head = elems.head.stripPrefix(pre)
+        if (head eq elems.head) this else Vertical((head :: elems.tail).reverse)
+    }
+
+    private def indented: Text = this match {
+      case Str(s, lines) => Str((" " * indentMargin) + s, lines)
+      case Fluid(relems) => Fluid(relems map (_.indented))
+      case Vertical(relems) => Vertical(relems map (_.indented))
+    }
+
+    def print(sb: StringBuilder, numberWidth: Int): Unit = this match {
+      case Str(s, lines) =>
+        if (numberWidth != 0) {
+          val ln = lines.show
+          if (ln.nonEmpty) {
+            val pad = (numberWidth - ln.length - 1)
+            assert(pad >= 0)
+            sb.append(" " * pad)
+            sb.append(ln)
+            sb.append("|")
+          }
+        }
+        sb.append(s)
+      case _ =>
+        var follow = false
+        for (elem <- relems.reverse) {
+          if (follow) sb.append(System.lineSeparator)
+          elem.print(sb, numberWidth)
+          follow = true
+        }
+    }
+
+    def maxLine: Int = this match {
+      case Str(_, lines) => lines.end
+      case _ => relems.foldLeft(-1)((acc, relem) => acc max relem.maxLine)
+    }
+
+    def mkString(width: Int, withLineNumbers: Boolean): String = {
+      val sb = new StringBuilder
+      val numberWidth = if (withLineNumbers) (2 * maxLine.toString.length) + 2 else 0
+      layout(width - numberWidth).print(sb, numberWidth)
+      sb.toString
+    }
+
+    def ~ (that: Text): Text =
+      if (this.isEmpty) that
+      else if (that.isEmpty) this
+      else Fluid(that :: this :: Nil)
+
+    def ~~ (that: Text): Text =
+      if (this.isEmpty) that
+      else if (that.isEmpty) this
+      else Fluid(that :: Str(" ") :: this :: Nil)
+
+    def over (that: Text): Vertical =
+      if (this.isVertical) Vertical(that :: this.relems)
+      else Vertical(that :: this :: Nil)
+  }
+
+  object Text {
+
+    /** The empty text */
+    def apply(): Text = Str("")
+
+    /** A concatenation of elements in `xs` and interspersed with
+     *  separator strings `sep`.
+     */
+    def apply(xs: Traversable[Text], sep: String = " "): Text =
+      if (sep == "\n") lines(xs)
+      else {
+        val ys = xs filterNot (_.isEmpty)
+        if (ys.isEmpty) Str("")
+        else ys reduce (_ ~ sep ~ _)
+      }
+
+    /** The given texts `xs`, each on a separate line */
+    def lines(xs: Traversable[Text]): Vertical = Vertical(xs.toList.reverse)
+
+    extension (text: => Text)
+      def provided(cond: Boolean): Text = if (cond) text else Str("")
+
+  }
+
+  case class Str(s: String, lineRange: LineRange = EmptyLineRange) extends Text {
+    override def relems: List[Text] = List(this)
+  }
+
+  case class Vertical(relems: List[Text]) extends Text
+  case class Fluid(relems: List[Text]) extends Text
+
+  class Closed(relems: List[Text]) extends Fluid(relems)
+
+  implicit def stringToText(s: String): Text = Str(s)
+
+  /** Inclusive line range */
+  case class LineRange(start: Int, end: Int) {
+    def union(that: LineRange): LineRange = LineRange(start min that.start, end max that.end)
+    def show: String =
+      if (start == end) (start + 1).toString
+      else if (start < end) s"${start + 1}-${end + 1}"
+      else "" // empty range
+  }
+
+  object EmptyLineRange extends LineRange(Int.MaxValue, Int.MinValue)
+}
diff --git a/tests/pos-with-compiler-cc/dotc/printing/package.scala b/tests/pos-with-compiler-cc/dotc/printing/package.scala
new file mode 100644
index 000000000000..b1d091ca45c1
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/printing/package.scala
@@ -0,0 +1,29 @@
+package dotty.tools.dotc
+
+import core.StdNames.{nme,tpnme}
+import util.Property.Key
+
+package object printing {
+
+  type Precedence = Int
+
+  val DotPrec: Int       = parsing.maxPrec
+  val AndTypePrec: Int   = parsing.precedence(tpnme.raw.AMP)
+  val OrTypePrec: Int    = parsing.precedence(tpnme.raw.BAR)
+  val OrPrec: Int        = parsing.precedence(nme.raw.BAR)
+  val InfixPrec: Int     = parsing.minInfixPrec
+  val GlobalPrec: Int    = parsing.minPrec
+  val TopLevelPrec: Int  = parsing.minPrec - 1
+
+  /** A property to indicate whether the compiler is currently doing -Xprint
+   *
+   *  -Xprint will print `sym.name` instead of `sym.originalName`
+   */
+  val XprintMode: Key[Unit] = new Key
+
+  /** @pre `nel` is non-empty list */
+  extension [A](nel: List[A])
+    private[printing] def intersperse(a: A): List[A] =
+      nel.flatMap(a :: _ :: Nil).tail
+
+}
diff --git a/tests/pos-with-compiler-cc/dotc/profile/AsyncHelper.scala b/tests/pos-with-compiler-cc/dotc/profile/AsyncHelper.scala
new file mode 100644
index 000000000000..2c4537b238a5
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/profile/AsyncHelper.scala
@@ -0,0 +1,142 @@
+package dotty.tools.dotc.profile
+
+import scala.language.unsafeNulls
+
+import java.util.concurrent.ThreadPoolExecutor.AbortPolicy
+import java.util.concurrent._
+import java.util.concurrent.atomic.AtomicInteger
+
+import dotty.tools.dotc.core.Phases.Phase
+import dotty.tools.dotc.core.Contexts._
+
+sealed trait AsyncHelper {
+
+  def newUnboundedQueueFixedThreadPool
+  (nThreads: Int,
+   shortId: String, priority : Int = Thread.NORM_PRIORITY) : ThreadPoolExecutor
+  def newBoundedQueueFixedThreadPool
+  (nThreads: Int, maxQueueSize: Int, rejectHandler: RejectedExecutionHandler,
+   shortId: String, priority : Int = Thread.NORM_PRIORITY) : ThreadPoolExecutor
+}
+
+
+object AsyncHelper {
+  def apply(phase: Phase)(using Context): AsyncHelper = ctx.profiler match {
+    case NoOpProfiler => new BasicAsyncHelper(phase)
+    case r: RealProfiler => new ProfilingAsyncHelper(phase, r)
+  }
+
+  private abstract class BaseAsyncHelper(phase: Phase)(using Context) extends AsyncHelper {
+    val baseGroup = new ThreadGroup(s"dotc-${phase.phaseName}")
+    private def childGroup(name: String) = new ThreadGroup(baseGroup, name)
+
+    protected def wrapRunnable(r: Runnable, shortId:String): Runnable
+
+    protected class CommonThreadFactory(shortId: String,
+                                        daemon: Boolean = true,
+                                        priority: Int) extends ThreadFactory {
+      private val group: ThreadGroup = childGroup(shortId)
+      private val threadNumber: AtomicInteger = new AtomicInteger(1)
+      private val namePrefix = s"${baseGroup.getName}-$shortId-"
+
+      override def newThread(r: Runnable): Thread = {
+        val wrapped = wrapRunnable(r, shortId)
+        val t: Thread = new Thread(group, wrapped, namePrefix + threadNumber.getAndIncrement, 0)
+        if (t.isDaemon != daemon) t.setDaemon(daemon)
+        if (t.getPriority != priority) t.setPriority(priority)
+        t
+      }
+    }
+  }
+
+  private final class BasicAsyncHelper(phase: Phase)(using Context) extends BaseAsyncHelper(phase) {
+
+    override def newUnboundedQueueFixedThreadPool(nThreads: Int, shortId: String, priority: Int): ThreadPoolExecutor = {
+      val threadFactory = new CommonThreadFactory(shortId, priority = priority)
+      //like Executors.newFixedThreadPool
+      new ThreadPoolExecutor(nThreads, nThreads, 0L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue[Runnable], threadFactory)
+    }
+
+    override def newBoundedQueueFixedThreadPool(nThreads: Int, maxQueueSize: Int, rejectHandler: RejectedExecutionHandler, shortId: String, priority: Int): ThreadPoolExecutor = {
+      val threadFactory = new CommonThreadFactory(shortId, priority = priority)
+      //like Executors.newFixedThreadPool
+      new ThreadPoolExecutor(nThreads, nThreads, 0L, TimeUnit.MILLISECONDS, new ArrayBlockingQueue[Runnable](maxQueueSize), threadFactory, rejectHandler)
+    }
+
+    override protected def wrapRunnable(r: Runnable, shortId:String): Runnable = r
+  }
+
+  private class ProfilingAsyncHelper(phase: Phase, private val profiler: RealProfiler)(using Context) extends BaseAsyncHelper(phase) {
+
+    override def newUnboundedQueueFixedThreadPool(nThreads: Int, shortId: String, priority: Int): ThreadPoolExecutor = {
+      val threadFactory = new CommonThreadFactory(shortId, priority = priority)
+      //like Executors.newFixedThreadPool
+      new SinglePhaseInstrumentedThreadPoolExecutor(nThreads, nThreads, 0L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue[Runnable], threadFactory, new AbortPolicy)
+    }
+
+    override def newBoundedQueueFixedThreadPool(nThreads: Int, maxQueueSize: Int, rejectHandler: RejectedExecutionHandler, shortId: String, priority: Int): ThreadPoolExecutor = {
+      val threadFactory = new CommonThreadFactory(shortId, priority = priority)
+      //like Executors.newFixedThreadPool
+      new SinglePhaseInstrumentedThreadPoolExecutor(nThreads, nThreads, 0L, TimeUnit.MILLISECONDS, new ArrayBlockingQueue[Runnable](maxQueueSize), threadFactory, rejectHandler)
+    }
+
+    override protected def wrapRunnable(r: Runnable, shortId:String): Runnable = {
+      () =>
+      val data = new ThreadProfileData
+      localData.set(data)
+
+      val profileStart = profiler.snapThread(0)
+      try r.run finally {
+        val snap = profiler.snapThread(data.idleNs)
+        val threadRange = ProfileRange(profileStart, snap, phase, shortId, data.taskCount, Thread.currentThread())
+        profiler.completeBackground(threadRange)
+      }
+    }
+
+    /**
+     * data for thread run. Not threadsafe, only written from a single thread
+     */
+    final class ThreadProfileData {
+      var firstStartNs = 0L
+      var taskCount = 0
+
+      var idleNs = 0L
+      var runningNs = 0L
+
+      var lastStartNs = 0L
+      var lastEndNs = 0L
+    }
+
+    val localData: ThreadLocal[ThreadProfileData] = new ThreadLocal[ThreadProfileData]
+
+    private class SinglePhaseInstrumentedThreadPoolExecutor
+    (   corePoolSize: Int, maximumPoolSize: Int, keepAliveTime: Long, unit: TimeUnit,
+        workQueue: BlockingQueue[Runnable], threadFactory: ThreadFactory, handler: RejectedExecutionHandler
+    ) extends ThreadPoolExecutor(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue, threadFactory, handler) {
+
+      override def beforeExecute(t: Thread, r: Runnable): Unit = {
+        val data = localData.get
+        data.taskCount += 1
+        val now = System.nanoTime()
+
+        if (data.firstStartNs == 0) data.firstStartNs = now
+        else data.idleNs += now - data.lastEndNs
+
+        data.lastStartNs = now
+
+        super.beforeExecute(t, r)
+      }
+
+      override def afterExecute(r: Runnable, t: Throwable): Unit = {
+        val now = System.nanoTime()
+        val data = localData.get
+
+        data.lastEndNs = now
+        data.runningNs += now - data.lastStartNs
+
+        super.afterExecute(r, t)
+      }
+    }
+  }
+}
+
diff --git a/tests/pos-with-compiler-cc/dotc/profile/ExtendedThreadMxBean.java b/tests/pos-with-compiler-cc/dotc/profile/ExtendedThreadMxBean.java
new file mode 100644
index 000000000000..68ae4f148cfd
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/profile/ExtendedThreadMxBean.java
@@ -0,0 +1,304 @@
+package dotty.tools.dotc.profile;
+
+import javax.management.ObjectName;
+import java.lang.management.ThreadInfo;
+import java.lang.management.ThreadMXBean;
+import java.lang.management.ManagementFactory;
+import java.lang.reflect.Method;
+
+@SuppressWarnings("unused")
+public abstract class ExtendedThreadMxBean implements ThreadMXBean {
+    static final ExtendedThreadMxBean proxy;
+
+    static {
+        ExtendedThreadMxBean local;
+        ThreadMXBean threadMx = ManagementFactory.getThreadMXBean();
+        try {
+            Class cls = Class.forName("com.sun.management.ThreadMXBean");
+            if (cls.isInstance(threadMx)) {
+                local = new SunThreadMxBean(threadMx);
+            } else {
+                local = new OtherThreadMxBean(threadMx);
+            }
+        } catch (ClassNotFoundException e) {
+            local = new OtherThreadMxBean(threadMx);
+        }
+        proxy = local;
+    }
+
+    protected final ThreadMXBean underlying;
+
+    protected ExtendedThreadMxBean(ThreadMXBean underlying) {
+        this.underlying = underlying;
+    }
+
+    public abstract long[] getThreadUserTime(long[] longs) throws Exception;
+
+    public abstract boolean isThreadAllocatedMemoryEnabled() throws Exception;
+
+    public abstract void setThreadAllocatedMemoryEnabled(boolean b) throws Exception;
+
+    public abstract long getThreadAllocatedBytes(long l) throws Exception;
+
+    public abstract long[] getThreadAllocatedBytes(long[] longs) throws Exception;
+
+    public abstract boolean isThreadAllocatedMemorySupported() throws Exception;
+
+    public abstract long[] getThreadCpuTime(long[] longs) throws Exception;
+    //common features from java.lang.management.ThreadMXBean
+
+    @Override
+    public int getThreadCount() {
+        return underlying.getThreadCount();
+    }
+
+    @Override
+    public int getPeakThreadCount() {
+        return underlying.getPeakThreadCount();
+    }
+
+    @Override
+    public long getTotalStartedThreadCount() {
+        return underlying.getTotalStartedThreadCount();
+    }
+
+    @Override
+    public int getDaemonThreadCount() {
+        return underlying.getDaemonThreadCount();
+    }
+
+    @Override
+    public long[] getAllThreadIds() {
+        return underlying.getAllThreadIds();
+    }
+
+    @Override
+    public ThreadInfo getThreadInfo(long id) {
+        return underlying.getThreadInfo(id);
+    }
+
+    @Override
+    public ThreadInfo[] getThreadInfo(long[] ids) {
+        return underlying.getThreadInfo(ids);
+    }
+
+    @Override
+    public ThreadInfo getThreadInfo(long id, int maxDepth) {
+        return underlying.getThreadInfo(id, maxDepth);
+    }
+
+    @Override
+    public ThreadInfo[] getThreadInfo(long[] ids, int maxDepth) {
+        return underlying.getThreadInfo(ids, maxDepth);
+    }
+
+    @Override
+    public boolean isThreadContentionMonitoringSupported() {
+        return underlying.isThreadContentionMonitoringSupported();
+    }
+
+    @Override
+    public boolean isThreadContentionMonitoringEnabled() {
+        return underlying.isThreadContentionMonitoringEnabled();
+    }
+
+    @Override
+    public void setThreadContentionMonitoringEnabled(boolean enable) {
+        underlying.setThreadContentionMonitoringEnabled(enable);
+    }
+
+    @Override
+    public long getCurrentThreadCpuTime() {
+        return underlying.getCurrentThreadCpuTime();
+    }
+
+    @Override
+    public long getCurrentThreadUserTime() {
+        return underlying.getCurrentThreadUserTime();
+    }
+
+    @Override
+    public long getThreadCpuTime(long id) {
+        return underlying.getThreadCpuTime(id);
+    }
+
+    @Override
+    public long getThreadUserTime(long id) {
+        return underlying.getThreadUserTime(id);
+    }
+
+    @Override
+    public boolean isThreadCpuTimeSupported() {
+        return underlying.isThreadCpuTimeSupported();
+    }
+
+    @Override
+    public boolean isCurrentThreadCpuTimeSupported() {
+        return underlying.isCurrentThreadCpuTimeSupported();
+    }
+
+    @Override
+    public boolean isThreadCpuTimeEnabled() {
+        return underlying.isThreadCpuTimeEnabled();
+    }
+
+    @Override
+    public void setThreadCpuTimeEnabled(boolean enable) {
+        underlying.setThreadCpuTimeEnabled(enable);
+    }
+
+    @Override
+    public long[] findMonitorDeadlockedThreads() {
+        return underlying.findMonitorDeadlockedThreads();
+    }
+
+    @Override
+    public void resetPeakThreadCount() {
+        underlying.resetPeakThreadCount();
+    }
+
+    @Override
+    public long[] findDeadlockedThreads() {
+        return underlying.findDeadlockedThreads();
+    }
+
+    @Override
+    public boolean isObjectMonitorUsageSupported() {
+        return underlying.isObjectMonitorUsageSupported();
+    }
+
+    @Override
+    public boolean isSynchronizerUsageSupported() {
+        return underlying.isSynchronizerUsageSupported();
+    }
+
+    @Override
+    public ThreadInfo[] getThreadInfo(long[] ids, boolean lockedMonitors, boolean lockedSynchronizers) {
+        return underlying.getThreadInfo(ids, lockedMonitors, lockedSynchronizers);
+    }
+
+    @Override
+    public ThreadInfo[] dumpAllThreads(boolean lockedMonitors, boolean lockedSynchronizers) {
+        return underlying.dumpAllThreads(lockedMonitors, lockedSynchronizers);
+    }
+
+    @Override
+    public ObjectName getObjectName() {
+        return underlying.getObjectName();
+    }
+}
+
+class OtherThreadMxBean extends ExtendedThreadMxBean {
+    OtherThreadMxBean(ThreadMXBean underlying) {
+        super(underlying);
+    }
+
+    @Override
+    public long[] getThreadUserTime(long[] longs) throws Exception {
+        return new long[0];
+    }
+
+    @Override
+    public boolean isThreadAllocatedMemoryEnabled() throws Exception {
+        return false;
+    }
+
+    @Override
+    public void setThreadAllocatedMemoryEnabled(boolean b) throws Exception {
+
+    }
+
+    @Override
+    public long getThreadAllocatedBytes(long l) throws Exception {
+        return -1;
+    }
+
+    @Override
+    public long[] getThreadAllocatedBytes(long[] longs) throws Exception {
+        return new long[0];
+    }
+
+    @Override
+    public boolean isThreadAllocatedMemorySupported() throws Exception {
+        return false;
+    }
+
+    @Override
+    public long[] getThreadCpuTime(long[] longs) throws Exception {
+        return new long[0];
+    }
+
+}
+
+
+class SunThreadMxBean extends ExtendedThreadMxBean {
+
+    private final ThreadMXBean real;
+
+    private final Method getThreadUserTimeMethod;
+    private final Method isThreadAllocatedMemoryEnabledMethod;
+    private final Method setThreadAllocatedMemoryEnabledMethod;
+    private final Method getThreadAllocatedBytesMethod1;
+    private final Method getThreadAllocatedBytesMethod2;
+    private final Method isThreadAllocatedMemorySupportedMethod;
+    private final Method getThreadCpuTimeMethod;
+
+
+    public SunThreadMxBean(ThreadMXBean underlying) {
+        super(underlying);
+        this.real = underlying;
+        try {
+            getThreadUserTimeMethod = real.getClass().getMethod("getThreadUserTime", long[].class);
+            isThreadAllocatedMemoryEnabledMethod = real.getClass().getMethod("isThreadAllocatedMemoryEnabled");
+            setThreadAllocatedMemoryEnabledMethod = real.getClass().getMethod("setThreadAllocatedMemoryEnabled", Boolean.TYPE);
+            getThreadAllocatedBytesMethod1 = real.getClass().getMethod("getThreadAllocatedBytes", Long.TYPE);
+            getThreadAllocatedBytesMethod2 = real.getClass().getMethod("getThreadAllocatedBytes", long[].class);
+            isThreadAllocatedMemorySupportedMethod = real.getClass().getMethod("isThreadAllocatedMemorySupported");
+            getThreadCpuTimeMethod = real.getClass().getMethod("getThreadCpuTime", long[].class);
+
+            getThreadUserTimeMethod.setAccessible(true);
+            isThreadAllocatedMemoryEnabledMethod.setAccessible(true);
+            setThreadAllocatedMemoryEnabledMethod.setAccessible(true);
+            getThreadAllocatedBytesMethod1.setAccessible(true);
+            getThreadAllocatedBytesMethod2.setAccessible(true);
+            isThreadAllocatedMemorySupportedMethod.setAccessible(true);
+            getThreadCpuTimeMethod.setAccessible(true);
+        } catch (Exception e) {
+            throw new IllegalStateException(e);
+        }
+    }
+
+
+    public boolean isExtended() {
+        return true;
+    }
+
+    public long[] getThreadUserTime(long[] longs) throws Exception {
+        return (long[]) getThreadUserTimeMethod.invoke(real, longs);
+    }
+
+    public boolean isThreadAllocatedMemoryEnabled() throws Exception {
+        return (boolean) isThreadAllocatedMemoryEnabledMethod.invoke(real);
+    }
+
+    public void setThreadAllocatedMemoryEnabled(boolean b) throws Exception {
+        setThreadAllocatedMemoryEnabledMethod.invoke(real, b);
+    }
+
+    public long getThreadAllocatedBytes(long l) throws Exception {
+        return (long) getThreadAllocatedBytesMethod1.invoke(real,l);
+    }
+
+    public long[] getThreadAllocatedBytes(long[] longs) throws Exception {
+        return (long[]) getThreadAllocatedBytesMethod2.invoke(real, longs);
+    }
+
+    public boolean isThreadAllocatedMemorySupported() throws Exception {
+        return (boolean) isThreadAllocatedMemorySupportedMethod.invoke(real);
+    }
+
+    public long[] getThreadCpuTime(long[] longs) throws Exception {
+        return (long[]) getThreadCpuTimeMethod.invoke(real, longs);
+
+    }
+}
diff --git a/tests/pos-with-compiler-cc/dotc/profile/ExternalToolHook.java b/tests/pos-with-compiler-cc/dotc/profile/ExternalToolHook.java
new file mode 100644
index 000000000000..274be637eb8e
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/profile/ExternalToolHook.java
@@ -0,0 +1,17 @@
+package dotty.tools.dotc.profile;
+
+/**
+ * This is an external tool hook, it allows an external tool such as YourKit or JProfiler to instrument a
+ * particular phase of the compiler.
+ * Profilers have hooks to allow starting and stopping profiling on a given method invocation.
+ * To use add -Yprofile-external-tool (defaults to typer) or -Yprofile-external-tool:<phase> (for a specific compiler phase)
+ * to the compiler flags.
+ *
+ * 'before' will be called at the start of the target phase and 'after' at the end, allowing custom profiling to be
+ * triggered.
+ */
+public class ExternalToolHook {
+    private ExternalToolHook() {}
+    public static void before() {}
+    public static void after() {}
+}
diff --git a/tests/pos-with-compiler-cc/dotc/profile/Profiler.scala b/tests/pos-with-compiler-cc/dotc/profile/Profiler.scala
new file mode 100644
index 000000000000..25c53903c10b
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/profile/Profiler.scala
@@ -0,0 +1,264 @@
+package dotty.tools.dotc.profile
+
+import scala.annotation.*
+import scala.language.unsafeNulls
+
+import java.io.{FileWriter, PrintWriter}
+import java.lang.management.{ManagementFactory, GarbageCollectorMXBean, RuntimeMXBean, MemoryMXBean, ClassLoadingMXBean, CompilationMXBean}
+import java.util.concurrent.TimeUnit
+import java.util.concurrent.atomic.AtomicInteger
+import javax.management.openmbean.CompositeData
+import javax.management.{Notification, NotificationEmitter, NotificationListener}
+
+import dotty.tools.dotc.core.Phases.Phase
+import dotty.tools.dotc.core.Contexts._
+import dotty.tools.io.AbstractFile
+
+object Profiler {
+  def apply()(using Context): Profiler =
+    if (!ctx.settings.YprofileEnabled.value) NoOpProfiler
+    else {
+      val reporter = if (ctx.settings.YprofileDestination.value != "")
+        new StreamProfileReporter(new PrintWriter(new FileWriter(ctx.settings.YprofileDestination.value, true)))
+      else ConsoleProfileReporter
+      new RealProfiler(reporter)
+    }
+
+  private[profile] val emptySnap: ProfileSnap = ProfileSnap(0, "", 0, 0, 0, 0, 0, 0)
+}
+
+case class GcEventData(pool:String, reportTimeNs: Long, gcStartMillis:Long, gcEndMillis:Long, name:String, action:String, cause:String, threads:Long)
+
+case class ProfileSnap(threadId: Long, threadName: String, snapTimeNanos : Long,
+                       idleTimeNanos:Long, cpuTimeNanos: Long, userTimeNanos: Long,
+                       allocatedBytes:Long, heapBytes:Long) {
+  def updateHeap(heapBytes:Long): ProfileSnap =
+    copy(heapBytes = heapBytes)
+}
+case class ProfileRange(start: ProfileSnap, end:ProfileSnap, phase:Phase, purpose:String, taskCount:Int, thread:Thread) {
+  def allocatedBytes: Long = end.allocatedBytes - start.allocatedBytes
+
+  def userNs: Long = end.userTimeNanos - start.userTimeNanos
+
+  def cpuNs: Long = end.cpuTimeNanos - start.cpuTimeNanos
+
+  def idleNs: Long = end.idleTimeNanos - start.idleTimeNanos
+
+  def runNs: Long = end.snapTimeNanos - start.snapTimeNanos
+
+
+  private def toMillis(ns: Long) = ns / 1000000.0D
+
+  private def toMegaBytes(bytes: Long) = bytes / 1000000.0D
+
+
+  def wallClockTimeMillis: Double = toMillis(end.snapTimeNanos - start.snapTimeNanos)
+
+  def idleTimeMillis: Double = toMillis(end.idleTimeNanos - start.idleTimeNanos)
+
+  def cpuTimeMillis: Double = toMillis(end.cpuTimeNanos - start.cpuTimeNanos)
+
+  def userTimeMillis: Double = toMillis(end.userTimeNanos - start.userTimeNanos)
+
+  def allocatedMB: Double = toMegaBytes(end.allocatedBytes - start.allocatedBytes)
+
+  def retainedHeapMB: Double = toMegaBytes(end.heapBytes - start.heapBytes)
+}
+
+sealed trait Profiler {
+
+  def finished(): Unit
+
+  def beforePhase(phase: Phase): ProfileSnap
+
+  def afterPhase(phase: Phase, profileBefore: ProfileSnap): Unit
+}
+private [profile] object NoOpProfiler extends Profiler {
+
+  override def beforePhase(phase: Phase): ProfileSnap = Profiler.emptySnap
+
+  override def afterPhase(phase: Phase, profileBefore: ProfileSnap): Unit = ()
+
+  override def finished(): Unit = ()
+}
+private [profile] object RealProfiler {
+  import scala.jdk.CollectionConverters._
+  val runtimeMx: RuntimeMXBean = ManagementFactory.getRuntimeMXBean
+  val memoryMx: MemoryMXBean = ManagementFactory.getMemoryMXBean
+  val gcMx: List[GarbageCollectorMXBean] = ManagementFactory.getGarbageCollectorMXBeans.asScala.toList
+  val classLoaderMx: ClassLoadingMXBean = ManagementFactory.getClassLoadingMXBean
+  val compileMx: CompilationMXBean = ManagementFactory.getCompilationMXBean
+  val threadMx: ExtendedThreadMxBean = ExtendedThreadMxBean.proxy
+  if (threadMx.isThreadCpuTimeSupported) threadMx.setThreadCpuTimeEnabled(true)
+  private val idGen = new AtomicInteger()
+}
+
+private [profile] class RealProfiler(reporter : ProfileReporter)(using Context) extends Profiler with NotificationListener {
+  def completeBackground(threadRange: ProfileRange): Unit =
+    reporter.reportBackground(this, threadRange)
+
+  def outDir: AbstractFile = ctx.settings.outputDir.value
+
+  val id: Int = RealProfiler.idGen.incrementAndGet()
+
+  private val mainThread = Thread.currentThread()
+
+  @nowarn("cat=deprecation")
+  private[profile] def snapThread(idleTimeNanos: Long): ProfileSnap = {
+    import RealProfiler._
+    val current = Thread.currentThread()
+
+    ProfileSnap(
+      threadId = current.getId,
+      threadName = current.getName,
+      snapTimeNanos = System.nanoTime(),
+      idleTimeNanos = idleTimeNanos,
+      cpuTimeNanos = threadMx.getCurrentThreadCpuTime,
+      userTimeNanos = threadMx.getCurrentThreadUserTime,
+      allocatedBytes = threadMx.getThreadAllocatedBytes(Thread.currentThread().getId),
+      heapBytes = readHeapUsage()
+    )
+  }
+  private def readHeapUsage() = RealProfiler.memoryMx.getHeapMemoryUsage.getUsed
+
+  @nowarn
+  private def doGC: Unit = {
+    System.gc()
+    System.runFinalization()
+  }
+
+  RealProfiler.gcMx foreach {
+    case emitter: NotificationEmitter => emitter.addNotificationListener(this, null, null)
+    case gc => println(s"Cant connect gcListener to ${gc.getClass}")
+  }
+
+  reporter.header(this)
+
+  override def finished(): Unit = {
+    //we may miss a GC event if gc is occurring as we call this
+    RealProfiler.gcMx foreach {
+      case emitter: NotificationEmitter => emitter.removeNotificationListener(this)
+      case gc =>
+    }
+    reporter.close(this)
+  }
+
+
+  override def handleNotification(notification: Notification, handback: scala.Any): Unit = {
+    import java.lang.{Long => jLong}
+    import java.lang.{Integer => jInt}
+    val reportNs = System.nanoTime()
+    val data = notification.getUserData
+    val seq = notification.getSequenceNumber
+    val message = notification.getMessage
+    val tpe = notification.getType
+    val time= notification.getTimeStamp
+    data match {
+      case cd: CompositeData if tpe == "com.sun.management.gc.notification" =>
+        val name = cd.get("gcName").toString
+        val action = cd.get("gcAction").toString
+        val cause = cd.get("gcCause").toString
+        val info = cd.get("gcInfo").asInstanceOf[CompositeData]
+        val duration = info.get("duration").asInstanceOf[jLong].longValue()
+        val startTime = info.get("startTime").asInstanceOf[jLong].longValue()
+        val endTime = info.get("endTime").asInstanceOf[jLong].longValue()
+        val threads = info.get("GcThreadCount").asInstanceOf[jInt].longValue()
+        reporter.reportGc(GcEventData("", reportNs, startTime, endTime, name, action, cause, threads))
+    }
+  }
+
+  override def afterPhase(phase: Phase, snapBefore: ProfileSnap): Unit = {
+    assert(mainThread eq Thread.currentThread())
+    val initialSnap = snapThread(0)
+    if (ctx.settings.YprofileExternalTool.value.contains(phase.toString)) {
+      println("Profile hook stop")
+      ExternalToolHook.after()
+    }
+    val finalSnap = if (ctx.settings.YprofileRunGcBetweenPhases.value.contains(phase.toString)) {
+      doGC
+      initialSnap.updateHeap(readHeapUsage())
+    }
+    else initialSnap
+
+    reporter.reportForeground(this, ProfileRange(snapBefore, finalSnap, phase, "", 0, Thread.currentThread))
+  }
+
+  override def beforePhase(phase: Phase): ProfileSnap = {
+    assert(mainThread eq Thread.currentThread())
+    if (ctx.settings.YprofileRunGcBetweenPhases.value.contains(phase.toString))
+      doGC
+    if (ctx.settings.YprofileExternalTool.value.contains(phase.toString)) {
+      println("Profile hook start")
+      ExternalToolHook.before()
+    }
+    snapThread(0)
+  }
+}
+
+
+case class EventType(name: String)
+object EventType {
+  //main thread with other tasks
+  val MAIN: EventType = EventType("main")
+  //other task ( background thread)
+  val BACKGROUND: EventType = EventType("background")
+  //total for compile
+  val GC: EventType = EventType("GC")
+}
+
+sealed trait ProfileReporter {
+  def reportBackground(profiler: RealProfiler, threadRange: ProfileRange): Unit
+  def reportForeground(profiler: RealProfiler, threadRange: ProfileRange): Unit
+
+  def reportGc(data: GcEventData): Unit
+
+  def header(profiler: RealProfiler) :Unit
+  def close(profiler: RealProfiler) :Unit
+}
+
+object ConsoleProfileReporter extends ProfileReporter {
+
+
+  override def reportBackground(profiler: RealProfiler, threadRange: ProfileRange): Unit =
+  // TODO
+    ???
+  override def reportForeground(profiler: RealProfiler, threadRange: ProfileRange): Unit =
+  // TODO
+    ???
+
+  override def close(profiler: RealProfiler): Unit = ()
+
+  override def header(profiler: RealProfiler): Unit =
+    println(s"Profiler start (${profiler.id}) ${profiler.outDir}")
+
+  override def reportGc(data: GcEventData): Unit =
+    println(s"Profiler GC reported ${data.gcEndMillis - data.gcStartMillis}ms")
+}
+
+class StreamProfileReporter(out:PrintWriter) extends ProfileReporter {
+  override def header(profiler: RealProfiler): Unit = {
+    out.println(s"info, ${profiler.id}, version, 2, output, ${profiler.outDir}")
+    out.println(s"header(main/background),startNs,endNs,runId,phaseId,phaseName,purpose,task-count,threadId,threadName,runNs,idleNs,cpuTimeNs,userTimeNs,allocatedByte,heapSize")
+    out.println(s"header(GC),startNs,endNs,startMs,endMs,name,action,cause,threads")
+  }
+
+  override def reportBackground(profiler: RealProfiler, threadRange: ProfileRange): Unit =
+    reportCommon(EventType.BACKGROUND, profiler, threadRange)
+  override def reportForeground(profiler: RealProfiler, threadRange: ProfileRange): Unit =
+    reportCommon(EventType.MAIN, profiler, threadRange)
+  @nowarn("cat=deprecation")
+  private def reportCommon(tpe:EventType, profiler: RealProfiler, threadRange: ProfileRange): Unit =
+    out.println(s"$tpe,${threadRange.start.snapTimeNanos},${threadRange.end.snapTimeNanos},${profiler.id},${threadRange.phase.id},${threadRange.phase.phaseName.replace(',', ' ')},${threadRange.purpose},${threadRange.taskCount},${threadRange.thread.getId},${threadRange.thread.getName},${threadRange.runNs},${threadRange.idleNs},${threadRange.cpuNs},${threadRange.userNs},${threadRange.allocatedBytes},${threadRange.end.heapBytes} ")
+
+  override def reportGc(data: GcEventData): Unit = {
+    val duration = TimeUnit.MILLISECONDS.toNanos(data.gcEndMillis - data.gcStartMillis + 1)
+    val start = data.reportTimeNs - duration
+    out.println(s"${EventType.GC},$start,${data.reportTimeNs},${data.gcStartMillis}, ${data.gcEndMillis},${data.name},${data.action},${data.cause},${data.threads}")
+  }
+
+
+  override def close(profiler: RealProfiler): Unit = {
+    out.flush
+    out.close
+  }
+}
diff --git a/tests/pos-with-compiler-cc/dotc/quoted/MacroExpansion.scala b/tests/pos-with-compiler-cc/dotc/quoted/MacroExpansion.scala
new file mode 100644
index 000000000000..141b349826b4
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/quoted/MacroExpansion.scala
@@ -0,0 +1,18 @@
+package dotty.tools.dotc.quoted
+
+import dotty.tools.dotc.ast.tpd
+import dotty.tools.dotc.core.Contexts._
+import dotty.tools.dotc.typer.Typer
+import dotty.tools.dotc.util.{Property, SourcePosition}
+
+object MacroExpansion {
+
+  private val MacroExpansionPosition = new Property.Key[SourcePosition]
+
+  def position(using Context): Option[SourcePosition] =
+    ctx.property(MacroExpansionPosition)
+
+  def context(inlinedFrom: tpd.Tree)(using Context): Context =
+    QuotesCache.init(ctx.fresh).setProperty(MacroExpansionPosition, SourcePosition(inlinedFrom.source, inlinedFrom.span)).setTypeAssigner(new Typer(ctx.nestingLevel + 1)).withSource(inlinedFrom.source)
+}
+
diff --git a/tests/pos-with-compiler-cc/dotc/quoted/PickledQuotes.scala b/tests/pos-with-compiler-cc/dotc/quoted/PickledQuotes.scala
new file mode 100644
index 000000000000..41f3fd4f64f3
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/quoted/PickledQuotes.scala
@@ -0,0 +1,270 @@
+package dotty.tools.dotc.quoted
+
+import dotty.tools.dotc.ast.Trees._
+import dotty.tools.dotc.ast.{TreeTypeMap, tpd}
+import dotty.tools.dotc.config.Printers._
+import dotty.tools.dotc.core.Contexts._
+import dotty.tools.dotc.core.Decorators._
+import dotty.tools.dotc.core.Mode
+import dotty.tools.dotc.core.Symbols._
+import dotty.tools.dotc.core.Types._
+import dotty.tools.dotc.core.tasty.{ PositionPickler, TastyPickler, TastyPrinter, TreePickler }
+import dotty.tools.dotc.core.tasty.DottyUnpickler
+import dotty.tools.dotc.core.tasty.TreeUnpickler.UnpickleMode
+import dotty.tools.dotc.report
+
+
+import scala.quoted.Quotes
+import scala.quoted.runtime.impl._
+
+import scala.collection.mutable
+
+import QuoteUtils._
+
+object PickledQuotes {
+  import tpd._
+
+  /** Pickle the tree of the quote into strings */
+  def pickleQuote(tree: Tree)(using Context): List[String] =
+    if (ctx.reporter.hasErrors) Nil
+    else {
+      assert(!tree.isInstanceOf[Hole]) // Should not be pickled as it represents `'{$x}` which should be optimized to `x`
+      val pickled = pickle(tree)
+      TastyString.pickle(pickled)
+    }
+
+  /** Transform the expression into its fully spliced Tree */
+  def quotedExprToTree[T](expr: quoted.Expr[T])(using Context): Tree = {
+    val expr1 = expr.asInstanceOf[ExprImpl]
+    ScopeException.checkInCorrectScope(expr1.scope, SpliceScope.getCurrent, expr1.tree, "Expr")
+    changeOwnerOfTree(expr1.tree, ctx.owner)
+  }
+
+  /** Transform the expression into its fully spliced TypeTree */
+  def quotedTypeToTree(tpe: quoted.Type[?])(using Context): Tree = {
+    val tpe1 = tpe.asInstanceOf[TypeImpl]
+    ScopeException.checkInCorrectScope(tpe1.scope, SpliceScope.getCurrent, tpe1.typeTree, "Type")
+    changeOwnerOfTree(tpe1.typeTree, ctx.owner)
+  }
+
+  /** `typeHole`/`types` argument of `QuoteUnpickler.{unpickleExpr,unpickleExprV2,unpickleType,unpickleTypeV2}` */
+  enum TypeHole:
+    /** `termHole` argument of `QuoteUnpickler.{unpickleExpr, unpickleType}`.
+     *  From code compiled with Scala 3.0.x and 3.1.x.
+     *  Note: For `unpickleType` it will always be `null`.
+     */
+    case V1(evalHole: Null | ((Int, Seq[scala.quoted.Type[?]]) => scala.quoted.Type[?]))
+    /** `termHole` argument of `QuoteUnpickler.unpickleExprV2`
+     *  From code compiled with Scala 3.2.0+
+     */
+    case V2(types: Null | Seq[scala.quoted.Type[?]])
+
+    def isEmpty: Boolean = this match
+      case V1(evalHole) => evalHole == null
+      case V2(types) => types == null
+
+  enum ExprHole:
+    /** `termHole` argument of `QuoteUnpickler.{unpickleExpr, unpickleType}`.
+     *  From code compiled with Scala 3.0.x and 3.1.x.
+     *  Note: For `unpickleType` it will always be `null`.
+     */
+    case V1(evalHole: Null | ((Int, Seq[ExprHole.ArgV1], scala.quoted.Quotes) => scala.quoted.Expr[?]))
+    /** `termHole` argument of `QuoteUnpickler.unpickleExprV2`
+     *  From code compiled with Scala 3.2.0+
+     */
+    case V2(evalHole: Null | ((Int, Seq[ExprHole.ArgV2], scala.quoted.Quotes) => scala.quoted.Expr[?]))
+
+  object ExprHole:
+    type ArgV1 = scala.quoted.Type[?] | (Quotes ?=> scala.quoted.Expr[Any])
+    type ArgV2 = scala.quoted.Type[?] | scala.quoted.Expr[Any]
+
+  /** Unpickle the tree contained in the TastyExpr */
+  def unpickleTerm(pickled: String | List[String], typeHole: TypeHole, termHole: ExprHole)(using Context): Tree = {
+    val unpickled = withMode(Mode.ReadPositions)(unpickle(pickled, isType = false))
+    val Inlined(call, Nil, expansion) = unpickled: @unchecked
+    val inlineCtx = inlineContext(call)
+    val expansion1 = spliceTypes(expansion, typeHole)(using inlineCtx)
+    val expansion2 = spliceTerms(expansion1, typeHole, termHole)(using inlineCtx)
+    cpy.Inlined(unpickled)(call, Nil, expansion2)
+  }
+
+
+  /** Unpickle the tree contained in the TastyType */
+  def unpickleTypeTree(pickled: String | List[String], typeHole: TypeHole)(using Context): Tree = {
+    val unpickled = withMode(Mode.ReadPositions)(unpickle(pickled, isType = true))
+    spliceTypes(unpickled, typeHole)
+  }
+
+  /** Replace all term holes with the spliced terms */
+  private def spliceTerms(tree: Tree, typeHole: TypeHole, termHole: ExprHole)(using Context): Tree = {
+    def evaluateHoles = new TreeMap {
+      override def transform(tree: tpd.Tree)(using Context): tpd.Tree = tree match {
+        case Hole(isTermHole, idx, args, _, _) =>
+          inContext(SpliceScope.contextWithNewSpliceScope(tree.sourcePos)) {
+            if isTermHole then
+              val quotedExpr = termHole match
+                case ExprHole.V1(evalHole) =>
+                  evalHole.nn.apply(idx, reifyExprHoleV1Args(args), QuotesImpl())
+                case ExprHole.V2(evalHole) =>
+                  evalHole.nn.apply(idx, reifyExprHoleV2Args(args), QuotesImpl())
+
+              val filled = PickledQuotes.quotedExprToTree(quotedExpr)
+
+              // We need to make sure a hole is created with the source file of the surrounding context, even if
+              // it filled with contents a different source file.
+              if filled.source == ctx.source then filled
+              else filled.cloneIn(ctx.source).withSpan(tree.span)
+            else
+              // For backwards compatibility with 3.0.x and 3.1.x
+              // In 3.2.0+ all these holes are handled by `spliceTypes` before we call `spliceTerms`.
+              //
+              // Replaces type holes generated by PickleQuotes (non-spliced types).
+              // These are types defined in a quote and used at the same level in a nested quote.
+              val TypeHole.V1(evalHole) = typeHole: @unchecked
+              val quotedType = evalHole.nn.apply(idx, reifyTypeHoleArgs(args))
+              PickledQuotes.quotedTypeToTree(quotedType)
+          }
+        case tree =>
+          if tree.isDef then
+            tree.symbol.annotations = tree.symbol.annotations.map {
+              annot => annot.derivedAnnotation(transform(annot.tree))
+            }
+          end if
+
+         val tree1 = super.transform(tree)
+         tree1.withType(mapAnnots(tree1.tpe))
+      }
+
+      // Evaluate holes in type annotations
+      private val mapAnnots = new TypeMap {
+        override def apply(tp: Type): Type = {
+            tp match
+              case tp @ AnnotatedType(underlying, annot) =>
+                val underlying1 = this(underlying)
+                derivedAnnotatedType(tp, underlying1, annot.derivedAnnotation(transform(annot.tree)))
+              case _ => mapOver(tp)
+        }
+      }
+    }
+    val tree1 = termHole match
+      case ExprHole.V2(null) => tree
+      case _ => evaluateHoles.transform(tree)
+    quotePickling.println(i"**** evaluated quote\n$tree1")
+    tree1
+  }
+
+  /** Replace all type holes generated with the spliced types */
+  private def spliceTypes(tree: Tree, typeHole: TypeHole)(using Context): Tree = {
+    if typeHole.isEmpty then tree
+    else tree match
+      case Block(stat :: rest, expr1) if stat.symbol.hasAnnotation(defn.QuotedRuntime_SplicedTypeAnnot) =>
+        val typeSpliceMap = (stat :: rest).iterator.map {
+          case tdef: TypeDef =>
+            assert(tdef.symbol.hasAnnotation(defn.QuotedRuntime_SplicedTypeAnnot))
+            val tree = typeHole match
+              case TypeHole.V1(evalHole) =>
+                tdef.rhs match
+                  case TypeBoundsTree(_, Hole(_, idx, args, _, _), _) =>
+                    // To keep for backwards compatibility. In some older version holes where created in the bounds.
+                    val quotedType = evalHole.nn.apply(idx, reifyTypeHoleArgs(args))
+                    PickledQuotes.quotedTypeToTree(quotedType)
+                  case TypeBoundsTree(_, tpt, _) =>
+                    // To keep for backwards compatibility. In some older version we missed the creation of some holes.
+                    tpt
+              case TypeHole.V2(types) =>
+                val Hole(_, idx, _, _, _) = tdef.rhs: @unchecked
+                PickledQuotes.quotedTypeToTree(types.nn.apply(idx))
+            (tdef.symbol, tree.tpe)
+        }.toMap
+        class ReplaceSplicedTyped extends TypeMap() {
+          override def apply(tp: Type): Type = tp match {
+            case tp: ClassInfo =>
+              tp.derivedClassInfo(declaredParents = tp.declaredParents.map(apply))
+            case tp: TypeRef =>
+              typeSpliceMap.get(tp.symbol) match
+                case Some(t) if tp.typeSymbol.hasAnnotation(defn.QuotedRuntime_SplicedTypeAnnot) => mapOver(t)
+                case _ => mapOver(tp)
+            case _ =>
+              mapOver(tp)
+          }
+        }
+        val expansion2 = new TreeTypeMap(new ReplaceSplicedTyped).transform(expr1)
+        quotePickling.println(i"**** typed quote\n${expansion2.show}")
+        expansion2
+      case _ =>
+        tree
+  }
+
+  def reifyTypeHoleArgs(args: List[Tree])(using Context): List[scala.quoted.Type[?]] =
+    args.map(arg => new TypeImpl(arg, SpliceScope.getCurrent))
+
+  def reifyExprHoleV1Args(args: List[Tree])(using Context): List[ExprHole.ArgV1] =
+    args.map { arg =>
+      if arg.isTerm then (q: Quotes) ?=> new ExprImpl(arg, SpliceScope.getCurrent)
+      else new TypeImpl(arg, SpliceScope.getCurrent)
+    }
+
+  def reifyExprHoleV2Args(args: List[Tree])(using Context): List[ExprHole.ArgV2] =
+    args.map { arg =>
+      if arg.isTerm then new ExprImpl(arg, SpliceScope.getCurrent)
+      else new TypeImpl(arg, SpliceScope.getCurrent)
+    }
+
+  // TASTY picklingtests/pos/quoteTest.scala
+
+  /** Pickle tree into it's TASTY bytes s*/
+  private def pickle(tree: Tree)(using Context): Array[Byte] = {
+    quotePickling.println(i"**** pickling quote of\n$tree")
+    val pickler = new TastyPickler(defn.RootClass)
+    val treePkl = new TreePickler(pickler)
+    treePkl.pickle(tree :: Nil)
+    treePkl.compactify()
+    if tree.span.exists then
+      val positionWarnings = new mutable.ListBuffer[String]()
+      val reference = ctx.settings.sourceroot.value
+      new PositionPickler(pickler, treePkl.buf.addrOfTree, treePkl.treeAnnots, reference)
+        .picklePositions(ctx.compilationUnit.source, tree :: Nil, positionWarnings)
+      positionWarnings.foreach(report.warning(_))
+
+    val pickled = pickler.assembleParts()
+    quotePickling.println(s"**** pickled quote\n${TastyPrinter.showContents(pickled, ctx.settings.color.value == "never")}")
+    pickled
+  }
+
+  /** Unpickle TASTY bytes into it's tree */
+  private def unpickle(pickled: String | List[String], isType: Boolean)(using Context): Tree = {
+    QuotesCache.getTree(pickled) match
+      case Some(tree) =>
+        quotePickling.println(s"**** Using cached quote for TASTY\n$tree")
+        treeOwner(tree) match
+          case Some(owner) =>
+            // Copy the cached tree to make sure the all definitions are unique.
+            TreeTypeMap(oldOwners = List(owner), newOwners = List(owner)).apply(tree)
+          case _ =>
+            tree
+
+      case _ =>
+        val bytes = pickled match
+          case pickled: String => TastyString.unpickle(pickled)
+          case pickled: List[String] => TastyString.unpickle(pickled)
+
+        quotePickling.println(s"**** unpickling quote from TASTY\n${TastyPrinter.showContents(bytes, ctx.settings.color.value == "never")}")
+
+        val mode = if (isType) UnpickleMode.TypeTree else UnpickleMode.Term
+        val unpickler = new DottyUnpickler(bytes, mode)
+        unpickler.enter(Set.empty)
+
+        val tree = unpickler.tree
+        QuotesCache(pickled) = tree
+
+        // Make sure trees and positions are fully loaded
+        new TreeTraverser {
+          def traverse(tree: Tree)(using Context): Unit = traverseChildren(tree)
+        }.traverse(tree)
+
+        quotePickling.println(i"**** unpickled quote\n$tree")
+
+        tree
+  }
+
+}
diff --git a/tests/pos-with-compiler-cc/dotc/quoted/QuoteUtils.scala b/tests/pos-with-compiler-cc/dotc/quoted/QuoteUtils.scala
new file mode 100644
index 000000000000..604c8da3420a
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/quoted/QuoteUtils.scala
@@ -0,0 +1,30 @@
+package dotty.tools.dotc.quoted
+
+import dotty.tools.dotc.ast.tpd
+import dotty.tools.dotc.core.Contexts._
+import dotty.tools.dotc.core.Symbols._
+
+object QuoteUtils:
+  import tpd._
+
+  /** Get the owner of a tree if it has one */
+  def treeOwner(tree: Tree)(using Context): Option[Symbol] = {
+    val getCurrentOwner = new TreeAccumulator[Option[Symbol]] {
+      def apply(x: Option[Symbol], tree: tpd.Tree)(using Context): Option[Symbol] =
+        if (x.isDefined) x
+        else tree match {
+          case tree: DefTree => Some(tree.symbol.owner)
+          case _ => foldOver(x, tree)
+        }
+    }
+    getCurrentOwner(None, tree)
+  }
+
+  /** Changes the owner of the tree based on the current owner of the tree */
+  def changeOwnerOfTree(tree: Tree, owner: Symbol)(using Context): Tree = {
+    treeOwner(tree) match
+      case Some(oldOwner) if oldOwner != owner => tree.changeOwner(oldOwner, owner)
+      case _ => tree
+  }
+
+end QuoteUtils
diff --git a/tests/pos-with-compiler-cc/dotc/quoted/QuotesCache.scala b/tests/pos-with-compiler-cc/dotc/quoted/QuotesCache.scala
new file mode 100644
index 000000000000..c063e437cb19
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/quoted/QuotesCache.scala
@@ -0,0 +1,26 @@
+package dotty.tools.dotc.quoted
+
+import dotty.tools.dotc.core.Contexts._
+import dotty.tools.dotc.util.Property
+import dotty.tools.dotc.ast.tpd
+
+
+object QuotesCache {
+  import tpd._
+
+  /** A key to be used in a context property that caches the unpickled trees */
+  private val QuotesCacheKey = new Property.Key[collection.mutable.Map[String | List[String], Tree]]
+
+
+  /** Get the cached tree of the quote */
+  def getTree(pickled: String | List[String])(using Context): Option[Tree] =
+    ctx.property(QuotesCacheKey).get.get(pickled)
+
+  /** Update the cached tree of the quote */
+  def update(pickled: String | List[String], tree: Tree)(using Context): Unit =
+    ctx.property(QuotesCacheKey).get.update(pickled, tree)
+
+  /** Context with a cache for quote trees and tasty bytes */
+  def init(ctx: FreshContext): ctx.type =
+    ctx.setProperty(QuotesCacheKey, collection.mutable.Map.empty)
+}
diff --git a/tests/pos-with-compiler-cc/dotc/quoted/TastyString.scala b/tests/pos-with-compiler-cc/dotc/quoted/TastyString.scala
new file mode 100644
index 000000000000..369e646e883e
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/quoted/TastyString.scala
@@ -0,0 +1,31 @@
+package dotty.tools.dotc.quoted
+
+import scala.language.unsafeNulls
+
+import java.util.Base64
+import java.nio.charset.StandardCharsets.UTF_8
+
+/** Utils for String representation of TASTY */
+object TastyString {
+
+  // Max size of a string literal in the bytecode
+  private inline val maxStringSize = 65535
+
+  /** Encode TASTY bytes into a List of String */
+  def pickle(bytes: Array[Byte]): List[String] = {
+    val str = new String(Base64.getEncoder().encode(bytes), UTF_8)
+    str.toSeq.sliding(maxStringSize, maxStringSize).map(_.unwrap).toList
+  }
+
+  /** Decode the List of Strings into TASTY bytes */
+  def unpickle(strings: List[String]): Array[Byte] = {
+    val string = new StringBuilder
+    strings.foreach(string.append)
+    Base64.getDecoder().decode(string.result().getBytes(UTF_8))
+  }
+
+  /** Decode the Strings into TASTY bytes */
+  def unpickle(string: String): Array[Byte] =
+    Base64.getDecoder().decode(string.getBytes(UTF_8))
+
+}
diff --git a/tests/pos-with-compiler-cc/dotc/quoted/reflect/FromSymbol.scala b/tests/pos-with-compiler-cc/dotc/quoted/reflect/FromSymbol.scala
new file mode 100644
index 000000000000..87d0cbb7be08
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/quoted/reflect/FromSymbol.scala
@@ -0,0 +1,62 @@
+package dotty.tools.dotc.quoted
+package reflect
+
+import dotty.tools.dotc.ast.tpd
+import dotty.tools.dotc.ast.untpd
+import dotty.tools.dotc.core.Contexts._
+import dotty.tools.dotc.core.Flags._
+import dotty.tools.dotc.core.StdNames._
+import dotty.tools.dotc.core.Symbols._
+import dotty.tools.dotc.core.Types._
+
+object FromSymbol {
+
+  def definitionFromSym(sym: Symbol)(using Context): tpd.Tree = {
+    assert(sym.exists, "Cannot get tree of no symbol")
+    assert(!sym.is(Package), "Cannot get tree of package symbol")
+    if (sym.isClass) classDef(sym.asClass)
+    else if (sym.isType && sym.is(Case)) typeBindFromSym(sym.asType)
+    else if (sym.isType) typeDefFromSym(sym.asType)
+    else if (sym.is(Method)) defDefFromSym(sym.asTerm)
+    else if (sym.is(Case, butNot = ModuleVal | EnumVal)) bindFromSym(sym.asTerm)
+    else valDefFromSym(sym.asTerm)
+  }
+
+  def classDef(cls: ClassSymbol)(using Context): tpd.TypeDef = cls.defTree match {
+    case tree: tpd.TypeDef => tree
+    case tpd.EmptyTree =>
+      val constrSym = cls.unforcedDecls.find(_.isPrimaryConstructor).orElse(
+        // Dummy constructor for classes such as `<refinement>`
+        newSymbol(cls, nme.CONSTRUCTOR, EmptyFlags, NoType)
+      )
+      val constr = tpd.DefDef(constrSym.asTerm)
+      val parents = cls.info.parents.map(tpd.TypeTree(_))
+      val body = cls.unforcedDecls.filter(!_.isPrimaryConstructor).map(s => definitionFromSym(s))
+      tpd.ClassDefWithParents(cls, constr, parents, body)
+  }
+
+  def typeDefFromSym(sym: TypeSymbol)(using Context): tpd.TypeDef = sym.defTree match {
+    case tree: tpd.TypeDef => tree
+    case tpd.EmptyTree => tpd.TypeDef(sym)
+  }
+
+  def defDefFromSym(sym: TermSymbol)(using Context): tpd.DefDef = sym.defTree match {
+    case tree: tpd.DefDef => tree
+    case tpd.EmptyTree => tpd.DefDef(sym)
+  }
+
+  def valDefFromSym(sym: TermSymbol)(using Context): tpd.ValDef = sym.defTree match {
+    case tree: tpd.ValDef => tree
+    case tpd.EmptyTree => tpd.ValDef(sym)
+  }
+
+  def bindFromSym(sym: TermSymbol)(using Context): tpd.Bind = sym.defTree match {
+    case tree: tpd.Bind => tree
+    case tpd.EmptyTree => tpd.Bind(sym, untpd.Ident(nme.WILDCARD).withType(sym.typeRef))
+  }
+
+  def typeBindFromSym(sym: TypeSymbol)(using Context): tpd.Bind = sym.defTree match {
+    case tree: tpd.Bind => tree
+    case tpd.EmptyTree => tpd.Bind(sym, untpd.Ident(nme.WILDCARD).withType(sym.typeRef))
+  }
+}
diff --git a/tests/pos-with-compiler-cc/dotc/report.scala b/tests/pos-with-compiler-cc/dotc/report.scala
new file mode 100644
index 000000000000..636da444696c
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/report.scala
@@ -0,0 +1,143 @@
+package dotty.tools.dotc
+
+import reporting._
+import Diagnostic._
+import util.{SourcePosition, NoSourcePosition, SrcPos}
+import core._
+import Contexts._, Symbols._, Decorators._
+import config.SourceVersion
+import ast._
+import config.Feature.sourceVersion
+import java.lang.System.currentTimeMillis
+import language.experimental.pureFunctions
+
+object report:
+
+  /** For sending messages that are printed only if -verbose is set */
+  def inform(msg: -> String, pos: SrcPos = NoSourcePosition)(using Context): Unit =
+    if ctx.settings.verbose.value then echo(msg, pos)
+
+  def echo(msg: -> String, pos: SrcPos = NoSourcePosition)(using Context): Unit =
+    ctx.reporter.report(new Info(msg.toMessage, pos.sourcePos))
+
+  private def issueWarning(warning: Warning)(using Context): Unit =
+    ctx.reporter.report(warning)
+
+  def deprecationWarning(msg: Message, pos: SrcPos)(using Context): Unit =
+    issueWarning(new DeprecationWarning(msg, pos.sourcePos))
+
+  def deprecationWarning(msg: -> String, pos: SrcPos)(using Context): Unit =
+    deprecationWarning(msg.toMessage, pos)
+
+  def migrationWarning(msg: Message, pos: SrcPos)(using Context): Unit =
+    issueWarning(new MigrationWarning(msg, pos.sourcePos))
+
+  def migrationWarning(msg: -> String, pos: SrcPos)(using Context): Unit =
+    migrationWarning(msg.toMessage, pos)
+
+  def uncheckedWarning(msg: Message, pos: SrcPos)(using Context): Unit =
+    issueWarning(new UncheckedWarning(msg, pos.sourcePos))
+
+  def uncheckedWarning(msg: -> String, pos: SrcPos)(using Context): Unit =
+    uncheckedWarning(msg.toMessage, pos)
+
+  def featureWarning(msg: Message, pos: SrcPos)(using Context): Unit =
+    issueWarning(new FeatureWarning(msg, pos.sourcePos))
+
+  def featureWarning(msg: -> String, pos: SrcPos)(using Context): Unit =
+    featureWarning(msg.toMessage, pos)
+
+  def featureWarning(feature: String, featureDescription: -> String,
+      featureUseSite: Symbol, required: Boolean, pos: SrcPos)(using Context): Unit = {
+    val req = if (required) "needs to" else "should"
+    val fqname = s"scala.language.$feature"
+
+    val explain =
+      if ctx.reporter.isReportedFeatureUseSite(featureUseSite) then ""
+      else
+        ctx.reporter.reportNewFeatureUseSite(featureUseSite)
+        s"""
+           |See the Scala docs for value $fqname for a discussion
+           |why the feature $req be explicitly enabled.""".stripMargin
+
+    def msg = s"""$featureDescription $req be enabled
+                 |by adding the import clause 'import $fqname'
+                 |or by setting the compiler option -language:$feature.$explain""".stripMargin
+    if (required) error(msg, pos)
+    else issueWarning(new FeatureWarning(msg.toMessage, pos.sourcePos))
+  }
+
+  def warning(msg: Message, pos: SrcPos)(using Context): Unit =
+    issueWarning(new Warning(msg, addInlineds(pos)))
+
+  def warning(msg: -> String, pos: SrcPos = NoSourcePosition)(using Context): Unit =
+    warning(msg.toMessage, pos)
+
+  def error(msg: Message, pos: SrcPos)(using Context): Unit =
+    val fullPos = addInlineds(pos)
+    ctx.reporter.report(new Error(msg, fullPos))
+    if ctx.settings.YdebugError.value then Thread.dumpStack()
+
+  def error(msg: -> String, pos: SrcPos = NoSourcePosition)(using Context): Unit =
+    error(msg.toMessage, pos)
+
+  def error(ex: TypeError, pos: SrcPos)(using Context): Unit =
+    val fullPos = addInlineds(pos)
+    ctx.reporter.report(new StickyError(ex.toMessage, fullPos))
+    if ctx.settings.YdebugError.value then Thread.dumpStack()
+
+  def errorOrMigrationWarning(msg: Message, pos: SrcPos, from: SourceVersion)(using Context): Unit =
+    if sourceVersion.isAtLeast(from) then
+      if sourceVersion.isMigrating && sourceVersion.ordinal <= from.ordinal then migrationWarning(msg, pos)
+      else error(msg, pos)
+
+  def errorOrMigrationWarning(msg: -> String, pos: SrcPos, from: SourceVersion)(using Context): Unit =
+    errorOrMigrationWarning(msg.toMessage, pos, from)
+
+  def gradualErrorOrMigrationWarning(msg: Message, pos: SrcPos, warnFrom: SourceVersion, errorFrom: SourceVersion)(using Context): Unit =
+    if sourceVersion.isAtLeast(errorFrom) then errorOrMigrationWarning(msg, pos, errorFrom)
+    else if sourceVersion.isAtLeast(warnFrom) then warning(msg, pos)
+
+  def gradualErrorOrMigrationWarning(msg: -> String, pos: SrcPos, warnFrom: SourceVersion, errorFrom: SourceVersion)(using Context): Unit =
+    gradualErrorOrMigrationWarning(msg.toMessage, pos, warnFrom, errorFrom)
+
+  def restrictionError(msg: Message, pos: SrcPos = NoSourcePosition)(using Context): Unit =
+    error(msg.mapMsg("Implementation restriction: " + _), pos)
+
+  def incompleteInputError(msg: Message, pos: SrcPos = NoSourcePosition)(using Context): Unit =
+    ctx.reporter.incomplete(new Error(msg, pos.sourcePos))
+
+  /** Log msg if settings.log contains the current phase.
+   *  See [[config.CompilerCommand#explainAdvanced]] for the exact meaning of
+   *  "contains" here.
+   */
+  def log(msg: -> String, pos: SrcPos = NoSourcePosition)(using Context): Unit =
+    if (ctx.settings.Ylog.value.containsPhase(ctx.phase))
+      echo(s"[log ${ctx.phase}] $msg", pos)
+
+  def debuglog(msg: -> String)(using Context): Unit =
+    if (ctx.debug) log(msg)
+
+  def informTime(msg: -> String, start: Long)(using Context): Unit = {
+    def elapsed = s" in ${currentTimeMillis - start}ms"
+    informProgress(msg + elapsed)
+  }
+
+  def informProgress(msg: -> String)(using Context): Unit =
+    inform("[" + msg + "]")
+
+  def logWith[T](msg: -> String)(value: T)(using Context): T = {
+    log(msg + " " + value)
+    value
+  }
+
+  def debugwarn(msg: -> String, pos: SrcPos = NoSourcePosition)(using Context): Unit =
+    if (ctx.settings.Ydebug.value) warning(msg, pos)
+
+  private def addInlineds(pos: SrcPos)(using Context): SourcePosition =
+    def recur(pos: SourcePosition, inlineds: List[Trees.Tree[?]]): SourcePosition = inlineds match
+      case inlined :: inlineds1 => pos.withOuter(recur(inlined.sourcePos, inlineds1))
+      case Nil => pos
+    recur(pos.sourcePos, tpd.enclosingInlineds)
+
+end report
diff --git a/tests/pos-with-compiler-cc/dotc/reporting/AbstractReporter.scala b/tests/pos-with-compiler-cc/dotc/reporting/AbstractReporter.scala
new file mode 100644
index 000000000000..630df31014f7
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/reporting/AbstractReporter.scala
@@ -0,0 +1,8 @@
+package dotty.tools
+package dotc
+package reporting
+
+/**
+ * This class mixes in a few standard traits, so that it is easier to extend from Java.
+ */
+abstract class AbstractReporter extends Reporter with UniqueMessagePositions with HideNonSensicalMessages with MessageRendering
diff --git a/tests/pos-with-compiler-cc/dotc/reporting/ConsoleReporter.scala b/tests/pos-with-compiler-cc/dotc/reporting/ConsoleReporter.scala
new file mode 100644
index 000000000000..a95af962c053
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/reporting/ConsoleReporter.scala
@@ -0,0 +1,37 @@
+package dotty.tools
+package dotc
+package reporting
+
+import core.Contexts._
+import java.io.{ BufferedReader, PrintWriter }
+import Diagnostic.Error
+
+/**
+  * This class implements a Reporter that displays messages on a text console
+  */
+class ConsoleReporter(
+  reader: BufferedReader = Console.in,
+  writer: PrintWriter = new PrintWriter(Console.err, true)
+) extends ConsoleReporter.AbstractConsoleReporter {
+  override def printMessage(msg: String): Unit = { writer.print(msg + "\n"); writer.flush() }
+  override def flush()(using Context): Unit    = writer.flush()
+
+  override def doReport(dia: Diagnostic)(using Context): Unit = {
+    super.doReport(dia)
+    dia match
+      case dia: Error if ctx.settings.Xprompt.value => Reporter.displayPrompt(reader, writer)
+      case _                                        =>
+  }
+}
+
+object ConsoleReporter {
+  abstract class AbstractConsoleReporter extends AbstractReporter {
+    /** Prints the message. */
+    def printMessage(msg: String): Unit
+
+    /** Prints the message with the given position indication. */
+    def doReport(dia: Diagnostic)(using Context): Unit = {
+      printMessage(messageAndPos(dia))
+    }
+  }
+}
diff --git a/tests/pos-with-compiler-cc/dotc/reporting/Diagnostic.scala b/tests/pos-with-compiler-cc/dotc/reporting/Diagnostic.scala
new file mode 100644
index 000000000000..b792aed4264e
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/reporting/Diagnostic.scala
@@ -0,0 +1,107 @@
+package dotty.tools
+package dotc
+package reporting
+
+import scala.language.unsafeNulls
+
+import dotty.tools.dotc.config.Settings.Setting
+import dotty.tools.dotc.core.Contexts._
+import dotty.tools.dotc.interfaces.Diagnostic.{ERROR, INFO, WARNING}
+import dotty.tools.dotc.util.SourcePosition
+
+import java.util.Optional
+import scala.util.chaining._
+import core.Decorators.toMessage
+import language.experimental.pureFunctions
+
+object Diagnostic:
+
+  def shouldExplain(dia: Diagnostic)(using Context): Boolean =
+    ctx.settings.explain.value && dia.msg.canExplain
+    || ctx.settings.explainTypes.value && dia.msg.isInstanceOf[TypeMismatchMsg]
+        // keep old explain-types behavior for backwards compatibility and cross-compilation
+
+  // `Diagnostics to be consumed by `Reporter` ---------------------- //
+  class Error(
+    msg: Message,
+    pos: SourcePosition
+  ) extends Diagnostic(msg, pos, ERROR):
+    def this(str: -> String, pos: SourcePosition) = this(str.toMessage, pos)
+
+  /** A sticky error is an error that should not be hidden by backtracking and
+   *  trying some alternative path. Typically, errors issued after catching
+   *  a TypeError exception are sticky.
+   */
+  class StickyError(
+    msg: Message,
+    pos: SourcePosition
+  ) extends Error(msg, pos)
+
+  class Warning(
+    msg: Message,
+    pos: SourcePosition
+  ) extends Diagnostic(msg, pos, WARNING) {
+    def toError: Error = new Error(msg, pos).tap(e => if isVerbose then e.setVerbose())
+    def toInfo: Info = new Info(msg, pos).tap(e => if isVerbose then e.setVerbose())
+    def isSummarizedConditional(using Context): Boolean = false
+  }
+
+  class Info(
+    msg: Message,
+    pos: SourcePosition
+  ) extends Diagnostic(msg, pos, INFO):
+    def this(str: -> String, pos: SourcePosition) = this(str.toMessage, pos)
+
+  abstract class ConditionalWarning(
+    msg: Message,
+    pos: SourcePosition
+  ) extends Warning(msg, pos) {
+    def enablingOption(using Context): Setting[Boolean]
+    override def isSummarizedConditional(using Context): Boolean = !enablingOption.value
+  }
+
+  class FeatureWarning(
+    msg: Message,
+    pos: SourcePosition
+  ) extends ConditionalWarning(msg, pos) {
+    def enablingOption(using Context): Setting[Boolean] = ctx.settings.feature
+  }
+
+  class UncheckedWarning(
+    msg: Message,
+    pos: SourcePosition
+  ) extends ConditionalWarning(msg, pos) {
+    def enablingOption(using Context): Setting[Boolean] = ctx.settings.unchecked
+  }
+
+  class DeprecationWarning(
+    msg: Message,
+    pos: SourcePosition
+  ) extends ConditionalWarning(msg, pos) {
+    def enablingOption(using Context): Setting[Boolean] = ctx.settings.deprecation
+  }
+
+  class MigrationWarning(
+    msg: Message,
+    pos: SourcePosition
+  ) extends Warning(msg, pos)
+
+class Diagnostic(
+  val msg: Message,
+  val pos: SourcePosition,
+  val level: Int
+) extends Exception with interfaces.Diagnostic:
+  private var verbose: Boolean = false
+  def isVerbose: Boolean = verbose
+  def setVerbose(): this.type =
+    verbose = true
+    this
+
+  override def position: Optional[interfaces.SourcePosition] =
+    if (pos.exists && pos.source.exists) Optional.of(pos) else Optional.empty()
+  override def message: String =
+    msg.message.replaceAll("\u001B\\[[;\\d]*m", "")
+
+  override def toString: String = s"$getClass at $pos: $message"
+  override def getMessage(): String = message
+end Diagnostic
diff --git a/tests/pos-with-compiler-cc/dotc/reporting/ErrorMessageID.scala b/tests/pos-with-compiler-cc/dotc/reporting/ErrorMessageID.scala
new file mode 100644
index 000000000000..d9140a6309b8
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/reporting/ErrorMessageID.scala
@@ -0,0 +1,197 @@
+package dotty.tools.dotc.reporting
+
+//////////////////////////////////////////////////////////////////////////
+// IMPORTANT                                                            //
+// Only add new IDs at end of the enumeration list and never remove IDs //
+//////////////////////////////////////////////////////////////////////////
+
+/** Unique IDs identifying the messages, this will be used to reference documentation online.
+ *
+ *  @param isActive Whether or not the compile still emits this ErrorMessageID
+ **/
+enum ErrorMessageID(val isActive: Boolean = true) extends java.lang.Enum[ErrorMessageID]:
+
+  case NoExplanationID // errorNumber: -1
+
+  case EmptyCatchOrFinallyBlockID extends ErrorMessageID(isActive = false) // errorNumber: 0
+  case EmptyCatchBlockID // errorNumber: 1
+  case EmptyCatchAndFinallyBlockID // errorNumber: 2
+  case DeprecatedWithOperatorID // errorNumber: 3
+  case CaseClassMissingParamListID // errorNumber: 4
+  case DuplicateBindID // errorNumber: 5
+  case MissingIdentID // errorNumber: 6
+  case TypeMismatchID // errorNumber: 7
+  case NotAMemberID // errorNumber: 8
+  case EarlyDefinitionsNotSupportedID // errorNumber: 9
+  case TopLevelImplicitClassID extends ErrorMessageID(isActive = false) // errorNumber: 10
+  case ImplicitCaseClassID // errorNumber: 11
+  case ImplicitClassPrimaryConstructorArityID // errorNumber: 12
+  case ObjectMayNotHaveSelfTypeID // errorNumber: 13
+  case TupleTooLongID extends ErrorMessageID(isActive = false) // errorNumber: 14
+  case RepeatedModifierID // errorNumber: 15
+  case InterpolatedStringErrorID // errorNumber: 16
+  case UnboundPlaceholderParameterID // errorNumber: 17
+  case IllegalStartSimpleExprID // errorNumber: 18
+  case MissingReturnTypeID // errorNumber: 19
+  case YieldOrDoExpectedInForComprehensionID // errorNumber: 20
+  case ProperDefinitionNotFoundID // errorNumber: 21
+  case ByNameParameterNotSupportedID // errorNumber: 22
+  case WrongNumberOfTypeArgsID // errorNumber: 23
+  case IllegalVariableInPatternAlternativeID // errorNumber: 24
+  case IdentifierExpectedID // errorNumber: 25
+  case AuxConstructorNeedsNonImplicitParameterID // errorNumber: 26
+  case VarArgsParamMustComeLastID // errorNumber: 27
+  case IllegalLiteralID // errorNumber: 28
+  case PatternMatchExhaustivityID // errorNumber: 29
+  case MatchCaseUnreachableID // errorNumber: 30
+  case SeqWildcardPatternPosID // errorNumber: 31
+  case IllegalStartOfSimplePatternID // errorNumber: 32
+  case PkgDuplicateSymbolID // errorNumber: 33
+  case ExistentialTypesNoLongerSupportedID // errorNumber: 34
+  case UnboundWildcardTypeID // errorNumber: 35
+  case DanglingThisInPathID extends ErrorMessageID(isActive = false) // errorNumber: 36
+  case OverridesNothingID // errorNumber: 37
+  case OverridesNothingButNameExistsID // errorNumber: 38
+  case ForwardReferenceExtendsOverDefinitionID // errorNumber: 39
+  case ExpectedTokenButFoundID // errorNumber: 40
+  case MixedLeftAndRightAssociativeOpsID // errorNumber: 41
+  case CantInstantiateAbstractClassOrTraitID // errorNumber: 42
+  case UnreducibleApplicationID // errorNumber: 43
+  case OverloadedOrRecursiveMethodNeedsResultTypeID // errorNumber: 44
+  case RecursiveValueNeedsResultTypeID // errorNumber: 45
+  case CyclicReferenceInvolvingID // errorNumber: 46
+  case CyclicReferenceInvolvingImplicitID // errorNumber: 47
+  case SuperQualMustBeParentID // errorNumber: 48
+  case AmbiguousReferenceID // errorNumber: 49
+  case MethodDoesNotTakeParametersId // errorNumber: 50
+  case AmbiguousOverloadID // errorNumber: 51
+  case ReassignmentToValID // errorNumber: 52
+  case TypeDoesNotTakeParametersID // errorNumber: 53
+  case ParameterizedTypeLacksArgumentsID extends ErrorMessageID(isActive = false) // errorNumber: 54
+  case VarValParametersMayNotBeCallByNameID // errorNumber: 55
+  case MissingTypeParameterForID // errorNumber: 56
+  case DoesNotConformToBoundID // errorNumber: 57
+  case DoesNotConformToSelfTypeID // errorNumber: 58
+  case DoesNotConformToSelfTypeCantBeInstantiatedID // errorNumber: 59
+  case AbstractMemberMayNotHaveModifierID // errorNumber: 60
+  case TopLevelCantBeImplicitID extends ErrorMessageID(isActive = false) // errorNumber: 61
+  case TypesAndTraitsCantBeImplicitID // errorNumber: 62
+  case OnlyClassesCanBeAbstractID // errorNumber: 63
+  case AbstractOverrideOnlyInTraitsID // errorNumber: 64
+  case TraitsMayNotBeFinalID // errorNumber: 65
+  case NativeMembersMayNotHaveImplementationID // errorNumber: 66
+  case OnlyClassesCanHaveDeclaredButUndefinedMembersID // errorNumber: 67
+  case CannotExtendAnyValID // errorNumber: 68
+  case CannotHaveSameNameAsID // errorNumber: 69
+  case ValueClassesMayNotDefineInnerID // errorNumber: 70
+  case ValueClassesMayNotDefineNonParameterFieldID // errorNumber: 71
+  case ValueClassesMayNotDefineASecondaryConstructorID // errorNumber: 72
+  case ValueClassesMayNotContainInitalizationID // errorNumber: 73
+  case ValueClassesMayNotBeAbstractID // errorNumber: 74
+  case ValueClassesMayNotBeContaintedID // errorNumber: 75
+  case ValueClassesMayNotWrapAnotherValueClassID // errorNumber: 76
+  case ValueClassParameterMayNotBeAVarID // errorNumber: 77
+  case ValueClassNeedsExactlyOneValParamID // errorNumber: 78
+  case OnlyCaseClassOrCaseObjectAllowedID extends ErrorMessageID(isActive = false) // errorNumber: 79
+  case ExpectedTopLevelDefID extends ErrorMessageID(isActive = false) // errorNumber: 80
+  case AnonymousFunctionMissingParamTypeID // errorNumber: 81
+  case SuperCallsNotAllowedInlineableID // errorNumber: 82
+  case NotAPathID // errorNumber: 83
+  case WildcardOnTypeArgumentNotAllowedOnNewID // errorNumber: 84
+  case FunctionTypeNeedsNonEmptyParameterListID // errorNumber: 85
+  case WrongNumberOfParametersID // errorNumber: 86
+  case DuplicatePrivateProtectedQualifierID // errorNumber: 87
+  case ExpectedStartOfTopLevelDefinitionID // errorNumber: 88
+  case MissingReturnTypeWithReturnStatementID // errorNumber: 89
+  case NoReturnFromInlineableID // errorNumber: 90
+  case ReturnOutsideMethodDefinitionID // errorNumber: 91
+  case UncheckedTypePatternID // errorNumber: 92
+  case ExtendFinalClassID // errorNumber: 93
+  case EnumCaseDefinitionInNonEnumOwnerID // errorNumber: 94
+  case ExpectedTypeBoundOrEqualsID // errorNumber: 95
+  case ClassAndCompanionNameClashID // errorNumber: 96
+  case TailrecNotApplicableID // errorNumber: 97
+  case FailureToEliminateExistentialID // errorNumber: 98
+  case OnlyFunctionsCanBeFollowedByUnderscoreID // errorNumber: 99
+  case MissingEmptyArgumentListID // errorNumber: 100
+  case DuplicateNamedTypeParameterID // errorNumber: 101
+  case UndefinedNamedTypeParameterID // errorNumber: 102
+  case IllegalStartOfStatementID // errorNumber: 1033
+  case TraitIsExpectedID // errorNumber: 104
+  case TraitRedefinedFinalMethodFromAnyRefID // errorNumber: 105
+  case PackageNameAlreadyDefinedID // errorNumber: 106
+  case UnapplyInvalidNumberOfArgumentsID // errorNumber: 107
+  case UnapplyInvalidReturnTypeID // errorNumber: 108
+  case StaticFieldsOnlyAllowedInObjectsID // errorNumber: 109
+  case CyclicInheritanceID // errorNumber: 110
+  case BadSymbolicReferenceID // errorNumber: 111
+  case UnableToExtendSealedClassID // errorNumber: 112
+  case SymbolHasUnparsableVersionNumberID // errorNumber: 113
+  case SymbolChangedSemanticsInVersionID // errorNumber: 114
+  case UnableToEmitSwitchID // errorNumber: 115
+  case MissingCompanionForStaticID // errorNumber: 116
+  case PolymorphicMethodMissingTypeInParentID // errorNumber: 117
+  case ParamsNoInlineID // errorNumber: 118
+  case JavaSymbolIsNotAValueID // errorNumber: 119
+  case DoubleDefinitionID // errorNumber: 120
+  case MatchCaseOnlyNullWarningID // errorNumber: 121
+  case ImportRenamedTwiceID // errorNumber: 122
+  case TypeTestAlwaysDivergesID // errorNumber: 123
+  case TermMemberNeedsNeedsResultTypeForImplicitSearchID // errorNumber: 124
+  case ClassCannotExtendEnumID // errorNumber: 125
+  case ValueClassParameterMayNotBeCallByNameID // errorNumber: 126
+  case NotAnExtractorID // errorNumber: 127
+  case MemberWithSameNameAsStaticID // errorNumber: 128
+  case PureExpressionInStatementPositionID // errorNumber: 129
+  case TraitCompanionWithMutableStaticID // errorNumber: 130
+  case LazyStaticFieldID // errorNumber: 131
+  case StaticOverridingNonStaticMembersID // errorNumber: 132
+  case OverloadInRefinementID // errorNumber: 133
+  case NoMatchingOverloadID // errorNumber: 134
+  case StableIdentPatternID // errorNumber: 135
+  case StaticFieldsShouldPrecedeNonStaticID // errorNumber: 136
+  case IllegalSuperAccessorID // errorNumber: 137
+  case TraitParameterUsedAsParentPrefixID // errorNumber: 138
+  case UnknownNamedEnclosingClassOrObjectID // errorNumber: 139
+  case IllegalCyclicTypeReferenceID // errorNumber: 140
+  case MissingTypeParameterInTypeAppID // errorNumber: 141
+  case SkolemInInferredID // errorNumber: 142
+  case ErasedTypesCanOnlyBeFunctionTypesID // errorNumber: 143
+  case CaseClassMissingNonImplicitParamListID // errorNumber: 144
+  case EnumerationsShouldNotBeEmptyID // errorNumber: 145
+  case IllegalParameterInitID // errorNumber: 146
+  case RedundantModifierID // errorNumber: 147
+  case TypedCaseDoesNotExplicitlyExtendTypedEnumID // errorNumber: 148
+  case IllegalRedefinitionOfStandardKindID // errorNumber: 149
+  case NoExtensionMethodAllowedID // errorNumber: 150
+  case ExtensionMethodCannotHaveTypeParamsID // errorNumber: 151
+  case ExtensionCanOnlyHaveDefsID // errorNumber: 152
+  case UnexpectedPatternForSummonFromID // errorNumber: 153
+  case AnonymousInstanceCannotBeEmptyID // errorNumber: 154
+  case TypeSpliceInValPatternID extends ErrorMessageID(isActive = false) // errorNumber: 155
+  case ModifierNotAllowedForDefinitionID // errorNumber: 156
+  case CannotExtendJavaEnumID // errorNumber: 157
+  case InvalidReferenceInImplicitNotFoundAnnotationID // errorNumber: 158
+  case TraitMayNotDefineNativeMethodID // errorNumber: 159
+  case JavaEnumParentArgsID // errorNumber: 160
+  case AlreadyDefinedID // errorNumber: 161
+  case CaseClassInInlinedCodeID // errorNumber: 162
+  case OverrideTypeMismatchErrorID // errorNumber: 163
+  case OverrideErrorID // errorNumber: 164
+  case MatchableWarningID // errorNumber: 165
+  case CannotExtendFunctionID // errorNumber: 166
+  case LossyWideningConstantConversionID // errorNumber: 167
+  case ImplicitSearchTooLargeID // errorNumber: 168
+  case TargetNameOnTopLevelClassID // errorNumber: 169
+  case NotClassTypeID // errorNumber 170
+  case MissingArgumentID // errorNumer 171
+
+  def errorNumber = ordinal - 1
+
+object ErrorMessageID:
+  def fromErrorNumber(n: Int): Option[ErrorMessageID] =
+    val enumId = n + 1
+    if enumId >= 1 && enumId < ErrorMessageID.values.length then
+      Some(fromOrdinal(enumId))
+    else
+      None
diff --git a/tests/pos-with-compiler-cc/dotc/reporting/ExploringReporter.scala b/tests/pos-with-compiler-cc/dotc/reporting/ExploringReporter.scala
new file mode 100644
index 000000000000..a2062bd1b2c7
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/reporting/ExploringReporter.scala
@@ -0,0 +1,23 @@
+package dotty.tools
+package dotc
+package reporting
+
+import scala.language.unsafeNulls
+
+import collection.mutable
+import core.Contexts.Context
+import Diagnostic._
+
+/** A re-usable Reporter used in Contexts#test */
+class ExploringReporter extends StoreReporter(null, fromTyperState = false):
+  infos = new mutable.ListBuffer[Diagnostic]
+
+  override def hasUnreportedErrors: Boolean =
+    infos.exists(_.isInstanceOf[Error])
+
+  override def removeBufferedMessages(using Context): List[Diagnostic] =
+    try infos.toList finally reset()
+
+  def reset(): Unit = infos.clear()
+
+end ExploringReporter
\ No newline at end of file
diff --git a/tests/pos-with-compiler-cc/dotc/reporting/HideNonSensicalMessages.scala b/tests/pos-with-compiler-cc/dotc/reporting/HideNonSensicalMessages.scala
new file mode 100644
index 000000000000..9b6a3c75ba5d
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/reporting/HideNonSensicalMessages.scala
@@ -0,0 +1,20 @@
+package dotty.tools
+package dotc
+package reporting
+
+import core.Contexts._
+
+/**
+ * This trait implements `isHidden` so that we avoid reporting non-sensical messages.
+ */
+trait HideNonSensicalMessages extends Reporter {
+  /** Hides non-sensical messages, unless we haven't reported any error yet or
+   *  `-Yshow-suppressed-errors` is set.
+   */
+  override def isHidden(dia: Diagnostic)(using Context): Boolean =
+    super.isHidden(dia) || {
+        dia.msg.isNonSensical &&
+        hasErrors && // if there are no errors yet, report even if diagnostic is non-sensical
+        !ctx.settings.YshowSuppressedErrors.value
+    }
+}
diff --git a/tests/pos-with-compiler-cc/dotc/reporting/Message.scala b/tests/pos-with-compiler-cc/dotc/reporting/Message.scala
new file mode 100644
index 000000000000..62ee4c54c354
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/reporting/Message.scala
@@ -0,0 +1,161 @@
+package dotty.tools
+package dotc
+package reporting
+
+import core.Contexts.*, core.Decorators.*, core.Mode
+import config.SourceVersion
+import scala.language.unsafeNulls
+import scala.annotation.threadUnsafe
+import language.experimental.pureFunctions
+
+object Message {
+  val nonSensicalStartTag: String = "<nonsensical>"
+  val nonSensicalEndTag: String = "</nonsensical>"
+
+  def rewriteNotice(what: String, version: SourceVersion | Null = null, options: String = "")(using Context): String =
+    if !ctx.mode.is(Mode.Interactive) then
+      val sourceStr = if version != null then i"-source $version" else ""
+      val optionStr =
+        if options.isEmpty then sourceStr
+        else if sourceStr.isEmpty then options
+        else i"$sourceStr $options"
+      i"\n$what can be rewritten automatically under -rewrite $optionStr."
+    else ""
+}
+
+/** A `Message` contains all semantic information necessary to easily
+  * comprehend what caused the message to be logged. Each message can be turned
+  * into a `Diagnostic` which contains the log level and can later be
+  * consumed by a subclass of `Reporter`. However, the error position is only
+  * part of `Diagnostic`, not `Message`.
+  *
+  * NOTE: you should not persist a message directly, because most messages take
+  * an implicit `Context` and these contexts weigh in at about 4mb per instance.
+  * Therefore, persisting these will result in a memory leak.
+  *
+  * Instead use the `persist` method to create an instance that does not keep a
+  * reference to these contexts.
+  *
+  * @param errorId a unique id identifying the message, this will be
+  *                used to reference documentation online
+  */
+abstract class Message(val errorId: ErrorMessageID) { self =>
+  import Message._
+
+  /** The `msg` contains the diagnostic message e.g:
+    *
+    * > expected: String
+    * > found:    Int
+    *
+    * This message will be placed underneath the position given by the enclosing
+    * `Diagnostic`. The message is given in raw form, with possible embedded
+    *  <nonsensical> tags.
+    */
+  protected def msg: String
+
+  /** The kind of the error message, e.g. "Syntax" or "Type Mismatch".
+    * This will be printed as "$kind Error", "$kind Warning", etc, on the first
+    * line of the message.
+    */
+  def kind: MessageKind
+
+  /** The explanation should provide a detailed description of why the error
+    * occurred and use examples from the user's own code to illustrate how to
+    * avoid these errors. It might contain embedded <nonsensical> tags.
+    */
+  protected def explain: String
+
+  /** A message suffix that can be added for certain subclasses */
+  protected def msgSuffix: String = ""
+
+  /** Does this message have an explanation?
+   *  This is normally the same as `explain.nonEmpty` but can be overridden
+   *  if we need a way to return `true` without actually calling the
+   *  `explain` method.
+   */
+  def canExplain: Boolean = explain.nonEmpty
+
+  private var myMsg: String | Null = null
+  private var myIsNonSensical: Boolean = false
+
+  private def dropNonSensical(msg: String): String =
+    if msg.contains(nonSensicalStartTag) then
+      myIsNonSensical = true
+      // myMsg might be composed of several d"..." invocations -> nested
+      // nonsensical tags possible
+      msg
+        .replace(nonSensicalStartTag, "")
+        .replace(nonSensicalEndTag, "")
+    else msg
+
+  /** The message with potential embedded <nonsensical> tags */
+  def rawMessage = message
+
+  /** The message to report. <nonsensical> tags are filtered out */
+  @threadUnsafe lazy val message: String = dropNonSensical(msg + msgSuffix)
+
+  /** The explanation to report. <nonsensical> tags are filtered out */
+  @threadUnsafe lazy val explanation: String = dropNonSensical(explain)
+
+  /** A message is non-sensical if it contains references to <nonsensical>
+   *  tags.  Such tags are inserted by the error diagnostic framework if a
+   *  message contains references to internally generated error types. Normally
+   *  we want to suppress error messages referring to types like this because
+   *  they look weird and are normally follow-up errors to something that was
+   *  diagnosed before.
+   */
+  def isNonSensical: Boolean = { message; myIsNonSensical }
+
+  /** The implicit `Context` in messages is a large thing that we don't want
+    * persisted. This method gets around that by duplicating the message,
+    * forcing its `msg` and `explanation` vals and dropping the implicit context
+    * that was captured in the original message.
+    */
+  def persist: Message = new Message(errorId) {
+    val kind       = self.kind
+    val msg        = self.msg
+    val explain    = self.explain
+    override val canExplain = self.canExplain
+  }
+
+  def append(suffix: -> String): Message = mapMsg(_ ++ suffix)
+
+  def mapMsg(f: String -> String): Message = new Message(errorId):
+    val kind       = self.kind
+    def msg        = f(self.msg)
+    def explain    = self.explain
+    override def canExplain = self.canExplain
+
+  def appendExplanation(suffix: -> String): Message = new Message(errorId):
+    val kind       = self.kind
+    def msg        = self.msg
+    def explain    = self.explain ++ suffix
+    override def canExplain = true
+
+  /** Override with `true` for messages that should always be shown even if their
+   *  position overlaps another messsage of a different class. On the other hand
+   *  multiple messages of the same class with overlapping positions will lead
+   *  to only a single message of that class to be issued.
+   */
+  def showAlways = false
+
+  override def toString = msg
+}
+
+/** The fallback `Message` containing no explanation and having no `kind` */
+class NoExplanation(msgFn: -> String) extends Message(ErrorMessageID.NoExplanationID) {
+  def msg: String = msgFn
+  def explain: String = ""
+  val kind: MessageKind = MessageKind.NoKind
+
+  override def toString(): String = msg
+}
+
+/** The extractor for `NoExplanation` can be used to check whether any error
+  * lacks an explanation
+  */
+object NoExplanation {
+  def unapply(m: Message): Option[Message] =
+    if (m.explanation == "") Some(m)
+    else None
+}
diff --git a/tests/pos-with-compiler-cc/dotc/reporting/MessageKind.scala b/tests/pos-with-compiler-cc/dotc/reporting/MessageKind.scala
new file mode 100644
index 000000000000..f039ed900a76
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/reporting/MessageKind.scala
@@ -0,0 +1,41 @@
+package dotty.tools.dotc.reporting
+
+/** Message kinds that can be used in a Message.
+ *  NOTE: Keep in mind that if you have a new message or a new ErrorMessageID
+ *  that doesn't fit well into an existing kind, create a new one.
+ */
+enum MessageKind:
+  case NoKind
+  case Syntax
+  case Type
+  case TypeMismatch
+  case Naming
+  case Declaration
+  case NotFound
+  case PatternMatch
+  case Cyclic
+  case Reference
+  case DocComment
+  case LossyConversion
+  case PatternMatchExhaustivity
+  case MatchCaseUnreachable
+  case Compatibility
+  case PotentialIssue
+
+  /** Human readable message that will end up being shown to the user.
+   *  NOTE: This is only used in the situation where you have multiple words
+   *  and don't want to rely on the default toString of the enum.
+   */
+  def message: String =
+    this match
+      case NoKind => "No Kind"
+      case TypeMismatch => "Type Mismatch"
+      case NotFound => "Not Found"
+      case PatternMatch => "Pattern Match"
+      case DocComment => "Doc Comment"
+      case LossyConversion => "Lossy Conversion"
+      case PatternMatchExhaustivity => "Pattern Match Exhaustivity"
+      case MatchCaseUnreachable => "Match case Unreachable"
+      case PotentialIssue => "Potential Issue"
+      case kind => kind.toString
+end MessageKind
diff --git a/tests/pos-with-compiler-cc/dotc/reporting/MessageRendering.scala b/tests/pos-with-compiler-cc/dotc/reporting/MessageRendering.scala
new file mode 100644
index 000000000000..f53359fb8b19
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/reporting/MessageRendering.scala
@@ -0,0 +1,324 @@
+package dotty.tools
+package dotc
+package reporting
+
+import scala.language.unsafeNulls
+
+import java.lang.System.{lineSeparator => EOL}
+
+import core.Contexts._
+import core.Decorators._
+import printing.Highlighting.{Blue, Red, Yellow}
+import printing.SyntaxHighlighting
+import Diagnostic._
+import util.{ SourcePosition, NoSourcePosition }
+import util.Chars.{ LF, CR, FF, SU }
+import scala.annotation.switch
+
+import scala.collection.mutable
+
+trait MessageRendering {
+  import Highlight.*
+  import Offsets.*
+
+  /** Remove ANSI coloring from `str`, useful for getting real length of
+    * strings
+    *
+    * @return string stripped of ANSI escape codes
+    */
+  def stripColor(str: String): String =
+    str.replaceAll("\u001b\\[.*?m", "")
+
+  /** List of all the inline calls that surround the position */
+  def inlinePosStack(pos: SourcePosition): List[SourcePosition] =
+    if pos.outer != null && pos.outer.exists then pos :: inlinePosStack(pos.outer)
+    else Nil
+
+  /** Get the sourcelines before and after the position, as well as the offset
+    * for rendering line numbers
+    *
+    * @return (lines before error, lines after error, line numbers offset)
+    */
+  private def sourceLines(pos: SourcePosition)(using Context, Level, Offset): (List[String], List[String], Int) = {
+    assert(pos.exists && pos.source.file.exists)
+    var maxLen = Int.MinValue
+    def render(offsetAndLine: (Int, String)): String = {
+      val (offset1, line) = offsetAndLine
+      val lineNbr = (pos.source.offsetToLine(offset1) + 1).toString
+      val prefix = String.format(s"%${offset - 2}s |", lineNbr)
+      maxLen = math.max(maxLen, prefix.length)
+      val lnum = hl(" " * math.max(0, maxLen - prefix.length - 1) + prefix)
+      lnum + line.stripLineEnd
+    }
+
+    def linesFrom(arr: Array[Char]): List[String] = {
+      def pred(c: Char) = (c: @switch) match {
+        case LF | CR | FF | SU => true
+        case _ => false
+      }
+      val (line, rest0) = arr.span(!pred(_))
+      val (_, rest) = rest0.span(pred)
+      new String(line) :: { if (rest.isEmpty) Nil else linesFrom(rest) }
+    }
+
+    val syntax =
+      if (ctx.settings.color.value != "never")
+        SyntaxHighlighting.highlight(new String(pos.linesSlice)).toCharArray
+      else pos.linesSlice
+    val lines = linesFrom(syntax)
+    val (before, after) = pos.beforeAndAfterPoint
+
+    (
+      before.zip(lines).map(render),
+      after.zip(lines.drop(before.length)).map(render),
+      maxLen
+    )
+  }
+
+  /** Generate box containing the report title
+   *
+   *  ```
+   *  -- Error: source.scala ---------------------
+   *  ```
+   */
+  private def boxTitle(title: String)(using Context, Level, Offset): String =
+    val pageWidth = ctx.settings.pageWidth.value
+    val line = "-" * (pageWidth - title.length - 4)
+    hl(s"-- $title $line")
+
+  /** The position markers aligned under the error
+   *
+   *  ```
+   *    |         ^^^^^
+   *  ```
+   */
+  private def positionMarker(pos: SourcePosition)(using Context, Level, Offset): String = {
+    val padding = pos.startColumnPadding
+    val carets =
+      if (pos.startLine == pos.endLine)
+        "^" * math.max(1, pos.endColumn - pos.startColumn)
+      else "^"
+    hl(s"$offsetBox$padding$carets")
+  }
+
+  /** The horizontal line with the given offset
+   *
+   *  ```
+   *    |
+   *  ```
+   */
+  private def offsetBox(using Context, Level, Offset): String =
+    val prefix = " " * (offset - 1)
+    hl(s"$prefix|")
+
+  /** The end of a box section
+   *
+   *  ```
+   *    |---------------
+   *  ```
+   *  Or if there `soft` is true,
+   *  ```
+   *    |- - - - - - - -
+   *  ```
+   */
+  private def newBox(soft: Boolean = false)(using Context, Level, Offset): String =
+    val pageWidth = ctx.settings.pageWidth.value
+    val prefix = " " * (offset - 1)
+    val lineWidth = (pageWidth - offset)
+    val line = if soft then ("- " * ((lineWidth + 1) / 2)).trim else "-" * lineWidth
+    hl(s"$prefix|$line")
+
+  /** The end of a box section
+   *
+   *  ```
+   *     ----------------
+   *  ```
+   */
+  private def endBox(using Context, Level, Offset): String =
+    val pageWidth = ctx.settings.pageWidth.value
+    val prefix = " " * (offset - 1)
+    val line = "-" * (pageWidth - offset)
+    hl(s"${prefix} $line")
+
+  /** The error message (`msg`) aligned under `pos`
+    *
+    * @return aligned error message
+    */
+  private def errorMsg(pos: SourcePosition, msg: String)(using Context, Level, Offset): String = {
+    val padding = msg.linesIterator.foldLeft(pos.startColumnPadding) { (pad, line) =>
+      val lineLength = stripColor(line).length
+      val maxPad = math.max(0, ctx.settings.pageWidth.value - offset - lineLength) - offset
+
+      if (maxPad < pad.length) " " * maxPad
+      else pad
+    }
+
+    msg.linesIterator
+      .map { line => offsetBox + (if line.isEmpty then "" else padding + line) }
+      .mkString(EOL)
+  }
+
+  /** The source file path, line and column numbers from the given SourcePosition */
+  protected def posFileStr(pos: SourcePosition): String =
+    val path = pos.source.file.path
+    if pos.exists then s"$path:${pos.line + 1}:${pos.column}" else path
+
+  /** The separator between errors containing the source file and error type
+    *
+    * @return separator containing error location and kind
+    */
+  private def posStr(
+    pos: SourcePosition,
+    message: Message,
+    diagnosticString: String
+  )(using Context, Level, Offset): String =
+    assert(
+      message.errorId.isActive,
+      """|Attempting to use an ErrorMessageID that is marked as inactive.
+         |The ID either needs to be marked as active or you need to use another.""".stripMargin
+    )
+    if (pos.source != NoSourcePosition.source) then
+      hl({
+        val realPos = pos.nonInlined
+        val fileAndPos = posFileStr(realPos)
+        val errId =
+          if (message.errorId != ErrorMessageID.NoExplanationID) then
+            val errorNumber = message.errorId.errorNumber
+            s"[E${"0" * (3 - errorNumber.toString.length) + errorNumber}] "
+          else ""
+        val kind =
+          if (message.kind == MessageKind.NoKind) then diagnosticString
+          else s"${message.kind.message} $diagnosticString"
+        val title =
+          if fileAndPos.isEmpty then s"$errId$kind:" // this happens in dotty.tools.repl.ScriptedTests // TODO add name of source or remove `:` (and update test files)
+          else s"$errId$kind: $fileAndPos"
+        boxTitle(title)
+      })
+    else ""
+  end posStr
+
+  /** Explanation rendered under "Explanation" header */
+  def explanation(m: Message)(using Context): String = {
+    val sb = new StringBuilder(
+      s"""|
+          |${Blue("Explanation").show}
+          |${Blue("===========").show}""".stripMargin
+    )
+    sb.append(EOL).append(m.explanation)
+    if (!m.explanation.endsWith(EOL)) sb.append(EOL)
+    sb.toString
+  }
+
+  private def appendFilterHelp(dia: Diagnostic, sb: mutable.StringBuilder): Unit =
+    import dia._
+    val hasId = msg.errorId.errorNumber >= 0
+    val category = dia match {
+      case _: UncheckedWarning => "unchecked"
+      case _: DeprecationWarning => "deprecation"
+      case _: FeatureWarning => "feature"
+      case _ => ""
+    }
+    if (hasId || category.nonEmpty)
+      sb.append(EOL).append("Matching filters for @nowarn or -Wconf:")
+      if (hasId)
+        sb.append(EOL).append("  - id=E").append(msg.errorId.errorNumber)
+        sb.append(EOL).append("  - name=").append(msg.errorId.productPrefix.stripSuffix("ID"))
+      if (category.nonEmpty)
+        sb.append(EOL).append("  - cat=").append(category)
+
+  /** The whole message rendered from `msg` */
+  def messageAndPos(dia: Diagnostic)(using Context): String = {
+    import dia._
+    val pos1 = pos.nonInlined
+    val inlineStack = inlinePosStack(pos).filter(_ != pos1)
+    val maxLineNumber =
+      if pos.exists then (pos1 :: inlineStack).map(_.endLine).max + 1
+      else 0
+    given Level = Level(level)
+    given Offset = Offset(maxLineNumber.toString.length + 2)
+    val sb = mutable.StringBuilder()
+    val posString = posStr(pos, msg, diagnosticLevel(dia))
+    if (posString.nonEmpty) sb.append(posString).append(EOL)
+    if (pos.exists) {
+      val pos1 = pos.nonInlined
+      if (pos1.exists && pos1.source.file.exists) {
+        val (srcBefore, srcAfter, offset) = sourceLines(pos1)
+        val marker = positionMarker(pos1)
+        val err = errorMsg(pos1, msg.message)
+        sb.append((srcBefore ::: marker :: err :: srcAfter).mkString(EOL))
+
+        if inlineStack.nonEmpty then
+          sb.append(EOL).append(newBox())
+          sb.append(EOL).append(offsetBox).append(i"Inline stack trace")
+          for inlinedPos <- inlineStack if inlinedPos != pos1 do
+            sb.append(EOL).append(newBox(soft = true))
+            sb.append(EOL).append(offsetBox).append(i"This location contains code that was inlined from $pos")
+            if inlinedPos.source.file.exists then
+              val (srcBefore, srcAfter, _) = sourceLines(inlinedPos)
+              val marker = positionMarker(inlinedPos)
+              sb.append(EOL).append((srcBefore ::: marker :: srcAfter).mkString(EOL))
+          sb.append(EOL).append(endBox)
+      }
+      else sb.append(msg.message)
+    }
+    else sb.append(msg.message)
+    if (dia.isVerbose)
+      appendFilterHelp(dia, sb)
+
+    if Diagnostic.shouldExplain(dia) then
+      sb.append(EOL).append(newBox())
+      sb.append(EOL).append(offsetBox).append(" Explanation (enabled by `-explain`)")
+      sb.append(EOL).append(newBox(soft = true))
+      dia.msg.explanation.split(raw"\R").foreach { line =>
+        sb.append(EOL).append(offsetBox).append(if line.isEmpty then "" else " ").append(line)
+      }
+      sb.append(EOL).append(endBox)
+    else if dia.msg.canExplain then
+      sb.append(EOL).append(offsetBox)
+      sb.append(EOL).append(offsetBox).append(" longer explanation available when compiling with `-explain`")
+
+    sb.toString
+  }
+
+  private  def hl(str: String)(using Context, Level): String =
+    summon[Level].value match
+      case interfaces.Diagnostic.ERROR   => Red(str).show
+      case interfaces.Diagnostic.WARNING => Yellow(str).show
+      case interfaces.Diagnostic.INFO    => Blue(str).show
+
+  private def diagnosticLevel(dia: Diagnostic): String =
+    dia match {
+      case dia: FeatureWarning => "Feature Warning"
+      case dia: DeprecationWarning => "Deprecation Warning"
+      case dia: UncheckedWarning => "Unchecked Warning"
+      case dia: MigrationWarning => "Migration Warning"
+      case _ => dia.level match // Diagnostic isn't sealed (e.g. created in the REPL) so provide a fallback
+        case interfaces.Diagnostic.ERROR   => "Error"
+        case interfaces.Diagnostic.WARNING => "Warning"
+        case interfaces.Diagnostic.INFO    => "Info"
+    }
+
+}
+
+private object Highlight {
+  opaque type Level = Int
+  extension (level: Level) def value: Int = level
+  object Level:
+    def apply(level: Int): Level = level
+}
+
+/** Size of the left offset added by the box
+ *
+ *  ```
+ *  -- Error: ... ------------
+ *  4 |  foo
+ *    |  ^^^
+ *  ^^^ // size of this offset
+ *  ```
+ */
+private object Offsets {
+  opaque type Offset = Int
+  def offset(using o: Offset): Int = o
+  object Offset:
+    def apply(level: Int): Offset = level
+}
diff --git a/tests/pos-with-compiler-cc/dotc/reporting/Profile.scala b/tests/pos-with-compiler-cc/dotc/reporting/Profile.scala
new file mode 100644
index 000000000000..6e2f83364dbe
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/reporting/Profile.scala
@@ -0,0 +1,157 @@
+package dotty.tools
+package dotc
+package reporting
+
+import core.*
+import Contexts.{Context, ctx}
+import Symbols.{Symbol, NoSymbol}
+import collection.mutable
+import util.{EqHashMap, NoSourcePosition}
+import util.Spans.{Span, NoSpan}
+import Decorators.i
+import parsing.Scanners.Scanner
+import io.AbstractFile
+import annotation.internal.sharable
+
+abstract class Profile:
+  def unitProfile(unit: CompilationUnit): Profile.Info
+  def recordNewLine()(using Context): Unit
+  def recordNewToken()(using Context): Unit
+  def recordTasty(size: Int)(using Context): Unit
+  def recordMethodSize(meth: Symbol, size: Int, span: Span)(using Context): Unit
+  def printSummary()(using Context): Unit
+
+object Profile:
+  def current(using Context): Profile =
+    val run = ctx.run
+    if run == null then NoProfile else run.profile
+
+  inline val TastyChunkSize = 50
+
+  def chunks(size: Int) = (size + TastyChunkSize - 1) / TastyChunkSize
+
+  case class MethodInfo(meth: Symbol, size: Int, span: Span)
+  @sharable object NoInfo extends MethodInfo(NoSymbol, 0, NoSpan)
+
+  class Info(details: Int):
+    var lineCount: Int = 0
+    var tokenCount: Int = 0
+    var tastySize: Int = 0
+    def complexity: Float = chunks(tastySize).toFloat/lineCount
+    val leading: Array[MethodInfo] = Array.fill[MethodInfo](details)(NoInfo)
+
+    def recordMethodSize(meth: Symbol, size: Int, span: Span): Unit =
+      var i = leading.length
+      while i > 0 && leading(i - 1).size < size do
+        if i < leading.length then leading(i) = leading(i - 1)
+        i -= 1
+      if i < leading.length then
+        leading(i) = MethodInfo(meth, size, span)
+  end Info
+end Profile
+
+class ActiveProfile(details: Int) extends Profile:
+
+  private val pinfo = new EqHashMap[CompilationUnit, Profile.Info]
+
+  private val junkInfo = new Profile.Info(0)
+
+  private def curInfo(using Context): Profile.Info =
+    val unit: CompilationUnit | Null = ctx.compilationUnit
+    if unit == null || unit.source.file.isVirtual then junkInfo else unitProfile(unit)
+
+  def unitProfile(unit: CompilationUnit): Profile.Info =
+    pinfo.getOrElseUpdate(unit, new Profile.Info(details))
+
+  def recordNewLine()(using Context): Unit =
+    curInfo.lineCount += 1
+  def recordNewToken()(using Context): Unit =
+    curInfo.tokenCount += 1
+  def recordTasty(size: Int)(using Context): Unit =
+    curInfo.tastySize += size
+  def recordMethodSize(meth: Symbol, size: Int, span: Span)(using Context): Unit =
+    curInfo.recordMethodSize(meth, size, span)
+
+  def printSummary()(using Context): Unit =
+    val units =
+      val rawUnits = pinfo.keysIterator.toArray
+      ctx.settings.VprofileSortedBy.value match
+        case "name"       => rawUnits.sortBy(_.source.file.name)
+        case "path"       => rawUnits.sortBy(_.source.file.path)
+        case "lines"      => rawUnits.sortBy(unitProfile(_).lineCount)
+        case "tokens"     => rawUnits.sortBy(unitProfile(_).tokenCount)
+        case "complexity" => rawUnits.sortBy(unitProfile(_).complexity)
+        case _            => rawUnits.sortBy(unitProfile(_).tastySize)
+
+    def printHeader(sourceNameWidth: Int, methNameWidth: Int = 0): String =
+      val prefix =
+        if methNameWidth > 0
+        then s"%-${sourceNameWidth}s %-${methNameWidth}s".format("Sourcefile", "Method")
+        else s"%-${sourceNameWidth}s".format("Sourcefile")
+      val layout = s"%-${prefix.length}s %6s %8s %7s %s    %s"
+      report.echo(layout.format(prefix, "Lines", "Tokens", "Tasty", " Complexity/Line", "Directory"))
+      layout
+
+    def printInfo(layout: String, name: String, info: Profile.Info, path: String) =
+      val complexity = info.complexity
+      val explanation =
+        if complexity < 1       then "low     "
+        else if complexity < 5  then "moderate"
+        else if complexity < 25 then "high    "
+        else                         "extreme "
+      report.echo(layout.format(
+        name, info.lineCount, info.tokenCount, Profile.chunks(info.tastySize),
+        s"${"%6.2f".format(complexity)}  $explanation", path))
+
+    def safeMax(xs: Array[Int]) = if xs.isEmpty then 10 else xs.max.max(10).min(50)
+
+    def printAndAggregateSourceInfos(): Profile.Info =
+      val sourceNameWidth = safeMax(units.map(_.source.file.name.length))
+      val layout = printHeader(sourceNameWidth)
+      val agg = new Profile.Info(details)
+      for unit <- units do
+        val file = unit.source.file
+        val info = unitProfile(unit)
+        printInfo(layout, file.name, info, file.container.path)
+        agg.lineCount += info.lineCount
+        agg.tokenCount += info.tokenCount
+        agg.tastySize += info.tastySize
+        for Profile.MethodInfo(meth, size, span) <- info.leading do
+          agg.recordMethodSize(meth, size, span)
+      if units.length > 1 then
+        report.echo(s"${"-" * sourceNameWidth}------------------------------------------")
+        printInfo(layout, "Total", agg, "")
+      agg
+
+    def printDetails(agg: Profile.Info): Unit =
+      val sourceNameWidth = safeMax(agg.leading.map(_.meth.source.name.length))
+      val methNameWidth = safeMax(agg.leading.map(_.meth.name.toString.length))
+      report.echo("\nMost complex methods:")
+      val layout = printHeader(sourceNameWidth, methNameWidth)
+      for
+        Profile.MethodInfo(meth, size, span) <- agg.leading.reverse
+        unit <- units.find(_.source.eq(meth.source))
+      do
+        val methProfile = new ActiveProfile(0)
+        val methCtx = ctx.fresh.setCompilationUnit(unit)
+        val s = Scanner(meth.source, span.start, methProfile)(using methCtx)
+        while s.offset < span.end do s.nextToken()
+        val info = methProfile.unitProfile(unit)
+        info.lineCount += 1
+        info.tastySize = size
+        val file = meth.source.file
+        val header = s"%-${sourceNameWidth}s %-${methNameWidth}s".format(file.name, meth.name)
+        printInfo(layout, header, info, file.container.path)
+
+    val agg = printAndAggregateSourceInfos()
+    if details > 0 then printDetails(agg)
+  end printSummary
+end ActiveProfile
+
+object NoProfile extends Profile:
+  def unitProfile(unit: CompilationUnit) = unsupported("NoProfile.info")
+  def recordNewLine()(using Context): Unit = ()
+  def recordNewToken()(using Context): Unit = ()
+  def recordTasty(size: Int)(using Context): Unit = ()
+  def recordMethodSize(meth: Symbol, size: Int, span: Span)(using Context): Unit = ()
+  def printSummary()(using Context): Unit = ()
diff --git a/tests/pos-with-compiler-cc/dotc/reporting/Reporter.scala b/tests/pos-with-compiler-cc/dotc/reporting/Reporter.scala
new file mode 100644
index 000000000000..2cb9ce50cbbe
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/reporting/Reporter.scala
@@ -0,0 +1,271 @@
+package dotty.tools
+package dotc
+package reporting
+
+import scala.language.unsafeNulls
+
+import dotty.tools.dotc.core.Contexts._
+import dotty.tools.dotc.core.Mode
+import dotty.tools.dotc.core.Symbols.{NoSymbol, Symbol}
+import dotty.tools.dotc.reporting.Diagnostic._
+import dotty.tools.dotc.reporting.Message._
+import dotty.tools.dotc.util.NoSourcePosition
+import core.Decorators.toMessage
+
+import java.io.{BufferedReader, PrintWriter}
+import scala.annotation.internal.sharable
+import scala.collection.mutable
+import scala.caps.unsafe.unsafeUnbox
+import language.experimental.pureFunctions
+
+object Reporter {
+  /** Convert a SimpleReporter into a real Reporter */
+  def fromSimpleReporter(simple: interfaces.SimpleReporter): Reporter =
+    new Reporter with UniqueMessagePositions with HideNonSensicalMessages {
+      override def doReport(dia: Diagnostic)(using Context): Unit = simple.report(dia)
+    }
+
+  /** A reporter that ignores reports, and doesn't record errors */
+  @sharable object NoReporter extends Reporter {
+    def doReport(dia: Diagnostic)(using Context): Unit = ()
+    override def report(dia: Diagnostic)(using Context): Unit = ()
+  }
+
+  type ErrorHandler = (Diagnostic, Context) => Unit
+
+  private val defaultIncompleteHandler: (Diagnostic, Context) -> Unit =
+    (mc, ctx) => ctx.reporter.report(mc)(using ctx)
+
+  /** Show prompt if `-Xprompt` is passed as a flag to the compiler */
+  def displayPrompt(reader: BufferedReader, writer: PrintWriter): Unit = {
+    writer.println()
+    writer.print("a)bort, s)tack, r)esume: ")
+    writer.flush()
+    if (reader != null) {
+      def loop(): Unit = reader.read match {
+        case 'a' | 'A' =>
+          new Throwable().printStackTrace(writer)
+          System.exit(1)
+        case 's' | 'S' =>
+          new Throwable().printStackTrace(writer)
+          writer.println()
+          writer.flush()
+        case 'r' | 'R' =>
+          ()
+        case _ =>
+          loop()
+      }
+      loop()
+    }
+  }
+}
+
+/**
+ * This interface provides methods to issue information, warning and
+ * error messages.
+ */
+abstract class Reporter extends interfaces.ReporterResult {
+  import Reporter._
+
+  /** Report a diagnostic */
+  def doReport(dia: Diagnostic)(using Context): Unit
+
+  /** Whether very long lines can be truncated.  This exists so important
+   *  debugging information (like printing the classpath) is not rendered
+   *  invisible due to the max message length.
+   */
+  private var _truncationOK: Boolean = true
+  def truncationOK: Boolean = _truncationOK
+  def withoutTruncating[T](body: => T): T = {
+    val saved = _truncationOK
+    _truncationOK = false
+    try body
+    finally _truncationOK = saved
+  }
+
+  private var incompleteHandler: ErrorHandler = defaultIncompleteHandler
+
+  def withIncompleteHandler[T](handler: ErrorHandler)(op: => T): T = {
+    val saved = incompleteHandler.unsafeUnbox
+    incompleteHandler = handler
+    try op
+    finally incompleteHandler = saved
+  }
+
+  private def isIncompleteChecking =
+    incompleteHandler.unsafeUnbox ne defaultIncompleteHandler
+
+  private var _errorCount = 0
+  private var _warningCount = 0
+
+  /** The number of errors reported by this reporter (ignoring outer reporters) */
+  def errorCount: Int = _errorCount
+
+  /** The number of warnings reported by this reporter (ignoring outer reporters) */
+  def warningCount: Int = _warningCount
+
+  /** Have errors been reported by this reporter (ignoring outer reporters)? */
+  def hasErrors: Boolean = errorCount > 0
+
+  /** Have warnings been reported by this reporter (ignoring outer reporters)? */
+  def hasWarnings: Boolean = warningCount > 0
+
+  private var errors: List[Error] = Nil
+
+  /** All errors reported by this reporter (ignoring outer reporters) */
+  def allErrors: List[Error] = errors
+
+  /** Were sticky errors reported? Overridden in StoreReporter. */
+  def hasStickyErrors: Boolean = false
+
+  /** Have errors been reported by this reporter, or in the
+   *  case where this is a StoreReporter, by an outer reporter?
+   */
+  def errorsReported: Boolean = hasErrors
+
+  /** Run `op` and return `true` if errors were reported by this reporter.
+   */
+  def reportsErrorsFor(op: Context ?=> Unit)(using Context): Boolean = {
+    val initial = errorCount
+    op
+    errorCount > initial
+  }
+
+  private var reportedFeaturesUseSites = Set[Symbol]()
+
+  def isReportedFeatureUseSite(featureTrait: Symbol): Boolean =
+    featureTrait.ne(NoSymbol) && reportedFeaturesUseSites.contains(featureTrait)
+
+  def reportNewFeatureUseSite(featureTrait: Symbol): Unit = reportedFeaturesUseSites += featureTrait
+
+  var unreportedWarnings: Map[String, Int] = Map.empty
+
+  def addUnreported(key: String, n: Int): Unit =
+    val count = unreportedWarnings.getOrElse(key, 0)
+    unreportedWarnings = unreportedWarnings.updated(key, count + n)
+
+  /** Issue the diagnostic, ignoring `-Wconf` and `@nowarn` configurations,
+   *  but still honouring `-nowarn`, `-Werror`, and conditional warnings. */
+  def issueUnconfigured(dia: Diagnostic)(using Context): Unit = dia match
+    case w: Warning if ctx.settings.silentWarnings.value    =>
+    case w: ConditionalWarning if w.isSummarizedConditional =>
+      val key = w.enablingOption.name
+      addUnreported(key, 1)
+    case _                                                  =>
+      // conditional warnings that are not enabled are not fatal
+      val d = dia match
+        case w: Warning if ctx.settings.XfatalWarnings.value => w.toError
+        case _                                               => dia
+      if !isHidden(d) then // avoid isHidden test for summarized warnings so that message is not forced
+        markReported(d)
+        withMode(Mode.Printing)(doReport(d))
+        d match {
+          case _: Warning => _warningCount += 1
+          case e: Error   =>
+            errors = e :: errors
+            _errorCount += 1
+            if ctx.typerState.isGlobalCommittable then
+              ctx.base.errorsToBeReported = true
+          case _: Info    => // nothing to do here
+          // match error if d is something else
+        }
+  end issueUnconfigured
+
+  def issueIfNotSuppressed(dia: Diagnostic)(using Context): Unit =
+    def go() =
+      import Action._
+      dia match
+        case w: Warning => WConf.parsed.action(w) match
+          case Error   => issueUnconfigured(w.toError)
+          case Warning => issueUnconfigured(w)
+          case Verbose => issueUnconfigured(w.setVerbose())
+          case Info    => issueUnconfigured(w.toInfo)
+          case Silent  =>
+        case _ => issueUnconfigured(dia)
+
+    // `ctx.run` can be null in test, also in the repl when parsing the first line. The parser runs early, the Run is
+    // only created in ReplDriver.compile when a line is submitted. This means that `@nowarn` doesnt work on parser
+    // warnings in the first line.
+    val run = ctx.run
+    dia match
+      case w: Warning if run != null =>
+        val sup = run.suppressions
+        if sup.suppressionsComplete(w.pos.source) then sup.nowarnAction(w) match
+          case Action.Warning => go()
+          case Action.Verbose => w.setVerbose(); go()
+          case Action.Silent =>
+        else
+          // ParseResult.isIncomplete creates a new source file and reporter to check if the input is complete.
+          // The reporter's warnings are discarded, and we should not add them to the run's suspended messages,
+          // otherwise they are later reported.
+          if !isIncompleteChecking then
+            sup.addSuspendedMessage(w)
+      case _ => go()
+  end issueIfNotSuppressed
+
+  def report(dia: Diagnostic)(using Context): Unit = issueIfNotSuppressed(dia)
+
+  def incomplete(dia: Diagnostic)(using Context): Unit =
+    incompleteHandler.unsafeUnbox(dia, ctx)
+
+  /** Summary of warnings and errors */
+  def summary: String = {
+    val b = new mutable.ListBuffer[String]
+    if (warningCount > 0)
+      b += countString(warningCount, "warning") + " found"
+    if (errorCount > 0)
+      b += countString(errorCount, "error") + " found"
+    b.mkString("\n")
+  }
+
+  def summarizeUnreportedWarnings()(using Context): Unit =
+    for (settingName, count) <- unreportedWarnings do
+      val were = if count == 1 then "was" else "were"
+      val msg = s"there $were ${countString(count, settingName.tail + " warning")}; re-run with $settingName for details"
+      report(Warning(msg.toMessage, NoSourcePosition))
+
+  /** Print the summary of warnings and errors */
+  def printSummary()(using Context): Unit = {
+    val s = summary
+    if (s != "") report(new Info(s, NoSourcePosition))
+  }
+
+  /** Returns a string meaning "n elements". */
+  protected def countString(n: Int, elements: String): String = n match {
+    case 0 => s"no ${elements}s"
+    case 1 => s"1 ${elements}"
+    case _ => s"$n ${elements}s"
+  }
+
+  /** Should this diagnostic not be reported at all? */
+  def isHidden(dia: Diagnostic)(using Context): Boolean =
+    ctx.mode.is(Mode.Printing)
+
+  def markReported(dia: Diagnostic)(using Context): Unit = ()
+
+  /** Does this reporter contain errors that have yet to be reported by its outer reporter ?
+   *  Note: this is always false when there is no outer reporter.
+   */
+  def hasUnreportedErrors: Boolean = false
+
+  /** Does this reporter contain any message that have yet to be reported by its outer reporter ?
+   *  This includes any warning stored in `unreportedWarnings` which need to be propagated to
+   *  get an accurate count of unreported warnings in the outer reporter.
+   */
+  def hasUnreportedMessages(using Context): Boolean =
+    pendingMessages.nonEmpty || unreportedWarnings.nonEmpty
+
+  /** If this reporter buffers messages, remove and return all buffered messages. */
+  def removeBufferedMessages(using Context): List[Diagnostic] = Nil
+
+  /** Issue all messages in this reporter to next outer one, or make sure they are written. */
+  def flush()(using Context): Unit =
+    val msgs = removeBufferedMessages
+    if msgs.nonEmpty then msgs.foreach(ctx.reporter.report)
+    for (key, count) <- unreportedWarnings do
+      ctx.reporter.addUnreported(key, count)
+    unreportedWarnings = Map.empty
+
+  /** If this reporter buffers messages, all buffered messages, otherwise Nil */
+  def pendingMessages(using Context): List[Diagnostic] = Nil
+}
diff --git a/tests/pos-with-compiler-cc/dotc/reporting/StoreReporter.scala b/tests/pos-with-compiler-cc/dotc/reporting/StoreReporter.scala
new file mode 100644
index 000000000000..9783a3208a60
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/reporting/StoreReporter.scala
@@ -0,0 +1,51 @@
+package dotty.tools
+package dotc
+package reporting
+
+import core.Contexts._
+import collection.mutable
+import config.Printers.typr
+import Diagnostic._
+
+/** This class implements a Reporter that stores all messages
+  *
+  * Beware that this reporter can leak memory, and force messages in two
+  * scenarios:
+  *
+  * - During debugging `config.Printers.typr` is set from `noPrinter` to `new
+  *   Printer`, which forces the message
+  * - The reporter is not flushed and the message containers capture a
+  *   `Context` (about 4MB)
+  */
+class StoreReporter(outer: Reporter | Null = Reporter.NoReporter, fromTyperState: Boolean = false) extends Reporter {
+
+  protected var infos: mutable.ListBuffer[Diagnostic] | Null = null
+
+  def doReport(dia: Diagnostic)(using Context): Unit = {
+    typr.println(s">>>> StoredError: ${dia.message}") // !!! DEBUG
+    if (infos == null) infos = new mutable.ListBuffer
+    infos.uncheckedNN += dia
+  }
+
+  override def hasUnreportedErrors: Boolean =
+    outer != null && infos != null && infos.uncheckedNN.exists(_.isInstanceOf[Error])
+
+  override def hasStickyErrors: Boolean =
+    infos != null && infos.uncheckedNN.exists(_.isInstanceOf[StickyError])
+
+  override def removeBufferedMessages(using Context): List[Diagnostic] =
+    if (infos != null) try infos.uncheckedNN.toList finally infos = null
+    else Nil
+
+  override def pendingMessages(using Context): List[Diagnostic] =
+    if (infos != null) infos.uncheckedNN.toList else Nil
+
+  override def errorsReported: Boolean = hasErrors || (outer != null && outer.errorsReported)
+
+  // If this is a TyperState buffering reporter then buffer the messages,
+  // so that then only when the messages are unbuffered (when the reporter if flushed)
+  // do they go through -Wconf, and possibly then buffered on the Run as a suspended message
+  override def report(dia: Diagnostic)(using Context): Unit =
+    if fromTyperState then issueUnconfigured(dia)
+    else super.report(dia)
+}
diff --git a/tests/pos-with-compiler-cc/dotc/reporting/TestReporter.scala b/tests/pos-with-compiler-cc/dotc/reporting/TestReporter.scala
new file mode 100644
index 000000000000..8d7204a93fa2
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/reporting/TestReporter.scala
@@ -0,0 +1,14 @@
+package dotty.tools
+package dotc
+package reporting
+
+import scala.language.unsafeNulls
+
+import collection.mutable
+import Diagnostic._
+
+/** A re-usable Reporter used in Contexts#test */
+class TestingReporter extends StoreReporter(null, fromTyperState = false):
+  infos = new mutable.ListBuffer[Diagnostic]
+  override def hasUnreportedErrors: Boolean = infos.exists(_.isInstanceOf[Error])
+  def reset(): Unit = infos.clear()
diff --git a/tests/pos-with-compiler-cc/dotc/reporting/ThrowingReporter.scala b/tests/pos-with-compiler-cc/dotc/reporting/ThrowingReporter.scala
new file mode 100644
index 000000000000..ad47a9d30536
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/reporting/ThrowingReporter.scala
@@ -0,0 +1,17 @@
+package dotty.tools
+package dotc
+package reporting
+
+import core.Contexts._
+import Diagnostic.Error
+
+/**
+ * This class implements a Reporter that throws all errors and sends warnings and other
+ * info to the underlying reporter.
+ */
+class ThrowingReporter(reportInfo: Reporter) extends Reporter {
+  def doReport(dia: Diagnostic)(using Context): Unit = dia match {
+    case _: Error => throw dia
+    case _ => reportInfo.doReport(dia)
+  }
+}
diff --git a/tests/pos-with-compiler-cc/dotc/reporting/UniqueMessagePositions.scala b/tests/pos-with-compiler-cc/dotc/reporting/UniqueMessagePositions.scala
new file mode 100644
index 000000000000..98fd7da3032a
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/reporting/UniqueMessagePositions.scala
@@ -0,0 +1,38 @@
+package dotty.tools
+package dotc
+package reporting
+
+import scala.collection.mutable
+import util.SourceFile
+import core.Contexts._
+
+/** This trait implements `isHidden` so that multiple messages per position
+  * are suppressed, unless they are of increasing severity. */
+trait UniqueMessagePositions extends Reporter {
+
+  private val positions = new mutable.HashMap[(SourceFile, Integer), Diagnostic]
+
+  extension (dia1: Diagnostic)
+    private def hides(dia2: Diagnostic)(using Context): Boolean =
+      if dia2.msg.showAlways then dia1.msg.getClass == dia2.msg.getClass
+      else dia1.level >= dia2.level
+
+  /** Logs a position and returns true if it was already logged.
+   *  @note  Two positions are considered identical for logging if they have the same point.
+   */
+  override def isHidden(dia: Diagnostic)(using Context): Boolean =
+    super.isHidden(dia)
+    ||
+      dia.pos.exists
+      && !ctx.settings.YshowSuppressedErrors.value
+      && (dia.pos.start to dia.pos.end).exists(pos =>
+            positions.get((ctx.source, pos)).exists(_.hides(dia)))
+
+  override def markReported(dia: Diagnostic)(using Context): Unit =
+    if dia.pos.exists then
+      for (pos <- dia.pos.start to dia.pos.end)
+        positions.get(ctx.source, pos) match
+          case Some(dia1) if dia1.hides(dia) =>
+          case _ => positions((ctx.source, pos)) = dia
+    super.markReported(dia)
+}
diff --git a/tests/pos-with-compiler-cc/dotc/reporting/WConf.scala b/tests/pos-with-compiler-cc/dotc/reporting/WConf.scala
new file mode 100644
index 000000000000..21e10e894e0b
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/reporting/WConf.scala
@@ -0,0 +1,126 @@
+package dotty.tools
+package dotc
+package reporting
+
+import scala.language.unsafeNulls
+
+import dotty.tools.dotc.core.Contexts._
+import dotty.tools.dotc.util.SourcePosition
+
+import java.util.regex.PatternSyntaxException
+import scala.annotation.internal.sharable
+import scala.util.matching.Regex
+
+enum MessageFilter:
+  def matches(message: Diagnostic): Boolean = this match
+    case Any => true
+    case Deprecated => message.isInstanceOf[Diagnostic.DeprecationWarning]
+    case Feature => message.isInstanceOf[Diagnostic.FeatureWarning]
+    case Unchecked => message.isInstanceOf[Diagnostic.UncheckedWarning]
+    case MessagePattern(pattern) =>
+      val noHighlight = message.msg.rawMessage.replaceAll("\\e\\[[\\d;]*[^\\d;]","")
+      pattern.findFirstIn(noHighlight).nonEmpty
+    case MessageID(errorId) => message.msg.errorId == errorId
+    case None => false
+
+  case Any, Deprecated, Feature, Unchecked, None
+  case MessagePattern(pattern: Regex)
+  case MessageID(errorId: ErrorMessageID)
+
+enum Action:
+  case Error, Warning, Verbose, Info, Silent
+
+final case class WConf(confs: List[(List[MessageFilter], Action)]):
+  def action(message: Diagnostic): Action = confs.collectFirst {
+    case (filters, action) if filters.forall(_.matches(message)) => action
+  }.getOrElse(Action.Warning)
+
+object WConf:
+  import Action._
+  import MessageFilter._
+
+  private type Conf = (List[MessageFilter], Action)
+
+  def parseAction(s: String): Either[List[String], Action] = s match
+    case "error" | "e"            => Right(Error)
+    case "warning" | "w"          => Right(Warning)
+    case "verbose" | "v"          => Right(Verbose)
+    case "info" | "i"             => Right(Info)
+    case "silent" | "s"           => Right(Silent)
+    case _                        => Left(List(s"unknown action: `$s`"))
+
+  private def regex(s: String) =
+    try Right(s.r)
+    catch case e: PatternSyntaxException => Left(s"invalid pattern `$s`: ${e.getMessage}")
+
+  @sharable val Splitter = raw"([^=]+)=(.+)".r
+  @sharable val ErrorId = raw"E?(\d+)".r
+
+  def parseFilters(s: String): Either[List[String], List[MessageFilter]] =
+    // TODO: don't split on escaped \&
+    val (parseErrors, filters) = s.split('&').toList.partitionMap(parseFilter)
+    if parseErrors.nonEmpty then Left(parseErrors)
+    else if filters.isEmpty then Left(List("no filters or no action defined"))
+    else Right(filters)
+
+  def parseFilter(s: String): Either[String, MessageFilter] = s match
+    case "any" => Right(Any)
+    case Splitter(filter, conf) => filter match
+      case "msg" => regex(conf).map(MessagePattern.apply)
+      case "id" => conf match
+        case ErrorId(num) =>
+          ErrorMessageID.fromErrorNumber(num.toInt) match
+            case Some(errId) if errId.isActive => Right(MessageID(errId))
+            case Some(errId) => Left(s"E${num} is marked as inactive.")
+            case _ => Left(s"Unknown error message number: E${num}")
+        case _ =>
+          Left(s"invalid error message id: $conf")
+      case "name" =>
+        try Right(MessageID(ErrorMessageID.valueOf(conf + "ID")))
+        catch case _: IllegalArgumentException => Left(s"unknown error message name: $conf")
+
+      case "cat" => conf match
+        case "deprecation" => Right(Deprecated)
+        case "feature"     => Right(Feature)
+        case "unchecked"   => Right(Unchecked)
+        case _             => Left(s"unknown category: $conf")
+      case _ => Left(s"unknown filter: $filter")
+    case _ => Left(s"unknown filter: $s")
+
+  def parsed(using Context): WConf =
+    val setting = ctx.settings.Wconf.value
+    def cached = ctx.base.wConfCache
+    if cached == null || cached._1 != setting then
+      val conf = fromSettings(setting)
+      ctx.base.wConfCache = (setting, conf.getOrElse(WConf(Nil)))
+      conf.swap.foreach(msgs =>
+        val multiHelp =
+          if setting.sizeIs > 1 then
+            """
+              |Note: for multiple filters, use `-Wconf:filter1:action1,filter2:action2`
+              |      or alternatively          `-Wconf:filter1:action1 -Wconf:filter2:action2`""".stripMargin
+          else ""
+        report.warning(s"Failed to parse `-Wconf` configuration: ${ctx.settings.Wconf.value.mkString(",")}\n${msgs.mkString("\n")}$multiHelp"))
+    cached._2
+
+  def fromSettings(settings: List[String]): Either[List[String], WConf] =
+    if (settings.isEmpty) Right(WConf(Nil))
+    else
+      val parsedConfs: List[Either[List[String], (List[MessageFilter], Action)]] = settings.map(conf =>
+        val filtersAndAction = conf.split(':')
+        if filtersAndAction.length != 2 then Left(List("exactly one `:` expected (<filter>&...&<filter>:<action>)"))
+        else
+          parseFilters(filtersAndAction(0)).flatMap(filters =>
+            parseAction(filtersAndAction(1)).map((filters, _))))
+      val (parseErrorss, configs) = parsedConfs.partitionMap(identity)
+      if (parseErrorss.nonEmpty) Left(parseErrorss.flatten)
+      else Right(WConf(configs))
+
+class Suppression(val annotPos: SourcePosition, filters: List[MessageFilter], val start: Int, end: Int, val verbose: Boolean):
+  private[this] var _used = false
+  def used: Boolean = _used
+  def markUsed(): Unit = { _used = true }
+
+  def matches(dia: Diagnostic): Boolean =
+    val pos = dia.pos
+    pos.exists && start <= pos.start && pos.end <= end && filters.forall(_.matches(dia))
diff --git a/tests/pos-with-compiler-cc/dotc/reporting/messages.scala b/tests/pos-with-compiler-cc/dotc/reporting/messages.scala
new file mode 100644
index 000000000000..06bd76dfceda
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/reporting/messages.scala
@@ -0,0 +1,2537 @@
+package dotty.tools
+package dotc
+package reporting
+
+import core._
+import Contexts._
+import Decorators._, Symbols._, Names._, NameOps._, Types._, Flags._, Phases._
+import Denotations.SingleDenotation
+import SymDenotations.SymDenotation
+import NameKinds.WildcardParamName
+import parsing.Scanners.Token
+import parsing.Tokens
+import printing.Highlighting._
+import printing.Formatting
+import ErrorMessageID._
+import ast.Trees
+import config.{Feature, ScalaVersion}
+import typer.ErrorReporting.{err, matchReductionAddendum}
+import typer.ProtoTypes.ViewProto
+import typer.Implicits.Candidate
+import scala.util.control.NonFatal
+import StdNames.nme
+import printing.Formatting.hl
+import ast.Trees._
+import ast.untpd
+import ast.tpd
+import transform.SymUtils._
+import cc.CaptureSet.IdentityCaptRefMap
+import language.experimental.pureFunctions
+
+/**  Messages
+  *  ========
+  *  The role of messages is to provide the necessary details for a simple to
+  *  understand diagnostic event. Each message can be turned into a message
+  *  container (one of the above) by calling the appropriate method on them.
+  *  For instance:
+  *
+  *  ```scala
+  *  EmptyCatchBlock(tree).error(pos)   // res: Error
+  *  EmptyCatchBlock(tree).warning(pos) // res: Warning
+  *  ```
+  */
+
+  abstract class SyntaxMsg(errorId: ErrorMessageID) extends Message(errorId):
+    def kind = MessageKind.Syntax
+
+  abstract class TypeMsg(errorId: ErrorMessageID) extends Message(errorId):
+    def kind = MessageKind.Type
+
+  trait ShowMatchTrace(tps: Type*)(using Context) extends Message:
+    override def msgSuffix: String = matchReductionAddendum(tps*)
+
+  abstract class TypeMismatchMsg(found: Type, expected: Type)(errorId: ErrorMessageID)(using Context)
+  extends Message(errorId), ShowMatchTrace(found, expected):
+    def kind = MessageKind.TypeMismatch
+    def explain = err.whyNoMatchStr(found, expected)
+    override def canExplain = true
+
+  abstract class NamingMsg(errorId: ErrorMessageID) extends Message(errorId):
+    def kind = MessageKind.Naming
+
+  abstract class DeclarationMsg(errorId: ErrorMessageID) extends Message(errorId):
+    def kind = MessageKind.Declaration
+
+  /** A simple not found message (either for idents, or member selection.
+   *  Messages of this class are sometimes dropped in favor of other, more
+   *  specific messages.
+   */
+  abstract class NotFoundMsg(errorId: ErrorMessageID) extends Message(errorId):
+    def kind = MessageKind.NotFound
+    def name: Name
+
+  abstract class PatternMatchMsg(errorId: ErrorMessageID) extends Message(errorId):
+    def kind = MessageKind.PatternMatch
+
+  abstract class CyclicMsg(errorId: ErrorMessageID) extends Message(errorId):
+    def kind = MessageKind.Cyclic
+
+  abstract class ReferenceMsg(errorId: ErrorMessageID) extends Message(errorId):
+    def kind = MessageKind.Reference
+
+  abstract class EmptyCatchOrFinallyBlock(tryBody: untpd.Tree, errNo: ErrorMessageID)(using Context)
+  extends SyntaxMsg(errNo) {
+    def explain = {
+      val tryString = tryBody match {
+        case Block(Nil, untpd.EmptyTree) => "{}"
+        case _ => tryBody.show
+      }
+
+      val code1 =
+        s"""|import scala.util.control.NonFatal
+            |
+            |try $tryString catch {
+            |  case NonFatal(e) => ???
+            |}""".stripMargin
+
+      val code2 =
+        s"""|try $tryString finally {
+            |  // perform your cleanup here!
+            |}""".stripMargin
+
+      em"""|A ${hl("try")} expression should be followed by some mechanism to handle any exceptions
+           |thrown. Typically a ${hl("catch")} expression follows the ${hl("try")} and pattern matches
+           |on any expected exceptions. For example:
+           |
+           |$code1
+           |
+           |It is also possible to follow a ${hl("try")} immediately by a ${hl("finally")} - letting the
+           |exception propagate - but still allowing for some clean up in ${hl("finally")}:
+           |
+           |$code2
+           |
+           |It is recommended to use the ${hl("NonFatal")} extractor to catch all exceptions as it
+           |correctly handles transfer functions like ${hl("return")}."""
+    }
+  }
+
+  class EmptyCatchBlock(tryBody: untpd.Tree)(using Context)
+  extends EmptyCatchOrFinallyBlock(tryBody, EmptyCatchBlockID) {
+    def msg =
+      em"""|The ${hl("catch")} block does not contain a valid expression, try
+           |adding a case like - ${hl("case e: Exception =>")} to the block"""
+  }
+
+  class EmptyCatchAndFinallyBlock(tryBody: untpd.Tree)(using Context)
+  extends EmptyCatchOrFinallyBlock(tryBody, EmptyCatchAndFinallyBlockID) {
+    def msg =
+      em"""|A ${hl("try")} without ${hl("catch")} or ${hl("finally")} is equivalent to putting
+           |its body in a block; no exceptions are handled."""
+  }
+
+  class DeprecatedWithOperator()(using Context)
+  extends SyntaxMsg(DeprecatedWithOperatorID) {
+    def msg =
+      em"""${hl("with")} as a type operator has been deprecated; use ${hl("&")} instead"""
+    def explain =
+      em"""|Dotty introduces intersection types - ${hl("&")} types. These replace the
+           |use of the ${hl("with")} keyword. There are a few differences in
+           |semantics between intersection types and using ${hl("with")}."""
+  }
+
+  class CaseClassMissingParamList(cdef: untpd.TypeDef)(using Context)
+  extends SyntaxMsg(CaseClassMissingParamListID) {
+    def msg =
+      em"""|A ${hl("case class")} must have at least one parameter list"""
+
+    def explain =
+      em"""|${cdef.name} must have at least one parameter list, if you would rather
+           |have a singleton representation of ${cdef.name}, use a "${hl("case object")}".
+           |Or, add an explicit ${hl("()")} as a parameter list to ${cdef.name}."""
+  }
+
+  class AnonymousFunctionMissingParamType(param: untpd.ValDef,
+                                          tree: untpd.Function,
+                                          pt: Type)
+                                          (using Context)
+  extends TypeMsg(AnonymousFunctionMissingParamTypeID) {
+    def msg = {
+      val ofFun =
+        if param.name.is(WildcardParamName)
+           || (MethodType.syntheticParamNames(tree.args.length + 1) contains param.name)
+        then i" of expanded function:\n$tree"
+        else ""
+
+      val inferred =
+        if (pt == WildcardType) ""
+        else i"\nWhat I could infer was: $pt"
+
+      i"""Missing parameter type
+         |
+         |I could not infer the type of the parameter ${param.name}$ofFun.$inferred"""
+    }
+
+    def explain = ""
+  }
+
+  class WildcardOnTypeArgumentNotAllowedOnNew()(using Context)
+  extends SyntaxMsg(WildcardOnTypeArgumentNotAllowedOnNewID) {
+    def msg = "Type argument must be fully defined"
+    def explain =
+      val code1: String =
+        """
+          |object TyperDemo {
+          |  class Team[A]
+          |  val team = new Team[?]
+          |}
+        """.stripMargin
+
+      val code2: String =
+        """
+          |object TyperDemo {
+          |  class Team[A]
+          |  val team = new Team[Int]
+          |}
+        """.stripMargin
+      em"""|Wildcard on arguments is not allowed when declaring a new type.
+           |
+           |Given the following example:
+           |
+           |$code1
+           |
+           |You must complete all the type parameters, for instance:
+           |
+           |$code2 """
+  }
+
+
+  // Type Errors ------------------------------------------------------------ //
+  class DuplicateBind(bind: untpd.Bind, tree: untpd.CaseDef)(using Context)
+  extends NamingMsg(DuplicateBindID) {
+    def msg = em"duplicate pattern variable: ${bind.name}"
+
+    def explain = {
+      val pat = tree.pat.show
+      val guard = tree.guard match {
+        case untpd.EmptyTree => ""
+        case guard => s"if ${guard.show}"
+      }
+
+      val body = tree.body match {
+        case Block(Nil, untpd.EmptyTree) => ""
+        case body => s" ${body.show}"
+      }
+
+      val caseDef = s"case $pat$guard => $body"
+
+      em"""|For each ${hl("case")} bound variable names have to be unique. In:
+           |
+           |$caseDef
+           |
+           |${bind.name} is not unique. Rename one of the bound variables!"""
+    }
+  }
+
+  class MissingIdent(tree: untpd.Ident, treeKind: String, val name: Name)(using Context)
+  extends NotFoundMsg(MissingIdentID) {
+    def msg = em"Not found: $treeKind$name"
+    def explain = {
+      em"""|The identifier for `$treeKind$name` is not bound, that is,
+           |no declaration for this identifier can be found.
+           |That can happen, for example, if `$name` or its declaration has either been
+           |misspelt or if an import is missing."""
+    }
+  }
+
+  class TypeMismatch(found: Type,  expected: Type, inTree: Option[untpd.Tree],  addenda: -> String*)(using Context)
+    extends TypeMismatchMsg(found, expected)(TypeMismatchID):
+
+    // replace constrained TypeParamRefs and their typevars by their bounds where possible
+    // and the bounds are not f-bounds.
+    // The idea is that if the bounds are also not-subtypes of each other to report
+    // the type mismatch on the bounds instead of the original TypeParamRefs, since
+    // these are usually easier to analyze. We exclude F-bounds since these would
+    // lead to a recursive infinite expansion.
+    object reported extends TypeMap, IdentityCaptRefMap:
+      def setVariance(v: Int) = variance = v
+      val constraint = mapCtx.typerState.constraint
+      var fbounded = false
+      def apply(tp: Type): Type = tp match
+        case tp: TypeParamRef =>
+          constraint.entry(tp) match
+            case bounds: TypeBounds =>
+              if variance < 0 then apply(TypeComparer.fullUpperBound(tp))
+              else if variance > 0 then apply(TypeComparer.fullLowerBound(tp))
+              else tp
+            case NoType => tp
+            case instType => apply(instType)
+        case tp: TypeVar =>
+          apply(tp.stripTypeVar)
+        case tp: LazyRef =>
+          fbounded = true
+          tp
+        case _ =>
+          mapOver(tp)
+
+    def msg =
+      val found1 = reported(found)
+      reported.setVariance(-1)
+      val expected1 = reported(expected)
+      val (found2, expected2) =
+        if (found1 frozen_<:< expected1) || reported.fbounded then (found, expected)
+        else (found1, expected1)
+      val postScript = addenda.find(!_.isEmpty) match
+        case Some(p) => p
+        case None =>
+          if expected.isTopType || found.isBottomType
+          then ""
+          else ctx.typer.importSuggestionAddendum(ViewProto(found.widen, expected))
+      val (where, printCtx) = Formatting.disambiguateTypes(found2, expected2)
+      val whereSuffix = if (where.isEmpty) where else s"\n\n$where"
+      val (foundStr, expectedStr) = Formatting.typeDiff(found2, expected2)(using printCtx)
+      s"""|Found:    $foundStr
+          |Required: $expectedStr""".stripMargin
+        + whereSuffix + postScript
+
+    override def explain =
+      val treeStr = inTree.map(x => s"\nTree: ${x.show}").getOrElse("")
+      treeStr + "\n" + super.explain
+
+  end TypeMismatch
+
+  class NotAMember(site: Type, val name: Name, selected: String, addendum: -> String = "")(using Context)
+  extends NotFoundMsg(NotAMemberID), ShowMatchTrace(site) {
+    //println(i"site = $site, decls = ${site.decls}, source = ${site.typeSymbol.sourceFile}") //DEBUG
+
+    def msg = {
+      import core.Flags._
+      val maxDist = 3  // maximal number of differences to be considered for a hint
+      val missing = name.show
+
+      // The symbols of all non-synthetic, non-private members of `site`
+      // that are of the same type/term kind as the missing member.
+      def candidates: Set[Symbol] =
+        for
+          bc <- site.widen.baseClasses.toSet
+          sym <- bc.info.decls.filter(sym =>
+            sym.isType == name.isTypeName
+            && !sym.isConstructor
+            && !sym.flagsUNSAFE.isOneOf(Synthetic | Private))
+        yield sym
+
+      // Calculate Levenshtein distance
+      def distance(s1: String, s2: String): Int =
+        val dist = Array.ofDim[Int](s2.length + 1, s1.length + 1)
+        for
+          j <- 0 to s2.length
+          i <- 0 to s1.length
+        do
+          dist(j)(i) =
+            if j == 0 then i
+            else if i == 0 then j
+            else if s2(j - 1) == s1(i - 1) then dist(j - 1)(i - 1)
+            else (dist(j - 1)(i) min dist(j)(i - 1) min dist(j - 1)(i - 1)) + 1
+        dist(s2.length)(s1.length)
+
+      // A list of possible candidate symbols with their Levenstein distances
+      // to the name of the missing member
+      def closest: List[(Int, Symbol)] = candidates
+        .toList
+        .map(sym => (distance(sym.name.show, missing), sym))
+        .filter((d, sym) => d <= maxDist && d < missing.length && d < sym.name.show.length)
+        .sortBy((d, sym) => (d, sym.name.show))  // sort by distance first, alphabetically second
+
+      val enumClause =
+        if ((name eq nme.values) || (name eq nme.valueOf)) && site.classSymbol.companionClass.isEnumClass then
+          val kind = if name eq nme.values then i"${nme.values} array" else i"${nme.valueOf} lookup method"
+          // an assumption is made here that the values and valueOf methods were not generated
+          // because the enum defines non-singleton cases
+          i"""
+              |Although ${site.classSymbol.companionClass} is an enum, it has non-singleton cases,
+              |meaning a $kind is not defined"""
+        else
+          ""
+
+      def prefixEnumClause(addendum: String) =
+        if enumClause.nonEmpty then s".$enumClause$addendum" else addendum
+
+      val finalAddendum =
+        if addendum.nonEmpty then prefixEnumClause(addendum)
+        else closest match
+          case (d, sym) :: _ =>
+            val siteName = site match
+              case site: NamedType => site.name.show
+              case site => i"$site"
+            val showName =
+              // Add .type to the name if it is a module
+              if sym.is(ModuleClass) then s"${sym.name.show}.type"
+              else sym.name.show
+            s" - did you mean $siteName.$showName?$enumClause"
+          case Nil => prefixEnumClause("")
+
+      ex"$selected $name is not a member of ${site.widen}$finalAddendum"
+    }
+
+    def explain = ""
+  }
+
+  class EarlyDefinitionsNotSupported()(using Context)
+  extends SyntaxMsg(EarlyDefinitionsNotSupportedID) {
+    def msg = "Early definitions are not supported; use trait parameters instead"
+
+    def explain = {
+      val code1 =
+        """|trait Logging {
+           |  val f: File
+           |  f.open()
+           |  onExit(f.close())
+           |  def log(msg: String) = f.write(msg)
+           |}
+           |
+           |class B extends Logging {
+           |  val f = new File("log.data") // triggers a NullPointerException
+           |}
+           |
+           |// early definition gets around the NullPointerException
+           |class C extends {
+           |  val f = new File("log.data")
+           |} with Logging""".stripMargin
+
+      val code2 =
+        """|trait Logging(f: File) {
+           |  f.open()
+           |  onExit(f.close())
+           |  def log(msg: String) = f.write(msg)
+           |}
+           |
+           |class C extends Logging(new File("log.data"))""".stripMargin
+
+      em"""|Earlier versions of Scala did not support trait parameters and "early
+           |definitions" (also known as "early initializers") were used as an alternative.
+           |
+           |Example of old syntax:
+           |
+           |$code1
+           |
+           |The above code can now be written as:
+           |
+           |$code2
+           |"""
+    }
+  }
+
+  class TopLevelImplicitClass(cdef: untpd.TypeDef)(using Context)
+  extends SyntaxMsg(TopLevelImplicitClassID) {
+    def msg = em"""An ${hl("implicit class")} may not be top-level"""
+
+    def explain = {
+      val TypeDef(name, impl @ Template(constr0, parents, self, _)) = cdef: @unchecked
+      val exampleArgs =
+        if(constr0.termParamss.isEmpty) "..."
+        else constr0.termParamss(0).map(_.withMods(untpd.Modifiers()).show).mkString(", ")
+      def defHasBody[T] = impl.body.exists(!_.isEmpty)
+      val exampleBody = if (defHasBody) "{\n ...\n }" else ""
+      em"""|There may not be any method, member or object in scope with the same name as
+           |the implicit class and a case class automatically gets a companion object with
+           |the same name created by the compiler which would cause a naming conflict if it
+           |were allowed.
+           |           |
+           |To resolve the conflict declare ${cdef.name} inside of an ${hl("object")} then import the class
+           |from the object at the use site if needed, for example:
+           |
+           |object Implicits {
+           |  implicit class ${cdef.name}($exampleArgs)$exampleBody
+           |}
+           |
+           |// At the use site:
+           |import Implicits.${cdef.name}"""
+    }
+  }
+
+  class ImplicitCaseClass(cdef: untpd.TypeDef)(using Context)
+  extends SyntaxMsg(ImplicitCaseClassID) {
+    def msg = em"""A ${hl("case class")} may not be defined as ${hl("implicit")}"""
+
+    def explain =
+      em"""|Implicit classes may not be case classes. Instead use a plain class:
+           |
+           |implicit class ${cdef.name}...
+           |
+           |"""
+  }
+
+  class ImplicitClassPrimaryConstructorArity()(using Context)
+  extends SyntaxMsg(ImplicitClassPrimaryConstructorArityID){
+    def msg = "Implicit classes must accept exactly one primary constructor parameter"
+    def explain = {
+      val example = "implicit class RichDate(date: java.util.Date)"
+      em"""Implicit classes may only take one non-implicit argument in their constructor. For example:
+          |
+          | $example
+          |
+          |While it’s possible to create an implicit class with more than one non-implicit argument,
+          |such classes aren’t used during implicit lookup.
+          |"""
+    }
+  }
+
+  class ObjectMayNotHaveSelfType(mdef: untpd.ModuleDef)(using Context)
+  extends SyntaxMsg(ObjectMayNotHaveSelfTypeID) {
+    def msg = em"""${hl("object")}s must not have a self ${hl("type")}"""
+
+    def explain = {
+      val untpd.ModuleDef(name, tmpl) = mdef
+      val ValDef(_, selfTpt, _) = tmpl.self
+      em"""|${hl("object")}s must not have a self ${hl("type")}:
+           |
+           |Consider these alternative solutions:
+           |  - Create a trait or a class instead of an object
+           |  - Let the object extend a trait containing the self type:
+           |
+           |    object $name extends ${selfTpt.show}"""
+    }
+  }
+
+  class RepeatedModifier(modifier: String)(implicit ctx:Context)
+  extends SyntaxMsg(RepeatedModifierID) {
+    def msg = em"""Repeated modifier $modifier"""
+
+    def explain = {
+      val code1 = em"""private private val Origin = Point(0, 0)"""
+      val code2 = em"""private final val Origin = Point(0, 0)"""
+      em"""This happens when you accidentally specify the same modifier twice.
+           |
+           |Example:
+           |
+           |$code1
+           |
+           |instead of
+           |
+           |$code2
+           |
+           |"""
+    }
+  }
+
+  class InterpolatedStringError()(implicit ctx:Context)
+  extends SyntaxMsg(InterpolatedStringErrorID) {
+    def msg = "Error in interpolated string: identifier or block expected"
+    def explain = {
+      val code1 = "s\"$new Point(0, 0)\""
+      val code2 = "s\"${new Point(0, 0)}\""
+      em"""|This usually happens when you forget to place your expressions inside curly braces.
+           |
+           |$code1
+           |
+           |should be written as
+           |
+           |$code2
+           |"""
+    }
+  }
+
+  class UnboundPlaceholderParameter()(implicit ctx:Context)
+  extends SyntaxMsg(UnboundPlaceholderParameterID) {
+    def msg = em"""Unbound placeholder parameter; incorrect use of ${hl("_")}"""
+    def explain =
+      em"""|The ${hl("_")} placeholder syntax was used where it could not be bound.
+           |Consider explicitly writing the variable binding.
+           |
+           |This can be done by replacing ${hl("_")} with a variable (eg. ${hl("x")})
+           |and adding ${hl("x =>")} where applicable.
+           |
+           |Example before:
+           |
+           |${hl("{ _ }")}
+           |
+           |Example after:
+           |
+           |${hl("x => { x }")}
+           |
+           |Another common occurrence for this error is defining a val with ${hl("_")}:
+           |
+           |${hl("val a = _")}
+           |
+           |But this val definition isn't very useful, it can never be assigned
+           |another value. And thus will always remain uninitialized.
+           |Consider replacing the ${hl("val")} with ${hl("var")}:
+           |
+           |${hl("var a = _")}
+           |
+           |Note that this use of ${hl("_")} is not placeholder syntax,
+           |but an uninitialized var definition.
+           |Only fields can be left uninitialized in this manner; local variables
+           |must be initialized.
+           |
+           |Another occurrence for this error is self type definition.
+           |The ${hl("_")} can be replaced with ${hl("this")}.
+           |
+           |Example before:
+           |
+           |${hl("trait A { _: B => ... ")}
+           |
+           |Example after:
+           |
+           |${hl("trait A { this: B => ... ")}
+           |"""
+  }
+
+  class IllegalStartSimpleExpr(illegalToken: String)(using Context)
+  extends SyntaxMsg(IllegalStartSimpleExprID) {
+    def msg = em"expression expected but ${Red(illegalToken)} found"
+    def explain = {
+      em"""|An expression cannot start with ${Red(illegalToken)}."""
+    }
+  }
+
+  class MissingReturnType()(implicit ctx:Context)
+  extends SyntaxMsg(MissingReturnTypeID) {
+    def msg = "Missing return type"
+    def explain =
+      em"""|An abstract declaration must have a return type. For example:
+           |
+           |trait Shape:
+           |  ${hl("def area: Double")} // abstract declaration returning a Double"""
+  }
+
+  class MissingReturnTypeWithReturnStatement(method: Symbol)(using Context)
+  extends SyntaxMsg(MissingReturnTypeWithReturnStatementID) {
+    def msg = em"$method has a return statement; it needs a result type"
+    def explain =
+      em"""|If a method contains a ${hl("return")} statement, it must have an
+           |explicit return type. For example:
+           |
+           |${hl("def good: Int /* explicit return type */ = return 1")}"""
+  }
+
+  class YieldOrDoExpectedInForComprehension()(using Context)
+  extends SyntaxMsg(YieldOrDoExpectedInForComprehensionID) {
+    def msg = em"${hl("yield")} or ${hl("do")} expected"
+
+    def explain =
+      em"""|When the enumerators in a for comprehension are not placed in parentheses or
+           |braces, a ${hl("do")} or ${hl("yield")} statement is required after the enumerators
+           |section of the comprehension.
+           |
+           |You can save some keystrokes by omitting the parentheses and writing
+           |
+           |${hl("val numbers = for i <- 1 to 3 yield i")}
+           |
+           |  instead of
+           |
+           |${hl("val numbers = for (i <- 1 to 3) yield i")}
+           |
+           |but the ${hl("yield")} keyword is still required.
+           |
+           |For comprehensions that simply perform a side effect without yielding anything
+           |can also be written without parentheses but a ${hl("do")} keyword has to be
+           |included. For example,
+           |
+           |${hl("for (i <- 1 to 3) println(i)")}
+           |
+           |can be written as
+           |
+           |${hl("for i <- 1 to 3 do println(i) // notice the 'do' keyword")}
+           |
+           |"""
+  }
+
+  class ProperDefinitionNotFound()(using Context)
+  extends Message(ProperDefinitionNotFoundID) {
+    def kind = MessageKind.DocComment
+    def msg = em"""Proper definition was not found in ${hl("@usecase")}"""
+
+    def explain = {
+      val noUsecase =
+        "def map[B, That](f: A => B)(implicit bf: CanBuildFrom[List[A], B, That]): That"
+
+      val usecase =
+        """|/** Map from List[A] => List[B]
+           |  *
+           |  * @usecase def map[B](f: A => B): List[B]
+           |  */
+           |def map[B, That](f: A => B)(implicit bf: CanBuildFrom[List[A], B, That]): That
+           |""".stripMargin
+
+      em"""|Usecases are only supported for ${hl("def")}s. They exist because with Scala's
+           |advanced type-system, we sometimes end up with seemingly scary signatures.
+           |The usage of these methods, however, needs not be - for instance the ${hl("map")}
+           |function
+           |
+           |${hl("List(1, 2, 3).map(2 * _) // res: List(2, 4, 6)")}
+           |
+           |is easy to understand and use - but has a rather bulky signature:
+           |
+           |$noUsecase
+           |
+           |to mitigate this and ease the usage of such functions we have the ${hl("@usecase")}
+           |annotation for docstrings. Which can be used like this:
+           |
+           |$usecase
+           |
+           |When creating the docs, the signature of the method is substituted by the
+           |usecase and the compiler makes sure that it is valid. Because of this, you're
+           |only allowed to use ${hl("def")}s when defining usecases."""
+    }
+  }
+
+  class ByNameParameterNotSupported(tpe: untpd.Tree)(using Context)
+  extends SyntaxMsg(ByNameParameterNotSupportedID) {
+    def msg = em"By-name parameter type ${tpe} not allowed here."
+
+    def explain =
+      em"""|By-name parameters act like functions that are only evaluated when referenced,
+           |allowing for lazy evaluation of a parameter.
+           |
+           |An example of using a by-name parameter would look like:
+           |${hl("def func(f: => Boolean) = f // 'f' is evaluated when referenced within the function")}
+           |
+           |An example of the syntax of passing an actual function as a parameter:
+           |${hl("def func(f: (Boolean => Boolean)) = f(true)")}
+           |
+           |or:
+           |
+           |${hl("def func(f: Boolean => Boolean) = f(true)")}
+           |
+           |And the usage could be as such:
+           |${hl("func(bool => // do something...)")}
+           |"""
+  }
+
+  class WrongNumberOfTypeArgs(fntpe: Type, expectedArgs: List[ParamInfo], actual: List[untpd.Tree])(using Context)
+  extends SyntaxMsg(WrongNumberOfTypeArgsID) {
+
+    private val expectedCount = expectedArgs.length
+    private val actualCount = actual.length
+    private val msgPrefix = if (actualCount > expectedCount) "Too many" else "Not enough"
+
+    def msg =
+      val expectedArgString = expectedArgs
+        .map(_.paramName.unexpandedName.show)
+        .mkString("[", ", ", "]")
+      val actualArgString = actual.map(_.show).mkString("[", ", ", "]")
+      val prettyName =
+        try fntpe.termSymbol match
+          case NoSymbol => fntpe.show
+          case symbol   => symbol.showFullName
+        catch case NonFatal(ex) => fntpe.show
+      em"""|$msgPrefix type arguments for $prettyName$expectedArgString
+           |expected: $expectedArgString
+           |actual:   $actualArgString""".stripMargin
+
+    def explain = {
+      val tooManyTypeParams =
+        """|val tuple2: (Int, String) = (1, "one")
+           |val list: List[(Int, String)] = List(tuple2)""".stripMargin
+
+      if (actualCount > expectedCount)
+        em"""|You have supplied too many type parameters
+             |
+             |For example List takes a single type parameter (List[A])
+             |If you need to hold more types in a list then you need to combine them
+             |into another data type that can contain the number of types you need,
+             |In this example one solution would be to use a Tuple:
+             |
+             |${tooManyTypeParams}"""
+      else
+        em"""|You have not supplied enough type parameters
+             |If you specify one type parameter then you need to specify every type parameter."""
+    }
+  }
+
+  class IllegalVariableInPatternAlternative(name: Name)(using Context)
+  extends SyntaxMsg(IllegalVariableInPatternAlternativeID) {
+    def msg = em"Illegal variable $name in pattern alternative"
+    def explain = {
+      val varInAlternative =
+        """|def g(pair: (Int,Int)): Int = pair match {
+           |  case (1, n) | (n, 1) => n
+           |  case _ => 0
+           |}""".stripMargin
+
+      val fixedVarInAlternative =
+        """|def g(pair: (Int,Int)): Int = pair match {
+           |  case (1, n) => n
+           |  case (n, 1) => n
+           |  case _ => 0
+           |}""".stripMargin
+
+      em"""|Variables are not allowed within alternate pattern matches. You can workaround
+           |this issue by adding additional cases for each alternative. For example, the
+           |illegal function:
+           |
+           |$varInAlternative
+           |could be implemented by moving each alternative into a separate case:
+           |
+           |$fixedVarInAlternative"""
+    }
+  }
+
+  class IdentifierExpected(identifier: String)(using Context)
+  extends SyntaxMsg(IdentifierExpectedID) {
+    def msg = "identifier expected"
+    def explain = {
+      val wrongIdentifier = em"def foo: $identifier = {...}"
+      val validIdentifier = em"def foo = {...}"
+      em"""|An identifier expected, but $identifier found. This could be because
+           |$identifier is not a valid identifier. As a workaround, the compiler could
+           |infer the type for you. For example, instead of:
+           |
+           |$wrongIdentifier
+           |
+           |Write your code like:
+           |
+           |$validIdentifier
+           |
+           |"""
+    }
+  }
+
+  class AuxConstructorNeedsNonImplicitParameter()(implicit ctx:Context)
+  extends SyntaxMsg(AuxConstructorNeedsNonImplicitParameterID) {
+    def msg = "Auxiliary constructor needs non-implicit parameter list"
+    def explain =
+      em"""|Only the primary constructor is allowed an ${hl("implicit")} parameter list;
+           |auxiliary constructors need non-implicit parameter lists. When a primary
+           |constructor has an implicit argslist, auxiliary constructors that call the
+           |primary constructor must specify the implicit value.
+           |
+           |To resolve this issue check for:
+           | - Forgotten parenthesis on ${hl("this")} (${hl("def this() = { ... }")})
+           | - Auxiliary constructors specify the implicit value
+           |"""
+  }
+
+  class IllegalLiteral()(using Context)
+  extends SyntaxMsg(IllegalLiteralID) {
+    def msg = "Illegal literal"
+    def explain =
+      em"""|Available literals can be divided into several groups:
+           | - Integer literals: 0, 21, 0xFFFFFFFF, -42L
+           | - Floating Point Literals: 0.0, 1e30f, 3.14159f, 1.0e-100, .1
+           | - Boolean Literals: true, false
+           | - Character Literals: 'a', '\u0041', '\n'
+           | - String Literals: "Hello, World!"
+           | - null
+           |"""
+  }
+
+  class LossyWideningConstantConversion(sourceType: Type, targetType: Type)(using Context)
+  extends Message(LossyWideningConstantConversionID):
+    def kind = MessageKind.LossyConversion
+    def msg = em"""|Widening conversion from $sourceType to $targetType loses precision.
+                   |Write `.to$targetType` instead.""".stripMargin
+    def explain = ""
+
+  class PatternMatchExhaustivity(uncoveredFn: -> String, hasMore: Boolean)(using Context)
+  extends Message(PatternMatchExhaustivityID) {
+    def kind = MessageKind.PatternMatchExhaustivity
+    lazy val uncovered = uncoveredFn
+    def msg =
+      val addendum = if hasMore then "(More unmatched cases are elided)" else ""
+      em"""|${hl("match")} may not be exhaustive.
+           |
+           |It would fail on pattern case: $uncovered
+           |$addendum"""
+
+
+    def explain =
+      em"""|There are several ways to make the match exhaustive:
+           | - Add missing cases as shown in the warning
+           | - If an extractor always return ${hl("Some(...)")}, write ${hl("Some[X]")} for its return type
+           | - Add a ${hl("case _ => ...")} at the end to match all remaining cases
+           |"""
+  }
+
+  class UncheckedTypePattern(msgFn: -> String)(using Context)
+    extends PatternMatchMsg(UncheckedTypePatternID) {
+    def msg = msgFn
+    def explain =
+      em"""|Type arguments and type refinements are erased during compile time, thus it's
+           |impossible to check them at run-time.
+           |
+           |You can either replace the type arguments by ${hl("_")} or use `@unchecked`.
+           |"""
+  }
+
+  class MatchCaseUnreachable()(using Context)
+  extends Message(MatchCaseUnreachableID) {
+    def kind = MessageKind.MatchCaseUnreachable
+    def msg = "Unreachable case"
+    def explain = ""
+  }
+
+  class MatchCaseOnlyNullWarning()(using Context)
+  extends PatternMatchMsg(MatchCaseOnlyNullWarningID) {
+    def msg = em"""Unreachable case except for ${hl("null")} (if this is intentional, consider writing ${hl("case null =>")} instead)."""
+    def explain = ""
+  }
+
+  class MatchableWarning(tp: Type, pattern: Boolean)(using Context)
+  extends TypeMsg(MatchableWarningID) {
+    def msg =
+      val kind = if pattern then "pattern selector" else "value"
+      em"""${kind} should be an instance of Matchable,,
+          |but it has unmatchable type $tp instead"""
+
+    def explain =
+      if pattern then
+        em"""A value of type $tp cannot be the selector of a match expression
+            |since it is not constrained to be `Matchable`. Matching on unconstrained
+            |values is disallowed since it can uncover implementation details that
+            |were intended to be hidden and thereby can violate paramtetricity laws
+            |for reasoning about programs.
+            |
+            |The restriction can be overridden by appending `.asMatchable` to
+            |the selector value. `asMatchable` needs to be imported from
+            |scala.compiletime. Example:
+            |
+            |    import compiletime.asMatchable
+            |    def f[X](x: X) = x.asMatchable match { ... }"""
+      else
+        em"""The value can be converted to a `Matchable` by appending `.asMatchable`.
+            |`asMatchable` needs to be imported from scala.compiletime."""
+  }
+
+  class SeqWildcardPatternPos()(using Context)
+  extends SyntaxMsg(SeqWildcardPatternPosID) {
+    def msg = em"""${hl("*")} can be used only for last argument"""
+    def explain = {
+      val code =
+        """def sumOfTheFirstTwo(list: List[Int]): Int = list match {
+          |  case List(first, second, x*) => first + second
+          |  case _ => 0
+          |}"""
+      em"""|Sequence wildcard pattern is expected at the end of an argument list.
+           |This pattern matches any remaining elements in a sequence.
+           |Consider the following example:
+           |
+           |$code
+           |
+           |Calling:
+           |
+           |${hl("sumOfTheFirstTwo(List(1, 2, 10))")}
+           |
+           |would give 3 as a result"""
+    }
+  }
+
+  class IllegalStartOfSimplePattern()(using Context)
+  extends SyntaxMsg(IllegalStartOfSimplePatternID) {
+    def msg = "pattern expected"
+    def explain = {
+      val sipCode =
+        """def f(x: Int, y: Int) = x match {
+          |  case `y` => ...
+          |}
+        """
+      val constructorPatternsCode =
+        """case class Person(name: String, age: Int)
+          |
+          |def test(p: Person) = p match {
+          |  case Person(name, age) => ...
+          |}
+        """
+      val tupplePatternsCode =
+        """def swap(tuple: (String, Int)): (Int, String) = tuple match {
+          |  case (text, number) => (number, text)
+          |}
+        """
+      val patternSequencesCode =
+        """def getSecondValue(list: List[Int]): Int = list match {
+          |  case List(_, second, x:_*) => second
+          |  case _ => 0
+          |}"""
+      em"""|Simple patterns can be divided into several groups:
+           |- Variable Patterns: ${hl("case x => ...")}.
+           |  It matches any value, and binds the variable name to that value.
+           |  A special case is the wild-card pattern _ which is treated as if it was a fresh
+           |  variable on each occurrence.
+           |
+           |- Typed Patterns: ${hl("case x: Int => ...")} or ${hl("case _: Int => ...")}.
+           |  This pattern matches any value matched by the specified type; it binds the variable
+           |  name to that value.
+           |
+           |- Literal Patterns: ${hl("case 123 => ...")} or ${hl("case 'A' => ...")}.
+           |  This type of pattern matches any value that is equal to the specified literal.
+           |
+           |- Stable Identifier Patterns:
+           |
+           |  $sipCode
+           |
+           |  the match succeeds only if the x argument and the y argument of f are equal.
+           |
+           |- Constructor Patterns:
+           |
+           |  $constructorPatternsCode
+           |
+           |  The pattern binds all object's fields to the variable names (name and age, in this
+           |  case).
+           |
+           |- Tuple Patterns:
+           |
+           |  $tupplePatternsCode
+           |
+           |  Calling:
+           |
+           |  ${hl("""swap(("Luftballons", 99)""")}
+           |
+           |  would give ${hl("""(99, "Luftballons")""")} as a result.
+           |
+           |- Pattern Sequences:
+           |
+           |  $patternSequencesCode
+           |
+           |  Calling:
+           |
+           |  ${hl("getSecondValue(List(1, 10, 2))")}
+           |
+           |  would give 10 as a result.
+           |  This pattern is possible because a companion object for the List class has a method
+           |  with the following signature:
+           |
+           |  ${hl("def unapplySeq[A](x: List[A]): Some[List[A]]")}
+           |"""
+    }
+  }
+
+  class PkgDuplicateSymbol(existing: Symbol)(using Context)
+  extends NamingMsg(PkgDuplicateSymbolID) {
+    def msg = em"Trying to define package with same name as $existing"
+    def explain = ""
+  }
+
+  class ExistentialTypesNoLongerSupported()(using Context)
+  extends SyntaxMsg(ExistentialTypesNoLongerSupportedID) {
+    def msg =
+      em"""|Existential types are no longer supported -
+           |use a wildcard or dependent type instead"""
+    def explain =
+      em"""|The use of existential types is no longer supported.
+           |
+           |You should use a wildcard or dependent type instead.
+           |
+           |For example:
+           |
+           |Instead of using ${hl("forSome")} to specify a type variable
+           |
+           |${hl("List[T forSome { type T }]")}
+           |
+           |Try using a wildcard type variable
+           |
+           |${hl("List[?]")}
+           |"""
+  }
+
+  class UnboundWildcardType()(using Context)
+  extends SyntaxMsg(UnboundWildcardTypeID) {
+    def msg = "Unbound wildcard type"
+    def explain =
+      em"""|The wildcard type syntax (${hl("_")}) was used where it could not be bound.
+           |Replace ${hl("_")} with a non-wildcard type. If the type doesn't matter,
+           |try replacing ${hl("_")} with ${hl("Any")}.
+           |
+           |Examples:
+           |
+           |- Parameter lists
+           |
+           |  Instead of:
+           |    ${hl("def foo(x: _) = ...")}
+           |
+           |  Use ${hl("Any")} if the type doesn't matter:
+           |    ${hl("def foo(x: Any) = ...")}
+           |
+           |- Type arguments
+           |
+           |  Instead of:
+           |    ${hl("val foo = List[?](1, 2)")}
+           |
+           |  Use:
+           |    ${hl("val foo = List[Int](1, 2)")}
+           |
+           |- Type bounds
+           |
+           |  Instead of:
+           |    ${hl("def foo[T <: _](x: T) = ...")}
+           |
+           |  Remove the bounds if the type doesn't matter:
+           |    ${hl("def foo[T](x: T) = ...")}
+           |
+           |- ${hl("val")} and ${hl("def")} types
+           |
+           |  Instead of:
+           |    ${hl("val foo: _ = 3")}
+           |
+           |  Use:
+           |    ${hl("val foo: Int = 3")}
+           |"""
+  }
+
+  class OverridesNothing(member: Symbol)(using Context)
+  extends DeclarationMsg(OverridesNothingID) {
+    def msg = em"""${member} overrides nothing"""
+
+    def explain =
+      em"""|There must be a field or method with the name ${member.name} in a super
+           |class of ${member.owner} to override it. Did you misspell it?
+           |Are you extending the right classes?
+           |"""
+  }
+
+  class OverridesNothingButNameExists(member: Symbol, existing: List[Denotations.SingleDenotation])(using Context)
+  extends DeclarationMsg(OverridesNothingButNameExistsID) {
+    def msg =
+      val what =
+        if !existing.exists(_.symbol.hasTargetName(member.targetName))
+        then "target name"
+        else "signature"
+      em"""${member} has a different $what than the overridden declaration"""
+    def explain =
+      val existingDecl: String = existing.map(_.showDcl).mkString("  \n")
+      em"""|There must be a non-final field or method with the name ${member.name} and the
+           |same parameter list in a super class of ${member.owner} to override it.
+           |
+           |  ${member.showDcl}
+           |
+           |The super classes of ${member.owner} contain the following members
+           |named ${member.name}:
+           |  ${existingDecl}
+           |"""
+  }
+
+  class OverrideError(override val msg: String) extends DeclarationMsg(OverrideErrorID):
+    def explain = ""
+
+  class OverrideTypeMismatchError(override val msg: String, memberTp: Type, otherTp: Type)(using Context)
+  extends DeclarationMsg(OverrideTypeMismatchErrorID):
+    def explain = err.whyNoMatchStr(memberTp, otherTp)
+    override def canExplain = true
+
+  class ForwardReferenceExtendsOverDefinition(value: Symbol, definition: Symbol)(using Context)
+  extends ReferenceMsg(ForwardReferenceExtendsOverDefinitionID) {
+    def msg = em"${definition.name} is a forward reference extending over the definition of ${value.name}"
+
+    def explain =
+      em"""|${definition.name} is used before you define it, and the definition of ${value.name}
+           |appears between that use and the definition of ${definition.name}.
+           |
+           |Forward references are allowed only, if there are no value definitions between
+           |the reference and the referred method definition.
+           |
+           |Define ${definition.name} before it is used,
+           |or move the definition of ${value.name} so it does not appear between
+           |the declaration of ${definition.name} and its use,
+           |or define ${value.name} as lazy.
+           |""".stripMargin
+  }
+
+  class ExpectedTokenButFound(expected: Token, found: Token)(using Context)
+  extends SyntaxMsg(ExpectedTokenButFoundID) {
+
+    private lazy val foundText = Tokens.showToken(found)
+
+    def msg =
+      val expectedText =
+        if (Tokens.isIdentifier(expected)) "an identifier"
+        else Tokens.showToken(expected)
+      em"""${expectedText} expected, but ${foundText} found"""
+
+    def explain =
+      if (Tokens.isIdentifier(expected) && Tokens.isKeyword(found))
+        s"""
+         |If you want to use $foundText as identifier, you may put it in backticks: `${Tokens.tokenString(found)}`.""".stripMargin
+      else
+        ""
+  }
+
+  class MixedLeftAndRightAssociativeOps(op1: Name, op2: Name, op2LeftAssoc: Boolean)(using Context)
+  extends SyntaxMsg(MixedLeftAndRightAssociativeOpsID) {
+    def msg =
+      val op1Asso: String = if (op2LeftAssoc) "which is right-associative" else "which is left-associative"
+      val op2Asso: String = if (op2LeftAssoc) "which is left-associative" else "which is right-associative"
+      em"${op1} (${op1Asso}) and ${op2} ($op2Asso) have same precedence and may not be mixed"
+    def explain =
+      s"""|The operators ${op1} and ${op2} are used as infix operators in the same expression,
+          |but they bind to different sides:
+          |${op1} is applied to the operand to its ${if (op2LeftAssoc) "right" else "left"}
+          |${op2} is applied to the operand to its ${if (op2LeftAssoc) "left" else "right"}
+          |As both have the same precedence the compiler can't decide which to apply first.
+          |
+          |You may use parenthesis to make the application order explicit,
+          |or use method application syntax operand1.${op1}(operand2).
+          |
+          |Operators ending in a colon ${hl(":")} are right-associative. All other operators are left-associative.
+          |
+          |Infix operator precedence is determined by the operator's first character. Characters are listed
+          |below in increasing order of precedence, with characters on the same line having the same precedence.
+          |  (all letters)
+          |  |
+          |  ^
+          |  &
+          |  = !
+          |  < >
+          |  :
+          |  + -
+          |  * / %
+          |  (all other special characters)
+          |Operators starting with a letter have lowest precedence, followed by operators starting with `|`, etc.
+          |""".stripMargin
+  }
+
+  class CantInstantiateAbstractClassOrTrait(cls: Symbol, isTrait: Boolean)(using Context)
+  extends TypeMsg(CantInstantiateAbstractClassOrTraitID) {
+    private val traitOrAbstract = if (isTrait) "a trait" else "abstract"
+    def msg = em"""${cls.name} is ${traitOrAbstract}; it cannot be instantiated"""
+    def explain =
+      em"""|Abstract classes and traits need to be extended by a concrete class or object
+           |to make their functionality accessible.
+           |
+           |You may want to create an anonymous class extending ${cls.name} with
+           |  ${s"class ${cls.name} { }"}
+           |
+           |or add a companion object with
+           |  ${s"object ${cls.name} extends ${cls.name}"}
+           |
+           |You need to implement any abstract members in both cases.
+           |""".stripMargin
+  }
+
+  class UnreducibleApplication(tycon: Type)(using Context) extends TypeMsg(UnreducibleApplicationID):
+    def msg = em"unreducible application of higher-kinded type $tycon to wildcard arguments"
+    def explain =
+      em"""|An abstract type constructor cannot be applied to wildcard arguments.
+           |Such applications are equivalent to existential types, which are not
+           |supported in Scala 3."""
+
+  class OverloadedOrRecursiveMethodNeedsResultType(cycleSym: Symbol)(using Context)
+  extends CyclicMsg(OverloadedOrRecursiveMethodNeedsResultTypeID) {
+    def msg = em"""Overloaded or recursive $cycleSym needs return type"""
+    def explain =
+      em"""Case 1: $cycleSym is overloaded
+          |If there are multiple methods named $cycleSym and at least one definition of
+          |it calls another, you need to specify the calling method's return type.
+          |
+          |Case 2: $cycleSym is recursive
+          |If $cycleSym calls itself on any path (even through mutual recursion), you need to specify the return type
+          |of $cycleSym or of a definition it's mutually recursive with.
+          |""".stripMargin
+  }
+
+  class RecursiveValueNeedsResultType(cycleSym: Symbol)(using Context)
+  extends CyclicMsg(RecursiveValueNeedsResultTypeID) {
+    def msg = em"""Recursive $cycleSym needs type"""
+    def explain =
+      em"""The definition of $cycleSym is recursive and you need to specify its type.
+          |""".stripMargin
+  }
+
+  class CyclicReferenceInvolving(denot: SymDenotation)(using Context)
+  extends CyclicMsg(CyclicReferenceInvolvingID) {
+    def msg =
+      val where = if denot.exists then s" involving $denot" else ""
+      em"Cyclic reference$where"
+    def explain =
+      em"""|$denot is declared as part of a cycle which makes it impossible for the
+           |compiler to decide upon ${denot.name}'s type.
+           |To avoid this error, try giving ${denot.name} an explicit type.
+           |""".stripMargin
+  }
+
+  class CyclicReferenceInvolvingImplicit(cycleSym: Symbol)(using Context)
+  extends CyclicMsg(CyclicReferenceInvolvingImplicitID) {
+    def msg = em"""Cyclic reference involving implicit $cycleSym"""
+    def explain =
+      em"""|$cycleSym is declared as part of a cycle which makes it impossible for the
+           |compiler to decide upon ${cycleSym.name}'s type.
+           |This might happen when the right hand-side of $cycleSym's definition involves an implicit search.
+           |To avoid this error, try giving ${cycleSym.name} an explicit type.
+           |""".stripMargin
+  }
+
+  class SkolemInInferred(tree: tpd.Tree, pt: Type, argument: tpd.Tree)(using Context)
+  extends TypeMsg(SkolemInInferredID):
+    private def argStr =
+      if argument.isEmpty then ""
+      else i" from argument of type ${argument.tpe.widen}"
+    def msg =
+      em"""Failure to generate given instance for type $pt$argStr)
+          |
+          |I found: $tree
+          |But the part corresponding to `<skolem>` is not a reference that can be generated.
+          |This might be because resolution yielded as given instance a function that is not
+          |known to be total and side-effect free."""
+    def explain =
+      em"""The part of given resolution that corresponds to `<skolem>` produced a term that
+          |is not a stable reference. Therefore a given instance could not be generated.
+          |
+          |To trouble-shoot the problem, try to supply an explicit expression instead of
+          |relying on implicit search at this point."""
+
+  class SuperQualMustBeParent(qual: untpd.Ident, cls: ClassSymbol)(using Context)
+  extends ReferenceMsg(SuperQualMustBeParentID) {
+    def msg = em"""|$qual does not name a parent of $cls"""
+    def explain =
+      val parents: Seq[String] = (cls.info.parents map (_.typeSymbol.name.show)).sorted
+      em"""|When a qualifier ${hl("T")} is used in a ${hl("super")} prefix of the form ${hl("C.super[T]")},
+           |${hl("T")} must be a parent type of ${hl("C")}.
+           |
+           |In this case, the parents of $cls are:
+           |${parents.mkString("  - ", "\n  - ", "")}
+           |""".stripMargin
+  }
+
+  class VarArgsParamMustComeLast()(using Context)
+  extends SyntaxMsg(VarArgsParamMustComeLastID) {
+    def msg = em"""${hl("varargs")} parameter must come last"""
+    def explain =
+      em"""|The ${hl("varargs")} field must be the last field in the method signature.
+           |Attempting to define a field in a method signature after a ${hl("varargs")} field is an error.
+           |"""
+  }
+
+  import typer.Typer.BindingPrec
+
+  class AmbiguousReference(name: Name, newPrec: BindingPrec, prevPrec: BindingPrec, prevCtx: Context)(using Context)
+    extends ReferenceMsg(AmbiguousReferenceID) {
+
+    /** A string which explains how something was bound; Depending on `prec` this is either
+      *      imported by <tree>
+      *  or  defined in <symbol>
+      */
+    private def bindingString(prec: BindingPrec, whereFound: Context, qualifier: String = "") = {
+      val howVisible = prec match {
+        case BindingPrec.Definition => "defined"
+        case BindingPrec.Inheritance => "inherited"
+        case BindingPrec.NamedImport => "imported by name"
+        case BindingPrec.WildImport => "imported"
+        case BindingPrec.PackageClause => "found"
+        case BindingPrec.NothingBound => assert(false)
+      }
+      if (prec.isImportPrec) {
+        ex"""$howVisible$qualifier by ${em"${whereFound.importInfo}"}"""
+      } else
+        ex"""$howVisible$qualifier in ${em"${whereFound.owner}"}"""
+    }
+
+    def msg =
+      i"""|Reference to ${em"$name"} is ambiguous,
+          |it is both ${bindingString(newPrec, ctx)}
+          |and ${bindingString(prevPrec, prevCtx, " subsequently")}"""
+
+    def explain =
+      em"""|The compiler can't decide which of the possible choices you
+           |are referencing with $name: A definition of lower precedence
+           |in an inner scope, or a definition with higher precedence in
+           |an outer scope.
+           |Note:
+           | - Definitions in an enclosing scope take precedence over inherited definitions
+           | - Definitions take precedence over imports
+           | - Named imports take precedence over wildcard imports
+           | - You may replace a name when imported using
+           |   ${hl("import")} scala.{ $name => ${name.show + "Tick"} }
+           |"""
+  }
+
+  class MethodDoesNotTakeParameters(tree: tpd.Tree)(using Context)
+  extends TypeMsg(MethodDoesNotTakeParametersId) {
+    def methodSymbol: Symbol =
+      def recur(t: tpd.Tree): Symbol =
+        val sym = tpd.methPart(t).symbol
+        if sym == defn.Any_typeCast then
+          t match
+            case TypeApply(Select(qual, _), _) => recur(qual)
+            case _ => sym
+        else sym
+      recur(tree)
+
+    def msg = {
+      val more = if (tree.isInstanceOf[tpd.Apply]) " more" else ""
+      val meth = methodSymbol
+      val methStr = if (meth.exists) meth.showLocated else "expression"
+      em"$methStr does not take$more parameters"
+    }
+
+    def explain = {
+      val isNullary = methodSymbol.info.isInstanceOf[ExprType]
+      val addendum =
+        if (isNullary) "\nNullary methods may not be called with parenthesis"
+        else ""
+
+      "You have specified more parameter lists than defined in the method definition(s)." + addendum
+    }
+
+  }
+
+  class AmbiguousOverload(tree: tpd.Tree, val alternatives: List[SingleDenotation], pt: Type, addendum: String = "")(
+    implicit ctx: Context)
+  extends ReferenceMsg(AmbiguousOverloadID) {
+    private def all = if (alternatives.length == 2) "both" else "all"
+    def msg =
+      em"""|Ambiguous overload. The ${err.overloadedAltsStr(alternatives)}
+           |$all match ${err.expectedTypeStr(pt)}$addendum""".stripMargin
+    def explain =
+      em"""|There are ${alternatives.length} methods that could be referenced as the compiler knows too little
+           |about the expected type.
+           |You may specify the expected type e.g. by
+           |- assigning it to a value with a specified type, or
+           |- adding a type ascription as in ${hl("instance.myMethod: String => Int")}
+           |"""
+  }
+
+  class ReassignmentToVal(name: Name)(using Context)
+    extends TypeMsg(ReassignmentToValID) {
+    def msg = em"""Reassignment to val $name"""
+    def explain =
+      em"""|You can not assign a new value to $name as values can't be changed.
+           |Keep in mind that every statement has a value, so you may e.g. use
+           |  ${hl("val")} $name ${hl("= if (condition) 2 else 5")}
+           |In case you need a reassignable name, you can declare it as
+           |variable
+           |  ${hl("var")} $name ${hl("=")} ...
+           |""".stripMargin
+  }
+
+  class TypeDoesNotTakeParameters(tpe: Type, params: List[Trees.Tree[Trees.Untyped]])(using Context)
+    extends TypeMsg(TypeDoesNotTakeParametersID) {
+    private def fboundsAddendum =
+      if tpe.typeSymbol.isAllOf(Provisional | TypeParam) then
+        "\n(Note that F-bounds of type parameters may not be type lambdas)"
+      else ""
+    def msg = em"$tpe does not take type parameters$fboundsAddendum"
+    def explain =
+      val ps =
+        if (params.size == 1) s"a type parameter ${params.head}"
+        else s"type parameters ${params.map(_.show).mkString(", ")}"
+      i"""You specified ${NoColor(ps)} for ${em"$tpe"}, which is not
+         |declared to take any.
+         |"""
+  }
+
+  class VarValParametersMayNotBeCallByName(name: TermName, mutable: Boolean)(using Context)
+    extends SyntaxMsg(VarValParametersMayNotBeCallByNameID) {
+    def varOrVal = if (mutable) em"${hl("var")}" else em"${hl("val")}"
+    def msg = s"$varOrVal parameters may not be call-by-name"
+    def explain =
+      em"""${hl("var")} and ${hl("val")} parameters of classes and traits may no be call-by-name. In case you
+          |want the parameter to be evaluated on demand, consider making it just a parameter
+          |and a ${hl("def")} in the class such as
+          |  ${s"class MyClass(${name}Tick: => String) {"}
+          |  ${s"  def $name() = ${name}Tick"}
+          |  ${hl("}")}
+          |"""
+  }
+
+  class MissingTypeParameterFor(tpe: Type)(using Context)
+    extends SyntaxMsg(MissingTypeParameterForID) {
+    def msg =
+      if (tpe.derivesFrom(defn.AnyKindClass)) em"${tpe} cannot be used as a value type"
+      else em"Missing type parameter for ${tpe}"
+    def explain = ""
+  }
+
+  class MissingTypeParameterInTypeApp(tpe: Type)(using Context)
+    extends TypeMsg(MissingTypeParameterInTypeAppID) {
+    def numParams = tpe.typeParams.length
+    def parameters = if (numParams == 1) "parameter" else "parameters"
+    def msg = em"Missing type $parameters for $tpe"
+    def explain = em"A fully applied type is expected but $tpe takes $numParams $parameters"
+  }
+
+  class MissingArgument(pname: Name, methString: String)(using Context)
+    extends TypeMsg(MissingArgumentID):
+    def msg =
+      if pname.firstPart contains '$' then s"not enough arguments for $methString"
+      else s"missing argument for parameter $pname of $methString"
+    def explain = ""
+
+  class DoesNotConformToBound(tpe: Type, which: String, bound: Type)(using Context)
+    extends TypeMismatchMsg(
+      if which == "lower" then bound else tpe,
+      if which == "lower" then tpe else bound)(DoesNotConformToBoundID):
+    private def isBounds = tpe match
+      case TypeBounds(lo, hi) => lo ne hi
+      case _ => false
+    override def canExplain = !isBounds
+    def msg =
+      if isBounds then
+        em"Type argument ${tpe} does not overlap with $which bound $bound"
+      else
+        em"Type argument ${tpe} does not conform to $which bound $bound"
+
+  class DoesNotConformToSelfType(category: String, selfType: Type, cls: Symbol,
+                                 otherSelf: Type, relation: String, other: Symbol)(
+    implicit ctx: Context)
+    extends TypeMismatchMsg(selfType, otherSelf)(DoesNotConformToSelfTypeID) {
+    def msg = em"""$category: self type $selfType of $cls does not conform to self type $otherSelf
+                  |of $relation $other"""
+  }
+
+  class DoesNotConformToSelfTypeCantBeInstantiated(tp: Type, selfType: Type)(
+    implicit ctx: Context)
+    extends TypeMismatchMsg(tp, selfType)(DoesNotConformToSelfTypeCantBeInstantiatedID) {
+    def msg = em"""$tp does not conform to its self type $selfType; cannot be instantiated"""
+  }
+
+  class IllegalParameterInit(found: Type, expected: Type, param: Symbol, cls: Symbol)(using Context)
+    extends TypeMismatchMsg(found, expected)(IllegalParameterInitID):
+    def msg =
+      em"""illegal parameter initialization of $param.
+          |
+          |  The argument passed for $param has type: $found
+          |  but $cls expects $param to have type: $expected"""
+
+  class AbstractMemberMayNotHaveModifier(sym: Symbol, flag: FlagSet)(
+    implicit ctx: Context)
+    extends SyntaxMsg(AbstractMemberMayNotHaveModifierID) {
+    def msg = em"""${hl("abstract")} $sym may not have `${flag.flagsString}` modifier"""
+    def explain = ""
+  }
+
+  class TypesAndTraitsCantBeImplicit()(using Context)
+    extends SyntaxMsg(TypesAndTraitsCantBeImplicitID) {
+    def msg = em"""${hl("implicit")} modifier cannot be used for types or traits"""
+    def explain = ""
+  }
+
+  class OnlyClassesCanBeAbstract(sym: Symbol)(
+    implicit ctx: Context)
+    extends SyntaxMsg(OnlyClassesCanBeAbstractID) {
+    def explain = ""
+    def msg = em"""${hl("abstract")} modifier can be used only for classes; it should be omitted for abstract members"""
+  }
+
+  class AbstractOverrideOnlyInTraits(sym: Symbol)(
+    implicit ctx: Context)
+    extends SyntaxMsg(AbstractOverrideOnlyInTraitsID) {
+    def msg = em"""${hl("abstract override")} modifier only allowed for members of traits"""
+    def explain = ""
+  }
+
+  class TraitsMayNotBeFinal(sym: Symbol)(
+    implicit ctx: Context)
+    extends SyntaxMsg(TraitsMayNotBeFinalID) {
+    def msg = em"""$sym may not be ${hl("final")}"""
+    def explain =
+      "A trait can never be final since it is abstract and must be extended to be useful."
+  }
+
+  class NativeMembersMayNotHaveImplementation(sym: Symbol)(
+    implicit ctx: Context)
+    extends SyntaxMsg(NativeMembersMayNotHaveImplementationID) {
+    def msg = em"""${hl("@native")} members may not have an implementation"""
+    def explain = ""
+  }
+
+  class TraitMayNotDefineNativeMethod(sym: Symbol)(
+    implicit ctx: Context)
+    extends SyntaxMsg(TraitMayNotDefineNativeMethodID) {
+    def msg = em"""A trait cannot define a ${hl("@native")} method."""
+    def explain = ""
+  }
+
+  class OnlyClassesCanHaveDeclaredButUndefinedMembers(sym: Symbol)(
+    implicit ctx: Context)
+    extends SyntaxMsg(OnlyClassesCanHaveDeclaredButUndefinedMembersID) {
+
+    private def varNote =
+      if (sym.is(Mutable)) "Note that variables need to be initialized to be defined."
+      else ""
+    def msg = em"""Declaration of $sym not allowed here: only classes can have declared but undefined members"""
+    def explain = s"$varNote"
+  }
+
+  class CannotExtendAnyVal(sym: Symbol)(using Context)
+    extends SyntaxMsg(CannotExtendAnyValID) {
+    def msg = em"""$sym cannot extend ${hl("AnyVal")}"""
+    def explain =
+      em"""Only classes (not traits) are allowed to extend ${hl("AnyVal")}, but traits may extend
+          |${hl("Any")} to become ${Green("\"universal traits\"")} which may only have ${hl("def")} members.
+          |Universal traits can be mixed into classes that extend ${hl("AnyVal")}.
+          |"""
+  }
+
+  class CannotExtendJavaEnum(sym: Symbol)(using Context)
+    extends SyntaxMsg(CannotExtendJavaEnumID) {
+      def msg = em"""$sym cannot extend ${hl("java.lang.Enum")}: only enums defined with the ${hl("enum")} syntax can"""
+      def explain = ""
+    }
+
+  class CannotExtendContextFunction(sym: Symbol)(using Context)
+    extends SyntaxMsg(CannotExtendFunctionID) {
+      def msg = em"""$sym cannot extend a context function class"""
+      def explain = ""
+    }
+
+  class JavaEnumParentArgs(parent: Type)(using Context)
+    extends TypeMsg(JavaEnumParentArgsID) {
+      def msg = em"""not enough arguments for constructor Enum: ${hl("(name: String, ordinal: Int)")}: ${hl(parent.show)}"""
+      def explain = ""
+    }
+
+  class CannotHaveSameNameAs(sym: Symbol, cls: Symbol, reason: CannotHaveSameNameAs.Reason)(using Context)
+    extends SyntaxMsg(CannotHaveSameNameAsID) {
+    import CannotHaveSameNameAs._
+    def reasonMessage: String = reason match {
+      case CannotBeOverridden => "class definitions cannot be overridden"
+      case DefinedInSelf(self) =>
+        s"""cannot define ${sym.showKind} member with the same name as a ${cls.showKind} member in self reference ${self.name}.
+           |(Note: this can be resolved by using another name)
+           |""".stripMargin
+    }
+
+    def msg = em"""$sym cannot have the same name as ${cls.showLocated} -- """ + reasonMessage
+    def explain = ""
+  }
+  object CannotHaveSameNameAs {
+    sealed trait Reason
+    case object CannotBeOverridden extends Reason
+    case class DefinedInSelf(self: tpd.ValDef) extends Reason
+  }
+
+  class ValueClassesMayNotDefineInner(valueClass: Symbol, inner: Symbol)(using Context)
+    extends SyntaxMsg(ValueClassesMayNotDefineInnerID) {
+    def msg = em"""Value classes may not define an inner class"""
+    def explain = ""
+  }
+
+  class ValueClassesMayNotDefineNonParameterField(valueClass: Symbol, field: Symbol)(using Context)
+    extends SyntaxMsg(ValueClassesMayNotDefineNonParameterFieldID) {
+    def msg = em"""Value classes may not define non-parameter field"""
+    def explain = ""
+  }
+
+  class ValueClassesMayNotDefineASecondaryConstructor(valueClass: Symbol, constructor: Symbol)(using Context)
+    extends SyntaxMsg(ValueClassesMayNotDefineASecondaryConstructorID) {
+    def msg = em"""Value classes may not define a secondary constructor"""
+    def explain = ""
+  }
+
+  class ValueClassesMayNotContainInitalization(valueClass: Symbol)(using Context)
+    extends SyntaxMsg(ValueClassesMayNotContainInitalizationID) {
+    def msg = em"""Value classes may not contain initialization statements"""
+    def explain = ""
+  }
+
+  class ValueClassesMayNotBeAbstract(valueClass: Symbol)(using Context)
+    extends SyntaxMsg(ValueClassesMayNotBeAbstractID) {
+    def msg = em"""Value classes may not be ${hl("abstract")}"""
+    def explain = ""
+  }
+
+  class ValueClassesMayNotBeContainted(valueClass: Symbol)(using Context)
+    extends SyntaxMsg(ValueClassesMayNotBeContaintedID) {
+    private def localOrMember = if (valueClass.owner.isTerm) "local class" else "member of another class"
+    def msg = s"""Value classes may not be a $localOrMember"""
+    def explain = ""
+  }
+
+  class ValueClassesMayNotWrapAnotherValueClass(valueClass: Symbol)(using Context)
+    extends SyntaxMsg(ValueClassesMayNotWrapAnotherValueClassID) {
+    def msg = """A value class may not wrap another user-defined value class"""
+    def explain = ""
+  }
+
+  class ValueClassParameterMayNotBeAVar(valueClass: Symbol, param: Symbol)(using Context)
+    extends SyntaxMsg(ValueClassParameterMayNotBeAVarID) {
+    def msg = em"""A value class parameter may not be a ${hl("var")}"""
+    def explain =
+      em"""A value class must have exactly one ${hl("val")} parameter."""
+  }
+
+  class ValueClassNeedsOneValParam(valueClass: Symbol)(using Context)
+    extends SyntaxMsg(ValueClassNeedsExactlyOneValParamID) {
+    def msg = em"""Value class needs one ${hl("val")} parameter"""
+    def explain = ""
+  }
+
+  class ValueClassParameterMayNotBeCallByName(valueClass: Symbol, param: Symbol)(using Context)
+    extends SyntaxMsg(ValueClassParameterMayNotBeCallByNameID) {
+    def msg = s"Value class parameter `${param.name}` may not be call-by-name"
+    def explain = ""
+  }
+
+  class SuperCallsNotAllowedInlineable(symbol: Symbol)(using Context)
+    extends SyntaxMsg(SuperCallsNotAllowedInlineableID) {
+    def msg = em"Super call not allowed in inlineable $symbol"
+    def explain = "Method inlining prohibits calling superclass methods, as it may lead to confusion about which super is being called."
+  }
+
+  class NotAPath(tp: Type, usage: String)(using Context) extends TypeMsg(NotAPathID):
+    def msg = em"$tp is not a valid $usage, since it is not an immutable path"
+    def explain =
+      i"""An immutable path is
+         | - a reference to an immutable value, or
+         | - a reference to `this`, or
+         | - a selection of an immutable path with an immutable value."""
+
+  class WrongNumberOfParameters(expected: Int)(using Context)
+    extends SyntaxMsg(WrongNumberOfParametersID) {
+    def msg = s"Wrong number of parameters, expected: $expected"
+    def explain = ""
+  }
+
+  class DuplicatePrivateProtectedQualifier()(using Context)
+    extends SyntaxMsg(DuplicatePrivateProtectedQualifierID) {
+    def msg = "Duplicate private/protected qualifier"
+    def explain =
+      em"It is not allowed to combine `private` and `protected` modifiers even if they are qualified to different scopes"
+  }
+
+  class ExpectedStartOfTopLevelDefinition()(using Context)
+    extends SyntaxMsg(ExpectedStartOfTopLevelDefinitionID) {
+    def msg = "Expected start of definition"
+    def explain =
+      em"You have to provide either ${hl("class")}, ${hl("trait")}, ${hl("object")}, or ${hl("enum")} definitions after qualifiers"
+  }
+
+  class NoReturnFromInlineable(owner: Symbol)(using Context)
+    extends SyntaxMsg(NoReturnFromInlineableID) {
+    def msg = em"No explicit ${hl("return")} allowed from inlineable $owner"
+    def explain =
+      em"""Methods marked with ${hl("inline")} modifier may not use ${hl("return")} statements.
+          |Instead, you should rely on the last expression's value being
+          |returned from a method.
+          |"""
+  }
+
+  class ReturnOutsideMethodDefinition(owner: Symbol)(using Context)
+    extends SyntaxMsg(ReturnOutsideMethodDefinitionID) {
+    def msg = em"${hl("return")} outside method definition"
+    def explain =
+      em"""You used ${hl("return")} in ${owner}.
+          |${hl("return")} is a keyword and may only be used within method declarations.
+          |"""
+  }
+
+  class ExtendFinalClass(clazz:Symbol, finalClazz: Symbol)(using Context)
+    extends SyntaxMsg(ExtendFinalClassID) {
+    def msg = em"$clazz cannot extend ${hl("final")} $finalClazz"
+    def explain =
+      em"""A class marked with the ${hl("final")} keyword cannot be extended"""
+  }
+
+  class ExpectedTypeBoundOrEquals(found: Token)(using Context)
+    extends SyntaxMsg(ExpectedTypeBoundOrEqualsID) {
+    def msg = em"${hl("=")}, ${hl(">:")}, or ${hl("<:")} expected, but ${Tokens.showToken(found)} found"
+
+    def explain =
+      em"""Type parameters and abstract types may be constrained by a type bound.
+           |Such type bounds limit the concrete values of the type variables and possibly
+           |reveal more information about the members of such types.
+           |
+           |A lower type bound ${hl("B >: A")} expresses that the type variable ${hl("B")}
+           |refers to a supertype of type ${hl("A")}.
+           |
+           |An upper type bound ${hl("T <: A")} declares that type variable ${hl("T")}
+           |refers to a subtype of type ${hl("A")}.
+           |"""
+  }
+
+  class ClassAndCompanionNameClash(cls: Symbol, other: Symbol)(using Context)
+    extends NamingMsg(ClassAndCompanionNameClashID) {
+    def msg =
+      val name = cls.name.stripModuleClassSuffix
+      em"Name clash: both ${cls.owner} and its companion object defines $name"
+    def explain =
+      em"""|A ${cls.kindString} and its companion object cannot both define a ${hl("class")}, ${hl("trait")} or ${hl("object")} with the same name:
+           |  - ${cls.owner} defines ${cls}
+           |  - ${other.owner} defines ${other}"""
+  }
+
+  class TailrecNotApplicable(symbol: Symbol)(using Context)
+    extends SyntaxMsg(TailrecNotApplicableID) {
+    def msg = {
+      val reason =
+        if (!symbol.is(Method)) em"$symbol isn't a method"
+        else if (symbol.is(Deferred)) em"$symbol is abstract"
+        else if (!symbol.isEffectivelyFinal) em"$symbol is neither ${hl("private")} nor ${hl("final")} so can be overridden"
+        else em"$symbol contains no recursive calls"
+
+      s"TailRec optimisation not applicable, $reason"
+    }
+    def explain = ""
+  }
+
+  class FailureToEliminateExistential(tp: Type, tp1: Type, tp2: Type, boundSyms: List[Symbol], classRoot: Symbol)(using Context)
+    extends Message(FailureToEliminateExistentialID) {
+    def kind = MessageKind.Compatibility
+    def msg =
+      val originalType = ctx.printer.dclsText(boundSyms, "; ").show
+      em"""An existential type that came from a Scala-2 classfile for $classRoot
+          |cannot be mapped accurately to a Scala-3 equivalent.
+          |original type    : $tp forSome ${originalType}
+          |reduces to       : $tp1
+          |type used instead: $tp2
+          |This choice can cause follow-on type errors or hide type errors.
+          |Proceed at own risk."""
+    def explain =
+      em"""Existential types in their full generality are no longer supported.
+          |Scala-3 does applications of class types to wildcard type arguments.
+          |Other forms of existential types that come from Scala-2 classfiles
+          |are only approximated in a best-effort way."""
+  }
+
+  class OnlyFunctionsCanBeFollowedByUnderscore(tp: Type)(using Context)
+    extends SyntaxMsg(OnlyFunctionsCanBeFollowedByUnderscoreID) {
+    def msg = em"Only function types can be followed by ${hl("_")} but the current expression has type $tp"
+    def explain =
+      em"""The syntax ${hl("x _")} is no longer supported if ${hl("x")} is not a function.
+          |To convert to a function value, you need to explicitly write ${hl("() => x")}"""
+  }
+
+  class MissingEmptyArgumentList(method: String)(using Context)
+    extends SyntaxMsg(MissingEmptyArgumentListID) {
+    def msg = em"$method must be called with ${hl("()")} argument"
+    def explain = {
+      val codeExample =
+        """def next(): T = ...
+          |next     // is expanded to next()"""
+
+      em"""Previously an empty argument list () was implicitly inserted when calling a nullary method without arguments. E.g.
+          |
+          |$codeExample
+          |
+          |In Dotty, this idiom is an error. The application syntax has to follow exactly the parameter syntax.
+          |Excluded from this rule are methods that are defined in Java or that override methods defined in Java."""
+    }
+  }
+
+  class DuplicateNamedTypeParameter(name: Name)(using Context)
+    extends SyntaxMsg(DuplicateNamedTypeParameterID) {
+    def msg = em"Type parameter $name was defined multiple times."
+    def explain = ""
+  }
+
+  class UndefinedNamedTypeParameter(undefinedName: Name, definedNames: List[Name])(using Context)
+    extends SyntaxMsg(UndefinedNamedTypeParameterID) {
+    def msg = em"Type parameter $undefinedName is undefined. Expected one of ${definedNames.map(_.show).mkString(", ")}."
+    def explain = ""
+  }
+
+  class IllegalStartOfStatement(what: String, isModifier: Boolean, isStat: Boolean)(using Context) extends SyntaxMsg(IllegalStartOfStatementID) {
+    def msg =
+      if isStat then
+        "this kind of statement is not allowed here"
+      else
+        val addendum = if isModifier then ": this modifier is not allowed here" else ""
+        s"Illegal start of $what$addendum"
+    def explain =
+      i"""A statement is an import or export, a definition or an expression.
+         |Some statements are only allowed in certain contexts"""
+  }
+
+  class TraitIsExpected(symbol: Symbol)(using Context) extends SyntaxMsg(TraitIsExpectedID) {
+    def msg = em"$symbol is not a trait"
+    def explain = {
+      val errorCodeExample =
+        """class A
+          |class B
+          |
+          |val a = new A with B // will fail with a compile error - class B is not a trait""".stripMargin
+      val codeExample =
+        """class A
+          |trait B
+          |
+          |val a = new A with B // compiles normally""".stripMargin
+
+      em"""Only traits can be mixed into classes using a ${hl("with")} keyword.
+          |Consider the following example:
+          |
+          |$errorCodeExample
+          |
+          |The example mentioned above would fail because B is not a trait.
+          |But if you make B a trait it will be compiled without any errors:
+          |
+          |$codeExample
+          |"""
+    }
+  }
+
+  class TraitRedefinedFinalMethodFromAnyRef(method: Symbol)(using Context) extends SyntaxMsg(TraitRedefinedFinalMethodFromAnyRefID) {
+    def msg = em"Traits cannot redefine final $method from ${hl("class AnyRef")}."
+    def explain = ""
+  }
+
+  class AlreadyDefined(name: Name, owner: Symbol, conflicting: Symbol)(using Context) extends NamingMsg(AlreadyDefinedID):
+    private def where: String =
+      if conflicting.effectiveOwner.is(Package) && conflicting.associatedFile != null then
+        i" in ${conflicting.associatedFile}"
+      else if conflicting.owner == owner then ""
+      else i" in ${conflicting.owner}"
+    private def note =
+      if owner.is(Method) || conflicting.is(Method) then
+        "\n\nNote that overloaded methods must all be defined in the same group of toplevel definitions"
+      else ""
+    def msg =
+      if conflicting.isTerm != name.isTermName then
+        em"$name clashes with $conflicting$where; the two must be defined together"
+      else
+        em"$name is already defined as $conflicting$where$note"
+    def explain = ""
+
+  class PackageNameAlreadyDefined(pkg: Symbol)(using Context) extends NamingMsg(PackageNameAlreadyDefinedID) {
+    lazy val (where, or) =
+      if pkg.associatedFile == null then ("", "")
+      else (s" in ${pkg.associatedFile}", " or delete the containing class file")
+    def msg = em"""${pkg.name} is the name of $pkg$where.
+                          |It cannot be used at the same time as the name of a package."""
+    def explain =
+      em"""An ${hl("object")} or other toplevel definition cannot have the same name as an existing ${hl("package")}.
+          |Rename either one of them$or."""
+  }
+
+  class UnapplyInvalidNumberOfArguments(qual: untpd.Tree, argTypes: List[Type])(using Context)
+    extends SyntaxMsg(UnapplyInvalidNumberOfArgumentsID) {
+    def msg = em"Wrong number of argument patterns for $qual; expected: ($argTypes%, %)"
+    def explain =
+      em"""The Unapply method of $qual was used with incorrect number of arguments.
+          |Expected usage would be something like:
+          |case $qual(${argTypes.map(_ => '_')}%, %) => ...
+          |
+        |where subsequent arguments would have following types: ($argTypes%, %).
+        |""".stripMargin
+  }
+
+  class UnapplyInvalidReturnType(unapplyResult: Type, unapplyName: Name)(using Context)
+    extends DeclarationMsg(UnapplyInvalidReturnTypeID) {
+    def msg =
+      val addendum =
+        if Feature.migrateTo3 && unapplyName == nme.unapplySeq
+        then "\nYou might want to try to rewrite the extractor to use `unapply` instead."
+        else ""
+      em"""| ${Red(i"$unapplyResult")} is not a valid result type of an $unapplyName method of an ${Magenta("extractor")}.$addendum"""
+    def explain = if (unapplyName.show == "unapply")
+      em"""
+          |To be used as an extractor, an unapply method has to return a type that either:
+          | - has members ${Magenta("isEmpty: Boolean")} and ${Magenta("get: S")} (usually an ${Green("Option[S]")})
+          | - is a ${Green("Boolean")}
+          | - is a ${Green("Product")} (like a ${Magenta("Tuple2[T1, T2]")})
+          |
+          |class A(val i: Int)
+          |
+          |object B {
+          |  def unapply(a: A): ${Green("Option[Int]")} = Some(a.i)
+          |}
+          |
+          |object C {
+          |  def unapply(a: A): ${Green("Boolean")} = a.i == 2
+          |}
+          |
+          |object D {
+          |  def unapply(a: A): ${Green("(Int, Int)")} = (a.i, a.i)
+          |}
+          |
+          |object Test {
+          |  def test(a: A) = a match {
+          |    ${Magenta("case B(1)")} => 1
+          |    ${Magenta("case a @ C()")} => 2
+          |    ${Magenta("case D(3, 3)")} => 3
+          |  }
+          |}
+        """.stripMargin
+    else
+      em"""
+          |To be used as an extractor, an unapplySeq method has to return a type which has members
+          |${Magenta("isEmpty: Boolean")} and ${Magenta("get: S")} where ${Magenta("S <: Seq[V]")} (usually an ${Green("Option[Seq[V]]")}):
+          |
+          |object CharList {
+          |  def unapplySeq(s: String): ${Green("Option[Seq[Char]")} = Some(s.toList)
+          |
+          |  "example" match {
+          |    ${Magenta("case CharList(c1, c2, c3, c4, _, _, _)")} =>
+          |      println(s"$$c1,$$c2,$$c3,$$c4")
+          |    case _ =>
+          |      println("Expected *exactly* 7 characters!")
+          |  }
+          |}
+        """.stripMargin
+  }
+
+  class StaticFieldsOnlyAllowedInObjects(member: Symbol)(using Context) extends SyntaxMsg(StaticFieldsOnlyAllowedInObjectsID) {
+    def msg = em"${hl("@static")} $member in ${member.owner} must be defined inside a static ${hl("object")}."
+    def explain =
+      em"${hl("@static")} members are only allowed inside objects."
+  }
+
+  class StaticFieldsShouldPrecedeNonStatic(member: Symbol, defns: List[tpd.Tree])(using Context) extends SyntaxMsg(StaticFieldsShouldPrecedeNonStaticID) {
+    def msg = em"${hl("@static")} $member in ${member.owner} must be defined before non-static fields."
+    def explain = {
+      val nonStatics = defns.takeWhile(_.symbol != member).take(3).filter(_.isInstanceOf[tpd.ValDef])
+      val codeExample = s"""object ${member.owner.name.firstPart} {
+                        |  @static ${member} = ...
+                        |  ${nonStatics.map(m => s"${m.symbol} = ...").mkString("\n  ")}
+                        |  ...
+                        |}"""
+      em"""The fields annotated with @static should precede any non @static fields.
+        |This ensures that we do not introduce surprises for users in initialization order of this class.
+        |Static field are initialized when class loading the code of Foo.
+        |Non static fields are only initialized the first  time that Foo is accessed.
+        |
+        |The definition of ${member.name} should have been before the non ${hl("@static val")}s:
+        |$codeExample
+        |"""
+    }
+  }
+
+  class CyclicInheritance(symbol: Symbol, addendum: -> String)(using Context) extends SyntaxMsg(CyclicInheritanceID) {
+    def msg = em"Cyclic inheritance: $symbol extends itself$addendum"
+    def explain = {
+      val codeExample = "class A extends A"
+
+      em"""Cyclic inheritance is prohibited in Dotty.
+          |Consider the following example:
+          |
+          |$codeExample
+          |
+          |The example mentioned above would fail because this type of inheritance hierarchy
+          |creates a "cycle" where a not yet defined class A extends itself which makes
+          |impossible to instantiate an object of this class"""
+    }
+  }
+
+  class BadSymbolicReference(denot: SymDenotation)(using Context)
+  extends ReferenceMsg(BadSymbolicReferenceID) {
+    def msg = {
+      val denotationOwner = denot.owner
+      val denotationName = ctx.fresh.setSetting(ctx.settings.YdebugNames, true).printer.nameString(denot.name)
+      val file = denot.symbol.associatedFile
+      val (location, src) =
+        if (file != null) (s" in $file", file.toString)
+        else ("", "the signature")
+
+      em"""Bad symbolic reference. A signature$location
+          |refers to $denotationName in ${denotationOwner.showKind} ${denotationOwner.showFullName} which is not available.
+          |It may be completely missing from the current classpath, or the version on
+          |the classpath might be incompatible with the version used when compiling $src."""
+    }
+
+    def explain = ""
+  }
+
+  class UnableToExtendSealedClass(pclazz: Symbol)(using Context) extends SyntaxMsg(UnableToExtendSealedClassID) {
+    def msg = em"Cannot extend ${hl("sealed")} $pclazz in a different source file"
+    def explain = "A sealed class or trait can only be extended in the same file as its declaration"
+  }
+
+  class SymbolHasUnparsableVersionNumber(symbol: Symbol, errorMessage: String)(using Context)
+  extends SyntaxMsg(SymbolHasUnparsableVersionNumberID) {
+    def msg = em"${symbol.showLocated} has an unparsable version number: $errorMessage"
+    def explain =
+      em"""The ${symbol.showLocated} is marked with ${hl("@migration")} indicating it has changed semantics
+          |between versions and the ${hl("-Xmigration")} settings is used to warn about constructs
+          |whose behavior may have changed since version change."""
+  }
+
+  class SymbolChangedSemanticsInVersion(
+    symbol: Symbol,
+    migrationVersion: ScalaVersion,
+    migrationMessage: String
+  )(using Context) extends SyntaxMsg(SymbolChangedSemanticsInVersionID) {
+    def msg = em"${symbol.showLocated} has changed semantics in version $migrationVersion: $migrationMessage"
+    def explain =
+      em"""The ${symbol.showLocated} is marked with ${hl("@migration")} indicating it has changed semantics
+          |between versions and the ${hl("-Xmigration")} settings is used to warn about constructs
+          |whose behavior may have changed since version change."""
+  }
+
+  class UnableToEmitSwitch()(using Context)
+  extends SyntaxMsg(UnableToEmitSwitchID) {
+    def msg = em"Could not emit switch for ${hl("@switch")} annotated match"
+    def explain = {
+      val codeExample =
+        """val ConstantB = 'B'
+          |final val ConstantC = 'C'
+          |def tokenMe(ch: Char) = (ch: @switch) match {
+          |  case '\t' | '\n' => 1
+          |  case 'A'         => 2
+          |  case ConstantB   => 3  // a non-literal may prevent switch generation: this would not compile
+          |  case ConstantC   => 4  // a constant value is allowed
+          |  case _           => 5
+          |}""".stripMargin
+
+      em"""If annotated with ${hl("@switch")}, the compiler will verify that the match has been compiled to a
+          |tableswitch or lookupswitch and issue an error if it instead compiles into a series of conditional
+          |expressions. Example usage:
+          |
+          |$codeExample
+          |
+          |The compiler will not apply the optimisation if:
+          |- the matched value is not of type ${hl("Int")}, ${hl("Byte")}, ${hl("Short")} or ${hl("Char")}
+          |- the matched value is not a constant literal
+          |- there are less than three cases"""
+    }
+  }
+
+  class MissingCompanionForStatic(member: Symbol)(using Context)
+  extends SyntaxMsg(MissingCompanionForStaticID) {
+    def msg = em"${member.owner} does not have a companion class"
+    def explain =
+      em"An object that contains ${hl("@static")} members must have a companion class."
+  }
+
+  class PolymorphicMethodMissingTypeInParent(rsym: Symbol, parentSym: Symbol)(using Context)
+  extends SyntaxMsg(PolymorphicMethodMissingTypeInParentID) {
+    def msg = em"Polymorphic refinement $rsym without matching type in parent $parentSym is no longer allowed"
+    def explain =
+      em"""Polymorphic $rsym is not allowed in the structural refinement of $parentSym because
+          |$rsym does not override any method in $parentSym. Structural refinement does not allow for
+          |polymorphic methods."""
+  }
+
+  class ParamsNoInline(owner: Symbol)(using Context)
+    extends SyntaxMsg(ParamsNoInlineID) {
+    def msg = em"""${hl("inline")} modifier can only be used for parameters of inline methods"""
+    def explain = ""
+  }
+
+  class JavaSymbolIsNotAValue(symbol: Symbol)(using Context) extends TypeMsg(JavaSymbolIsNotAValueID) {
+    def msg = {
+      val kind =
+        if (symbol is Package) em"$symbol"
+        else em"Java defined ${hl("class " + symbol.name)}"
+
+      s"$kind is not a value"
+    }
+    def explain = ""
+  }
+
+  class DoubleDefinition(decl: Symbol, previousDecl: Symbol, base: Symbol)(using Context) extends NamingMsg(DoubleDefinitionID) {
+    def msg = {
+      def nameAnd = if (decl.name != previousDecl.name) " name and" else ""
+      def erasedType = if ctx.erasedTypes then i" ${decl.info}" else ""
+      def details(using Context): String =
+        if (decl.isRealMethod && previousDecl.isRealMethod) {
+          import Signature.MatchDegree._
+
+          // compare the signatures when both symbols represent methods
+          decl.signature.matchDegree(previousDecl.signature) match {
+            case NoMatch =>
+              // If the signatures don't match at all at the current phase, then
+              // they might match after erasure.
+              if ctx.phase.id <= elimErasedValueTypePhase.id then
+                atPhase(elimErasedValueTypePhase.next)(details)
+              else
+                "" // shouldn't be reachable
+            case ParamMatch =>
+              "have matching parameter types."
+            case MethodNotAMethodMatch =>
+              "neither has parameters."
+            case FullMatch =>
+              val hint =
+                if !decl.hasAnnotation(defn.TargetNameAnnot)
+                   && !previousDecl.hasAnnotation(defn.TargetNameAnnot)
+                then
+                  i"""
+                     |
+                     |Consider adding a @targetName annotation to one of the conflicting definitions
+                     |for disambiguation."""
+                else ""
+              i"have the same$nameAnd type$erasedType after erasure.$hint"
+          }
+        }
+        else ""
+      def symLocation(sym: Symbol) = {
+        val lineDesc =
+          if (sym.span.exists && sym.span != sym.owner.span)
+            s" at line ${sym.srcPos.line + 1}"
+          else ""
+        i"in ${sym.owner}${lineDesc}"
+      }
+      val clashDescription =
+        if (decl.owner eq previousDecl.owner)
+          "Double definition"
+        else if ((decl.owner eq base) || (previousDecl eq base))
+          "Name clash between defined and inherited member"
+        else
+          "Name clash between inherited members"
+
+      atPhase(typerPhase) {
+        em"""$clashDescription:
+            |${previousDecl.showDcl} ${symLocation(previousDecl)} and
+            |${decl.showDcl} ${symLocation(decl)}
+            |"""
+      } + details
+    }
+    def explain = ""
+  }
+
+  class ImportRenamedTwice(ident: untpd.Ident)(using Context) extends SyntaxMsg(ImportRenamedTwiceID) {
+    def msg = s"${ident.show} is renamed twice on the same import line."
+    def explain = ""
+  }
+
+  class TypeTestAlwaysDiverges(scrutTp: Type, testTp: Type)(using Context) extends SyntaxMsg(TypeTestAlwaysDivergesID) {
+    def msg =
+      s"This type test will never return a result since the scrutinee type ${scrutTp.show} does not contain any value."
+    def explain = ""
+  }
+
+  // Relative of CyclicReferenceInvolvingImplicit and RecursiveValueNeedsResultType
+  class TermMemberNeedsResultTypeForImplicitSearch(cycleSym: Symbol)(using Context)
+    extends CyclicMsg(TermMemberNeedsNeedsResultTypeForImplicitSearchID) {
+    def msg = em"""$cycleSym needs result type because its right-hand side attempts implicit search"""
+    def explain =
+      em"""|The right hand-side of $cycleSym's definition requires an implicit search at the highlighted position.
+           |To avoid this error, give `$cycleSym` an explicit type.
+           |""".stripMargin
+  }
+
+  class ClassCannotExtendEnum(cls: Symbol, parent: Symbol)(using Context) extends SyntaxMsg(ClassCannotExtendEnumID) {
+    def msg = em"""$cls in ${cls.owner} extends enum ${parent.name}, but extending enums is prohibited."""
+    def explain = ""
+  }
+
+  class NotAnExtractor(tree: untpd.Tree)(using Context) extends SyntaxMsg(NotAnExtractorID) {
+    def msg = em"$tree cannot be used as an extractor in a pattern because it lacks an unapply or unapplySeq method"
+    def explain =
+      em"""|An ${hl("unapply")} method should be defined in an ${hl("object")} as follow:
+           |  - If it is just a test, return a ${hl("Boolean")}. For example ${hl("case even()")}
+           |  - If it returns a single sub-value of type T, return an ${hl("Option[T]")}
+           |  - If it returns several sub-values T1,...,Tn, group them in an optional tuple ${hl("Option[(T1,...,Tn)]")}
+           |
+           |Sometimes, the number of sub-values isn't fixed and we would like to return a sequence.
+           |For this reason, you can also define patterns through ${hl("unapplySeq")} which returns ${hl("Option[Seq[T]]")}.
+           |This mechanism is used for instance in pattern ${hl("case List(x1, ..., xn)")}""".stripMargin
+  }
+
+  class MemberWithSameNameAsStatic()(using Context)
+    extends SyntaxMsg(MemberWithSameNameAsStaticID) {
+    def msg = em"Companion classes cannot define members with same name as a ${hl("@static")} member"
+    def explain = ""
+  }
+
+  class PureExpressionInStatementPosition(stat: untpd.Tree, val exprOwner: Symbol)(using Context)
+    extends Message(PureExpressionInStatementPositionID) {
+    def kind = MessageKind.PotentialIssue
+    def msg = "A pure expression does nothing in statement position; you may be omitting necessary parentheses"
+    def explain =
+      em"""The pure expression $stat doesn't have any side effect and its result is not assigned elsewhere.
+          |It can be removed without changing the semantics of the program. This may indicate an error.""".stripMargin
+  }
+
+  class TraitCompanionWithMutableStatic()(using Context)
+    extends SyntaxMsg(TraitCompanionWithMutableStaticID) {
+    def msg = em"Companion of traits cannot define mutable @static fields"
+    def explain = ""
+  }
+
+  class LazyStaticField()(using Context)
+    extends SyntaxMsg(LazyStaticFieldID) {
+    def msg = em"Lazy @static fields are not supported"
+    def explain = ""
+  }
+
+  class StaticOverridingNonStaticMembers()(using Context)
+    extends SyntaxMsg(StaticOverridingNonStaticMembersID) {
+    def msg = em"${hl("@static")} members cannot override or implement non-static ones"
+    def explain = ""
+  }
+
+  class OverloadInRefinement(rsym: Symbol)(using Context)
+    extends DeclarationMsg(OverloadInRefinementID) {
+    def msg = "Refinements cannot introduce overloaded definitions"
+    def explain =
+      em"""The refinement `$rsym` introduces an overloaded definition.
+          |Refinements cannot contain overloaded definitions.""".stripMargin
+  }
+
+  class NoMatchingOverload(val alternatives: List[SingleDenotation], pt: Type)(using Context)
+    extends TypeMsg(NoMatchingOverloadID) {
+    def msg =
+      em"""None of the ${err.overloadedAltsStr(alternatives)}
+          |match ${err.expectedTypeStr(pt)}"""
+    def explain = ""
+  }
+  class StableIdentPattern(tree: untpd.Tree, pt: Type)(using Context)
+    extends TypeMsg(StableIdentPatternID) {
+    def msg =
+      em"""Stable identifier required, but $tree found"""
+    def explain = ""
+  }
+
+  class IllegalSuperAccessor(base: Symbol, memberName: Name, targetName: Name,
+      acc: Symbol, accTp: Type,
+      other: Symbol, otherTp: Type)(using Context) extends DeclarationMsg(IllegalSuperAccessorID) {
+    def msg = {
+      // The mixin containing a super-call that requires a super-accessor
+      val accMixin = acc.owner
+      // The class or trait that the super-accessor should resolve too in `base`
+      val otherMixin = other.owner
+      // The super-call in `accMixin`
+      val superCall = hl(i"super.$memberName")
+      // The super-call that the super-accesors in `base` forwards to
+      val resolvedSuperCall = hl(i"super[${otherMixin.name}].$memberName")
+      // The super-call that we would have called if `super` in traits behaved like it
+      // does in classes, i.e. followed the linearization of the trait itself.
+      val staticSuperCall = {
+        val staticSuper = accMixin.asClass.info.parents.reverse
+          .find(_.nonPrivateMember(memberName)
+            .matchingDenotation(accMixin.thisType, acc.info, targetName).exists)
+        val staticSuperName = staticSuper match {
+          case Some(parent) =>
+            parent.classSymbol.name.show
+          case None => // Might be reachable under separate compilation
+            "SomeParent"
+        }
+        hl(i"super[$staticSuperName].$memberName")
+      }
+      ex"""$base cannot be defined due to a conflict between its parents when
+          |implementing a super-accessor for $memberName in $accMixin:
+          |
+          |1. One of its parent (${accMixin.name}) contains a call $superCall in its body,
+          |   and when a super-call in a trait is written without an explicit parent
+          |   listed in brackets, it is implemented by a generated super-accessor in
+          |   the class that extends this trait based on the linearization order of
+          |   the class.
+          |2. Because ${otherMixin.name} comes before ${accMixin.name} in the linearization
+          |   order of ${base.name}, and because ${otherMixin.name} overrides $memberName,
+          |   the super-accessor in ${base.name} is implemented as a call to
+          |   $resolvedSuperCall.
+          |3. However,
+          |   ${otherTp.widenExpr} (the type of $resolvedSuperCall in ${base.name})
+          |   is not a subtype of
+          |   ${accTp.widenExpr} (the type of $memberName in $accMixin).
+          |   Hence, the super-accessor that needs to be generated in ${base.name}
+          |   is illegal.
+          |
+          |Here are two possible ways to resolve this:
+          |
+          |1. Change the linearization order of ${base.name} such that
+          |   ${accMixin.name} comes before ${otherMixin.name}.
+          |2. Alternatively, replace $superCall in the body of $accMixin by a
+          |   super-call to a specific parent, e.g. $staticSuperCall
+          |""".stripMargin
+    }
+    def explain = ""
+  }
+
+  class TraitParameterUsedAsParentPrefix(cls: Symbol)(using Context)
+    extends DeclarationMsg(TraitParameterUsedAsParentPrefixID) {
+    def msg =
+      s"${cls.show} cannot extend from a parent that is derived via its own parameters"
+    def explain =
+      ex"""
+          |The parent class/trait that ${cls.show} extends from is obtained from
+          |the parameter of ${cls.show}. This is disallowed in order to prevent
+          |outer-related Null Pointer Exceptions in Scala.
+          |
+          |In order to fix this issue consider directly extending from the parent rather
+          |than obtaining it from the parameters of ${cls.show}.
+          |""".stripMargin
+  }
+
+  class UnknownNamedEnclosingClassOrObject(name: TypeName)(using Context)
+    extends ReferenceMsg(UnknownNamedEnclosingClassOrObjectID) {
+    def msg =
+      em"""no enclosing class or object is named '${hl(name.show)}'"""
+    def explain =
+      ex"""
+      |The class or object named '${hl(name.show)}' was used as a visibility
+      |modifier, but could not be resolved. Make sure that
+      |'${hl(name.show)}' is not misspelled and has been imported into the
+      |current scope.
+      """.stripMargin
+    }
+
+  class IllegalCyclicTypeReference(sym: Symbol, where: String, lastChecked: Type)(using Context)
+    extends CyclicMsg(IllegalCyclicTypeReferenceID) {
+    def msg =
+      val lastCheckedStr =
+        try lastChecked.show
+        catch case ex: CyclicReference => "..."
+      i"illegal cyclic type reference: ${where} ${hl(lastCheckedStr)} of $sym refers back to the type itself"
+    def explain = ""
+  }
+
+  class ErasedTypesCanOnlyBeFunctionTypes()(using Context)
+    extends SyntaxMsg(ErasedTypesCanOnlyBeFunctionTypesID) {
+    def msg = "Types with erased keyword can only be function types `(erased ...) => ...`"
+    def explain = ""
+  }
+
+  class CaseClassMissingNonImplicitParamList(cdef: untpd.TypeDef)(using Context)
+    extends SyntaxMsg(CaseClassMissingNonImplicitParamListID) {
+    def msg =
+      em"""|A ${hl("case class")} must have at least one leading non-implicit parameter list"""
+
+    def explain =
+      em"""|${cdef.name} must have at least one leading non-implicit parameter list,
+           | if you're aiming to have a case class parametrized only by implicit ones, you should
+           | add an explicit ${hl("()")} as the first parameter list to ${cdef.name}.""".stripMargin
+  }
+
+  class EnumerationsShouldNotBeEmpty(cdef: untpd.TypeDef)(using Context)
+    extends SyntaxMsg(EnumerationsShouldNotBeEmptyID) {
+    def msg = "Enumerations must contain at least one case"
+
+    def explain =
+      em"""|Enumeration ${cdef.name} must contain at least one case
+           |Example Usage:
+           | ${hl("enum")} ${cdef.name} {
+           |    ${hl("case")} Option1, Option2
+           | }
+           |""".stripMargin
+  }
+
+  class TypedCaseDoesNotExplicitlyExtendTypedEnum(enumDef: Symbol, caseDef: untpd.TypeDef)(using Context)
+    extends SyntaxMsg(TypedCaseDoesNotExplicitlyExtendTypedEnumID) {
+    def msg = i"explicit extends clause needed because both enum case and enum class have type parameters"
+
+    def explain =
+      em"""Enumerations where the enum class as well as the enum case have type parameters need
+          |an explicit extends.
+          |for example:
+          | ${hl("enum")} ${enumDef.name}[T] {
+          |  ${hl("case")} ${caseDef.name}[U](u: U) ${hl("extends")} ${enumDef.name}[U]
+          | }
+          |""".stripMargin
+  }
+
+  class IllegalRedefinitionOfStandardKind(kindType: String, name: Name)(using Context)
+    extends SyntaxMsg(IllegalRedefinitionOfStandardKindID) {
+    def msg = em"illegal redefinition of standard $kindType $name"
+    def explain =
+      em"""| "$name" is a standard Scala core `$kindType`
+           | Please choose a different name to avoid conflicts
+           |""".stripMargin
+  }
+
+  class NoExtensionMethodAllowed(mdef: untpd.DefDef)(using Context)
+    extends SyntaxMsg(NoExtensionMethodAllowedID) {
+    def msg = em"No extension method allowed here, since collective parameters are given"
+    def explain =
+      em"""|Extension method:
+           |  `${mdef}`
+           |is defined inside an extension clause which has collective parameters.
+           |""".stripMargin
+  }
+
+  class ExtensionMethodCannotHaveTypeParams(mdef: untpd.DefDef)(using Context)
+    extends SyntaxMsg(ExtensionMethodCannotHaveTypeParamsID) {
+    def msg = i"Extension method cannot have type parameters since some were already given previously"
+
+    def explain =
+      em"""|Extension method:
+           |  `${mdef}`
+           |has type parameters `[${mdef.leadingTypeParams.map(_.show).mkString(",")}]`, while the extension clause has
+           |it's own type parameters. Please consider moving these to the extension clause's type parameter list.
+           |""".stripMargin
+  }
+
+  class ExtensionCanOnlyHaveDefs(mdef: untpd.Tree)(using Context)
+    extends SyntaxMsg(ExtensionCanOnlyHaveDefsID) {
+    def msg = em"Only methods allowed here, since collective parameters are given"
+    def explain =
+      em"""Extension clauses can only have `def`s
+          | `${mdef.show}` is not a valid expression here.
+          |""".stripMargin
+  }
+
+  class UnexpectedPatternForSummonFrom(tree: Tree[_])(using Context)
+    extends SyntaxMsg(UnexpectedPatternForSummonFromID) {
+    def msg = em"Unexpected pattern for summonFrom. Expected ${hl("`x: T`")} or ${hl("`_`")}"
+    def explain =
+      em"""|The pattern "${tree.show}" provided in the ${hl("case")} expression of the ${hl("summonFrom")},
+           | needs to be of the form ${hl("`x: T`")} or ${hl("`_`")}.
+           |
+           | Example usage:
+           | inline def a = summonFrom {
+           |  case x: T => ???
+           | }
+           |
+           | or
+           | inline def a = summonFrom {
+           |  case _ => ???
+           | }
+           |""".stripMargin
+  }
+
+  class AnonymousInstanceCannotBeEmpty(impl:  untpd.Template)(using Context)
+    extends SyntaxMsg(AnonymousInstanceCannotBeEmptyID) {
+    def msg = i"anonymous instance must implement a type or have at least one extension method"
+    def explain =
+      em"""|Anonymous instances cannot be defined with an empty body. The block
+           |`${impl.show}` should either contain an implemented type or at least one extension method.
+           |""".stripMargin
+  }
+
+  class ModifierNotAllowedForDefinition(flag: Flag)(using Context)
+    extends SyntaxMsg(ModifierNotAllowedForDefinitionID) {
+    def msg = em"Modifier ${hl(flag.flagsString)} is not allowed for this definition"
+    def explain = ""
+  }
+
+  class RedundantModifier(flag: Flag)(using Context)
+    extends SyntaxMsg(RedundantModifierID) {
+    def msg = em"Modifier ${hl(flag.flagsString)} is redundant for this definition"
+    def explain = ""
+  }
+
+  class InvalidReferenceInImplicitNotFoundAnnotation(typeVar: String, owner: String)(using Context)
+    extends ReferenceMsg(InvalidReferenceInImplicitNotFoundAnnotationID) {
+    def msg = em"""|Invalid reference to a type variable ${hl(typeVar)} found in the annotation argument.
+                   |The variable does not occur as a parameter in the scope of ${hl(owner)}.
+                   |""".stripMargin
+    def explain = ""
+  }
+
+  class CaseClassInInlinedCode(tree: tpd.Tree)(using Context)
+    extends SyntaxMsg(CaseClassInInlinedCodeID) {
+
+    def defKind = if tree.symbol.is(Module) then "object" else "class"
+    def msg = s"Case $defKind definitions are not allowed in inline methods or quoted code. Use a normal $defKind instead."
+    def explain =
+      em"""Case class/object definitions generate a considerable footprint in code size.
+          |Inlining such definition would multiply this footprint for each call site.
+          |""".stripMargin
+  }
+
+  class ImplicitSearchTooLargeWarning(limit: Int, openSearchPairs: List[(Candidate, Type)])(using Context)
+    extends TypeMsg(ImplicitSearchTooLargeID):
+    override def showAlways = true
+    def showQuery(query: (Candidate, Type)): String =
+      i"  ${query._1.ref.symbol.showLocated}  for  ${query._2}}"
+    def msg =
+      em"""Implicit search problem too large.
+          |an implicit search was terminated with failure after trying $limit expressions.
+          |The root candidate for the search was:
+          |
+          |${showQuery(openSearchPairs.last)}
+          |
+          |You can change the behavior by setting the `-Ximplicit-search-limit` value.
+          |Smaller values cause the search to fail faster.
+          |Larger values might make a very large search problem succeed.
+          |"""
+    def explain =
+      em"""The overflow happened with the following lists of tried expressions and target types,
+          |starting with the root query:
+          |
+          |${openSearchPairs.reverse.map(showQuery)}%\n%
+        """
+
+  class TargetNameOnTopLevelClass(symbol: Symbol)(using Context)
+  extends SyntaxMsg(TargetNameOnTopLevelClassID):
+    def msg = em"${hl("@targetName")} annotation not allowed on top-level $symbol"
+    def explain =
+      val annot = symbol.getAnnotation(defn.TargetNameAnnot).get
+      em"""The @targetName annotation may be applied to a top-level ${hl("val")} or ${hl("def")}, but not
+          |a top-level ${hl("class")}, ${hl("trait")}, or ${hl("object")}.
+          |
+          |This restriction is due to the naming convention of Java classfiles, whose filenames
+          |are based on the name of the class defined within. If @targetName were permitted
+          |here, the name of the classfile would be based on the target name, and the compiler
+          |could not associate that classfile with the Scala-visible defined name of the class.
+          |
+          |If your use case requires @targetName, consider wrapping $symbol in an ${hl("object")}
+          |(and possibly exporting it), as in the following example:
+          |
+          |${hl("object Wrapper:")}
+          |  $annot $symbol { ... }
+          |
+          |${hl("export")} Wrapper.${symbol.name}  ${hl("// optional")}"""
+
+  class NotClassType(tp: Type)(using Context)
+  extends TypeMsg(NotClassTypeID), ShowMatchTrace(tp):
+    def msg = ex"$tp is not a class type"
+    def explain = ""
+
diff --git a/tests/pos-with-compiler-cc/dotc/reporting/trace.scala b/tests/pos-with-compiler-cc/dotc/reporting/trace.scala
new file mode 100644
index 000000000000..7c114b51ed21
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/reporting/trace.scala
@@ -0,0 +1,108 @@
+package dotty.tools
+package dotc
+package reporting
+
+import scala.language.unsafeNulls
+
+import core.Contexts._
+import config.Config
+import config.Printers
+import core.Mode
+
+/** Exposes the {{{ trace("question") { op } }}} syntax.
+ *
+ * Traced operations will print indented messages if enabled.
+ * Tracing depends on [[Config.tracingEnabled]] and [[dotty.tools.dotc.config.ScalaSettings.Ylog]].
+ * Tracing can be forced by replacing [[trace]] with [[trace.force]] or [[trace.log]] (see below).
+ */
+object trace extends TraceSyntax:
+  inline def isEnabled = Config.tracingEnabled
+  protected val isForced = false
+
+  object force extends TraceSyntax:
+    inline def isEnabled: true = true
+    protected val isForced = true
+
+  object log extends TraceSyntax:
+    inline def isEnabled: true = true
+    protected val isForced = false
+end trace
+
+/** This module is carefully optimized to give zero overhead if Config.tracingEnabled
+ *  is false. The `trace` operation is called in various hotspots, so every tiny bit
+ *  of overhead is unacceptable: boxing, closures, additional method calls are all out.
+ */
+trait TraceSyntax:
+
+  inline def isEnabled: Boolean
+  protected val isForced: Boolean
+
+  inline def onDebug[TD](inline question: String)(inline op: TD)(using Context): TD =
+    conditionally(ctx.settings.YdebugTrace.value, question, false)(op)
+
+  inline def conditionally[TC](inline cond: Boolean, inline question: String, inline show: Boolean)(inline op: TC)(using Context): TC =
+    inline if isEnabled then
+      apply(question, if cond then Printers.default else Printers.noPrinter, show)(op)
+    else op
+
+  inline def apply[T, U >: T](inline question: String, inline printer: Printers.Printer, inline showOp: U => String)(inline op: T)(using Context): T =
+    inline if isEnabled then
+      doTrace[T](question, printer, showOp)(op)
+    else op
+
+  inline def apply[T](inline question: String, inline printer: Printers.Printer, inline show: Boolean)(inline op: T)(using Context): T =
+    inline if isEnabled then
+      doTrace[T](question, printer, if show then showShowable(_) else alwaysToString)(op)
+    else op
+
+  inline def apply[T](inline question: String, inline printer: Printers.Printer)(inline op: T)(using Context): T =
+    apply[T](question, printer, false)(op)
+
+  inline def apply[T](inline question: String, inline show: Boolean)(inline op: T)(using Context): T =
+    apply[T](question, Printers.default, show)(op)
+
+  inline def apply[T](inline question: String)(inline op: T)(using Context): T =
+    apply[T](question, false)(op)
+
+  private def showShowable(x: Any)(using Context) = x match
+    case x: printing.Showable => x.show
+    case _ => String.valueOf(x)
+
+  private val alwaysToString = (x: Any) => String.valueOf(x)
+
+  private def doTrace[T](question: => String,
+                         printer: Printers.Printer = Printers.default,
+                         showOp: T => String = alwaysToString)
+                        (op: => T)(using Context): T =
+    if ctx.mode.is(Mode.Printing) || !isForced && (printer eq Printers.noPrinter) then op
+    else
+      // Avoid evaluating question multiple time, since each evaluation
+      // may cause some extra logging output.
+      val q = question
+      val leading = s"==> $q?"
+      val trailing = (res: T) => s"<== $q = ${showOp(res)}"
+      var finalized = false
+      var logctx = ctx
+      while logctx.reporter.isInstanceOf[StoreReporter] do logctx = logctx.outer
+      def margin = ctx.base.indentTab * ctx.base.indent
+      def doLog(s: String) = if isForced then println(s) else report.log(s)(using logctx)
+      def finalize(msg: String) =
+        if !finalized then
+          ctx.base.indent -= 1
+          doLog(s"$margin$msg")
+          finalized = true
+      try
+        doLog(s"$margin$leading")
+        ctx.base.indent += 1
+        val res = op
+        finalize(trailing(res))
+        res
+      catch
+        case ex: runtime.NonLocalReturnControl[T] =>
+          finalize(trailing(ex.value))
+          throw ex
+        case ex: Throwable =>
+          val msg = s"<== $q = <missing> (with exception $ex)"
+          finalize(msg)
+          throw ex
+end TraceSyntax
diff --git a/tests/pos-with-compiler-cc/dotc/rewrites/Rewrites.scala b/tests/pos-with-compiler-cc/dotc/rewrites/Rewrites.scala
new file mode 100644
index 000000000000..96e88e5c68ae
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/rewrites/Rewrites.scala
@@ -0,0 +1,102 @@
+package dotty.tools.dotc
+package rewrites
+
+import util.{SourceFile, Spans}
+import Spans.Span
+import core.Contexts._
+import collection.mutable
+import scala.annotation.tailrec
+import dotty.tools.dotc.reporting.Reporter
+
+import java.io.OutputStreamWriter
+import java.nio.charset.StandardCharsets.UTF_8
+
+/** Handles rewriting of Scala2 files to Dotty */
+object Rewrites {
+  private class PatchedFiles extends mutable.HashMap[SourceFile, Patches]
+
+  private case class Patch(span: Span, replacement: String) {
+    def delta = replacement.length - (span.end - span.start)
+  }
+
+  private class Patches(source: SourceFile) {
+    private[Rewrites] val pbuf = new mutable.ListBuffer[Patch]()
+
+    def addPatch(span: Span, replacement: String): Unit =
+      pbuf.indexWhere(p => p.span.start == span.start && p.span.end == span.end) match {
+        case i if i >= 0 => pbuf.update(i, Patch(span, replacement))
+        case _           => pbuf += Patch(span, replacement)
+      }
+
+    def apply(cs: Array[Char]): Array[Char] = {
+      val delta = pbuf.map(_.delta).sum
+      val patches = pbuf.toList.sortBy(_.span.start)
+      if (patches.nonEmpty)
+        patches.reduceLeft {(p1, p2) =>
+          assert(p1.span.end <= p2.span.start, s"overlapping patches in $source: $p1 and $p2")
+          p2
+        }
+      val ds = new Array[Char](cs.length + delta)
+      @tailrec def loop(ps: List[Patch], inIdx: Int, outIdx: Int): Unit = {
+        def copy(upTo: Int): Int = {
+          val untouched = upTo - inIdx
+          System.arraycopy(cs, inIdx, ds, outIdx, untouched)
+          outIdx + untouched
+        }
+        ps match {
+          case patch @ Patch(span, replacement) :: ps1 =>
+            val outNew = copy(span.start)
+            replacement.copyToArray(ds, outNew)
+            loop(ps1, span.end, outNew + replacement.length)
+          case Nil =>
+            val outNew = copy(cs.length)
+            assert(outNew == ds.length, s"$outNew != ${ds.length}")
+        }
+      }
+      loop(patches, 0, 0)
+      ds
+    }
+
+    def writeBack(): Unit =
+      val chars = apply(source.underlying.content)
+      val osw = OutputStreamWriter(source.file.output, UTF_8)
+      try osw.write(chars, 0, chars.length)
+      finally osw.close()
+  }
+
+  /** If -rewrite is set, record a patch that replaces the range
+   *  given by `span` in `source` by `replacement`
+   */
+  def patch(source: SourceFile, span: Span, replacement: String)(using Context): Unit =
+    if ctx.reporter != Reporter.NoReporter // NoReporter is used for syntax highlighting
+    then ctx.settings.rewrite.value.foreach(_.patched
+         .getOrElseUpdate(source, new Patches(source))
+         .addPatch(span, replacement)
+    )
+
+  /** Patch position in `ctx.compilationUnit.source`. */
+  def patch(span: Span, replacement: String)(using Context): Unit =
+    patch(ctx.compilationUnit.source, span, replacement)
+
+  /** Does `span` overlap with a patch region of `source`? */
+  def overlapsPatch(source: SourceFile, span: Span)(using Context): Boolean =
+    ctx.settings.rewrite.value.exists(rewrites =>
+      rewrites.patched.get(source).exists(patches =>
+        patches.pbuf.exists(patch => patch.span.overlaps(span))))
+
+  /** If -rewrite is set, apply all patches and overwrite patched source files.
+   */
+  def writeBack()(using Context): Unit =
+    for (rewrites <- ctx.settings.rewrite.value; source <- rewrites.patched.keys) {
+      report.echo(s"[patched file ${source.file.path}]")
+      rewrites.patched(source).writeBack()
+    }
+}
+
+/** A completely encapsulated class representing rewrite state, used
+ *  as an optional setting.
+ */
+class Rewrites {
+  import Rewrites._
+  private val patched = new PatchedFiles
+}
diff --git a/tests/pos-with-compiler-cc/dotc/sbt/APIUtils.scala b/tests/pos-with-compiler-cc/dotc/sbt/APIUtils.scala
new file mode 100644
index 000000000000..aa98f79c8e3b
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/sbt/APIUtils.scala
@@ -0,0 +1,55 @@
+package dotty.tools.dotc
+package sbt
+
+import scala.language.unsafeNulls
+
+import core._
+import Contexts._
+import Flags._
+import Symbols._
+import NameOps._
+
+import xsbti.api
+import xsbti.api.SafeLazy.strict
+
+/** Utilities to deal with xsbti.api.
+ *
+ *  Mostly comes from https://github.com/sbt/zinc/blob/c46643f3e68d7d4f270bf318e3f150f5a59c0aab/internal/zinc-apiinfo/src/main/scala/xsbt/api/APIUtil.scala
+ */
+object APIUtils {
+  private object Constants {
+    val PublicAccess = api.Public.create()
+    val EmptyModifiers = new api.Modifiers(false, false, false, false, false, false, false, false)
+    val EmptyStructure = api.Structure.of(strict(Array.empty), strict(Array.empty), strict(Array.empty))
+    val EmptyType = api.EmptyType.of()
+  }
+
+  import Constants._
+
+  /** Registers a dummy class for sbt's incremental compilation.
+   *
+   *  If a compiler phase creates a new named (module) class/trait after the phase
+   *  `ExtractAPI`, it must register that class for sbt's incremental compilation
+   *  on its own, lest crashes happen. In theory, the full API of the class needs
+   *  to be constructed, but if the class is never accessed by Scala source code,
+   *  a dummy empty class can be registered instead, using this method.
+   */
+  def registerDummyClass(classSym: ClassSymbol)(using Context): Unit = {
+    if (ctx.sbtCallback != null) {
+      val classLike = emptyClassLike(classSym)
+      ctx.sbtCallback.api(ctx.compilationUnit.source.file.file, classLike)
+    }
+  }
+
+  // See APIUtils.emptyClassLike
+  private def emptyClassLike(classSym: ClassSymbol)(using Context): api.ClassLike = {
+    val name = classSym.fullName.stripModuleClassSuffix.toString
+    val definitionType =
+      if (classSym.is(Trait)) api.DefinitionType.Trait
+      else if (classSym.is(Module)) api.DefinitionType.Module
+      else api.DefinitionType.ClassDef
+    val topLevel = classSym.isTopLevelClass
+    api.ClassLike.of(name, PublicAccess, EmptyModifiers, Array.empty, definitionType,
+      strict(EmptyType), strict(EmptyStructure), Array.empty, Array.empty, topLevel, Array.empty)
+  }
+}
diff --git a/tests/pos-with-compiler-cc/dotc/sbt/ExtractAPI.scala b/tests/pos-with-compiler-cc/dotc/sbt/ExtractAPI.scala
new file mode 100644
index 000000000000..e75133c78759
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/sbt/ExtractAPI.scala
@@ -0,0 +1,833 @@
+package dotty.tools.dotc
+package sbt
+
+import scala.language.unsafeNulls
+
+import ExtractDependencies.internalError
+import ast.{Positioned, Trees, tpd}
+import core._
+import core.Decorators._
+import Annotations._
+import Contexts._
+import Flags._
+import Phases._
+import Trees._
+import Types._
+import Symbols._
+import Names._
+import NameOps._
+import inlines.Inlines
+import transform.ValueClasses
+import transform.SymUtils._
+import dotty.tools.io.File
+import java.io.PrintWriter
+
+
+import scala.collection.mutable
+import scala.util.hashing.MurmurHash3
+import scala.util.chaining.*
+import language.experimental.pureFunctions
+
+/** This phase sends a representation of the API of classes to sbt via callbacks.
+ *
+ *  This is used by sbt for incremental recompilation.
+ *
+ *  See the documentation of `ExtractAPICollector`, `ExtractDependencies`,
+ *  `ExtractDependenciesCollector` and
+ *  http://www.scala-sbt.org/1.x/docs/Understanding-Recompilation.html for more
+ *  information on incremental recompilation.
+ *
+ *  The following flags affect this phase:
+ *   -Yforce-sbt-phases
+ *   -Ydump-sbt-inc
+ *
+ *  @see ExtractDependencies
+ */
+class ExtractAPI extends Phase {
+
+  override def phaseName: String = ExtractAPI.name
+
+  override def description: String = ExtractAPI.description
+
+  override def isRunnable(using Context): Boolean = {
+    def forceRun = ctx.settings.YdumpSbtInc.value || ctx.settings.YforceSbtPhases.value
+    super.isRunnable && (ctx.sbtCallback != null || forceRun)
+  }
+
+  // Check no needed. Does not transform trees
+  override def isCheckable: Boolean = false
+
+  // SuperAccessors need to be part of the API (see the scripted test
+  // `trait-super` for an example where this matters), this is only the case
+  // after `PostTyper` (unlike `ExtractDependencies`, the simplication to trees
+  // done by `PostTyper` do not affect this phase because it only cares about
+  // definitions, and `PostTyper` does not change definitions).
+  override def runsAfter: Set[String] = Set(transform.PostTyper.name)
+
+  override def run(using Context): Unit = {
+    val unit = ctx.compilationUnit
+    val sourceFile = unit.source.file
+    if (ctx.sbtCallback != null)
+      ctx.sbtCallback.startSource(sourceFile.file)
+
+    val apiTraverser = new ExtractAPICollector
+    val classes = apiTraverser.apiSource(unit.tpdTree)
+    val mainClasses = apiTraverser.mainClasses
+
+    if (ctx.settings.YdumpSbtInc.value) {
+      // Append to existing file that should have been created by ExtractDependencies
+      val pw = new PrintWriter(File(sourceFile.jpath).changeExtension("inc").toFile
+        .bufferedWriter(append = true), true)
+      try {
+        classes.foreach(source => pw.println(DefaultShowAPI(source)))
+      } finally pw.close()
+    }
+
+    if ctx.sbtCallback != null &&
+      !ctx.compilationUnit.suspendedAtInliningPhase // already registered before this unit was suspended
+    then
+      classes.foreach(ctx.sbtCallback.api(sourceFile.file, _))
+      mainClasses.foreach(ctx.sbtCallback.mainClass(sourceFile.file, _))
+  }
+}
+
+object ExtractAPI:
+  val name: String = "sbt-api"
+  val description: String = "sends a representation of the API of classes to sbt"
+
+/** Extracts full (including private members) API representation out of Symbols and Types.
+ *
+ *  The exact representation used for each type is not important: the only thing
+ *  that matters is that a binary-incompatible or source-incompatible change to
+ *  the API (for example, changing the signature of a method, or adding a parent
+ *  to a class) should result in a change to the API representation so that sbt
+ *  can recompile files that depend on this API.
+ *
+ *  Note that we only records types as they are defined and never "as seen from"
+ *  some other prefix because `Types#asSeenFrom` is a complex operation and
+ *  doing it for every inherited member would be slow, and because the number
+ *  of prefixes can be enormous in some cases:
+ *
+ *    class Outer {
+ *      type T <: S
+ *      type S
+ *      class A extends Outer { /*...*/ }
+ *      class B extends Outer { /*...*/ }
+ *      class C extends Outer { /*...*/ }
+ *      class D extends Outer { /*...*/ }
+ *      class E extends Outer { /*...*/ }
+ *    }
+ *
+ *  `S` might be refined in an arbitrary way inside `A` for example, this
+ *  affects the type of `T` as seen from `Outer#A`, so we could record that, but
+ *  the class `A` also contains itself as a member, so `Outer#A#A#A#...` is a
+ *  valid prefix for `T`. Even if we avoid loops, we still have a combinatorial
+ *  explosion of possible prefixes, like `Outer#A#B#C#D#E`.
+ *
+ *  It is much simpler to record `T` once where it is defined, but that means
+ *  that the API representation of `T` may not change even though `T` as seen
+ *  from some prefix has changed. This is why in `ExtractDependencies` we need
+ *  to traverse used types to not miss dependencies, see the documentation of
+ *  `ExtractDependencies#usedTypeTraverser`.
+ *
+ *  TODO: sbt does not store the full representation that we compute, instead it
+ *  hashes parts of it to reduce memory usage, then to see if something changed,
+ *  it compares the hashes instead of comparing the representations. We should
+ *  investigate whether we can just directly compute hashes in this phase
+ *  without going through an intermediate representation, see
+ *  http://www.scala-sbt.org/0.13/docs/Understanding-Recompilation.html#Hashing+an+API+representation
+ */
+private class ExtractAPICollector(using Context) extends ThunkHolder {
+  import tpd._
+  import xsbti.api
+
+  /** This cache is necessary for correctness, see the comment about inherited
+   *  members in `apiClassStructure`
+   */
+  private val classLikeCache = new mutable.HashMap[ClassSymbol, api.ClassLikeDef]
+  /** This cache is optional, it avoids recomputing representations */
+  private val typeCache = new mutable.HashMap[Type, api.Type]
+  /** This cache is necessary to avoid unstable name hashing when `typeCache` is present,
+   *  see the comment in the `RefinedType` case in `computeType`
+   *  The cache key is (api of RefinedType#parent, api of RefinedType#refinedInfo).
+   */
+  private val refinedTypeCache = new mutable.HashMap[(api.Type, api.Definition), api.Structure]
+
+  /** This cache is necessary to avoid infinite loops when hashing an inline "Body" annotation.
+   *  Its values are transitively seen inline references within a call chain starting from a single "origin" inline
+   *  definition. Avoid hashing an inline "Body" annotation if its associated definition is already in the cache.
+   *  Precondition: the cache is empty whenever we hash a new "origin" inline "Body" annotation.
+   */
+  private val seenInlineCache = mutable.HashSet.empty[Symbol]
+
+  /** This cache is optional, it avoids recomputing hashes of inline "Body" annotations,
+   *  e.g. when a concrete inline method is inherited by a subclass.
+   */
+  private val inlineBodyCache = mutable.HashMap.empty[Symbol, Int]
+
+  private val allNonLocalClassesInSrc = new mutable.HashSet[xsbti.api.ClassLike]
+  private val _mainClasses = new mutable.HashSet[String]
+
+  private object Constants {
+    val emptyStringArray = Array[String]()
+    val local            = api.ThisQualifier.create()
+    val public           = api.Public.create()
+    val privateLocal     = api.Private.create(local)
+    val protectedLocal   = api.Protected.create(local)
+    val unqualified      = api.Unqualified.create()
+    val thisPath         = api.This.create()
+    val emptyType        = api.EmptyType.create()
+    val emptyModifiers   =
+      new api.Modifiers(false, false, false, false, false,false, false, false)
+  }
+
+  /** Some Dotty types do not have a corresponding type in xsbti.api.* that
+   *  represents them. Until this is fixed we can workaround this by using
+   *  special annotations that can never appear in the source code to
+   *  represent these types.
+   *
+   *  @param tp      An approximation of the type we're trying to represent
+   *  @param marker  A special annotation to differentiate our type
+   */
+  private def withMarker(tp: api.Type, marker: api.Annotation) =
+    api.Annotated.of(tp, Array(marker))
+  private def marker(name: String) =
+    api.Annotation.of(api.Constant.of(Constants.emptyType, name), Array())
+  private val orMarker = marker("Or")
+  private val byNameMarker = marker("ByName")
+  private val matchMarker = marker("Match")
+  private val superMarker = marker("Super")
+
+  /** Extract the API representation of a source file */
+  def apiSource(tree: Tree): Seq[api.ClassLike] = {
+    def apiClasses(tree: Tree): Unit = tree match {
+      case PackageDef(_, stats) =>
+        stats.foreach(apiClasses)
+      case tree: TypeDef =>
+        apiClass(tree.symbol.asClass)
+      case _ =>
+    }
+
+    apiClasses(tree)
+    forceThunks()
+
+    allNonLocalClassesInSrc.toSeq
+  }
+
+  def apiClass(sym: ClassSymbol): api.ClassLikeDef =
+    classLikeCache.getOrElseUpdate(sym, computeClass(sym))
+
+  def mainClasses: Set[String] = {
+    forceThunks()
+    _mainClasses.toSet
+  }
+
+  private def computeClass(sym: ClassSymbol): api.ClassLikeDef = {
+    import xsbti.api.{DefinitionType => dt}
+    val defType =
+      if (sym.is(Trait)) dt.Trait
+      else if (sym.is(ModuleClass)) {
+        if (sym.is(PackageClass)) dt.PackageModule
+        else dt.Module
+      } else dt.ClassDef
+
+    val selfType = apiType(sym.givenSelfType)
+
+    val name = sym.fullName.stripModuleClassSuffix.toString
+      // We strip module class suffix. Zinc relies on a class and its companion having the same name
+
+    val tparams = sym.typeParams.map(apiTypeParameter).toArray
+
+    val structure = apiClassStructure(sym)
+    val acc = apiAccess(sym)
+    val modifiers = apiModifiers(sym)
+    val anns = apiAnnotations(sym, inlineOrigin = NoSymbol).toArray
+    val topLevel = sym.isTopLevelClass
+    val childrenOfSealedClass = sym.sealedDescendants.sorted(classFirstSort).map(c =>
+      if (c.isClass)
+        apiType(c.typeRef)
+      else
+        apiType(c.termRef)
+    ).toArray
+
+    val cl = api.ClassLike.of(
+      name, acc, modifiers, anns, defType, api.SafeLazy.strict(selfType), api.SafeLazy.strict(structure), Constants.emptyStringArray,
+      childrenOfSealedClass, topLevel, tparams)
+
+    allNonLocalClassesInSrc += cl
+
+    if (sym.isStatic && !sym.is(Trait) && ctx.platform.hasMainMethod(sym)) {
+       // If sym is an object, all main methods count, otherwise only @static ones count.
+      _mainClasses += name
+    }
+
+    api.ClassLikeDef.of(name, acc, modifiers, anns, tparams, defType)
+  }
+
+  def apiClassStructure(csym: ClassSymbol): api.Structure = {
+    val cinfo = csym.classInfo
+
+    val bases = {
+      val ancestorTypes0 =
+        try linearizedAncestorTypes(cinfo)
+        catch {
+          case ex: TypeError =>
+            // See neg/i1750a for an example where a cyclic error can arise.
+            // The root cause in this example is an illegal "override" of an inner trait
+            report.error(ex, csym.sourcePos)
+            defn.ObjectType :: Nil
+        }
+      if (ValueClasses.isDerivedValueClass(csym)) {
+        val underlying = ValueClasses.valueClassUnbox(csym).info.finalResultType
+        // The underlying type of a value class should be part of the name hash
+        // of the value class (see the test `value-class-underlying`), this is accomplished
+        // by adding the underlying type to the list of parent types.
+        underlying :: ancestorTypes0
+      } else
+        ancestorTypes0
+    }
+
+    val apiBases = bases.map(apiType)
+
+    // Synthetic methods that are always present do not affect the API
+    // and can therefore be ignored.
+    def alwaysPresent(s: Symbol) = csym.is(ModuleClass) && s.isConstructor
+    val decls = cinfo.decls.filter(!alwaysPresent(_))
+    val apiDecls = apiDefinitions(decls)
+
+    val declSet = decls.toSet
+    // TODO: We shouldn't have to compute inherited members. Instead, `Structure`
+    // should have a lazy `parentStructures` field.
+    val inherited = cinfo.baseClasses
+      .filter(bc => !bc.is(Scala2x))
+      .flatMap(_.classInfo.decls.filter(s => !(s.is(Private) || declSet.contains(s))))
+    // Inherited members need to be computed lazily because a class might contain
+    // itself as an inherited member, like in `class A { class B extends A }`,
+    // this works because of `classLikeCache`
+    val apiInherited = lzy(apiDefinitions(inherited).toArray)
+
+    api.Structure.of(api.SafeLazy.strict(apiBases.toArray), api.SafeLazy.strict(apiDecls.toArray), apiInherited)
+  }
+
+  def linearizedAncestorTypes(info: ClassInfo): List[Type] = {
+    val ref = info.appliedRef
+    // Note that the ordering of classes in `baseClasses` is important.
+    info.baseClasses.tail.map(ref.baseType)
+  }
+
+  // The hash generated by sbt for definitions is supposed to be symmetric so
+  // we shouldn't have to sort them, but it actually isn't symmetric for
+  // definitions which are classes, therefore we need to sort classes to
+  // ensure a stable hash.
+  // Modules and classes come first and are sorted by name, all other
+  // definitions come later and are not sorted.
+  private object classFirstSort extends Ordering[Symbol] {
+    override def compare(a: Symbol, b: Symbol) = {
+      val aIsClass = a.isClass
+      val bIsClass = b.isClass
+      if (aIsClass == bIsClass) {
+        if (aIsClass) {
+          if (a.is(Module) == b.is(Module))
+            a.fullName.toString.compareTo(b.fullName.toString)
+          else if (a.is(Module))
+            -1
+          else
+            1
+        } else
+          0
+      } else if (aIsClass)
+      -1
+    else
+      1
+    }
+  }
+
+  def apiDefinitions(defs: List[Symbol]): List[api.ClassDefinition] =
+    defs.sorted(classFirstSort).map(apiDefinition(_, inlineOrigin = NoSymbol))
+
+  /** `inlineOrigin` denotes an optional inline method that we are
+   *  currently hashing the body of. If it exists, include extra information
+   *  that is missing after erasure
+   */
+  def apiDefinition(sym: Symbol, inlineOrigin: Symbol): api.ClassDefinition = {
+    if (sym.isClass) {
+      apiClass(sym.asClass)
+    } else if (sym.isType) {
+      apiTypeMember(sym.asType)
+    } else if (sym.is(Mutable, butNot = Accessor)) {
+      api.Var.of(sym.name.toString, apiAccess(sym), apiModifiers(sym),
+        apiAnnotations(sym, inlineOrigin).toArray, apiType(sym.info))
+    } else if (sym.isStableMember && !sym.isRealMethod) {
+      api.Val.of(sym.name.toString, apiAccess(sym), apiModifiers(sym),
+        apiAnnotations(sym, inlineOrigin).toArray, apiType(sym.info))
+    } else {
+      apiDef(sym.asTerm, inlineOrigin)
+    }
+  }
+
+  /** `inlineOrigin` denotes an optional inline method that we are
+   *  currently hashing the body of. If it exists, include extra information
+   *  that is missing after erasure
+   */
+  def apiDef(sym: TermSymbol, inlineOrigin: Symbol): api.Def = {
+
+    var seenInlineExtras = false
+    var inlineExtras = 41
+
+    def mixInlineParam(p: Symbol): Unit =
+      if inlineOrigin.exists && p.is(Inline) then
+        seenInlineExtras = true
+        inlineExtras = hashInlineParam(p, inlineExtras)
+
+    def inlineExtrasAnnot: Option[api.Annotation] =
+      val h = inlineExtras
+      Option.when(seenInlineExtras) {
+        marker(s"${MurmurHash3.finalizeHash(h, "inlineExtras".hashCode)}")
+      }
+
+    def tparamList(pt: TypeLambda): List[api.TypeParameter] =
+      pt.paramNames.lazyZip(pt.paramInfos).map((pname, pbounds) =>
+        apiTypeParameter(pname.toString, 0, pbounds.lo, pbounds.hi)
+      )
+
+    def paramList(mt: MethodType, params: List[Symbol]): api.ParameterList =
+      val apiParams = params.lazyZip(mt.paramInfos).map((param, ptype) =>
+        mixInlineParam(param)
+        api.MethodParameter.of(
+          param.name.toString, apiType(ptype), param.is(HasDefault), api.ParameterModifier.Plain))
+      api.ParameterList.of(apiParams.toArray, mt.isImplicitMethod)
+
+    def paramLists(t: Type, paramss: List[List[Symbol]]): List[api.ParameterList] = t match {
+      case pt: TypeLambda =>
+        paramLists(pt.resultType, paramss.drop(1))
+      case mt @ MethodTpe(pnames, ptypes, restpe) =>
+        assert(paramss.nonEmpty && paramss.head.hasSameLengthAs(pnames),
+          i"mismatch for $sym, ${sym.info}, ${sym.paramSymss}")
+        paramList(mt, paramss.head) :: paramLists(restpe, paramss.tail)
+      case _ =>
+        Nil
+    }
+
+    /** returns list of pairs of 1: the position in all parameter lists, and 2: a type parameter list */
+    def tparamLists(t: Type, index: Int): List[(Int, List[api.TypeParameter])] = t match
+      case pt: TypeLambda =>
+        (index, tparamList(pt)) :: tparamLists(pt.resultType, index + 1)
+      case mt: MethodType =>
+        tparamLists(mt.resultType, index + 1)
+      case _ =>
+        Nil
+
+    val (tparams, tparamsExtras) = sym.info match
+      case pt: TypeLambda =>
+        (tparamList(pt), tparamLists(pt.resultType, index = 1))
+      case mt: MethodType =>
+        (Nil, tparamLists(mt.resultType, index = 1))
+      case _ =>
+        (Nil, Nil)
+
+    val vparamss = paramLists(sym.info, sym.paramSymss)
+    val retTp = sym.info.finalResultType.widenExpr
+
+    val tparamsExtraAnnot = Option.when(tparamsExtras.nonEmpty) {
+      marker(s"${hashTparamsExtras(tparamsExtras)("tparamsExtra".hashCode)}")
+    }
+
+    val annotations = inlineExtrasAnnot ++: tparamsExtraAnnot ++: apiAnnotations(sym, inlineOrigin)
+
+    api.Def.of(sym.zincMangledName.toString, apiAccess(sym), apiModifiers(sym),
+      annotations.toArray, tparams.toArray, vparamss.toArray, apiType(retTp))
+  }
+
+  def apiTypeMember(sym: TypeSymbol): api.TypeMember = {
+    val typeParams = Array[api.TypeParameter]()
+    val name = sym.name.toString
+    val access = apiAccess(sym)
+    val modifiers = apiModifiers(sym)
+    val as = apiAnnotations(sym, inlineOrigin = NoSymbol)
+    val tpe = sym.info
+
+    if (sym.isAliasType)
+      api.TypeAlias.of(name, access, modifiers, as.toArray, typeParams, apiType(tpe.bounds.hi))
+    else {
+      assert(sym.isAbstractType)
+      api.TypeDeclaration.of(name, access, modifiers, as.toArray, typeParams, apiType(tpe.bounds.lo), apiType(tpe.bounds.hi))
+    }
+  }
+
+  // Hack to represent dotty types which don't have an equivalent in xsbti
+  def combineApiTypes(apiTps: api.Type*): api.Type = {
+    api.Structure.of(api.SafeLazy.strict(apiTps.toArray),
+      api.SafeLazy.strict(Array()), api.SafeLazy.strict(Array()))
+  }
+
+  def apiType(tp: Type): api.Type = {
+    typeCache.getOrElseUpdate(tp, computeType(tp))
+  }
+
+  private def computeType(tp: Type): api.Type = {
+    // TODO: Never dealias. We currently have to dealias because
+    // sbt main class discovery relies on the signature of the main
+    // method being fully dealiased. See https://github.com/sbt/zinc/issues/102
+    val tp2 = if (!tp.isLambdaSub) tp.dealiasKeepAnnots else tp
+    tp2 match {
+      case NoPrefix | NoType =>
+        Constants.emptyType
+      case tp: NamedType =>
+        val sym = tp.symbol
+        // A type can sometimes be represented by multiple different NamedTypes
+        // (they will be `=:=` to each other, but not `==`), and the compiler
+        // may choose to use any of these representation, there is no stability
+        // guarantee. We avoid this instability by always normalizing the
+        // prefix: if it's a package, if we didn't do this sbt might conclude
+        // that some API changed when it didn't, leading to overcompilation
+        // (recompiling more things than what is needed for incremental
+        // compilation to be correct).
+        val prefix = if (sym.maybeOwner.is(Package)) // { type T } here T does not have an owner
+          sym.owner.thisType
+        else
+          tp.prefix
+        api.Projection.of(apiType(prefix), sym.name.toString)
+      case AppliedType(tycon, args) =>
+        def processArg(arg: Type): api.Type = arg match {
+          case arg @ TypeBounds(lo, hi) => // Handle wildcard parameters
+            if (lo.isDirectRef(defn.NothingClass) && hi.isDirectRef(defn.AnyClass))
+              Constants.emptyType
+            else {
+              val name = "_"
+              val ref = api.ParameterRef.of(name)
+              api.Existential.of(ref,
+                Array(apiTypeParameter(name, 0, lo, hi)))
+            }
+          case _ =>
+            apiType(arg)
+        }
+
+        val apiTycon = apiType(tycon)
+        val apiArgs = args.map(processArg)
+        api.Parameterized.of(apiTycon, apiArgs.toArray)
+      case tl: TypeLambda =>
+        val apiTparams = tl.typeParams.map(apiTypeParameter)
+        val apiRes = apiType(tl.resType)
+        api.Polymorphic.of(apiRes, apiTparams.toArray)
+      case rt: RefinedType =>
+        val name = rt.refinedName.toString
+        val parent = apiType(rt.parent)
+
+        def typeRefinement(name: String, tp: TypeBounds): api.TypeMember = tp match {
+          case TypeAlias(alias) =>
+            api.TypeAlias.of(name,
+              Constants.public, Constants.emptyModifiers, Array(), Array(), apiType(alias))
+          case TypeBounds(lo, hi) =>
+            api.TypeDeclaration.of(name,
+              Constants.public, Constants.emptyModifiers, Array(), Array(), apiType(lo), apiType(hi))
+        }
+        val decl = rt.refinedInfo match {
+          case rinfo: TypeBounds =>
+            typeRefinement(name, rinfo)
+          case _ =>
+            report.debuglog(i"sbt-api: skipped structural refinement in $rt")
+            null
+        }
+
+        // Aggressive caching for RefinedTypes: `typeCache` is enough as long as two
+        // RefinedType are `==`, but this is only the case when their `refinedInfo`
+        // are `==` and this is not always the case, consider:
+        //
+        //     val foo: { type Bla = a.b.T }
+        //     val bar: { type Bla = a.b.T }
+        //
+        // The sbt API representations of `foo` and `bar` (let's call them `apiFoo`
+        // and `apiBar`) will both be instances of `Structure`. If `typeCache` was
+        // the only cache, then in some cases we would have `apiFoo eq apiBar` and
+        // in other cases we would just have `apiFoo == apiBar` (this happens
+        // because the dotty representation of `a.b.T` is unstable, see the comment
+        // in the `NamedType` case above).
+        //
+        // The fact that we may or may not have `apiFoo eq apiBar` is more than
+        // an optimisation issue: it will determine whether the sbt name hash for
+        // `Bla` contains one or two entries (because sbt `NameHashing` will not
+        // traverse both `apiFoo` and `apiBar` if they are `eq`), therefore the
+        // name hash of `Bla` will be unstable, unless we make sure that
+        // `apiFoo == apiBar` always imply `apiFoo eq apiBar`. This is what
+        // `refinedTypeCache` is for.
+        refinedTypeCache.getOrElseUpdate((parent, decl), {
+          val adecl: Array[api.ClassDefinition] = if (decl == null) Array() else Array(decl)
+          api.Structure.of(api.SafeLazy.strict(Array(parent)), api.SafeLazy.strict(adecl), api.SafeLazy.strict(Array()))
+        })
+      case tp: RecType =>
+        apiType(tp.parent)
+      case RecThis(recType) =>
+        // `tp` must be present inside `recType`, so calling `apiType` on
+        // `recType` would lead to an infinite recursion, we avoid this by
+        //  computing the representation of `recType` lazily.
+        apiLazy(recType)
+      case tp: AndType =>
+        combineApiTypes(apiType(tp.tp1), apiType(tp.tp2))
+      case tp: OrType =>
+        val s = combineApiTypes(apiType(tp.tp1), apiType(tp.tp2))
+        withMarker(s, orMarker)
+      case ExprType(resultType) =>
+        withMarker(apiType(resultType), byNameMarker)
+      case MatchType(bound, scrut, cases) =>
+        val s = combineApiTypes(apiType(bound) :: apiType(scrut) :: cases.map(apiType): _*)
+        withMarker(s, matchMarker)
+      case ConstantType(constant) =>
+        api.Constant.of(apiType(constant.tpe), constant.stringValue)
+      case AnnotatedType(tpe, annot) =>
+        api.Annotated.of(apiType(tpe), Array(apiAnnotation(annot)))
+      case tp: ThisType =>
+        apiThis(tp.cls)
+      case tp: ParamRef =>
+        // TODO: Distinguishing parameters based on their names alone is not enough,
+        // the binder is also needed (at least for type lambdas).
+        api.ParameterRef.of(tp.paramName.toString)
+      case tp: LazyRef =>
+        apiType(tp.ref)
+      case tp: TypeVar =>
+        apiType(tp.underlying)
+      case SuperType(thistpe, supertpe) =>
+        val s = combineApiTypes(apiType(thistpe), apiType(supertpe))
+        withMarker(s, superMarker)
+      case _ => {
+        internalError(i"Unhandled type $tp of class ${tp.getClass}")
+        Constants.emptyType
+      }
+    }
+  }
+
+  def apiLazy(tp: -> Type): api.Type = {
+    // TODO: The sbt api needs a convenient way to make a lazy type.
+    // For now, we repurpose Structure for this.
+    val apiTp = lzy(Array(apiType(tp)))
+    api.Structure.of(apiTp, api.SafeLazy.strict(Array()), api.SafeLazy.strict(Array()))
+  }
+
+  def apiThis(sym: Symbol): api.Singleton = {
+    val pathComponents = sym.ownersIterator.takeWhile(!_.isEffectiveRoot)
+      .map(s => api.Id.of(s.name.toString))
+    api.Singleton.of(api.Path.of(pathComponents.toArray.reverse ++ Array(Constants.thisPath)))
+  }
+
+  def apiTypeParameter(tparam: ParamInfo): api.TypeParameter =
+    apiTypeParameter(tparam.paramName.toString, tparam.paramVarianceSign,
+      tparam.paramInfo.bounds.lo, tparam.paramInfo.bounds.hi)
+
+  def apiTypeParameter(name: String, variance: Int, lo: Type, hi: Type): api.TypeParameter =
+    api.TypeParameter.of(name, Array(), Array(), apiVariance(variance),
+      apiType(lo), apiType(hi))
+
+  def apiVariance(v: Int): api.Variance = {
+    import api.Variance._
+    if (v < 0) Contravariant
+    else if (v > 0) Covariant
+    else Invariant
+  }
+
+  def apiAccess(sym: Symbol): api.Access = {
+    // Symbols which are private[foo] do not have the flag Private set,
+    // but their `privateWithin` exists, see `Parsers#ParserCommon#normalize`.
+    if (!sym.isOneOf(Protected | Private) && !sym.privateWithin.exists)
+      Constants.public
+    else if (sym.isAllOf(PrivateLocal))
+      Constants.privateLocal
+    else if (sym.isAllOf(ProtectedLocal))
+      Constants.protectedLocal
+    else {
+      val qualifier =
+        if (sym.privateWithin eq NoSymbol)
+          Constants.unqualified
+        else
+          api.IdQualifier.of(sym.privateWithin.fullName.toString)
+      if (sym.is(Protected))
+        api.Protected.of(qualifier)
+      else
+        api.Private.of(qualifier)
+    }
+  }
+
+  def apiModifiers(sym: Symbol): api.Modifiers = {
+    val absOver = sym.is(AbsOverride)
+    val abs = absOver || sym.isOneOf(Trait | Abstract | Deferred)
+    val over = absOver || sym.is(Override)
+    new api.Modifiers(abs, over, sym.is(Final), sym.is(Sealed),
+      sym.isOneOf(GivenOrImplicit), sym.is(Lazy), sym.is(Macro), sym.isSuperAccessor)
+  }
+
+  /** `inlineOrigin` denotes an optional inline method that we are
+   *  currently hashing the body of.
+   */
+  def apiAnnotations(s: Symbol, inlineOrigin: Symbol): List[api.Annotation] = {
+    val annots = new mutable.ListBuffer[api.Annotation]
+    val inlineBody = Inlines.bodyToInline(s)
+    if !inlineBody.isEmpty then
+      // If the body of an inline def changes, all the reverse dependencies of
+      // this method need to be recompiled. sbt has no way of tracking method
+      // bodies, so we include the hash of the body of the method as part of the
+      // signature we send to sbt.
+
+      def hash[U](inlineOrigin: Symbol): Int =
+        assert(seenInlineCache.add(s)) // will fail if already seen, guarded by treeHash
+        treeHash(inlineBody, inlineOrigin)
+
+      val inlineHash =
+        if inlineOrigin.exists then hash(inlineOrigin)
+        else inlineBodyCache.getOrElseUpdate(s, hash(inlineOrigin = s).tap(_ => seenInlineCache.clear()))
+
+      annots += marker(inlineHash.toString)
+
+    end if
+
+    // In the Scala2 ExtractAPI phase we only extract annotations that extend
+    // StaticAnnotation, but in Dotty we currently pickle all annotations so we
+    // extract everything (except annotations missing from the classpath which
+    // we simply skip over, and inline body annotations which are handled above).
+    s.annotations.foreach { annot =>
+      val sym = annot.symbol
+      if sym.exists && sym != defn.BodyAnnot then
+        annots += apiAnnotation(annot)
+    }
+
+    annots.toList
+  }
+
+  /** Produce a hash for a tree that is as stable as possible:
+   *  it should stay the same across compiler runs, compiler instances,
+   *  JVMs, etc.
+   *
+   * `inlineOrigin` denotes an optional inline method that we are hashing the body of, where `tree` could be
+   * its body, or the body of another method referenced in a call chain leading to `inlineOrigin`.
+   *
+   * If `inlineOrigin` is NoSymbol, then tree is the tree of an annotation.
+   */
+  def treeHash(tree: Tree, inlineOrigin: Symbol): Int =
+    import core.Constants.*
+
+    def nameHash(n: Name, initHash: Int): Int =
+      val h =
+        if n.isTermName then
+          MurmurHash3.mix(initHash, TermNameHash)
+        else
+          MurmurHash3.mix(initHash, TypeNameHash)
+
+      // The hashCode of the name itself is not stable across compiler instances
+      MurmurHash3.mix(h, n.toString.hashCode)
+    end nameHash
+
+    def constantHash(c: Constant, initHash: Int): Int =
+      var h = MurmurHash3.mix(initHash, c.tag)
+      c.tag match
+        case NullTag =>
+          // No value to hash, the tag is enough.
+        case ClazzTag =>
+          // Go through `apiType` to get a value with a stable hash, it'd
+          // be better to use Murmur here too instead of relying on
+          // `hashCode`, but that would essentially mean duplicating
+          // https://github.com/sbt/zinc/blob/develop/internal/zinc-apiinfo/src/main/scala/xsbt/api/HashAPI.scala
+          // and at that point we might as well do type hashing on our own
+          // representation.
+          h = MurmurHash3.mix(h, apiType(c.typeValue).hashCode)
+        case _ =>
+          h = MurmurHash3.mix(h, c.value.hashCode)
+      h
+    end constantHash
+
+    def cannotHash(what: String, elem: Any, pos: Positioned): Unit =
+      internalError(i"Don't know how to produce a stable hash for $what", pos.sourcePos)
+
+    def positionedHash(p: ast.Positioned, initHash: Int): Int =
+      var h = initHash
+
+      p match
+        case p: WithLazyField[?] =>
+          p.forceIfLazy
+        case _ =>
+
+      if inlineOrigin.exists then
+        p match
+          case ref: RefTree @unchecked =>
+            val sym = ref.symbol
+            if sym.is(Inline, butNot = Param) && !seenInlineCache.contains(sym) then
+              // An inline method that calls another inline method will eventually inline the call
+              // at a non-inline callsite, in this case if the implementation of the nested call
+              // changes, then the callsite will have a different API, we should hash the definition
+              h = MurmurHash3.mix(h, apiDefinition(sym, inlineOrigin).hashCode)
+          case _ =>
+
+      // FIXME: If `p` is a tree we should probably take its type into account
+      // when hashing it, but producing a stable hash for a type is not trivial
+      // since the same type might have multiple representations, for method
+      // signatures this is already handled by `computeType` and the machinery
+      // in Zinc that generates hashes from that, if we can reliably produce
+      // stable hashes for types ourselves then we could bypass all that and
+      // send Zinc hashes directly.
+      h = MurmurHash3.mix(h, p.productPrefix.hashCode)
+      iteratorHash(p.productIterator, h)
+    end positionedHash
+
+    def iteratorHash(it: Iterator[Any], initHash: Int): Int =
+      var h = initHash
+      while it.hasNext do
+        it.next() match
+          case p: Positioned =>
+            h = positionedHash(p, h)
+          case xs: List[?] =>
+            h = iteratorHash(xs.iterator, h)
+          case c: Constant =>
+            h = constantHash(c, h)
+          case n: Name =>
+            h = nameHash(n, h)
+          case elem =>
+            cannotHash(what = i"`${elem.tryToShow}` of unknown class ${elem.getClass}", elem, tree)
+      h
+    end iteratorHash
+
+    val seed = 4 // https://xkcd.com/221
+    val h = positionedHash(tree, seed)
+    MurmurHash3.finalizeHash(h, 0)
+  end treeHash
+
+  /** Hash secondary type parameters in separate marker annotation.
+   *  We hash them separately because the position of type parameters is important.
+   */
+  private def hashTparamsExtras(tparamsExtras: List[(Int, List[api.TypeParameter])])(initHash: Int): Int =
+
+    def mixTparams(tparams: List[api.TypeParameter])(initHash: Int) =
+      var h = initHash
+      var elems = tparams
+      while elems.nonEmpty do
+        h = MurmurHash3.mix(h, elems.head.hashCode)
+        elems = elems.tail
+      h
+
+    def mixIndexAndTparams(index: Int, tparams: List[api.TypeParameter])(initHash: Int) =
+      mixTparams(tparams)(MurmurHash3.mix(initHash, index))
+
+    var h = initHash
+    var extras = tparamsExtras
+    var len = 0
+    while extras.nonEmpty do
+      h = mixIndexAndTparams(index = extras.head(0), tparams = extras.head(1))(h)
+      extras = extras.tail
+      len += 1
+    MurmurHash3.finalizeHash(h, len)
+  end hashTparamsExtras
+
+  /** Mix in the name hash also because otherwise switching which
+   *  parameter is inline will not affect the hash.
+   */
+  private def hashInlineParam(p: Symbol, h: Int) =
+    MurmurHash3.mix(p.name.toString.hashCode, MurmurHash3.mix(h, InlineParamHash))
+
+  def apiAnnotation(annot: Annotation): api.Annotation = {
+    // Like with inline defs, the whole body of the annotation and not just its
+    // type is part of its API so we need to store its hash, but Zinc wants us
+    // to extract the annotation type and its arguments, so we use a dummy
+    // annotation argument to store the hash of the tree. We still need to
+    // extract the annotation type in the way Zinc expects because sbt uses this
+    // information to find tests to run (for example junit tests are
+    // annotated @org.junit.Test).
+    api.Annotation.of(
+      apiType(annot.tree.tpe), // Used by sbt to find tests to run
+      Array(api.AnnotationArgument.of("TREE_HASH", treeHash(annot.tree, inlineOrigin = NoSymbol).toString)))
+  }
+}
diff --git a/tests/pos-with-compiler-cc/dotc/sbt/ExtractDependencies.scala b/tests/pos-with-compiler-cc/dotc/sbt/ExtractDependencies.scala
new file mode 100644
index 000000000000..a554c8e5066f
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/sbt/ExtractDependencies.scala
@@ -0,0 +1,504 @@
+package dotty.tools.dotc
+package sbt
+
+import scala.language.unsafeNulls
+
+import java.io.File
+import java.util.{Arrays, EnumSet}
+
+import dotty.tools.dotc.ast.tpd
+import dotty.tools.dotc.core.Contexts._
+import dotty.tools.dotc.core.Decorators._
+import dotty.tools.dotc.core.Flags._
+import dotty.tools.dotc.core.NameOps._
+import dotty.tools.dotc.core.Names._
+import dotty.tools.dotc.core.Phases._
+import dotty.tools.dotc.core.Symbols._
+import dotty.tools.dotc.core.Denotations.StaleSymbol
+import dotty.tools.dotc.core.Types._
+import dotty.tools.dotc.transform.SymUtils._
+import dotty.tools.dotc.util.{SrcPos, NoSourcePosition}
+import dotty.tools.io
+import dotty.tools.io.{AbstractFile, PlainFile, ZipArchive}
+import xsbti.UseScope
+import xsbti.api.DependencyContext
+import xsbti.api.DependencyContext._
+
+import scala.collection.{Set, mutable}
+import language.experimental.pureFunctions
+
+/** This phase sends information on classes' dependencies to sbt via callbacks.
+ *
+ *  This is used by sbt for incremental recompilation. Briefly, when a file
+ *  changes sbt will recompile it, if its API has changed (determined by what
+ *  `ExtractAPI` sent) then sbt will determine which reverse-dependencies
+ *  (determined by what `ExtractDependencies` sent) of the API have to be
+ *  recompiled depending on what changed.
+ *
+ *  See the documentation of `ExtractDependenciesCollector`, `ExtractAPI`,
+ *  `ExtractAPICollector` and
+ *  http://www.scala-sbt.org/0.13/docs/Understanding-Recompilation.html for more
+ *  information on how sbt incremental compilation works.
+ *
+ *  The following flags affect this phase:
+ *   -Yforce-sbt-phases
+ *   -Ydump-sbt-inc
+ *
+ *  @see ExtractAPI
+ */
+class ExtractDependencies extends Phase {
+  import ExtractDependencies._
+
+  override def phaseName: String = ExtractDependencies.name
+
+  override def description: String = ExtractDependencies.description
+
+  override def isRunnable(using Context): Boolean = {
+    def forceRun = ctx.settings.YdumpSbtInc.value || ctx.settings.YforceSbtPhases.value
+    super.isRunnable && (ctx.sbtCallback != null || forceRun)
+  }
+
+  // Check no needed. Does not transform trees
+  override def isCheckable: Boolean = false
+
+  // This phase should be run directly after `Frontend`, if it is run after
+  // `PostTyper`, some dependencies will be lost because trees get simplified.
+  // See the scripted test `constants` for an example where this matters.
+  // TODO: Add a `Phase#runsBefore` method ?
+
+  override def run(using Context): Unit = {
+    val unit = ctx.compilationUnit
+    val collector = new ExtractDependenciesCollector
+    collector.traverse(unit.tpdTree)
+
+    if (ctx.settings.YdumpSbtInc.value) {
+      val deps = collector.dependencies.map(_.toString).toArray[Object]
+      val names = collector.usedNames.map { case (clazz, names) => s"$clazz: $names" }.toArray[Object]
+      Arrays.sort(deps)
+      Arrays.sort(names)
+
+      val pw = io.File(unit.source.file.jpath).changeExtension("inc").toFile.printWriter()
+      // val pw = Console.out
+      try {
+        pw.println("Used Names:")
+        pw.println("===========")
+        names.foreach(pw.println)
+        pw.println()
+        pw.println("Dependencies:")
+        pw.println("=============")
+        deps.foreach(pw.println)
+      } finally pw.close()
+    }
+
+    if (ctx.sbtCallback != null) {
+      collector.usedNames.foreach {
+        case (clazz, usedNames) =>
+          val className = classNameAsString(clazz)
+          usedNames.names.foreach {
+            case (usedName, scopes) =>
+              ctx.sbtCallback.usedName(className, usedName.toString, scopes)
+          }
+      }
+
+      collector.dependencies.foreach(recordDependency)
+    }
+  }
+
+  /*
+   * Handles dependency on given symbol by trying to figure out if represents a term
+   * that is coming from either source code (not necessarily compiled in this compilation
+   * run) or from class file and calls respective callback method.
+   */
+  def recordDependency(dep: ClassDependency)(using Context): Unit = {
+    val fromClassName = classNameAsString(dep.from)
+    val sourceFile = ctx.compilationUnit.source.file.file
+
+    def binaryDependency(file: File, binaryClassName: String) =
+      ctx.sbtCallback.binaryDependency(file, binaryClassName, fromClassName, sourceFile, dep.context)
+
+    def processExternalDependency(depFile: AbstractFile, binaryClassName: String) = {
+      depFile match {
+        case ze: ZipArchive#Entry => // The dependency comes from a JAR
+          ze.underlyingSource match
+            case Some(zip) if zip.file != null =>
+              binaryDependency(zip.file, binaryClassName)
+            case _ =>
+        case pf: PlainFile => // The dependency comes from a class file
+          // FIXME: pf.file is null for classfiles coming from the modulepath
+          // (handled by JrtClassPath) because they cannot be represented as
+          // java.io.File, since the `binaryDependency` callback must take a
+          // java.io.File, this means that we cannot record dependencies coming
+          // from the modulepath. For now this isn't a big deal since we only
+          // support having the standard Java library on the modulepath.
+          if pf.file != null then
+            binaryDependency(pf.file, binaryClassName)
+        case _ =>
+          internalError(s"Ignoring dependency $depFile of unknown class ${depFile.getClass}}", dep.from.srcPos)
+      }
+    }
+
+    val depFile = dep.to.associatedFile
+    if (depFile != null) {
+      // Cannot ignore inheritance relationship coming from the same source (see sbt/zinc#417)
+      def allowLocal = dep.context == DependencyByInheritance || dep.context == LocalDependencyByInheritance
+      if (depFile.extension == "class") {
+        // Dependency is external -- source is undefined
+
+        // The fully qualified name on the JVM of the class corresponding to `dep.to`
+        val binaryClassName = {
+          val builder = new StringBuilder
+          val pkg = dep.to.enclosingPackageClass
+          if (!pkg.isEffectiveRoot) {
+            builder.append(pkg.fullName.mangledString)
+            builder.append(".")
+          }
+          val flatName = dep.to.flatName
+          // Some companion objects are fake (that is, they're a compiler fiction
+          // that doesn't correspond to a class that exists at runtime), this
+          // can happen in two cases:
+          // - If a Java class has static members.
+          // - If we create constructor proxies for a class (see NamerOps#addConstructorProxies).
+          //
+          // In both cases it's vital that we don't send the object name to
+          // zinc: when sbt is restarted, zinc will inspect the binary
+          // dependencies to see if they're still on the classpath, if it
+          // doesn't find them it will invalidate whatever referenced them, so
+          // any reference to a fake companion will lead to extra recompilations.
+          // Instead, use the class name since it's guaranteed to exist at runtime.
+          val clsFlatName = if (dep.to.isOneOf(JavaDefined | ConstructorProxy)) flatName.stripModuleClassSuffix else flatName
+          builder.append(clsFlatName.mangledString)
+          builder.toString
+        }
+
+        processExternalDependency(depFile, binaryClassName)
+      } else if (allowLocal || depFile.file != sourceFile) {
+        // We cannot ignore dependencies coming from the same source file because
+        // the dependency info needs to propagate. See source-dependencies/trait-trait-211.
+        val toClassName = classNameAsString(dep.to)
+        ctx.sbtCallback.classDependency(toClassName, fromClassName, dep.context)
+      }
+    }
+  }
+}
+
+object ExtractDependencies {
+  val name: String = "sbt-deps"
+  val description: String = "sends information on classes' dependencies to sbt"
+
+  def classNameAsString(sym: Symbol)(using Context): String =
+    sym.fullName.stripModuleClassSuffix.toString
+
+  /** Report an internal error in incremental compilation. */
+  def internalError(msg: -> String, pos: SrcPos = NoSourcePosition)(using Context): Unit =
+    report.error(s"Internal error in the incremental compiler while compiling ${ctx.compilationUnit.source}: $msg", pos)
+}
+
+private case class ClassDependency(from: Symbol, to: Symbol, context: DependencyContext)
+
+/** An object that maintain the set of used names from within a class */
+private final class UsedNamesInClass {
+  private val _names = new mutable.HashMap[Name, EnumSet[UseScope]]
+  def names: collection.Map[Name, EnumSet[UseScope]] = _names
+
+  def update(name: Name, scope: UseScope): Unit = {
+    val scopes = _names.getOrElseUpdate(name, EnumSet.noneOf(classOf[UseScope]))
+    scopes.add(scope)
+  }
+
+  override def toString(): String = {
+    val builder = new StringBuilder
+    names.foreach { case (name, scopes) =>
+      builder.append(name.mangledString)
+      builder.append(" in [")
+      scopes.forEach(scope => builder.append(scope.toString))
+      builder.append("]")
+      builder.append(", ")
+    }
+    builder.toString()
+  }
+}
+
+/** Extract the dependency information of a compilation unit.
+ *
+ *  To understand why we track the used names see the section "Name hashing
+ *  algorithm" in http://www.scala-sbt.org/0.13/docs/Understanding-Recompilation.html
+ *  To understand why we need to track dependencies introduced by inheritance
+ *  specially, see the subsection "Dependencies introduced by member reference and
+ *  inheritance" in the "Name hashing algorithm" section.
+ */
+private class ExtractDependenciesCollector extends tpd.TreeTraverser { thisTreeTraverser =>
+  import tpd._
+
+  private val _usedNames = new mutable.HashMap[Symbol, UsedNamesInClass]
+  private val _dependencies = new mutable.HashSet[ClassDependency]
+
+  /** The names used in this class, this does not include names which are only
+   *  defined and not referenced.
+   */
+  def usedNames: collection.Map[Symbol, UsedNamesInClass] = _usedNames
+
+  /** The set of class dependencies from this compilation unit.
+   */
+  def dependencies: Set[ClassDependency] = _dependencies
+
+  /** Top level import dependencies are registered as coming from a first top level
+   *  class/trait/object declared in the compilation unit. If none exists, issue warning.
+   */
+  private var _responsibleForImports: Symbol = _
+  private def responsibleForImports(using Context) = {
+    def firstClassOrModule(tree: Tree) = {
+      val acc = new TreeAccumulator[Symbol] {
+        def apply(x: Symbol, t: Tree)(using Context) =
+          t match {
+            case typeDef: TypeDef =>
+              typeDef.symbol
+            case other =>
+              foldOver(x, other)
+          }
+      }
+      acc(NoSymbol, tree)
+    }
+
+    if (_responsibleForImports == null) {
+      val tree = ctx.compilationUnit.tpdTree
+      _responsibleForImports = firstClassOrModule(tree)
+      if (!_responsibleForImports.exists)
+          report.warning("""|No class, trait or object is defined in the compilation unit.
+                         |The incremental compiler cannot record the dependency information in such case.
+                         |Some errors like unused import referring to a non-existent class might not be reported.
+                         |""".stripMargin, tree.sourcePos)
+    }
+    _responsibleForImports
+  }
+
+  private var lastOwner: Symbol = _
+  private var lastDepSource: Symbol = _
+
+  /**
+   * Resolves dependency source (that is, the closest non-local enclosing
+   * class from a given `ctx.owner`
+   */
+  private def resolveDependencySource(using Context): Symbol = {
+    def nonLocalEnclosingClass = {
+      var clazz = ctx.owner.enclosingClass
+      var owner = clazz
+
+      while (!owner.is(PackageClass)) {
+        if (owner.isTerm) {
+          clazz = owner.enclosingClass
+          owner = clazz
+        } else {
+          owner = owner.owner
+        }
+      }
+      clazz
+    }
+
+    if (lastOwner != ctx.owner) {
+      lastOwner = ctx.owner
+      val source = nonLocalEnclosingClass
+      lastDepSource = if (source.is(PackageClass)) responsibleForImports else source
+    }
+
+    lastDepSource
+  }
+
+  private def addUsedName(fromClass: Symbol, name: Name, scope: UseScope): Unit = {
+    val usedName = _usedNames.getOrElseUpdate(fromClass, new UsedNamesInClass)
+    usedName.update(name, scope)
+  }
+
+  private def addUsedName(name: Name, scope: UseScope)(using Context): Unit = {
+    val fromClass = resolveDependencySource
+    if (fromClass.exists) { // can happen when visiting imports
+      assert(fromClass.isClass)
+      addUsedName(fromClass, name, scope)
+    }
+  }
+
+  private def addMemberRefDependency(sym: Symbol)(using Context): Unit =
+    if (!ignoreDependency(sym)) {
+      val enclOrModuleClass = if (sym.is(ModuleVal)) sym.moduleClass else sym.enclosingClass
+      assert(enclOrModuleClass.isClass, s"$enclOrModuleClass, $sym")
+
+      val fromClass = resolveDependencySource
+      if (fromClass.exists) { // can happen when visiting imports
+        assert(fromClass.isClass)
+
+        addUsedName(fromClass, sym.zincMangledName, UseScope.Default)
+        // packages have class symbol. Only record them as used names but not dependency
+        if (!sym.is(Package)) {
+          _dependencies += ClassDependency(fromClass, enclOrModuleClass, DependencyByMemberRef)
+        }
+      }
+    }
+
+  private def addInheritanceDependencies(tree: Template)(using Context): Unit =
+    if (tree.parents.nonEmpty) {
+      val depContext = depContextOf(tree.symbol.owner)
+      val from = resolveDependencySource
+      for parent <- tree.parents do
+        _dependencies += ClassDependency(from, parent.tpe.classSymbol, depContext)
+    }
+
+  private def depContextOf(cls: Symbol)(using Context): DependencyContext =
+    if cls.isLocal then LocalDependencyByInheritance
+    else DependencyByInheritance
+
+  private def ignoreDependency(sym: Symbol)(using Context) =
+    try
+      !sym.exists ||
+      sym.isAbsent(canForce = false) || // ignore dependencies that have a symbol but do not exist.
+                                        // e.g. java.lang.Object companion object
+      sym.isEffectiveRoot ||
+      sym.isAnonymousFunction ||
+      sym.isAnonymousClass
+    catch case ex: StaleSymbol =>
+      // can happen for constructor proxies. Test case is pos-macros/i13532.
+      true
+
+
+  /** Traverse the tree of a source file and record the dependencies and used names which
+   *  can be retrieved using `dependencies` and`usedNames`.
+   */
+  override def traverse(tree: Tree)(using Context): Unit = try {
+    tree match {
+      case Match(selector, _) =>
+        addPatMatDependency(selector.tpe)
+      case Import(expr, selectors) =>
+        def lookupImported(name: Name) =
+          expr.tpe.member(name).symbol
+        def addImported(name: Name) = {
+          // importing a name means importing both a term and a type (if they exist)
+          addMemberRefDependency(lookupImported(name.toTermName))
+          addMemberRefDependency(lookupImported(name.toTypeName))
+        }
+        for sel <- selectors if !sel.isWildcard do
+          addImported(sel.name)
+          if sel.rename != sel.name then
+            addUsedName(sel.rename, UseScope.Default)
+      case exp @ Export(expr, selectors) =>
+        val dep = expr.tpe.classSymbol
+        if dep.exists && selectors.exists(_.isWildcard) then
+          // If an export is a wildcard, that means that the enclosing class
+          // has forwarders to all the applicable signatures in `dep`,
+          // those forwarders will cause member/type ref dependencies to be
+          // recorded. However, if `dep` adds more members with new names,
+          // there has been no record that the enclosing class needs to
+          // recompile to capture the new members. We add an
+          // inheritance dependency in the presence of wildcard exports
+          // to ensure all new members of `dep` are forwarded to.
+          val depContext = depContextOf(ctx.owner.lexicallyEnclosingClass)
+          val from = resolveDependencySource
+          _dependencies += ClassDependency(from, dep, depContext)
+      case t: TypeTree =>
+        addTypeDependency(t.tpe)
+      case ref: RefTree =>
+        addMemberRefDependency(ref.symbol)
+        addTypeDependency(ref.tpe)
+      case t: Template =>
+        addInheritanceDependencies(t)
+      case _ =>
+    }
+
+    tree match {
+      case Inlined(call, _, _) if !call.isEmpty =>
+        // The inlined call is normally ignored by TreeTraverser but we need to
+        // record it as a dependency
+        traverse(call)
+      case vd: ValDef if vd.symbol.is(ModuleVal) =>
+        // Don't visit module val
+      case t: Template if t.symbol.owner.is(ModuleClass) =>
+        // Don't visit self type of module class
+        traverse(t.constr)
+        t.parents.foreach(traverse)
+        t.body.foreach(traverse)
+      case _ =>
+        traverseChildren(tree)
+    }
+  } catch {
+    case ex: AssertionError =>
+      println(i"asserted failed while traversing $tree")
+      throw ex
+  }
+
+  /** Traverse a used type and record all the dependencies we need to keep track
+   *  of for incremental recompilation.
+   *
+   *  As a motivating example, given a type `T` defined as:
+   *
+   *    type T >: L <: H
+   *    type L <: A1
+   *    type H <: B1
+   *    class A1 extends A0
+   *    class B1 extends B0
+   *
+   *  We need to record a dependency on `T`, `L`, `H`, `A1`, `B1`. This is
+   *  necessary because the API representation that `ExtractAPI` produces for
+   *  `T` just refers to the strings "L" and "H", it does not contain their API
+   *  representation. Therefore, the name hash of `T` does not change if for
+   *  example the definition of `L` changes.
+   *
+   *  We do not need to keep track of superclasses like `A0` and `B0` because
+   *  the API representation of a class (and therefore its name hash) already
+   *  contains all necessary information on superclasses.
+   *
+   *  A natural question to ask is: Since traversing all referenced types to
+   *  find all these names is costly, why not change the API representation
+   *  produced by `ExtractAPI` to contain that information? This way the name
+   *  hash of `T` would change if any of the types it depends on change, and we
+   *  would only need to record a dependency on `T`. Unfortunately there is no
+   *  simple answer to the question "what does T depend on?" because it depends
+   *  on the prefix and `ExtractAPI` does not compute types as seen from every
+   *  possible prefix, the documentation of `ExtractAPI` explains why.
+   *
+   *  The tests in sbt `types-in-used-names-a`, `types-in-used-names-b`,
+   *  `as-seen-from-a` and `as-seen-from-b` rely on this.
+   */
+  private abstract class TypeDependencyTraverser(using Context) extends TypeTraverser() {
+    protected def addDependency(symbol: Symbol): Unit
+
+    // Avoid cycles by remembering both the types (testcase:
+    // tests/run/enum-values.scala) and the symbols of named types (testcase:
+    // tests/pos-java-interop/i13575) we've seen before.
+    private val seen = new mutable.HashSet[Symbol | Type]
+    def traverse(tp: Type): Unit = if (!seen.contains(tp)) {
+      seen += tp
+      tp match {
+        case tp: NamedType =>
+          val sym = tp.symbol
+          if !seen.contains(sym) && !sym.is(Package) then
+            seen += sym
+            addDependency(sym)
+            if !sym.isClass then traverse(tp.info)
+            traverse(tp.prefix)
+        case tp: ThisType =>
+          traverse(tp.underlying)
+        case tp: ConstantType =>
+          traverse(tp.underlying)
+        case tp: ParamRef =>
+          traverse(tp.underlying)
+        case _ =>
+          traverseChildren(tp)
+      }
+    }
+  }
+
+  def addTypeDependency(tpe: Type)(using Context): Unit = {
+    val traverser = new TypeDependencyTraverser {
+      def addDependency(symbol: Symbol) = addMemberRefDependency(symbol)
+    }
+    traverser.traverse(tpe)
+  }
+
+  def addPatMatDependency(tpe: Type)(using Context): Unit = {
+    val traverser = new TypeDependencyTraverser {
+      def addDependency(symbol: Symbol) =
+        if (!ignoreDependency(symbol) && symbol.is(Sealed)) {
+          val usedName = symbol.zincMangledName
+          addUsedName(usedName, UseScope.PatMatTarget)
+        }
+    }
+    traverser.traverse(tpe)
+  }
+}
diff --git a/tests/pos-with-compiler-cc/dotc/sbt/ShowAPI.scala b/tests/pos-with-compiler-cc/dotc/sbt/ShowAPI.scala
new file mode 100644
index 000000000000..cacb10cf98bc
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/sbt/ShowAPI.scala
@@ -0,0 +1,162 @@
+// This file is copied straight from
+// https://github.com/sbt/sbt/blob/0.13/compile/api/src/main/scala/xsbt/api/ShowAPI.scala
+// It is convenient to be able to pretty-print the API from Dotty itself to test
+// the sbt phase without having to run sbt.
+
+/* sbt -- Simple Build Tool
+ * Copyright 2010 Mark Harrah
+ */
+package dotty.tools.dotc
+package sbt
+
+import scala.language.unsafeNulls
+
+import xsbti.api._
+
+import scala.util.Try
+
+object DefaultShowAPI {
+  private lazy val defaultNesting = Try { java.lang.Integer.parseInt(sys.props.get("sbt.inc.apidiff.depth").get) } getOrElse 2
+
+  def apply(d: Definition): String = ShowAPI.showDefinition(d)(defaultNesting)
+  def apply(d: Type): String = ShowAPI.showType(d)(defaultNesting)
+  def apply(a: ClassLike): String = ShowAPI.showApi(a)(defaultNesting)
+}
+
+object ShowAPI {
+  private lazy val numDecls = Try { java.lang.Integer.parseInt(sys.props.get("sbt.inc.apidiff.decls").get) } getOrElse 0
+
+  private def truncateDecls(decls: Array[ClassDefinition]): Array[ClassDefinition] = if (numDecls <= 0) decls else decls.take(numDecls)
+  private def lines(ls: Seq[String]): String = ls.mkString("\n", "\n", "\n")
+
+  def showApi(c: ClassLike)(implicit nesting: Int): String =
+    showDefinition(c)
+
+  def showDefinition(d: Definition)(implicit nesting: Int): String = d match {
+    case v: Val              => showMonoDef(v, "val") + ": " + showType(v.tpe)
+    case v: Var              => showMonoDef(v, "var") + ": " + showType(v.tpe)
+    case d: Def              => showPolyDef(d, "def") + showValueParams(d.valueParameters.toIndexedSeq) + ": " + showType(d.returnType)
+    case ta: TypeAlias       => showPolyDef(ta, "type") + " = " + showType(ta.tpe)
+    case td: TypeDeclaration => showPolyDef(td, "type") + showBounds(td.lowerBound, td.upperBound)
+    case cl: ClassLike => showMonoDef(d, showDefinitionType(cl.definitionType)) +
+      showTypeParameters(cl.typeParameters.toIndexedSeq) + " extends " + showTemplate(cl)
+    case cl: ClassLikeDef => showPolyDef(cl, showDefinitionType(cl.definitionType))
+  }
+
+  private def showTemplate(cl: ClassLike)(implicit nesting: Int) =
+    if (nesting <= 0) "<nesting level reached>"
+    else {
+      val showSelf = if (cl.selfType.isInstanceOf[EmptyType]) "" else " self: " + showNestedType(cl.selfType) + " =>"
+
+      cl.structure.parents.map(showNestedType).mkString("", " with ", " {") + showSelf +
+        lines(truncateDecls(cl.structure.inherited).toIndexedSeq.map(d => "^inherited^ " + showNestedDefinition(d))) +
+        lines(truncateDecls(cl.structure.declared).toIndexedSeq.map(showNestedDefinition)) +
+        "}"
+    }
+
+  def showType(t: Type)(implicit nesting: Int): String = t match {
+    case st: Projection   => showType(st.prefix) + "#" + st.id
+    case st: ParameterRef => "<" + st.id + ">"
+    case st: Singleton    => showPath(st.path)
+    case st: EmptyType    => "<empty>"
+    case p: Parameterized => showType(p.baseType) + p.typeArguments.map(showType).mkString("[", ", ", "]")
+    case c: Constant      => showType(c.baseType) + "(" + c.value + ")"
+    case a: Annotated     => showAnnotations(a.annotations.toIndexedSeq) + " " + showType(a.baseType)
+    case s: Structure =>
+      s.parents.map(showType).mkString(" with ") + (
+        if (nesting <= 0) "{ <nesting level reached> }"
+        else truncateDecls(s.declared).map(showNestedDefinition).mkString(" {", "\n", "}")
+      )
+    case e: Existential =>
+      showType(e.baseType) + (
+        if (nesting <= 0) " forSome { <nesting level reached> }"
+        else e.clause.map(t => "type " + showNestedTypeParameter(t)).mkString(" forSome { ", "; ", " }")
+      )
+    case p: Polymorphic => showType(p.baseType) + (
+      if (nesting <= 0) " [ <nesting level reached> ]"
+      else showNestedTypeParameters(p.parameters.toIndexedSeq)
+    )
+  }
+
+  private def showPath(p: Path): String = p.components.map(showPathComponent).mkString(".")
+  private def showPathComponent(pc: PathComponent) = pc match {
+    case s: Super => "super[" + showPath(s.qualifier) + "]"
+    case _: This  => "this"
+    case i: Id    => i.id
+  }
+
+  private def space(s: String) = if (s.isEmpty) s else s + " "
+  private def showMonoDef(d: Definition, label: String)(implicit nesting: Int): String =
+    space(showAnnotations(d.annotations.toIndexedSeq)) + space(showAccess(d.access)) + space(showModifiers(d.modifiers)) + space(label) + d.name
+
+  private def showPolyDef(d: ParameterizedDefinition, label: String)(implicit nesting: Int): String =
+    showMonoDef(d, label) + showTypeParameters(d.typeParameters.toIndexedSeq)
+
+  private def showTypeParameters(tps: Seq[TypeParameter])(implicit nesting: Int): String =
+    if (tps.isEmpty) ""
+    else tps.map(showTypeParameter).mkString("[", ", ", "]")
+
+  private def showTypeParameter(tp: TypeParameter)(implicit nesting: Int): String =
+    showAnnotations(tp.annotations.toIndexedSeq) + " " + showVariance(tp.variance) + tp.id + showTypeParameters(tp.typeParameters.toIndexedSeq) + " " + showBounds(tp.lowerBound, tp.upperBound)
+
+  private def showAnnotations(as: Seq[Annotation])(implicit nesting: Int) = as.map(showAnnotation).mkString(" ")
+  private def showAnnotation(a: Annotation)(implicit nesting: Int) =
+    "@" + showType(a.base) + (
+      if (a.arguments.isEmpty) ""
+      else a.arguments.map(a => a.name + " = " + a.value).mkString("(", ", ", ")")
+    )
+
+  private def showBounds(lower: Type, upper: Type)(implicit nesting: Int): String = ">: " + showType(lower) + " <: " + showType(upper)
+
+  private def showValueParams(ps: Seq[ParameterList])(implicit nesting: Int): String =
+    ps.map(pl =>
+      pl.parameters.map(mp =>
+        mp.name + ": " + showParameterModifier(showType(mp.tpe), mp.modifier) + (if (mp.hasDefault) "= ..." else "")).mkString(if (pl.isImplicit) "(implicit " else "(", ", ", ")")).mkString("")
+
+  private def showParameterModifier(base: String, pm: ParameterModifier): String = pm match {
+    case ParameterModifier.Plain    => base
+    case ParameterModifier.Repeated => base + "*"
+    case ParameterModifier.ByName   => "=> " + base
+  }
+
+  private def showDefinitionType(d: DefinitionType) = d match {
+    case DefinitionType.Trait         => "trait"
+    case DefinitionType.ClassDef      => "class"
+    case DefinitionType.Module        => "object"
+    case DefinitionType.PackageModule => "package object"
+  }
+
+  private def showAccess(a: Access) = a match {
+    case p: Public    => ""
+    case p: Protected => "protected" + showQualifier(p.qualifier)
+    case p: Private   => "private" + showQualifier(p.qualifier)
+  }
+
+  private def showQualifier(q: Qualifier) = q match {
+    case _: Unqualified   => ""
+    case _: ThisQualifier => "[this]"
+    case i: IdQualifier   => "[" + i.value + "]"
+  }
+
+  private def showModifiers(m: Modifiers) = List(
+    (m.isOverride, "override"),
+    (m.isFinal, "final"),
+    (m.isSealed, "sealed"),
+    (m.isImplicit, "implicit"),
+    (m.isAbstract, "abstract"),
+    (m.isLazy, "lazy")
+  ).collect { case (true, mod) => mod }.mkString(" ")
+
+  private def showVariance(v: Variance) = v match {
+    case Variance.Invariant     => ""
+    case Variance.Covariant     => "+"
+    case Variance.Contravariant => "-"
+  }
+
+  // limit nesting to prevent cycles and generally keep output from getting humongous
+  private def showNestedType(tp: Type)(implicit nesting: Int) = showType(tp)(nesting - 1)
+  private def showNestedTypeParameter(tp: TypeParameter)(implicit nesting: Int) = showTypeParameter(tp)(nesting - 1)
+  private def showNestedTypeParameters(tps: Seq[TypeParameter])(implicit nesting: Int) = showTypeParameters(tps)(nesting - 1)
+  private def showNestedDefinition(d: Definition)(implicit nesting: Int) = showDefinition(d)(nesting - 1)
+}
+
diff --git a/tests/pos-with-compiler-cc/dotc/sbt/ThunkHolder.scala b/tests/pos-with-compiler-cc/dotc/sbt/ThunkHolder.scala
new file mode 100644
index 000000000000..d4ee3dc9a68f
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/sbt/ThunkHolder.scala
@@ -0,0 +1,33 @@
+package dotty.tools
+package dotc
+package sbt
+
+import scala.annotation.tailrec
+import scala.collection.mutable.ListBuffer
+import xsbti.api
+import language.experimental.pureFunctions
+
+/** Create and hold thunks. A thunk is a (potentially) unevaluated value
+ *  that may be evaluated once.
+ */
+private[sbt] trait ThunkHolder {
+  private val thunks = new ListBuffer[api.Lazy[?]]
+
+  /** Force all unevaluated thunks to prevent space leaks. */
+  @tailrec protected final def forceThunks(): Unit = if (!thunks.isEmpty) {
+    val toForce = thunks.toList
+    thunks.clear()
+    toForce.foreach(_.get())
+    // Forcing thunks may create new thunks
+    forceThunks()
+  }
+
+  /** Store the by-name parameter `s` in a `Lazy` container without evaluating it.
+   *  It will be forced by the next call to `forceThunks()`
+   */
+  def lzy[T <: AnyRef](t: -> T): api.Lazy[T] = {
+    val l = api.SafeLazy.apply(() => t).nn
+    thunks += l
+    l
+  }
+}
diff --git a/tests/pos-with-compiler-cc/dotc/sbt/package.scala b/tests/pos-with-compiler-cc/dotc/sbt/package.scala
new file mode 100644
index 000000000000..379a2e45ce40
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/sbt/package.scala
@@ -0,0 +1,20 @@
+package dotty.tools.dotc.sbt
+
+import dotty.tools.dotc.core.Contexts.Context
+import dotty.tools.dotc.core.Symbols.Symbol
+import dotty.tools.dotc.core.NameOps.stripModuleClassSuffix
+import dotty.tools.dotc.core.Names.Name
+
+inline val TermNameHash = 1987 // 300th prime
+inline val TypeNameHash = 1993 // 301st prime
+inline val InlineParamHash = 1997 // 302nd prime
+
+extension (sym: Symbol)
+
+  def constructorName(using Context) =
+    sym.owner.fullName ++ ";init;"
+
+  /** Mangle a JVM symbol name in a format better suited for internal uses by sbt. */
+  def zincMangledName(using Context): Name =
+    if (sym.isConstructor) constructorName
+    else sym.name.stripModuleClassSuffix
diff --git a/tests/pos-with-compiler-cc/dotc/semanticdb/ConstantOps.scala b/tests/pos-with-compiler-cc/dotc/semanticdb/ConstantOps.scala
new file mode 100644
index 000000000000..975d5480fe9b
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/semanticdb/ConstantOps.scala
@@ -0,0 +1,25 @@
+package dotty.tools
+package dotc
+package semanticdb
+
+import dotty.tools.dotc.{semanticdb => s}
+
+import core.Contexts.Context
+import core.Constants._
+
+object ConstantOps:
+  extension (const: Constant)
+    def toSemanticConst(using Context): s.Constant = const.tag match {
+      case UnitTag => s.UnitConstant()
+      case BooleanTag => s.BooleanConstant(const.booleanValue)
+      case ByteTag => s.ByteConstant(const.byteValue)
+      case ShortTag => s.ShortConstant(const.shortValue)
+      case CharTag => s.CharConstant(const.charValue)
+      case IntTag => s.IntConstant(const.intValue)
+      case LongTag => s.LongConstant(const.longValue)
+      case FloatTag => s.FloatConstant(const.floatValue)
+      case DoubleTag => s.DoubleConstant(const.doubleValue)
+      case StringTag => s.StringConstant(const.stringValue)
+      case NullTag => s.NullConstant()
+      case _ => throw new Error(s"Constant ${const} can't be converted to Semanticdb Constant.")
+    }
diff --git a/tests/pos-with-compiler-cc/dotc/semanticdb/Descriptor.scala b/tests/pos-with-compiler-cc/dotc/semanticdb/Descriptor.scala
new file mode 100644
index 000000000000..2743e37cb79f
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/semanticdb/Descriptor.scala
@@ -0,0 +1,122 @@
+package dotty.tools.dotc.semanticdb
+
+import scala.language.unsafeNulls
+
+import java.lang.System.{lineSeparator => EOL}
+import dotty.tools.dotc.semanticdb.{Descriptor => d}
+
+class DescriptorParser(s: String) {
+  var i = s.length
+  def fail() = {
+    val message = "invalid symbol format"
+    val caret = " " * i + "^"
+    sys.error(s"$message$EOL$s$EOL$caret")
+  }
+
+  val BOF = '\u0000'
+  val EOF = '\u001A'
+  var currChar = EOF
+  def readChar(): Char = {
+    if (i <= 0) {
+      if (i == 0) {
+        i -= 1
+        currChar = BOF
+        currChar
+      } else {
+        fail()
+      }
+    } else {
+      i -= 1
+      currChar = s(i)
+      currChar
+    }
+  }
+
+  def parseValue(): String = {
+    if (currChar == '`') {
+      val end = i
+      while (readChar() != '`') {}
+      readChar()
+      s.substring(i + 2, end)
+    } else {
+      val end = i + 1
+      if (!Character.isJavaIdentifierPart(currChar)) fail()
+      while (Character.isJavaIdentifierPart(readChar()) && currChar != BOF) {}
+      s.substring(i + 1, end)
+    }
+  }
+
+  def parseDisambiguator(): String = {
+    val end = i + 1
+    if (currChar != ')') fail()
+    while (readChar() != '(') {}
+    readChar()
+    s.substring(i + 1, end)
+  }
+
+  def parseDescriptor(): Descriptor = {
+    if (currChar == '.') {
+      readChar()
+      if (currChar == ')') {
+        val disambiguator = parseDisambiguator()
+        val value = parseValue()
+        d.Method(value, disambiguator)
+      } else {
+        d.Term(parseValue())
+      }
+    } else if (currChar == '#') {
+      readChar()
+      d.Type(parseValue())
+    } else if (currChar == '/') {
+      readChar()
+      d.Package(parseValue())
+    } else if (currChar == ')') {
+      readChar()
+      val value = parseValue()
+      if (currChar != '(') fail()
+      else readChar()
+      d.Parameter(value)
+    } else if (currChar == ']') {
+      readChar()
+      val value = parseValue()
+      if (currChar != '[') fail()
+      else readChar()
+      d.TypeParameter(value)
+    } else {
+      fail()
+    }
+  }
+
+  def entryPoint(): (Descriptor, String) = {
+    readChar()
+    val desc = parseDescriptor()
+    (desc, s.substring(0, i + 1))
+  }
+}
+
+object DescriptorParser {
+  def apply(symbol: String): (Descriptor, String) = {
+    val parser = new DescriptorParser(symbol)
+    parser.entryPoint()
+  }
+}
+
+sealed trait Descriptor {
+  def isNone: Boolean = this == d.None
+  def isTerm: Boolean = this.isInstanceOf[d.Term]
+  def isMethod: Boolean = this.isInstanceOf[d.Method]
+  def isType: Boolean = this.isInstanceOf[d.Type]
+  def isPackage: Boolean = this.isInstanceOf[d.Package]
+  def isParameter: Boolean = this.isInstanceOf[d.Parameter]
+  def isTypeParameter: Boolean = this.isInstanceOf[d.TypeParameter]
+  def value: String
+}
+object Descriptor {
+  case object None extends Descriptor { def value: String = "" }
+  final case class Term(value: String) extends Descriptor
+  final case class Method(value: String, disambiguator: String) extends Descriptor
+  final case class Type(value: String) extends Descriptor
+  final case class Package(value: String) extends Descriptor
+  final case class Parameter(value: String) extends Descriptor
+  final case class TypeParameter(value: String) extends Descriptor
+}
diff --git a/tests/pos-with-compiler-cc/dotc/semanticdb/ExtractSemanticDB.scala b/tests/pos-with-compiler-cc/dotc/semanticdb/ExtractSemanticDB.scala
new file mode 100644
index 000000000000..916503e94203
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/semanticdb/ExtractSemanticDB.scala
@@ -0,0 +1,515 @@
+package dotty.tools
+package dotc
+package semanticdb
+
+import scala.language.unsafeNulls
+
+import core._
+import Phases._
+import ast.tpd._
+import ast.Trees.{mods, WithEndMarker}
+import Contexts._
+import Symbols._
+import Flags._
+import Names.Name
+import StdNames.nme
+import NameOps._
+import Denotations.StaleSymbol
+import util.Spans.Span
+import util.SourceFile
+import transform.SymUtils._
+
+import scala.collection.mutable
+import scala.annotation.{ threadUnsafe => tu, tailrec }
+import scala.PartialFunction.condOpt
+
+import dotty.tools.dotc.{semanticdb => s}
+
+/** Extract symbol references and uses to semanticdb files.
+ *  See https://scalameta.org/docs/semanticdb/specification.html#symbol-1
+ *  for a description of the format.
+ *  TODO: Also extract type information
+ */
+class ExtractSemanticDB extends Phase:
+  import Scala3.{_, given}
+
+  override val phaseName: String = ExtractSemanticDB.name
+
+  override val description: String = ExtractSemanticDB.description
+
+  override def isRunnable(using Context) =
+    super.isRunnable && ctx.settings.Xsemanticdb.value
+
+  // Check not needed since it does not transform trees
+  override def isCheckable: Boolean = false
+
+  override def run(using Context): Unit =
+    val unit = ctx.compilationUnit
+    val extractor = Extractor()
+    extractor.extract(unit.tpdTree)
+    ExtractSemanticDB.write(unit.source, extractor.occurrences.toList, extractor.symbolInfos.toList, extractor.synthetics.toList)
+
+  /** Extractor of symbol occurrences from trees */
+  class Extractor extends TreeTraverser:
+    given s.SemanticSymbolBuilder = s.SemanticSymbolBuilder()
+    val synth = SyntheticsExtractor()
+    given converter: s.TypeOps = s.TypeOps()
+
+    /** The bodies of synthetic locals */
+    private val localBodies = mutable.HashMap[Symbol, Tree]()
+
+    /** The extracted symbol occurrences */
+    val occurrences: mutable.ListBuffer[SymbolOccurrence] = new mutable.ListBuffer()
+
+    /** The extracted symbol infos */
+    val symbolInfos = new mutable.ListBuffer[SymbolInformation]()
+
+    val synthetics = new mutable.ListBuffer[s.Synthetic]()
+
+    /** A cache of localN names */
+    val localNames: mutable.HashSet[String] = new mutable.HashSet()
+
+    /** The symbol occurrences generated so far, as a set */
+    private val generated = new mutable.HashSet[SymbolOccurrence]
+
+    def extract(tree: Tree)(using Context): Unit =
+      traverse(tree)
+      val fakeSyms = converter.fakeSymbols.map(_.symbolInfo(Set.empty)(using LinkMode.SymlinkChildren, converter))
+      symbolInfos.appendAll(fakeSyms)
+
+    /** Definitions of this symbol should be excluded from semanticdb */
+    private def excludeDef(sym: Symbol)(using Context): Boolean =
+      !sym.exists
+      || sym.isLocalDummy
+      // basically do not register synthetic symbols, except anonymous class
+      // `new Foo { ... }`
+      || (sym.is(Synthetic) && !sym.isAnonymousClass)
+      || sym.isSetter
+      || sym.isOldStyleImplicitConversion(forImplicitClassOnly = true)
+      || sym.owner.isGivenInstanceSummoner
+      || excludeDefOrUse(sym)
+
+    private def excludeDefOrUse(sym: Symbol)(using Context): Boolean =
+      !sym.exists
+      || sym.name.is(NameKinds.DefaultGetterName)
+      || sym.isConstructor && (sym.owner.is(ModuleClass) || !sym.isGlobal)
+      || excludeSymbol(sym)
+
+    private def excludeSymbol(sym: Symbol)(using Context): Boolean =
+      !sym.exists
+      || sym.is(ConstructorProxy)
+      || sym.name.isWildcard
+      || excludeQual(sym)
+
+    private def excludeQual(sym: Symbol)(using Context): Boolean =
+      !sym.exists
+      || sym.isAnonymousFunction
+      || sym.isAnonymousModuleVal
+      || sym.name.isEmptyNumbered
+
+    private def excludeChildren(sym: Symbol)(using Context): Boolean =
+      !sym.exists
+      || sym.is(Param) && sym.info.bounds.hi.isInstanceOf[Types.HKTypeLambda]
+      || sym.isOldStyleImplicitConversion(forImplicitClassOnly = true)
+
+    /** Uses of this symbol where the reference has given span should be excluded from semanticdb */
+    private def excludeUse(qualifier: Option[Symbol], sym: Symbol)(using Context): Boolean =
+      !sym.exists
+      || excludeDefOrUse(sym)
+      || sym.isConstructor && sym.owner.isAnnotation
+      || sym == defn.Any_typeCast
+      || sym.owner == defn.OpsPackageClass
+      || qualifier.exists(excludeQual)
+
+    private def traverseAnnotsOfDefinition(sym: Symbol)(using Context): Unit =
+      for annot <- sym.annotations do
+        if annot.tree.span.exists
+        && annot.tree.span.hasLength then
+          annot.tree match
+            case tree: Typed => () // hack for inline code
+            case tree        => traverse(tree)
+
+    override def traverse(tree: Tree)(using Context): Unit =
+
+      tree match
+        case tree: DefTree if tree.symbol.exists =>
+          traverseAnnotsOfDefinition(tree.symbol)
+        case _ =>
+          ()
+
+      tree match
+        case tree: PackageDef =>
+          tree.stats.foreach(traverse)
+          if !excludeDef(tree.pid.symbol) && tree.pid.span.hasLength then
+            tree.pid match
+              case tree: Select =>
+                traverse(tree.qualifier)
+                registerDefinition(tree.symbol, selectSpan(tree), Set.empty, tree.source)
+              case tree => registerDefinition(tree.symbol, tree.span, Set.empty, tree.source)
+        case tree: NamedDefTree =>
+          if !tree.symbol.isAllOf(ModuleValCreationFlags) then
+            tree match {
+              case tree: ValDef if tree.symbol.isAllOf(EnumValue) =>
+                tree.rhs match
+                case Block(TypeDef(_, template: Template) :: _, _) => // simple case with specialised extends clause
+                  template.parents.filter(!_.span.isZeroExtent).foreach(traverse)
+                case _ => // calls $new
+              case tree: ValDef if tree.symbol.isSelfSym =>
+                if tree.tpt.span.hasLength then
+                  traverse(tree.tpt)
+              case tree: DefDef if tree.symbol.isConstructor => // ignore typeparams for secondary ctors
+                tree.trailingParamss.foreach(_.foreach(traverse))
+                traverse(tree.rhs)
+              case tree: (DefDef | ValDef) if tree.symbol.isSyntheticWithIdent =>
+                tree match
+                  case tree: DefDef =>
+                    tree.paramss.foreach(_.foreach(param => registerSymbolSimple(param.symbol)))
+                  case tree: ValDef if tree.symbol.is(Given) =>
+                    traverse(tree.tpt)
+                  case _ =>
+                if !tree.symbol.isGlobal then
+                  localBodies(tree.symbol) = tree.rhs
+                // ignore rhs
+
+              case PatternValDef(pat, rhs) =>
+                traverse(rhs)
+                PatternValDef.collectPats(pat).foreach(traverse)
+              case tree: TypeDef =>
+                traverseChildren(tree)
+              case tree =>
+                if !excludeChildren(tree.symbol) then
+                  traverseChildren(tree)
+            }
+            if !excludeDef(tree.symbol) && (tree.span.hasLength || tree.symbol.isAnonymousClass) then
+              registerDefinition(tree.symbol, tree.nameSpan, symbolKinds(tree), tree.source)
+              val privateWithin = tree.symbol.privateWithin
+              if privateWithin.exists then
+                registerUseGuarded(None, privateWithin, spanOfSymbol(privateWithin, tree.span, tree.source), tree.source)
+            else if !excludeSymbol(tree.symbol) then
+              registerSymbol(tree.symbol, symbolKinds(tree))
+        case tree: Template if tree.symbol.owner.is(Invisible) =>
+          // do nothing
+          // exclude the symbols and synthetics generated by @main annotation
+          // (main class generated by @main has `Invisible` flag, see `MainProxies.scala`).
+        case tree: Template =>
+          val ctorSym = tree.constr.symbol
+          for parent <- tree.parentsOrDerived if parent.span.hasLength do
+            traverse(parent)
+          val selfSpan = tree.self.span
+          if selfSpan.exists && selfSpan.hasLength then
+            traverse(tree.self)
+          if tree.symbol.owner.isEnumClass then
+            tree.body.foreachUntilImport(traverse).foreach(traverse) // the first import statement
+          else
+            tree.body.foreach(traverse)
+          if !excludeDef(ctorSym) then
+            traverseAnnotsOfDefinition(ctorSym)
+            ctorParams(tree.constr.termParamss, tree.constr.leadingTypeParams, tree.body)
+            registerDefinition(ctorSym, tree.constr.nameSpan.startPos, Set.empty, tree.source)
+        case tree: Apply =>
+          @tu lazy val genParamSymbol: Name => String = tree.fun.symbol.funParamSymbol
+          traverse(tree.fun)
+          synth.tryFindSynthetic(tree).foreach(synthetics.addOne)
+          for arg <- tree.args do
+            arg match
+              case tree @ NamedArg(name, arg) =>
+                traverse(localBodies.get(arg.symbol).getOrElse(arg))
+                registerUse(genParamSymbol(name), tree.span.startPos.withEnd(tree.span.start + name.toString.length), tree.source)
+              case _ => traverse(arg)
+        case tree: Assign =>
+          val qualSym = condOpt(tree.lhs) { case Select(qual, _) if qual.symbol.exists => qual.symbol }
+          if !excludeUse(qualSym, tree.lhs.symbol) then
+            val lhs = tree.lhs.symbol
+            val setter = lhs.matchingSetter.orElse(lhs)
+            tree.lhs match
+              case tree: Select => registerUse(setter, selectSpan(tree), tree.source)
+              case tree         => registerUse(setter, tree.span, tree.source)
+            traverseChildren(tree.lhs)
+          traverse(tree.rhs)
+        case tree: Ident =>
+          if tree.name != nme.WILDCARD then
+            val sym = tree.symbol.adjustIfCtorTyparam
+            registerUseGuarded(None, sym, tree.span, tree.source)
+        case tree: Select =>
+          val qual = tree.qualifier
+          val qualSpan = qual.span
+          val sym = tree.symbol.adjustIfCtorTyparam
+          if qualSpan.exists && qualSpan.hasLength then
+            traverse(qual)
+          if (sym != NoSymbol)
+            registerUseGuarded(qual.symbol.ifExists, sym, selectSpan(tree), tree.source)
+          else
+            qual.symbol.info.lookupSym(tree.name).foreach(sym =>
+              registerUseGuarded(qual.symbol.ifExists, sym, selectSpan(tree), tree.source)
+            )
+        case tree: Import =>
+          if tree.span.exists && tree.span.hasLength then
+            traverseChildren(tree)
+            for sel <- tree.selectors do
+              val imported = sel.imported.name
+              if imported != nme.WILDCARD then
+                for alt <- tree.expr.tpe.member(imported).alternatives do
+                  registerUseGuarded(None, alt.symbol, sel.imported.span, tree.source)
+                  try
+                    if (alt.symbol.companionClass.exists)
+                      registerUseGuarded(None, alt.symbol.companionClass, sel.imported.span, tree.source)
+                  catch case ex: StaleSymbol =>
+                    // can happen for constructor proxies. Test case is pos-macros/i13532.
+                    ()
+
+        case tree: Inlined =>
+          traverse(tree.call)
+
+        case tree: TypeApply =>
+          synth.tryFindSynthetic(tree).foreach(synthetics.addOne)
+          traverseChildren(tree)
+
+        case tree: TypeTree =>
+          tree.typeOpt match
+            // Any types could be appear inside of `TypeTree`, but
+            // types that precent in source other than TypeRef are traversable and contain Ident tree nodes
+            // (e.g. TypeBoundsTree, AppliedTypeTree)
+            case Types.TypeRef(_, sym: Symbol) if namePresentInSource(sym, tree.span, tree.source) =>
+              registerUseGuarded(None, sym, tree.span, tree.source)
+            case _ => ()
+
+
+        case _ =>
+          traverseChildren(tree)
+
+      tree match
+        case tree: WithEndMarker[t] =>
+          val endSpan = tree.endSpan
+          if endSpan.exists &&
+            namePresentInSource(tree.symbol, endSpan, tree.source) then
+            // non-symbol end marker shouldn't have Symbol Occurrence
+            registerUseGuarded(None, tree.symbol, endSpan, tree.source)
+        case _ =>
+
+    end traverse
+
+    private object PatternValDef:
+
+      def unapply(tree: ValDef)(using Context): Option[(Tree, Tree)] = tree.rhs match
+
+        case Match(Typed(selected: Tree, tpt: TypeTree), CaseDef(pat: Tree, _, _) :: Nil)
+        if tpt.span.exists && !tpt.span.hasLength && tpt.tpe.isAnnotatedByUnchecked =>
+          Some((pat, selected))
+
+        case _ => None
+
+      extension (tpe: Types.Type)
+        private inline def isAnnotatedByUnchecked(using Context) = tpe match
+          case Types.AnnotatedType(_, annot) => annot.symbol == defn.UncheckedAnnot
+          case _                             => false
+
+      def collectPats(pat: Tree): List[Tree] =
+
+        @tailrec
+        def impl(acc: List[Tree], pats: List[Tree]): List[Tree] = pats match
+
+          case pat::pats => pat match
+            case Typed(UnApply(fun: Tree, _, args), tpt: Tree) => impl(fun::tpt::acc, args:::pats)
+            case Typed(obj: Ident, tpt: Tree)                  => impl(obj::tpt::acc, pats)
+            case UnApply(fun: Tree, _, args)                   => impl(fun::acc,      args:::pats)
+            case obj: Ident                                    => impl(obj::acc,      pats)
+            case _                                             => impl(acc,           pats)
+
+          case Nil => acc
+
+        impl(Nil, pat::Nil)
+
+    end PatternValDef
+
+
+
+    private def registerSymbol(sym: Symbol, symkinds: Set[SymbolKind])(using Context): Unit =
+      val sname = sym.symbolName
+      val isLocal = sname.isLocal
+      if !isLocal || !localNames.contains(sname) then
+        if isLocal then
+          localNames += sname
+        symbolInfos += sym.symbolInfo(symkinds)(using LinkMode.SymlinkChildren, converter)
+
+    private def registerSymbolSimple(sym: Symbol)(using Context): Unit =
+      registerSymbol(sym, Set.empty)
+
+    private def registerOccurrence(symbol: String, span: Span, role: SymbolOccurrence.Role, treeSource: SourceFile)(using Context): Unit =
+      val occ = SymbolOccurrence(range(span, treeSource), symbol, role)
+      if !generated.contains(occ) && occ.symbol.nonEmpty then
+        occurrences += occ
+        generated += occ
+
+    private def registerUseGuarded(qualSym: Option[Symbol], sym: Symbol, span: Span, treeSource: SourceFile)(using Context) =
+      if !excludeUse(qualSym, sym) && !span.isZeroExtent then
+        registerUse(sym, span, treeSource)
+
+    private def registerUse(sym: Symbol, span: Span, treeSource: SourceFile)(using Context): Unit =
+      registerUse(sym.symbolName, span, treeSource)
+
+    private def registerUse(symbol: String, span: Span, treeSource: SourceFile)(using Context): Unit =
+      registerOccurrence(symbol, span, SymbolOccurrence.Role.REFERENCE, treeSource)
+
+    private def registerDefinition(sym: Symbol, span: Span, symkinds: Set[SymbolKind], treeSource: SourceFile)(using Context) =
+      val sname = sym.symbolName
+      val finalSpan = if !span.hasLength || !sym.is(Given) || namePresentInSource(sym, span, treeSource) then
+        span
+      else
+        Span(span.start)
+
+      if namePresentInSource(sym, span, treeSource) || sym.isAnonymousClass then
+        registerOccurrence(sname, finalSpan, SymbolOccurrence.Role.DEFINITION, treeSource)
+      if !sym.is(Package) then
+        registerSymbol(sym, symkinds)
+
+    private def spanOfSymbol(sym: Symbol, span: Span, treeSource: SourceFile)(using Context): Span =
+      val contents = if treeSource.exists then treeSource.content() else Array.empty[Char]
+      val idx = contents.indexOfSlice(sym.name.show, span.start)
+      val start = if idx >= 0 then idx else span.start
+      Span(start, start + sym.name.show.length, start)
+
+    extension (list: List[List[ValDef]])
+      private  inline def isSingleArg = list match
+        case (_::Nil)::Nil => true
+        case _             => false
+
+    extension (tree: DefDef)
+      private def isSetterDef(using Context): Boolean =
+        tree.name.isSetterName && tree.mods.is(Accessor) && tree.termParamss.isSingleArg
+
+    private def findGetters(ctorParams: Set[Names.TermName], body: List[Tree])(using Context): Map[Names.TermName, ValDef] =
+      if ctorParams.isEmpty || body.isEmpty then
+        Map.empty
+      else
+        body.collect({
+          case tree: ValDef
+          if ctorParams.contains(tree.name)
+          && !tree.symbol.isPrivate =>
+            tree.name -> tree
+        }).toMap
+    end findGetters
+
+    private def selectSpan(tree: Select) =
+      val end = tree.span.end
+      val limit = tree.qualifier.span.end
+      val start =
+        if limit < end then
+          val len = tree.name.toString.length
+          if tree.source.content()(end - 1) == '`' then end - len - 2 else end - len
+        else limit
+      Span(start max limit, end)
+
+    extension (span: Span)
+      private def hasLength: Boolean = span.exists && !span.isZeroExtent
+
+    /**Consume head while not an import statement.
+     * Returns the rest of the list after the first import, or else the empty list
+     */
+    extension (body: List[Tree])
+      @tailrec private def foreachUntilImport(op: Tree => Unit): List[Tree] = body match
+        case ((_: Import) :: rest) => rest
+        case stat :: rest =>
+          op(stat)
+          rest.foreachUntilImport(op)
+        case Nil => Nil
+
+    extension (sym: Symbol)
+      private def adjustIfCtorTyparam(using Context) =
+        if sym.isType && sym.owner.exists && sym.owner.isConstructor then
+          matchingMemberType(sym, sym.owner.owner)
+        else
+          sym
+
+    private inline def matchingMemberType(ctorTypeParam: Symbol, classSym: Symbol)(using Context) =
+      classSym.info.member(ctorTypeParam.name).symbol
+
+    /**Necessary because not all of the eventual flags are propagated from the Tree to the symbol yet.
+     */
+    private def symbolKinds(tree: NamedDefTree)(using Context): Set[SymbolKind] =
+      if tree.symbol.isSelfSym then
+        Set.empty
+      else
+        val symkinds = mutable.HashSet.empty[SymbolKind]
+        tree match
+          case tree: ValDef =>
+            if !tree.symbol.is(Param) then
+              symkinds += (if tree.mods is Mutable then SymbolKind.Var else SymbolKind.Val)
+            if tree.rhs.isEmpty && !tree.symbol.isOneOf(TermParam | CaseAccessor | ParamAccessor) then
+              symkinds += SymbolKind.Abstract
+          case tree: DefDef =>
+            if tree.isSetterDef then
+              symkinds += SymbolKind.Setter
+            else if tree.rhs.isEmpty then
+              symkinds += SymbolKind.Abstract
+          // if symbol isType, it's type variable
+          case tree: Bind if (!tree.symbol.isType) =>
+            symkinds += SymbolKind.Val
+          case tree: Bind if (tree.symbol.isType) =>
+            symkinds += SymbolKind.TypeVal
+          case _ =>
+        symkinds.toSet
+
+    private def ctorParams(
+      vparamss: List[List[ValDef]], tparams: List[TypeDef], body: List[Tree])(using Context): Unit =
+      @tu lazy val getters = findGetters(vparamss.flatMap(_.map(_.name)).toSet, body)
+      for
+        vparams <- vparamss
+        vparam  <- vparams
+      do
+        traverse(vparam.tpt)
+        if !excludeSymbol(vparam.symbol) then
+          traverseAnnotsOfDefinition(vparam.symbol)
+          val symkinds =
+            getters.get(vparam.name).fold(SymbolKind.emptySet)(getter =>
+              if getter.mods.is(Mutable) then SymbolKind.VarSet else SymbolKind.ValSet)
+          registerSymbol(vparam.symbol, symkinds)
+        traverse(vparam.tpt)
+      tparams.foreach(tp => traverse(tp.rhs))
+
+
+object ExtractSemanticDB:
+  import java.nio.file.Path
+  import java.nio.file.Files
+  import java.nio.file.Paths
+
+  val name: String = "extractSemanticDB"
+  val description: String = "extract info into .semanticdb files"
+
+  def write(
+    source: SourceFile,
+    occurrences: List[SymbolOccurrence],
+    symbolInfos: List[SymbolInformation],
+    synthetics: List[Synthetic],
+  )(using Context): Unit =
+    def absolutePath(path: Path): Path = path.toAbsolutePath.normalize
+    val semanticdbTarget =
+      val semanticdbTargetSetting = ctx.settings.semanticdbTarget.value
+      absolutePath(
+        if semanticdbTargetSetting.isEmpty then ctx.settings.outputDir.value.jpath
+        else Paths.get(semanticdbTargetSetting)
+      )
+    val relPath = SourceFile.relativePath(source, ctx.settings.sourceroot.value)
+    val outpath = semanticdbTarget
+      .resolve("META-INF")
+      .resolve("semanticdb")
+      .resolve(relPath)
+      .resolveSibling(source.name + ".semanticdb")
+    Files.createDirectories(outpath.getParent())
+    val doc: TextDocument = TextDocument(
+      schema = Schema.SEMANTICDB4,
+      language = Language.SCALA,
+      uri = Tools.mkURIstring(Paths.get(relPath)),
+      text = "",
+      md5 = internal.MD5.compute(String(source.content)),
+      symbols = symbolInfos,
+      occurrences = occurrences,
+      synthetics = synthetics,
+    )
+    val docs = TextDocuments(List(doc))
+    val out = Files.newOutputStream(outpath)
+    try
+      val stream = internal.SemanticdbOutputStream.newInstance(out)
+      docs.writeTo(stream)
+      stream.flush()
+    finally
+      out.close()
diff --git a/tests/pos-with-compiler-cc/dotc/semanticdb/LinkMode.scala b/tests/pos-with-compiler-cc/dotc/semanticdb/LinkMode.scala
new file mode 100644
index 000000000000..aac4c1254892
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/semanticdb/LinkMode.scala
@@ -0,0 +1,4 @@
+package dotty.tools.dotc.semanticdb
+
+enum LinkMode:
+  case SymlinkChildren, HardlinkChildren
diff --git a/tests/pos-with-compiler-cc/dotc/semanticdb/PPrint.scala b/tests/pos-with-compiler-cc/dotc/semanticdb/PPrint.scala
new file mode 100644
index 000000000000..6814d923a062
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/semanticdb/PPrint.scala
@@ -0,0 +1,397 @@
+package dotty.tools.dotc.semanticdb
+
+import dotty.tools.dotc.{semanticdb => s}
+
+import scala.collection.mutable
+import dotty.tools.dotc.semanticdb.Scala3.given
+import SymbolInformation.Kind._
+import dotty.tools.dotc.util.SourceFile
+class SymbolInformationPrinter (symtab: PrinterSymtab):
+  val notes = InfoNotes()
+  val infoPrinter = InfoPrinter(notes)
+
+  def pprintSymbolInformation(info: SymbolInformation): String =
+    val sb = new StringBuilder()
+    sb.append(info.symbol).append(" => ")
+    sb.append(infoPrinter.pprint(info))
+    sb.toString
+
+  class InfoNotes:
+    private val noteSymtab = mutable.Map[String, SymbolInformation]()
+    def enter(info: SymbolInformation) =
+      if (symtab.info(info.symbol).isEmpty && info.kind != UNKNOWN_KIND)
+        noteSymtab(info.symbol) = info
+
+    def visit(sym: String): SymbolInformation =
+      val symtabInfo = noteSymtab.get(sym).orElse(symtab.info(sym))
+      symtabInfo.getOrElse {
+        val displayName = if sym.isGlobal then sym.desc.value else sym
+        SymbolInformation(symbol = sym, displayName = displayName)
+      }
+  end InfoNotes
+
+  class InfoPrinter(notes: InfoNotes):
+    private enum SymbolStyle:
+      case Reference, Definition
+    def pprint(info: SymbolInformation): String =
+      val sb = new StringBuilder()
+      val annotStr = info.annotations.map(pprint).mkString(" ")
+      if annotStr.nonEmpty then
+        sb.append(annotStr + " ")
+      sb.append(accessString(info.access))
+      if info.isAbstract then sb.append("abstract ")
+      if info.isFinal then sb.append("final ")
+      if info.isSealed then sb.append("sealed ")
+      if info.isImplicit then sb.append("implicit ")
+      if info.isLazy then sb.append("lazy ")
+      if info.isCase then sb.append("case ")
+      if info.isCovariant then sb.append("covariant ")
+      if info.isContravariant then sb.append("contravariant ")
+      if info.isVal then sb.append("val ")
+      if info.isVar then sb.append("var ")
+      if info.isStatic then sb.append("static ")
+      if info.isPrimary then sb.append("primary ")
+      if info.isEnum then sb.append("enum ")
+      if info.isDefault then sb.append("default ")
+      if info.isGiven then sb.append("given ")
+      if info.isInline then sb.append("inline ")
+      if info.isOpen then sb.append("open ")
+      if info.isTransparent then sb.append("transparent ")
+      if info.isInfix then sb.append("infix ")
+      if info.isOpaque then sb.append("opaque ")
+      info.kind match
+        case LOCAL => sb.append("local ")
+        case FIELD => sb.append("field ")
+        case METHOD => sb.append("method ")
+        case CONSTRUCTOR => sb.append("ctor ")
+        case MACRO => sb.append("macro ")
+        case TYPE => sb.append("type ")
+        case PARAMETER => sb.append("param ")
+        case SELF_PARAMETER => sb.append("selfparam ")
+        case TYPE_PARAMETER => sb.append("typeparam ")
+        case OBJECT => sb.append("object ")
+        case PACKAGE => sb.append("package ")
+        case PACKAGE_OBJECT => sb.append("package object ")
+        case CLASS => sb.append("class ")
+        case TRAIT => sb.append("trait ")
+        case INTERFACE => sb.append("interface ")
+        case UNKNOWN_KIND | Unrecognized(_) => sb.append("unknown ")
+      sb.append(s"${info.displayName}${info.prefixBeforeTpe}${pprint(info.signature)}")
+      info.overriddenSymbols match
+        case Nil => ()
+        case all => sb.append(s" <: ${all.mkString(", ")}")
+      sb.toString
+
+    private def pprintDef(info: SymbolInformation) =
+      notes.enter(info)
+      pprint(info.symbol, SymbolStyle.Definition)
+    def pprintRef(sym: String): String = pprint(sym, SymbolStyle.Reference)
+    private def pprintDef(sym: String): String = pprint(sym, SymbolStyle.Definition)
+    private def pprint(sym: String, style: SymbolStyle): String =
+      val info = notes.visit(sym)
+      style match
+        case SymbolStyle.Reference =>
+          info.displayName
+        case SymbolStyle.Definition =>
+          pprint(info)
+
+
+    private def pprint(sig: Signature): String =
+      sig match
+        case ClassSignature(tparams, parents, self, decls) =>
+          val sb = new StringBuilder()
+          if (tparams.infos.nonEmpty)
+            sb.append(tparams.infos.map(pprintDef).mkString("[", ", ", "] "))
+          if (parents.nonEmpty)
+            sb.append(parents.map(pprint).mkString("extends ", " with ", " "))
+          if (self.isDefined || decls.infos.nonEmpty) {
+            val selfStr = if (self.isDefined) s"self: ${pprint(self)} =>" else ""
+            val declsStr = if (decls.infos.nonEmpty) s"+${decls.infos.length} decls" else ""
+            sb.append(s"{ ${selfStr} ${declsStr} }")
+          }
+          sb.toString
+        case MethodSignature(tparams, paramss, res) =>
+          val sb = new StringBuilder()
+          if (tparams.infos.nonEmpty)
+            sb.append(tparams.infos.map(pprintDef).mkString("[", ", ", "]"))
+          paramss.foreach { params =>
+            val paramsStr = params.infos.map(pprintDef).mkString("(", ", ", ")")
+            sb.append(paramsStr)
+          }
+          sb.append(s": ${pprint(res)}")
+          sb.toString
+        case TypeSignature(tparams, lo, hi) =>
+          val sb = new StringBuilder()
+          if (tparams.infos.nonEmpty)
+            sb.append(tparams.infos.map(pprintDef).mkString("[", ", ", "]"))
+          if (lo == hi) {
+            sb.append(s" = ${pprint(lo)}")
+          } else {
+            lo match
+              case TypeRef(Type.Empty, "scala/Nothing#", Nil) => ()
+              case lo => sb.append(s" >: ${pprint(lo)}")
+            hi match
+              case TypeRef(Type.Empty, "scala/Any#", Nil) => ()
+              case TypeRef(Type.Empty, "java/lang/Object#", Nil) => ()
+              case hi => sb.append(s" <: ${pprint(hi)}")
+          }
+          sb.toString
+        case ValueSignature(tpe) =>
+          pprint(tpe)
+        case _ =>
+          "<?>"
+
+    protected def pprint(tpe: Type): String = {
+      def prefix(tpe: Type): String = tpe match
+        case TypeRef(pre, sym, args) =>
+          val preStr = pre match {
+            case _: SingleType | _: ThisType | _: SuperType =>
+              s"${prefix(pre)}."
+            case Type.Empty => ""
+            case _ =>
+              s"${prefix(pre)}#"
+          }
+          val argsStr = if (args.nonEmpty) args.map(normal).mkString("[", ", ", "]") else ""
+          s"${preStr}${pprintRef(sym)}${argsStr}"
+        case SingleType(pre, sym) =>
+          pre match {
+            case Type.Empty => pprintRef(sym)
+            case _ =>
+              s"${prefix(pre)}.${pprintRef(sym)}"
+          }
+        case ThisType(sym) =>
+          s"${pprintRef(sym)}.this"
+        case SuperType(pre, sym) =>
+          s"${prefix(pre)}.super[${pprintRef(sym)}]"
+        case ConstantType(const) =>
+          pprint(const)
+        case IntersectionType(types) =>
+          types.map(normal).mkString(" & ")
+        case UnionType(types) =>
+          types.map(normal).mkString(" | ")
+        case WithType(types) =>
+          types.map(normal).mkString(" with ")
+        case StructuralType(utpe, decls) =>
+          val declsStr =
+            if (decls.infos.nonEmpty)
+              s"{ ${decls.infos.map(pprintDef).mkString("; ")} }"
+            else "{}"
+          s"${normal(utpe)} ${declsStr}"
+        case AnnotatedType(anns, utpe) =>
+          s"${normal(utpe)} ${anns.map(pprint).mkString(" ")}"
+        case ExistentialType(utpe, decls) =>
+          val sdecls = decls.infos.map(pprintDef).mkString("; ")
+          val sutpe = normal(utpe)
+          s"${sutpe} forSome { ${sdecls} }"
+        case UniversalType(tparams, utpe) =>
+          val params = tparams.infos.map(_.displayName).mkString("[", ", ", "]")
+          val resType = normal(utpe)
+          s"${params} => ${resType}"
+        case ByNameType(utpe) =>
+          s"=> ${normal(utpe)}"
+        case RepeatedType(utpe) =>
+          s"${normal(utpe)}*"
+        case MatchType(scrutinee, cases) =>
+          val casesStr = cases.map { caseType =>
+            s"${pprint(caseType.key)} => ${pprint(caseType.body)}"
+          }.mkString(", ")
+          s"${pprint(scrutinee)} match { ${casesStr} }"
+        case x =>
+          "<?>"
+
+      def normal(tpe: Type): String = tpe match
+        case _: SingleType | _: ThisType | _: SuperType =>
+          s"${prefix(tpe)}.type"
+        case _ =>
+          prefix(tpe)
+      normal(tpe)
+    }
+
+    private def pprint(ann: Annotation): String =
+      ann.tpe match {
+        case Type.Empty => s"@<?>"
+        case tpe => s"@${pprint(tpe)}"
+      }
+
+    protected def pprint(const: Constant): String = const match {
+        case Constant.Empty =>
+          "<?>"
+        case UnitConstant() =>
+          "()"
+        case BooleanConstant(true) =>
+          "true"
+        case BooleanConstant(false) =>
+          "false"
+        case ByteConstant(value) =>
+          value.toByte.toString
+        case ShortConstant(value) =>
+          value.toShort.toString
+        case CharConstant(value) =>
+          s"'${value.toChar.toString}'"
+        case IntConstant(value) =>
+          value.toString
+        case LongConstant(value) =>
+          s"${value.toString}L"
+        case FloatConstant(value) =>
+          s"${value.toString}f"
+        case DoubleConstant(value) =>
+          value.toString
+        case StringConstant(value) =>
+          "\"" + value + "\""
+        case NullConstant() =>
+          "null"
+      }
+
+    private def accessString(access: Access): String =
+      access match
+        case Access.Empty => ""
+        case _: PublicAccess => ""
+        case _: PrivateAccess => "private "
+        case _: ProtectedAccess => "protected "
+        case _: PrivateThisAccess => "private[this] "
+        case _: ProtectedThisAccess => "protected[this] "
+        case PrivateWithinAccess(ssym) =>
+          s"private[${ssym}] "
+        case ProtectedWithinAccess(ssym) =>
+          s"protected[${ssym}] "
+    extension (scope: Scope)
+      private def infos: List[SymbolInformation] =
+        if (scope.symlinks.nonEmpty)
+          scope.symlinks.map(symbol => SymbolInformation(symbol = symbol)).toList
+        else
+          scope.hardlinks.toList
+
+    extension (scope: Option[Scope])
+      private def infos: List[SymbolInformation] = scope match {
+        case Some(s) => s.infos
+        case None => Nil
+      }
+  end InfoPrinter
+end SymbolInformationPrinter
+
+extension (info: SymbolInformation)
+  def prefixBeforeTpe: String = {
+    info.kind match {
+      case LOCAL | FIELD | PARAMETER | SELF_PARAMETER | UNKNOWN_KIND | Unrecognized(_) =>
+        ": "
+      case METHOD | CONSTRUCTOR | MACRO | TYPE | TYPE_PARAMETER | OBJECT | PACKAGE |
+          PACKAGE_OBJECT | CLASS | TRAIT | INTERFACE =>
+        " "
+    }
+  }
+
+trait PrinterSymtab:
+  def info(symbol: String): Option[SymbolInformation]
+object PrinterSymtab:
+  def fromTextDocument(doc: TextDocument): PrinterSymtab =
+    val map = doc.symbols.map(info => (info.symbol, info)).toMap
+    new PrinterSymtab {
+      override def info(symbol: String): Option[SymbolInformation] = map.get(symbol)
+    }
+
+def processRange(sb: StringBuilder, range: Range): Unit =
+  sb.append('[')
+    .append(range.startLine).append(':').append(range.startCharacter)
+    .append("..")
+    .append(range.endLine).append(':').append(range.endCharacter)
+    .append("):")
+
+
+
+class SyntheticPrinter(symtab: PrinterSymtab, source: SourceFile) extends SymbolInformationPrinter(symtab):
+
+  def pprint(synth: Synthetic): String =
+    val sb = new StringBuilder()
+    val notes = InfoNotes()
+    val treePrinter = TreePrinter(source, synth.range, notes)
+
+    synth.range match
+      case Some(range) =>
+        processRange(sb, range)
+        sb.append(source.substring(range))
+      case None =>
+        sb.append("[):")
+    sb.append(" => ")
+    sb.append(treePrinter.pprint(synth.tree))
+    sb.toString
+
+  extension (source: SourceFile)
+    private def substring(range: Option[s.Range]): String =
+      range match
+        case Some(range) => source.substring(range)
+        case None => ""
+    private def substring(range: s.Range): String =
+      /** get the line length of a given line */
+      def lineLength(line: Int): Int =
+        val isLastLine = source.lineToOffsetOpt(line).nonEmpty && source.lineToOffsetOpt(line + 1).isEmpty
+        if isLastLine then source.content.length - source.lineToOffset(line) - 1
+        else source.lineToOffset(line + 1) - source.lineToOffset(line) - 1 // -1 for newline char
+
+      val start = source.lineToOffset(range.startLine) +
+        math.min(range.startCharacter, lineLength(range.startLine))
+      val end = source.lineToOffset(range.endLine) +
+        math.min(range.endCharacter, lineLength(range.endLine))
+      new String(source.content, start, end - start)
+
+
+  // def pprint(tree: s.Tree, range: Option[Range]): String =
+  class TreePrinter(source: SourceFile, originalRange: Option[Range], notes: InfoNotes) extends InfoPrinter(notes):
+    def pprint(tree: Tree): String =
+      val sb = new StringBuilder()
+      processTree(tree)(using sb)
+      sb.toString
+
+
+    private def rep[T](xs: Seq[T], seq: String)(f: T => Unit)(using sb: StringBuilder): Unit =
+      xs.zipWithIndex.foreach { (x, i) =>
+        if i != 0 then sb.append(seq)
+        f(x)
+      }
+
+    private def processTree(tree: Tree)(using sb: StringBuilder): Unit =
+      tree match {
+        case tree: ApplyTree =>
+          processTree(tree.function)
+          sb.append("(")
+          rep(tree.arguments, ", ")(processTree)
+          sb.append(")")
+        case tree: FunctionTree =>
+          sb.append("{")
+          sb.append("(")
+          rep(tree.parameters, ", ")(processTree)
+          sb.append(") =>")
+          processTree(tree.body)
+          sb.append("}")
+        case tree: IdTree =>
+          sb.append(pprintRef(tree.symbol))
+        case tree: LiteralTree =>
+          sb.append(pprint(tree.constant))
+        case tree: MacroExpansionTree =>
+          sb.append("(`macro-expandee` : `")
+          sb.append(pprint(tree.tpe))
+          sb.append(")")
+        case tree: OriginalTree =>
+          if (tree.range == originalRange && originalRange.nonEmpty) then
+            sb.append("*")
+          else
+            sb.append("orig(")
+            sb.append(source.substring(tree.range))
+            sb.append(")")
+        case tree: SelectTree =>
+          processTree(tree.qualifier)
+          sb.append(".")
+          tree.id match
+            case Some(tree) => processTree(tree)
+            case None => ()
+        case tree: TypeApplyTree =>
+          processTree(tree.function)
+          sb.append("[")
+          rep(tree.typeArguments, ", ")((t) => sb.append(pprint(t)))
+          sb.append("]")
+
+        case _ =>
+          sb.append("<?>")
+      }
+
+
+end SyntheticPrinter
diff --git a/tests/pos-with-compiler-cc/dotc/semanticdb/Scala3.scala b/tests/pos-with-compiler-cc/dotc/semanticdb/Scala3.scala
new file mode 100644
index 000000000000..e157b52fe260
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/semanticdb/Scala3.scala
@@ -0,0 +1,536 @@
+package dotty.tools.dotc.semanticdb
+
+import dotty.tools.dotc.core
+import core.Symbols.{ Symbol , defn, NoSymbol }
+import core.Contexts._
+import core.Names
+import core.Names.Name
+import core.Types.{Type, TypeBounds}
+import core.Flags._
+import core.NameKinds
+import core.StdNames.nme
+import SymbolInformation.{Kind => k}
+import dotty.tools.dotc.util.SourceFile
+import dotty.tools.dotc.util.Spans.Span
+import dotty.tools.dotc.core.Names.Designator
+
+import java.lang.Character.{isJavaIdentifierPart, isJavaIdentifierStart}
+
+import scala.annotation.internal.sharable
+import scala.annotation.switch
+
+object Scala3:
+  import Symbols._
+  import core.NameOps._
+
+  @sharable private val unicodeEscape = raw"\$$u(\p{XDigit}{4})".r
+  @sharable private val locals        = raw"local(\d+)".r
+  @sharable private val ctor          = raw"[^;].*`<init>`\((?:\+\d+)?\)\.".r
+
+  private val WILDCARDTypeName = nme.WILDCARD.toTypeName
+
+  def range(span: Span, treeSource: SourceFile)(using Context): Option[Range] =
+    def lineCol(offset: Int) = (treeSource.offsetToLine(offset), treeSource.column(offset))
+    val (startLine, startCol) = lineCol(span.start)
+    val (endLine, endCol) = lineCol(span.end)
+    Some(Range(startLine, startCol, endLine, endCol))
+
+  def namePresentInSource(desig: Designator, span: Span, source:SourceFile)(using Context): Boolean =
+    if !span.exists then false
+    else
+      val content = source.content()
+      val (start, end) =
+        if content.lift(span.end - 1).exists(_ == '`') then
+          (span.start + 1, span.end - 1)
+        else (span.start, span.end)
+      val nameInSource = content.slice(start, end).mkString
+      // for secondary constructors `this`
+      desig match
+        case sym: Symbol =>
+          if sym.isConstructor && nameInSource == nme.THISkw.toString then
+            true
+          else
+            val target =
+              if sym.isPackageObject then sym.owner
+              else sym
+            nameInSource == target.name.stripModuleClassSuffix.lastPart.toString
+        case name: Name =>
+          // println(nameInSource)
+          // println(name.mangledString)
+          nameInSource == name.mangledString
+
+  sealed trait FakeSymbol {
+    private[Scala3] var sname: Option[String] = None
+  }
+
+  /** Fake symbol that represents wildcard symbol which will be converted to
+    * semanticdb symbol with
+    * - name: local...
+    * - SymbolInformation with signature TypeSignature of given type bound.
+    */
+  case class WildcardTypeSymbol(owner: Symbol, bounds: TypeBounds) extends FakeSymbol
+
+  case class TermParamRefSymbol(owner: Symbol, name: Name, tp: Type) extends FakeSymbol
+  case class TypeParamRefSymbol(owner: Symbol, name: Name, tp: TypeBounds) extends FakeSymbol
+  case class RefinementSymbol(owner: Symbol, name: Name, tp: Type) extends FakeSymbol
+  type SemanticSymbol = Symbol | FakeSymbol
+
+  given SemanticSymbolOps : AnyRef with
+    extension (sym: SemanticSymbol)
+      def name(using Context): Name = sym match
+        case s: Symbol => s.name
+        case s: WildcardTypeSymbol => nme.WILDCARD
+        case s: TermParamRefSymbol => s.name
+        case s: TypeParamRefSymbol => s.name
+        case s: RefinementSymbol => s.name
+
+      def symbolName(using builder: SemanticSymbolBuilder)(using Context): String =
+        sym match
+          case s: Symbol => builder.symbolName(s)
+          case s: FakeSymbol =>
+            s.sname.getOrElse {
+              val sname = builder.symbolName(s)
+              s.sname = Some(sname)
+              sname
+            }
+
+      def symbolInfo(symkinds: Set[SymbolKind])(using LinkMode, TypeOps, SemanticSymbolBuilder, Context): SymbolInformation =
+        sym match
+          case s: Symbol =>
+            val kind = s.symbolKind(symkinds)
+            val sname = sym.symbolName
+            val signature = s.info.toSemanticSig(s)
+            val symbolAnnotations = s.annotations.collect{
+              case annot if annot.symbol != defn.BodyAnnot && annot.symbol != defn.ChildAnnot =>
+                Annotation(annot.tree.tpe.toSemanticType(annot.symbol))
+            }
+            SymbolInformation(
+              symbol = sname,
+              language = Language.SCALA,
+              kind = kind,
+              properties = s.symbolProps(symkinds),
+              displayName = Symbols.displaySymbol(s),
+              signature = signature,
+              access = s.symbolAccess(kind),
+              overriddenSymbols = s.overriddenSymbols,
+              annotations = symbolAnnotations
+            )
+          case s: WildcardTypeSymbol =>
+            SymbolInformation(
+              symbol = symbolName,
+              language = Language.SCALA,
+              kind = SymbolInformation.Kind.TYPE,
+              displayName = nme.WILDCARD.show,
+              signature = s.bounds.toSemanticSig(s.owner),
+            )
+          case s: TermParamRefSymbol =>
+            SymbolInformation(
+              symbol = symbolName,
+              language = Language.SCALA,
+              kind = SymbolInformation.Kind.PARAMETER,
+              displayName = s.name.show.unescapeUnicode,
+              signature = s.tp.toSemanticSig(s.owner),
+            )
+          case s: TypeParamRefSymbol =>
+            SymbolInformation(
+              symbol = symbolName,
+              language = Language.SCALA,
+              kind = SymbolInformation.Kind.TYPE_PARAMETER,
+              displayName = s.name.show.unescapeUnicode,
+              signature = s.tp.toSemanticSig(s.owner),
+            )
+          case s: RefinementSymbol =>
+            val signature = s.tp.toSemanticSig(s.owner)
+            val kind = signature match
+              case _: TypeSignature => SymbolInformation.Kind.TYPE
+              case _: MethodSignature => SymbolInformation.Kind.METHOD
+              case _: ValueSignature => SymbolInformation.Kind.FIELD
+              case _ => SymbolInformation.Kind.UNKNOWN_KIND
+            SymbolInformation(
+              symbol = symbolName,
+              language = Language.SCALA,
+              kind = kind,
+              displayName = s.name.show.unescapeUnicode,
+              properties =
+                SymbolInformation.Property.ABSTRACT.value,
+              signature = signature,
+            )
+  end SemanticSymbolOps
+
+  enum SymbolKind derives CanEqual:
+    kind =>
+
+    case Val, Var, Setter, Abstract, TypeVal
+
+    def isVar: Boolean = kind match
+      case Var | Setter => true
+      case _            => false
+    def isVal: Boolean = kind == Val
+    def isTypeVal: Boolean = kind == TypeVal
+    def isVarOrVal: Boolean = kind.isVar || kind.isVal
+
+  end SymbolKind
+
+  object SymbolKind:
+    val ValSet   = Set(Val)
+    val VarSet   = Set(Var)
+    val emptySet = Set.empty[SymbolKind]
+  end SymbolKind
+
+  object Symbols:
+
+    val RootPackage: String = "_root_/"
+    val EmptyPackage: String = "_empty_/"
+    val LocalPrefix: String = "local"
+    val PackageObjectDescriptor: String = "package."
+    val s"${RootPackageName @ _}/" = RootPackage: @unchecked
+    val s"${EmptyPackageName @ _}/" = EmptyPackage: @unchecked
+
+    def displaySymbol(symbol: Symbol)(using Context): String =
+      if symbol.isPackageObject then
+        displaySymbol(symbol.owner)
+      else if symbol.is(ModuleClass) then
+        displaySymbol(symbol.sourceModule)
+      else if symbol == defn.RootPackage then
+        RootPackageName
+      else if symbol.isEmptyPackage then
+        EmptyPackageName
+      else
+        symbol.name.show
+
+  end Symbols
+
+
+  given NameOps: AnyRef with
+    extension (name: Name)
+      def isWildcard = name match
+        case nme.WILDCARD | WILDCARDTypeName => true
+        case _                               => name.is(NameKinds.WildcardParamName)
+
+      def isScala2PackageObjectName: Boolean = name match
+        case name: Names.TermName => name == nme.PACKAGE
+        case name: Names.TypeName =>
+          name.toTermName match
+          case NameKinds.ModuleClassName(original) => original.isScala2PackageObjectName
+          case _                                   => false
+
+      def isEmptyNumbered: Boolean =
+        !name.is(NameKinds.WildcardParamName)
+        && !name.is(NameKinds.EvidenceParamName)
+        && { name match
+          case NameKinds.AnyNumberedName(nme.EMPTY, _) => true
+          case _                                       => false
+        }
+
+      def isDynamic(using Context): Boolean =
+        name == nme.applyDynamic ||
+        name == nme.selectDynamic ||
+        name == nme.updateDynamic ||
+        name == nme.applyDynamicNamed
+  end NameOps
+
+  given SymbolOps: AnyRef with
+    extension (sym: Symbol)
+
+      def ifExists(using Context): Option[Symbol] = if sym.exists then Some(sym) else None
+
+      def isScala2PackageObject(using Context): Boolean =
+        sym.name.isScala2PackageObjectName && sym.owner.is(Package) && sym.is(Module)
+
+      def isAnonymous(using Context): Boolean =
+        sym.isAnonymousClass
+        || sym.isAnonymousModuleVal
+        || sym.isAnonymousFunction
+
+      def matchingSetter(using Context): Symbol =
+
+        val setterName = sym.name.toTermName.setterName
+
+        extension (t: Type) inline def matchingType = t.paramInfoss match
+          case (arg::Nil)::Nil => t.resultType == defn.UnitType && arg == sym.info
+          case _               => false
+
+        sym.owner.info.decls.find(s => s.name == setterName && s.info.matchingType)
+
+      /** Is symbol global? Non-global symbols get localN names */
+      def isGlobal(using Context): Boolean =
+        sym.exists && (
+          sym.is(Package)
+          || !sym.isSelfSym && (sym.is(Param) || sym.owner.isClass) && sym.owner.isGlobal
+        )
+
+      def isLocalWithinSameName(using Context): Boolean =
+        sym.exists && !sym.isGlobal && sym.name == sym.owner.name
+
+      /** Synthetic symbols that are not anonymous or numbered empty ident */
+      def isSyntheticWithIdent(using Context): Boolean =
+        sym.is(Synthetic) && !sym.isAnonymous && !sym.name.isEmptyNumbered
+
+      /** The semanticdb name of the given symbol */
+      def symbolName(using builder: SemanticSymbolBuilder)(using Context): String =
+        builder.symbolName(sym)
+
+      def funParamSymbol(using builder: SemanticSymbolBuilder)(using Context): Name => String =
+        builder.funParamSymbol(sym)
+
+      def symbolKind(symkinds: Set[SymbolKind])(using Context): SymbolInformation.Kind =
+        if sym.isTypeParam then
+          SymbolInformation.Kind.TYPE_PARAMETER
+        else if sym.is(TermParam) then
+          SymbolInformation.Kind.PARAMETER
+        else if sym.isTerm && sym.owner.isTerm then
+          SymbolInformation.Kind.LOCAL
+        else if sym.isInlineMethod || sym.is(Macro) then
+          SymbolInformation.Kind.MACRO
+        else if sym.isConstructor then
+          SymbolInformation.Kind.CONSTRUCTOR
+        else if sym.isSelfSym then
+          SymbolInformation.Kind.SELF_PARAMETER
+        else if sym.isOneOf(Method) || symkinds.exists(_.isVarOrVal) then
+          SymbolInformation.Kind.METHOD
+        else if sym.isPackageObject then
+          SymbolInformation.Kind.PACKAGE_OBJECT
+        else if sym.is(Module) then
+          SymbolInformation.Kind.OBJECT
+        else if sym.is(Package) then
+          SymbolInformation.Kind.PACKAGE
+        else if sym.isAllOf(JavaInterface) then
+          SymbolInformation.Kind.INTERFACE
+        else if sym.is(Trait) then
+          SymbolInformation.Kind.TRAIT
+        else if sym.isClass then
+          SymbolInformation.Kind.CLASS
+        else if sym.isType then
+          SymbolInformation.Kind.TYPE
+        else if sym.is(ParamAccessor) then
+          SymbolInformation.Kind.FIELD
+        else
+          SymbolInformation.Kind.UNKNOWN_KIND
+
+      def symbolProps(symkinds: Set[SymbolKind])(using Context): Int =
+        if sym.is(ModuleClass) then
+          return sym.sourceModule.symbolProps(symkinds)
+        var props = 0
+        if sym.isPrimaryConstructor then
+          props |= SymbolInformation.Property.PRIMARY.value
+        if sym.is(Abstract) || symkinds.contains(SymbolKind.Abstract) then
+          props |= SymbolInformation.Property.ABSTRACT.value
+        if sym.is(Final) then
+          props |= SymbolInformation.Property.FINAL.value
+        if sym.is(Sealed) then
+          props |= SymbolInformation.Property.SEALED.value
+        if sym.isOneOf(GivenOrImplicit) then
+          props |= SymbolInformation.Property.IMPLICIT.value
+        if sym.is(Lazy, butNot=Module) then
+          props |= SymbolInformation.Property.LAZY.value
+        if sym.isAllOf(Case | Module) ||
+          (sym.is(CaseClass) && !symkinds.exists(_.isTypeVal)) || // `t` of `case List[t] =>` (which has `CaseClass` flag) shouldn't be `CASE`
+          sym.isAllOf(EnumCase) then
+          props |= SymbolInformation.Property.CASE.value
+        if sym.is(Covariant) then
+          props |= SymbolInformation.Property.COVARIANT.value
+        if sym.is(Contravariant) then
+          props |= SymbolInformation.Property.CONTRAVARIANT.value
+        if sym.isAllOf(DefaultMethod | JavaDefined) || sym.is(Accessor) && sym.name.is(NameKinds.DefaultGetterName) then
+          props |= SymbolInformation.Property.DEFAULT.value
+        if symkinds.exists(_.isVal) then
+          props |= SymbolInformation.Property.VAL.value
+        if symkinds.exists(_.isVar) then
+          props |= SymbolInformation.Property.VAR.value
+        if sym.is(JavaStatic) then
+          props |= SymbolInformation.Property.STATIC.value
+        if sym.is(Enum) then
+          props |= SymbolInformation.Property.ENUM.value
+        if sym.is(Given) then
+          props |= SymbolInformation.Property.GIVEN.value
+        if sym.is(Inline) then
+          props |= SymbolInformation.Property.INLINE.value
+        if sym.is(Open) then
+          props |= SymbolInformation.Property.OPEN.value
+        if sym.is(Open) then
+          props |= SymbolInformation.Property.OPEN.value
+        if sym.is(Transparent) then
+          props |= SymbolInformation.Property.TRANSPARENT.value
+        if sym.is(Infix) then
+          props |= SymbolInformation.Property.INFIX.value
+        if sym.is(Opaque) then
+          props |= SymbolInformation.Property.OPAQUE.value
+        props
+
+      def symbolAccess(kind: SymbolInformation.Kind)(using Context, SemanticSymbolBuilder): Access =
+        kind match
+          case k.LOCAL | k.PARAMETER | k.SELF_PARAMETER | k.TYPE_PARAMETER | k.PACKAGE | k.PACKAGE_OBJECT =>
+            Access.Empty
+          case _ =>
+            if (sym.privateWithin == NoSymbol)
+              if (sym.isAllOf(PrivateLocal)) PrivateThisAccess()
+              else if (sym.is(Private)) PrivateAccess()
+              else if (sym.isAllOf(ProtectedLocal)) ProtectedThisAccess()
+              else if (sym.is(Protected)) ProtectedAccess()
+              else PublicAccess()
+            else
+              val ssym = sym.privateWithin.symbolName
+              if (sym.is(Protected)) ProtectedWithinAccess(ssym)
+              else PrivateWithinAccess(ssym)
+
+      def overriddenSymbols(using Context, SemanticSymbolBuilder): List[String] =
+        sym.allOverriddenSymbols.map(_.symbolName).toList
+  end SymbolOps
+
+  object LocalSymbol:
+
+    def unapply(symbolInfo: SymbolInformation): Option[Int] = symbolInfo.symbol match
+      case locals(ints) =>
+        val bi = BigInt(ints)
+        if bi.isValidInt then
+          Some(bi.toInt)
+        else
+          None
+
+      case _ => None
+
+  end LocalSymbol
+
+  extension (char: Char)
+    private inline def isGlobalTerminal = (char: @switch) match
+      case '/' | '.' | '#' | ']' | ')' => true
+      case _                           => false
+
+  given StringOps: AnyRef with
+    extension (symbol: String)
+      def isSymbol: Boolean = !symbol.isEmpty
+      def isRootPackage: Boolean = RootPackage == symbol
+      def isEmptyPackage: Boolean = EmptyPackage == symbol
+
+      def isGlobal: Boolean = !symbol.isEmpty && !symbol.isMulti && symbol.last.isGlobalTerminal
+      def isLocal: Boolean = !symbol.isEmpty && !symbol.isMulti && !symbol.last.isGlobalTerminal
+      def isMulti: Boolean = symbol startsWith ";"
+
+      def isConstructor: Boolean = ctor matches symbol
+      def isPackage: Boolean = !symbol.isEmpty && !symbol.isMulti && symbol.last == '/'
+      def isTerm: Boolean = !symbol.isEmpty && !symbol.isMulti && symbol.last == '.'
+      def isType: Boolean = !symbol.isEmpty && !symbol.isMulti && symbol.last == '#'
+      def isTypeParameter: Boolean = !symbol.isEmpty && !symbol.isMulti && symbol.last == ']'
+      def isParameter: Boolean = !symbol.isEmpty && !symbol.isMulti && symbol.last == ')'
+
+      def desc: Descriptor =
+        if isGlobal then DescriptorParser(symbol)._1
+        else Descriptor.None
+
+      def unescapeUnicode =
+        unicodeEscape.replaceAllIn(symbol, m => String.valueOf(Integer.parseInt(m.group(1), 16).toChar).nn)
+
+      def isJavaIdent =
+        symbol.nonEmpty && isJavaIdentifierStart(symbol.head) && symbol.tail.forall(isJavaIdentifierPart)
+  end StringOps
+
+  given InfoOps: AnyRef with
+    extension (info: SymbolInformation)
+      def isAbstract: Boolean = (info.properties & SymbolInformation.Property.ABSTRACT.value) != 0
+      def isFinal: Boolean = (info.properties & SymbolInformation.Property.FINAL.value) != 0
+      def isSealed: Boolean = (info.properties & SymbolInformation.Property.SEALED.value) != 0
+      def isImplicit: Boolean = (info.properties & SymbolInformation.Property.IMPLICIT.value) != 0
+      def isLazy: Boolean = (info.properties & SymbolInformation.Property.LAZY.value) != 0
+      def isCase: Boolean = (info.properties & SymbolInformation.Property.CASE.value) != 0
+      def isCovariant: Boolean = (info.properties & SymbolInformation.Property.COVARIANT.value) != 0
+      def isContravariant: Boolean = (info.properties & SymbolInformation.Property.CONTRAVARIANT.value) != 0
+      def isPrimary: Boolean = (info.properties & SymbolInformation.Property.PRIMARY.value) != 0
+      def isVal: Boolean = (info.properties & SymbolInformation.Property.VAL.value) != 0
+      def isVar: Boolean = (info.properties & SymbolInformation.Property.VAR.value) != 0
+      def isStatic: Boolean = (info.properties & SymbolInformation.Property.STATIC.value) != 0
+      def isEnum: Boolean = (info.properties & SymbolInformation.Property.ENUM.value) != 0
+      def isDefault: Boolean = (info.properties & SymbolInformation.Property.DEFAULT.value) != 0
+      def isGiven: Boolean = (info.properties & SymbolInformation.Property.GIVEN.value) != 0
+      def isInline: Boolean = (info.properties & SymbolInformation.Property.INLINE.value) != 0
+      def isOpen: Boolean = (info.properties & SymbolInformation.Property.OPEN.value) != 0
+      def isTransparent: Boolean = (info.properties & SymbolInformation.Property.TRANSPARENT.value) != 0
+      def isInfix: Boolean = (info.properties & SymbolInformation.Property.INFIX.value) != 0
+      def isOpaque: Boolean = (info.properties & SymbolInformation.Property.OPAQUE.value) != 0
+
+      def isUnknownKind: Boolean = info.kind.isUnknownKind
+      def isLocal: Boolean = info.kind.isLocal
+      def isField: Boolean = info.kind.isField
+      def isMethod: Boolean = info.kind.isMethod
+      def isConstructor: Boolean = info.kind.isConstructor
+      def isMacro: Boolean = info.kind.isMacro
+      def isType: Boolean = info.kind.isType
+      def isParameter: Boolean = info.kind.isParameter
+      def isSelfParameter: Boolean = info.kind.isSelfParameter
+      def isTypeParameter: Boolean = info.kind.isTypeParameter
+      def isObject: Boolean = info.kind.isObject
+      def isPackage: Boolean = info.kind.isPackage
+      def isPackageObject: Boolean = info.kind.isPackageObject
+      def isClass: Boolean = info.kind.isClass
+      def isTrait: Boolean = info.kind.isTrait
+      def isInterface: Boolean = info.kind.isInterface
+  end InfoOps
+
+  given RangeOps: AnyRef with
+    extension (range: Range)
+      def hasLength = range.endLine > range.startLine || range.endCharacter > range.startCharacter
+  end RangeOps
+
+  private def compareRange(x: Option[Range], y: Option[Range]): Int = x -> y match
+    case None -> _ | _ -> None => 0
+    case Some(a) -> Some(b) =>
+      val byLine = Integer.compare(a.startLine, b.startLine)
+      if (byLine != 0)
+        byLine
+      else // byCharacter
+        Integer.compare(a.startCharacter, b.startCharacter)
+
+  /** Sort symbol occurrences by their start position. */
+  given Ordering[SymbolOccurrence] = (x, y) => compareRange(x.range, y.range)
+
+  given Ordering[SymbolInformation] = Ordering.by[SymbolInformation, String](_.symbol)(IdentifierOrdering())
+
+  given Ordering[Synthetic] = (x, y) => compareRange(x.range, y.range)
+
+  /**
+    * A comparator for identifier like "Predef" or "Function10".
+    *
+    * Differences from the default string comparator:
+    * - works with CharSequences like compiler `Name`
+    * - orders numbers by their numerical value instead of lexicographical
+    *   - Good: `Function1`, `Function2`,  `Function10`
+    *   - Bad:  `Function1`, `Function10`, `Function2`
+    *
+    * taken from https://github.com/scalameta/scalameta/blob/master/semanticdb/metap/src/main/scala/scala/meta/internal/metap/IdentifierOrdering.scala
+    */
+  private class IdentifierOrdering[T <: CharSequence] extends Ordering[T]:
+
+    override def compare(o1: T, o2: T): Int =
+      val len = math.min(o1.length(), o2.length())
+      var i = 0
+      while i < len do
+        val a = o1.charAt(i)
+        val b = o2.charAt(i)
+        if a.isDigit && b.isDigit then
+          val byDigit = Integer.compare(toDigit(o1, i), toDigit(o2, i))
+          if (byDigit != 0) return byDigit
+          else
+            i = seekNonDigit(o1, i)
+        else
+          val result = Character.compare(a, b)
+          if result != 0 then
+            return result
+          i += 1
+      end while
+      Integer.compare(o1.length(), o2.length())
+    end compare
+
+    private def seekNonDigit(cs: T, i: Int): Int =
+      var curr = i
+      while curr < cs.length && cs.charAt(curr).isDigit do
+        curr += 1
+      curr
+    end seekNonDigit
+
+    private def toDigit(cs: T, i: Int): Int =
+      val digit = cs.subSequence(i, seekNonDigit(cs, i))
+      Integer.parseUnsignedInt(digit.toString)
+    end toDigit
+
+  end IdentifierOrdering
+
+end Scala3
diff --git a/tests/pos-with-compiler-cc/dotc/semanticdb/SemanticSymbolBuilder.scala b/tests/pos-with-compiler-cc/dotc/semanticdb/SemanticSymbolBuilder.scala
new file mode 100644
index 000000000000..c825032373f8
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/semanticdb/SemanticSymbolBuilder.scala
@@ -0,0 +1,150 @@
+package dotty.tools
+package dotc
+package semanticdb
+
+import core._
+import Contexts._
+import Symbols._
+import Flags._
+import Names.Name
+
+import scala.annotation.tailrec
+import scala.collection.mutable
+
+class SemanticSymbolBuilder:
+  import Scala3.{_, given}
+
+  private var nextLocalIdx: Int = 0
+
+  /** The index of a local symbol */
+  private val locals = mutable.HashMap[Symbol, Int]()
+
+  /** The local symbol(s) starting at given offset */
+  private val symsAtOffset = new mutable.HashMap[Int, Set[Symbol]]():
+    override def default(key: Int) = Set[Symbol]()
+
+
+  def symbolName(sym: Symbol)(using Context): String =
+    val b = StringBuilder(20)
+    addSymName(b, sym)
+    b.toString
+  def symbolName(sym: FakeSymbol)(using Context): String =
+    sym match
+      case sym: WildcardTypeSymbol =>
+        val b = StringBuilder(20)
+        addSymName(b, sym.owner)
+        b.append('['); addName(b, sym.name); b.append(']')
+        b.toString
+      case sym: TermParamRefSymbol =>
+        val b = StringBuilder(20)
+        addSymName(b, sym.owner)
+        b.append('('); addName(b, sym.name); b.append(')')
+        b.toString
+      case sym: TypeParamRefSymbol =>
+        val b = StringBuilder(20)
+        addSymName(b, sym.owner)
+        b.append('['); addName(b, sym.name); b.append(']')
+        b.toString
+      case sym: RefinementSymbol =>
+        val b = StringBuilder(20)
+        addLocalSymName(b)
+        b.toString
+
+  def funParamSymbol(sym: Symbol)(using Context): Name => String =
+    if sym.isGlobal then
+      val funSymbol = symbolName(sym)
+      name => s"$funSymbol($name)"
+    else
+      name => locals.keys.find(local => local.isTerm && local.owner == sym && local.name == name)
+                    .fold("<?>")(Symbols.LocalPrefix + locals(_))
+
+  private def addName(b: StringBuilder, name: Name): Unit =
+    val str = name.toString.unescapeUnicode
+    if str.isJavaIdent then b append str
+    else b append '`' append str append '`'
+
+  private def addLocalSymName(b: StringBuilder): Unit =
+    val idx = nextLocalIdx
+    nextLocalIdx += 1
+    b.append(Symbols.LocalPrefix).append(idx)
+
+  /** Add semanticdb name of the given symbol to string builder */
+  private def addSymName(b: StringBuilder, sym: Symbol)(using Context): Unit =
+
+    def addOwner(owner: Symbol): Unit =
+      if !owner.isRoot then addSymName(b, owner)
+
+    def addOverloadIdx(sym: Symbol): Unit =
+      val decls =
+        val decls0 = sym.owner.info.decls.lookupAll(sym.name)
+        if sym.owner.isAllOf(JavaModule) then
+          decls0 ++ sym.owner.companionClass.info.decls.lookupAll(sym.name)
+        else
+          decls0
+      end decls
+      val alts = decls.filter(_.isOneOf(Method | Mutable)).toList.reverse
+      def find(filter: Symbol => Boolean) = alts match
+        case notSym :: rest if !filter(notSym) =>
+          val idx = rest.indexWhere(filter).ensuring(_ >= 0)
+          b.append('+').append(idx + 1)
+        case _ =>
+      end find
+      val sig = sym.signature
+      find(_.signature == sig)
+
+    def addDescriptor(sym: Symbol): Unit =
+      if sym.is(ModuleClass) then
+        addDescriptor(sym.sourceModule)
+      else if sym.is(TypeParam) then
+        b.append('['); addName(b, sym.name); b.append(']')
+      else if sym.is(Param) then
+        b.append('('); addName(b, sym.name); b.append(')')
+      else if sym.isRoot then
+        b.append(Symbols.RootPackage)
+      else if sym.isEmptyPackage then
+        b.append(Symbols.EmptyPackage)
+      else if (sym.isScala2PackageObject) then
+        b.append(Symbols.PackageObjectDescriptor)
+      else
+        addName(b, sym.name)
+        if sym.is(Package) then b.append('/')
+        else if sym.isType || sym.isAllOf(JavaModule) then b.append('#')
+        else if sym.isOneOf(Method | Mutable)
+        && (!sym.is(StableRealizable) || sym.isConstructor) then
+          b.append('('); addOverloadIdx(sym); b.append(").")
+        else b.append('.')
+
+    /** The index of local symbol `sym`. Symbols with the same name and
+     *  the same starting position have the same index.
+     */
+    def localIdx(sym: Symbol)(using Context): Int =
+      val startPos =
+        // assert(sym.span.exists, s"$sym should have a span")
+        if (sym.span.exists) Some(sym.span.start) else None
+      @tailrec
+      def computeLocalIdx(sym: Symbol): Int = locals get sym match
+        case Some(idx) => idx
+        case None =>
+          (for {
+            pos <- startPos
+            syms <- symsAtOffset.get(pos)
+            found <- syms.find(_.name == sym.name)
+          } yield found) match
+            case Some(other) => computeLocalIdx(other)
+            case None =>
+              val idx = nextLocalIdx
+              nextLocalIdx += 1
+              locals(sym) = idx
+              startPos.foreach(pos => symsAtOffset(pos) += sym)
+              idx
+      end computeLocalIdx
+      computeLocalIdx(sym)
+    end localIdx
+
+    if sym.exists then
+      if sym.isGlobal then
+        addOwner(sym.owner); addDescriptor(sym)
+      else
+        b.append(Symbols.LocalPrefix).append(localIdx(sym))
+
+  end addSymName
diff --git a/tests/pos-with-compiler-cc/dotc/semanticdb/SyntheticsExtractor.scala b/tests/pos-with-compiler-cc/dotc/semanticdb/SyntheticsExtractor.scala
new file mode 100644
index 000000000000..50765a172ffd
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/semanticdb/SyntheticsExtractor.scala
@@ -0,0 +1,151 @@
+package dotty.tools.dotc.semanticdb
+
+import dotty.tools.dotc.ast.tpd._
+import dotty.tools.dotc.core.Contexts._
+import dotty.tools.dotc.core.Flags._
+import dotty.tools.dotc.core.StdNames.nme
+import dotty.tools.dotc.core.NameKinds
+import dotty.tools.dotc.{semanticdb => s}
+
+
+class SyntheticsExtractor:
+  import Scala3.{_, given}
+
+  val visited: collection.mutable.HashSet[Tree] = collection.mutable.HashSet()
+
+  def tryFindSynthetic(tree: Tree)(using Context, SemanticSymbolBuilder, TypeOps): Option[s.Synthetic] =
+    extension (synth: s.Synthetic)
+      def toOpt: Some[s.Synthetic] = Some(synth)
+
+    val forSynthetic = tree match // not yet supported (for synthetics)
+      case tree: Apply if isForSynthetic(tree) => true
+      case tree: TypeApply if isForSynthetic(tree) => true
+      case _ => false
+
+    if visited.contains(tree) || forSynthetic then None
+    else
+      tree match
+        case tree: TypeApply
+          if tree.span.isSynthetic &&
+            tree.args.forall(arg => !arg.symbol.isDefinedInSource) &&
+            !tree.span.isZeroExtent &&
+            (tree.fun match {
+              // for `Bar[Int]` of `class Foo extends Bar[Int]`
+              // we'll have `TypeTree(Select(New(AppliedTypeTree(...))), List(Int))`
+              // in this case, don't register `*[Int]` to synthetics as we already have `[Int]` in source.
+              case Select(New(AppliedTypeTree(_, _)), _) => false
+
+              // for `new SomeJavaClass[Int]()`
+              // there will be a synthesized default getter
+              // in addition to the source derived one.
+              case Select(_, name) if name.is(NameKinds.DefaultGetterName) => false
+              case Select(fun, _) if fun.symbol.name.isDynamic => false
+              case _ => true
+            }) =>
+          visited.add(tree)
+          val fnTree = tree.fun match
+            // Something like `List.apply[Int](1,2,3)`
+            case select @ Select(qual, _) if isSyntheticName(select) =>
+              s.SelectTree(
+                s.OriginalTree(range(qual.span, tree.source)),
+                Some(select.toSemanticId)
+              )
+            case _ =>
+              s.OriginalTree(
+                range(tree.fun.span, tree.source)
+              )
+          val targs = tree.args.map(targ => targ.tpe.toSemanticType(targ.symbol)(using LinkMode.SymlinkChildren))
+          s.Synthetic(
+            range(tree.span, tree.source),
+            s.TypeApplyTree(
+              fnTree, targs
+            )
+          ).toOpt
+
+        case tree: Apply
+          if tree.args.nonEmpty &&
+            tree.args.forall(arg =>
+              arg.symbol.isOneOf(GivenOrImplicit) &&
+              arg.span.isSynthetic
+            ) =>
+          s.Synthetic(
+            range(tree.span, tree.source),
+            s.ApplyTree(
+              tree.fun.toSemanticOriginal,
+              tree.args.map(_.toSemanticTree)
+            )
+          ).toOpt
+
+        case tree: Apply if tree.fun.symbol.is(Implicit) =>
+          val pos = range(tree.span, tree.source)
+          s.Synthetic(
+            pos,
+            s.ApplyTree(
+              tree.fun.toSemanticTree,
+              arguments = List(
+                s.OriginalTree(pos)
+              )
+            )
+          ).toOpt
+
+        case _ => None
+
+  private given TreeOps: AnyRef with
+    extension (tree: Tree)
+      def toSemanticTree(using Context, SemanticSymbolBuilder, TypeOps): s.Tree =
+        tree match
+          case tree: Apply =>
+            s.ApplyTree(
+              tree.fun.toSemanticQualifierTree,
+              tree.args.map(_.toSemanticTree)
+            )
+          case tree: TypeApply =>
+            s.TypeApplyTree(
+              tree.fun.toSemanticQualifierTree,
+              tree.args.map { targ =>
+                targ.tpe.toSemanticType(targ.symbol)(using LinkMode.SymlinkChildren)
+              }
+            )
+          case tree: Ident => tree.toSemanticId
+          case tree: Select => tree.toSemanticId
+          case _ => s.Tree.defaultInstance
+
+      def toSemanticQualifierTree(using Context, SemanticSymbolBuilder): s.Tree = tree match
+        case sel @ Select(qual, _) if sel.symbol.owner != qual.symbol =>
+          s.SelectTree(qual.toSemanticId, Some(sel.toSemanticId))
+        case fun => fun.toSemanticId
+
+      def toSemanticId(using Context, SemanticSymbolBuilder) =
+        s.IdTree(tree.symbol.symbolName)
+
+      def toSemanticOriginal(using Context) =
+        s.OriginalTree(range(tree.span, tree.source))
+  end TreeOps
+
+
+  private def isForSynthetic(tree: Tree): Boolean =
+    def isForComprehensionSyntheticName(select: Select): Boolean =
+      select.span.toSynthetic == select.qualifier.span.toSynthetic && (
+        select.name == nme.map ||
+        select.name == nme.flatMap ||
+        select.name == nme.withFilter ||
+        select.name == nme.foreach
+      )
+    tree match
+      case Apply(fun, _) => isForSynthetic(fun)
+      case TypeApply(fun, _) => isForSynthetic(fun)
+      case select: Select => isForComprehensionSyntheticName(select)
+      case _ => false
+
+  private def isSyntheticName(select: Select): Boolean =
+    select.span.toSynthetic == select.qualifier.span.toSynthetic && (
+      select.name == nme.apply ||
+      select.name == nme.update ||
+      select.name == nme.foreach ||
+      select.name == nme.withFilter ||
+      select.name == nme.flatMap ||
+      select.name == nme.map ||
+      select.name == nme.unapplySeq ||
+      select.name == nme.unapply)
+
+end SyntheticsExtractor
diff --git a/tests/pos-with-compiler-cc/dotc/semanticdb/Tools.scala b/tests/pos-with-compiler-cc/dotc/semanticdb/Tools.scala
new file mode 100644
index 000000000000..d37973237a9f
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/semanticdb/Tools.scala
@@ -0,0 +1,130 @@
+package dotty.tools.dotc.semanticdb
+
+import java.nio.file._
+import java.nio.charset.StandardCharsets
+import scala.jdk.CollectionConverters._
+import dotty.tools.dotc.util.SourceFile
+import dotty.tools.dotc.semanticdb.Scala3.given
+
+object Tools:
+
+  /** Converts a Path to a String that is URI encoded, without forcing absolute paths. */
+  def mkURIstring(path: Path): String =
+    // Calling `.toUri` on a relative path will convert it to absolute. Iteration through its parts instead preserves
+    // the resulting URI as relative.
+    // To prevent colon `:` from being treated as a scheme separator, prepend a slash `/` to each part to trick the URI
+    // parser into treating it as an absolute path, and then strip the spurious leading slash from the final result.
+    val uriParts = for part <- path.asScala yield new java.net.URI(null, null, "/" + part.toString, null)
+    uriParts.mkString.stripPrefix("/")
+
+  /** Load SemanticDB TextDocument for a single Scala source file
+   *
+   * @param scalaAbsolutePath Absolute path to a Scala source file.
+   * @param scalaRelativePath scalaAbsolutePath relativized by the sourceroot.
+   * @param semanticdbAbsolutePath Absolute path to the SemanticDB file.
+   */
+  def loadTextDocument(
+    scalaAbsolutePath: Path,
+    scalaRelativePath: Path,
+    semanticdbAbsolutePath: Path
+  ): TextDocument =
+    val reluri  = mkURIstring(scalaRelativePath)
+    val sdocs = parseTextDocuments(semanticdbAbsolutePath)
+    sdocs.documents.find(_.uri == reluri) match
+    case None => throw new NoSuchElementException(s"$scalaRelativePath")
+    case Some(document) =>
+      val text = new String(Files.readAllBytes(scalaAbsolutePath), StandardCharsets.UTF_8)
+      // Assert the SemanticDB payload is in-sync with the contents of the Scala file on disk.
+      val md5FingerprintOnDisk = internal.MD5.compute(text)
+      if document.md5 != md5FingerprintOnDisk then
+        throw new IllegalArgumentException(s"stale semanticdb: $scalaRelativePath")
+      else
+        // Update text document to include full text contents of the file.
+        document.copy(text = text)
+  end loadTextDocument
+
+  def loadTextDocumentUnsafe(scalaAbsolutePath: Path, semanticdbAbsolutePath: Path): TextDocument =
+    val docs = parseTextDocuments(semanticdbAbsolutePath).documents
+    assert(docs.length == 1)
+    docs.head.copy(text = new String(Files.readAllBytes(scalaAbsolutePath), StandardCharsets.UTF_8))
+
+  /** Parses SemanticDB text documents from an absolute path to a `*.semanticdb` file. */
+  private def parseTextDocuments(path: Path): TextDocuments =
+    val bytes = Files.readAllBytes(path).nn // NOTE: a semanticdb file is a TextDocuments message, not TextDocument
+    TextDocuments.parseFrom(bytes)
+
+  def metac(doc: TextDocument, realPath: Path)(using sb: StringBuilder): StringBuilder =
+    val symtab = PrinterSymtab.fromTextDocument(doc)
+    val symPrinter = SymbolInformationPrinter(symtab)
+    val realURI = realPath.toString
+    given sourceFile: SourceFile = SourceFile.virtual(doc.uri, doc.text)
+    val synthPrinter = SyntheticPrinter(symtab, sourceFile)
+    sb.append(realURI).nl
+    sb.append("-" * realURI.length).nl
+    sb.nl
+    sb.append("Summary:").nl
+    sb.append("Schema => ").append(schemaString(doc.schema)).nl
+    sb.append("Uri => ").append(doc.uri).nl
+    sb.append("Text => empty").nl
+    sb.append("Language => ").append(languageString(doc.language)).nl
+    sb.append("Symbols => ").append(doc.symbols.length).append(" entries").nl
+    sb.append("Occurrences => ").append(doc.occurrences.length).append(" entries").nl
+    if doc.synthetics.nonEmpty then
+      sb.append("Synthetics => ").append(doc.synthetics.length).append(" entries").nl
+    sb.nl
+    sb.append("Symbols:").nl
+    doc.symbols.sorted.foreach(s => processSymbol(s, symPrinter))
+    sb.nl
+    sb.append("Occurrences:").nl
+    doc.occurrences.sorted.foreach(processOccurrence)
+    sb.nl
+    if doc.synthetics.nonEmpty then
+      sb.append("Synthetics:").nl
+      doc.synthetics.sorted.foreach(s => processSynth(s, synthPrinter))
+      sb.nl
+    sb
+  end metac
+
+  private def schemaString(schema: Schema) =
+    import Schema._
+    schema match
+    case SEMANTICDB3     => "SemanticDB v3"
+    case SEMANTICDB4     => "SemanticDB v4"
+    case LEGACY          => "SemanticDB legacy"
+    case Unrecognized(_) => "unknown"
+  end schemaString
+
+  private def languageString(language: Language) =
+    import Language._
+    language match
+    case SCALA                              => "Scala"
+    case JAVA                               => "Java"
+    case UNKNOWN_LANGUAGE | Unrecognized(_) => "unknown"
+  end languageString
+
+  private def processSymbol(info: SymbolInformation, printer: SymbolInformationPrinter)(using sb: StringBuilder): Unit =
+    sb.append(printer.pprintSymbolInformation(info)).nl
+
+  private def processSynth(synth: Synthetic, printer: SyntheticPrinter)(using sb: StringBuilder): Unit =
+    sb.append(printer.pprint(synth)).nl
+
+  private def processOccurrence(occ: SymbolOccurrence)(using sb: StringBuilder, sourceFile: SourceFile): Unit =
+    occ.range match
+    case Some(range) =>
+      processRange(sb, range)
+      if range.endLine == range.startLine
+      && range.startCharacter != range.endCharacter
+      && !(occ.symbol.isConstructor && occ.role.isDefinition) then
+        val line = sourceFile.lineContent(sourceFile.lineToOffset(range.startLine))
+        assert(range.startCharacter <= line.length && range.endCharacter <= line.length,
+          s"Line is only ${line.length} - start line was ${range.startLine} in source ${sourceFile.name}"
+        )
+        sb.append(" ").append(line.substring(range.startCharacter, range.endCharacter))
+    case _ =>
+      sb.append("[):")
+    end match
+    sb.append(if occ.role.isReference then " -> " else " <- ").append(occ.symbol).nl
+  end processOccurrence
+
+  extension (sb: StringBuilder)
+    private inline def nl = sb.append(System.lineSeparator)
diff --git a/tests/pos-with-compiler-cc/dotc/semanticdb/TypeOps.scala b/tests/pos-with-compiler-cc/dotc/semanticdb/TypeOps.scala
new file mode 100644
index 000000000000..0ccaab48889a
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/semanticdb/TypeOps.scala
@@ -0,0 +1,526 @@
+package dotty.tools
+package dotc
+package semanticdb
+
+import core.Symbols._
+import core.Contexts.Context
+import core.Types._
+import core.Annotations.Annotation
+import core.Flags
+import core.Names.Name
+import core.StdNames.tpnme
+import scala.util.chaining.scalaUtilChainingOps
+
+import collection.mutable
+
+import dotty.tools.dotc.{semanticdb => s}
+import Scala3.{FakeSymbol, SemanticSymbol, WildcardTypeSymbol, TypeParamRefSymbol, TermParamRefSymbol, RefinementSymbol}
+import dotty.tools.dotc.core.Names.Designator
+
+class TypeOps:
+  import SymbolScopeOps._
+  import Scala3.given
+  private val paramRefSymtab = mutable.Map[(LambdaType, Name), Symbol]()
+  private val refinementSymtab = mutable.Map[(RefinedType, Name), Symbol]()
+
+  // save generated fake symbols so we can insert them into symbols section of SemanticDB
+  val fakeSymbols = mutable.Set[FakeSymbol]()
+  given typeOps: TypeOps = this
+
+  extension [T <: LambdaType | RefinedType](symtab: mutable.Map[(T, Name), Symbol])
+    private def lookup(
+      binder: T,
+      name: Name,
+    )(using Context): Option[Symbol] =
+      symtab.get((binder, name))
+
+  extension [T <: LambdaType | RefinedType](symtab: mutable.Map[(T, Name), Symbol])
+    private def lookupOrErr(
+      binder: T,
+      name: Name,
+      parent: Symbol,
+    )(using Context): Option[Symbol] =
+      // In case refinement or type param cannot be accessed from traverser and
+      // no symbols are registered to the symbol table, fall back to Type.member
+      symtab.lookup(binder, name) match
+        case found @ Some(_) => found
+        case None =>
+          val member = binder.member(name).symbol
+          if !member.exists then
+            symbolNotFound(binder, name, parent)
+            None
+          else
+            Some(member)
+
+  private def symbolNotFound(binder: Type, name: Name, parent: Symbol)(using ctx: Context): Unit =
+    warn(s"Ignoring ${name} of symbol ${parent}, type ${binder}")
+  private def symbolNotFound(name: Name, parent: Symbol)(using ctx: Context): Unit =
+    warn(s"Ignoring ${name} of symbol ${parent}")
+
+  private def warn(msg: String)(using ctx: Context): Unit =
+    report.warning(
+      s"Internal error in extracting SemanticDB while compiling ${ctx.compilationUnit.source}: ${msg}"
+    )
+
+  private def registerFakeSymbol(sym: FakeSymbol)(using Context, SemanticSymbolBuilder): Unit =
+    fakeSymbols.add(sym)
+
+  extension (tpe: Type)
+    def lookupSym(name: Name)(using Context): Option[Symbol] = {
+      def loop(ty: Type): Option[Symbol] = ty match
+        case rt: RefinedType =>
+          refinementSymtab.lookup(rt, name).orElse(
+            loop(rt.parent)
+          )
+        case rec: RecType =>
+          loop(rec.parent)
+        case AndType(tp1, tp2) =>
+          loop(tp1).orElse(loop(tp2))
+        case OrType(tp1, tp2) =>
+          loop(tp1).orElse(loop(tp2))
+        case _ =>
+          None
+      loop(tpe.dealias)
+    }
+
+    def toSemanticSig(using LinkMode, Context, SemanticSymbolBuilder)(sym: Symbol): s.Signature =
+      def enterParamRef(tpe: Type): Unit =
+        tpe match {
+          case lam: LambdaType =>
+            // Find the "actual" binder type for nested LambdaType
+            // For example, `def foo(x: T)(y: T): T` and for `<y>.owner.info` would be like
+            // `MethodType(...<x>, resType = MethodType(...<y>, resType = <T>))`.
+            // (Let's say the outer `MethodType` "outer", and `MethodType` who is
+            // `resType` of outer "inner")
+            //
+            // We try to find the "actual" binder of <y>: `inner`,
+            // and register them to the symbol table with `(<y>, inner) -> <y>`
+            // instead of `("y", outer) -> <y>`
+            if lam.paramNames.contains(sym.name) then
+              paramRefSymtab((lam, sym.name)) = sym
+            else
+              enterParamRef(lam.resType)
+
+          // for CaseType `case Array[t] => t` which is represented as [t] =>> MatchCase[Array[t], t]
+          case m: MatchType =>
+            m.cases.foreach(enterParamRef)
+
+          // for class constructor
+          // class C[T] { ... }
+          case cls: ClassInfo if sym.info.isInstanceOf[LambdaType] =>
+            val lam = sym.info.asInstanceOf[LambdaType]
+            cls.cls.typeParams.foreach { param =>
+              paramRefSymtab((lam, param.name)) = param
+            }
+
+          // type X[T] = ...
+          case tb: TypeBounds =>
+            enterParamRef(tb.lo)
+            enterParamRef(tb.hi)
+
+          case _ => ()
+        }
+
+      def enterRefined(tpe: Type): Unit =
+        tpe match {
+          case refined: RefinedType =>
+            val key = (refined, sym.name)
+            refinementSymtab(key) = sym
+
+          case rec: RecType =>
+            enterRefined(rec.parent)
+
+          // Register symbol for opaque type,
+          // opaque type alias will be stored into the refinement of
+          // the self type of the enclosing class.
+          // Key: the tuple of
+          //   - self-type of enclosing class
+          //   - name of the opaque type
+          // Value: the symbol of the opaque type
+          // See: SymDenotation.opaqueToBounds
+          case cls: ClassInfo if sym.is(Flags.Opaque) =>
+            cls.classSymbol.asClass.givenSelfType match
+              case rt: RefinedType =>
+                refinementSymtab((rt, sym.name)) = sym
+              case _ => ()
+
+          case cls: ClassInfo if (cls.cls.name == tpnme.REFINE_CLASS) =>
+            enterRefined(sym.owner.owner.info)
+
+          // type x = Person { refinement }
+          case tb: TypeBounds =>
+            // tb = TypeBounds(
+            //   lo = RefinedType(...)
+            //   hi = RefinedType(...)
+            // )
+            enterRefined(tb.lo)
+            enterRefined(tb.hi)
+
+          // def s(x: Int): { refinement } = ...
+          case expr: ExprType =>
+            enterRefined(expr.resType)
+          case m: LambdaType =>
+            enterRefined(m.resType)
+          case AndType(t1, t2) =>
+            enterRefined(t1)
+            enterRefined(t2)
+          case OrType(t1, t2) =>
+            enterRefined(t1)
+            enterRefined(t2)
+          case _ => ()
+        }
+      if sym.exists && sym.owner.exists then
+        enterParamRef(sym.owner.info)
+        enterRefined(sym.owner.info)
+
+      def loop(tpe: Type): s.Signature = tpe match {
+        case mp: MethodOrPoly =>
+          def flatten(
+            t: Type,
+            paramss: List[List[SemanticSymbol]],
+            tparams: List[SemanticSymbol]
+          ): (Type, List[List[SemanticSymbol]], List[SemanticSymbol]) = t match {
+            case mt: MethodType =>
+              val syms: List[SemanticSymbol] = mt.paramNames.zip(mt.paramInfos).map { (name, info) =>
+                paramRefSymtab.lookup(mt, name).getOrElse {
+                  TermParamRefSymbol(sym, name, info).tap(registerFakeSymbol)
+                }
+              }
+              flatten(mt.resType, paramss :+ syms, tparams)
+            case pt: PolyType =>
+              val syms: List[SemanticSymbol] = pt.paramNames.zip(pt.paramInfos).map { (name, info) =>
+                paramRefSymtab.lookup(pt, name).getOrElse {
+                  TypeParamRefSymbol(sym, name, info).tap(registerFakeSymbol)
+                }
+              }
+              flatten(pt.resType, paramss, tparams ++ syms)
+            case other =>
+              (other, paramss, tparams)
+          }
+          val (resType, paramss, tparams) = flatten(mp, Nil, Nil)
+
+          val sparamss = paramss.map(_.sscope)
+          val stparams = tparams.sscopeOpt
+          s.MethodSignature(
+            stparams,
+            sparamss,
+            resType.toSemanticType(sym)
+          )
+
+        case cls: ClassInfo =>
+          val stparams = cls.cls.typeParams.sscopeOpt
+          val sparents = cls.parents.map(_.toSemanticType(sym))
+          val sself = cls.selfType.toSemanticType(sym)
+          val decls = cls.decls.toList.sscopeOpt
+          s.ClassSignature(stparams, sparents, sself, decls)
+
+        case TypeBounds(lo, hi) =>
+          // for `type X[T] = T` is equivalent to `[T] =>> T`
+          def tparams(tpe: Type): (Type, List[SemanticSymbol]) = tpe match {
+            case lambda: HKTypeLambda =>
+              val paramSyms: List[SemanticSymbol] = lambda.paramNames.zip(lambda.paramInfos).map { (paramName, bounds) =>
+                // def x[T[_]] = ???
+                if paramName.isWildcard then
+                  WildcardTypeSymbol(sym, bounds).tap(registerFakeSymbol)
+                else
+                  paramRefSymtab.lookup(lambda, paramName).getOrElse {
+                    TypeParamRefSymbol(sym, paramName, bounds).tap(registerFakeSymbol)
+                  }
+              }
+              (lambda.resType, paramSyms)
+            case _ => (tpe, Nil)
+          }
+          val (loRes, loParams) = tparams(lo)
+          val (hiRes, hiParams) = tparams(hi)
+          val stparams = (loParams ++ hiParams).distinctBy(_.name).sscopeOpt
+          val slo = loRes.toSemanticType(sym)
+          val shi = hiRes.toSemanticType(sym)
+          s.TypeSignature(stparams, slo, shi)
+
+        case other =>
+          s.ValueSignature(
+            other.toSemanticType(sym)
+          )
+      }
+      loop(tpe)
+
+    def toSemanticType(sym: Symbol)(using LinkMode, SemanticSymbolBuilder, Context): s.Type =
+      import ConstantOps._
+      def loop(tpe: Type): s.Type = tpe match {
+        case t if t.isFromJavaObject =>
+          loop(defn.AnyType)
+        case ExprType(tpe) =>
+          val stpe = loop(tpe)
+          s.ByNameType(stpe)
+
+        // sym of `TypeRef(_, sym)` may not be a Symbol but Name in some cases
+        // e.g. in MatchType,
+        // case x *: xs => x *: Concat[xs, Ys]
+        // x and xs should have a typebounds <: Any, >: Nothing
+        // but Any (and Nothing) are represented as TypeRef(<scala>, "Any" <- Name)
+        case tr @ TypeRef(pre, _) if tr.symbol != NoSymbol =>
+          val spre = if tpe.hasTrivialPrefix then s.Type.Empty else loop(pre)
+          val ssym = tr.symbol.symbolName
+          s.TypeRef(spre, ssym, Seq.empty)
+
+        // when TypeRef refers the refinement of RefinedType e.g.
+        // TypeRef for `foo.B` in `trait T[A] { val foo: { type B = A } = ???; def bar(b: foo.B) = () }` has NoSymbol
+        case TypeRef(pre, name: Name) =>
+          val spre = if tpe.hasTrivialPrefix then s.Type.Empty else loop(pre)
+          val maybeSym = pre.widen.dealias.lookupSym(name)
+          maybeSym match
+            case Some(sym) =>
+              s.TypeRef(spre, sym.symbolName, Seq.empty)
+            case None => s.Type.Empty
+
+        case tr @ TermRef(pre, _) if tr.symbol != NoSymbol =>
+          val spre = if(tpe.hasTrivialPrefix) s.Type.Empty else loop(pre)
+          val ssym = tr.symbol.symbolName
+          s.SingleType(spre, ssym)
+
+        case TermRef(pre, name: Name) =>
+          val spre = if tpe.hasTrivialPrefix then s.Type.Empty else loop(pre)
+          val maybeSym = pre.widen.dealias match
+            case rt: RefinedType =>
+              refinementSymtab.lookupOrErr(rt, name, rt.typeSymbol)
+            case _ => None
+          maybeSym match
+            case Some(sym) =>
+              s.SingleType(spre, sym.symbolName)
+            case None => s.Type.Empty
+
+        case ThisType(TypeRef(_, sym: Symbol)) =>
+          s.ThisType(sym.symbolName)
+
+        case tref: TermParamRef =>
+          paramRefSymtab.lookupOrErr(
+            tref.binder, tref.paramName, sym
+          ) match
+            case Some(ref) =>
+              val ssym = ref.symbolName
+              s.SingleType(s.Type.Empty, ssym)
+            case None =>
+              s.Type.Empty
+
+        case tref: TypeParamRef =>
+          val tsym = paramRefSymtab.lookup(tref.binder, tref.paramName) match
+            case found @ Some(sym) => found
+            case None =>
+              tref.binder.typeParams.find(param => param.paramName == tref.paramName) match
+                case Some(param) =>
+                  val info = param.paramInfo
+                  Some(TypeParamRefSymbol(sym, tref.paramName, info).tap(registerFakeSymbol))
+                case None =>
+                  symbolNotFound(tref.binder, tref.paramName, sym)
+                  None
+          tsym match
+            case Some(sym) =>
+              val ssym = sym.symbolName
+              s.TypeRef(s.Type.Empty, ssym, Seq.empty)
+            case None =>
+              s.Type.Empty
+
+        case SuperType(thistpe, supertpe) =>
+          val spre = loop(thistpe.typeSymbol.info)
+          val ssym = supertpe.typeSymbol.symbolName
+          s.SuperType(spre, ssym)
+
+        // val clazzOf = classOf[...]
+        case ConstantType(const) if const.tag == core.Constants.ClazzTag =>
+          loop(const.typeValue)
+
+        case ConstantType(const) =>
+          s.ConstantType(const.toSemanticConst)
+
+        case matchType: MatchType =>
+          val scases = matchType.cases.map { caseType => caseType match {
+            case lam: HKTypeLambda => // case Array[t] => t
+              val paramSyms = lam.paramNames.flatMap { paramName =>
+                val key = (lam, paramName)
+                paramRefSymtab.get(key)
+              }.sscope
+              lam.resType match {
+                case defn.MatchCase(key, body) =>
+                  s.MatchType.CaseType(
+                    loop(key),
+                    loop(body)
+                  )
+                case _ => s.MatchType.CaseType() // shouldn't happen
+              }
+            case defn.MatchCase(key, body) =>
+              val skey = loop(key)
+              val sbody = loop(body)
+              s.MatchType.CaseType(skey, sbody)
+            case _ => s.MatchType.CaseType() // shouldn't happen
+          }}
+          val sscrutinee = loop(matchType.scrutinee)
+          val sbound = loop(matchType.bound)
+          s.MatchType(sscrutinee, scases)
+
+        case rt @ RefinedType(parent, name, info) =>
+          // `X { def x: Int; def y: Int }`
+          // RefinedType(
+          //   parent = RefinedType(
+          //     parent = TypeRef(..., X)
+          //     ...
+          //   )
+          //   refinedName = x
+          //   refinedInfo = TypeRef(..., Int)
+          // )
+          type RefinedInfo = (core.Names.Name, Type)
+          def flatten(tpe: Type, acc: List[RefinedInfo]): (Type, List[RefinedInfo]) = tpe match {
+            case RefinedType(parent, name, info) =>
+              flatten(parent, acc :+ (name, info))
+            case _ =>
+              (tpe, acc)
+          }
+
+          // flatten parent types to list
+          // e.g. `X with Y with Z { refined }`
+          // RefinedType(parent = AndType(X, AndType(Y, Z)), ...)
+          // => List(X, Y, Z)
+          def flattenParent(parent: Type): List[s.Type] = parent match {
+            case AndType(tp1, tp2) =>
+              flattenParent(tp1) ++ flattenParent(tp2)
+            case _ => List(loop(parent))
+          }
+
+          val (parent, refinedInfos) = flatten(rt, List.empty)
+          val stpe = s.IntersectionType(flattenParent(parent))
+
+          val decls: List[SemanticSymbol] = refinedInfos.map { (name, info) =>
+            refinementSymtab.lookup(rt, name).getOrElse {
+              RefinementSymbol(sym, name, info).tap(registerFakeSymbol)
+            }
+          }
+          val sdecls = decls.sscopeOpt(using LinkMode.HardlinkChildren)
+          s.StructuralType(stpe, sdecls)
+
+        case rec: RecType =>
+          loop(rec.parent) // should be handled as RefinedType
+
+        // repeated params: e.g. `Int*`, which is the syntax sugar of
+        // `Seq[Int] @Repeated` (or `Array[Int] @Repeated`)
+        // See: Desugar.scala and TypeApplications.scala
+        case AnnotatedType(AppliedType(_, targs), annot)
+          if (annot matches defn.RepeatedAnnot) && (targs.length == 1) =>
+          val stpe = loop(targs(0))
+          s.RepeatedType(stpe)
+
+        case ann: AnnotatedType if ann.annot.symbol.info.isInstanceOf[ClassInfo] =>
+          def flatten(tpe: Type, annots: List[Annotation]): (Type, List[Annotation]) = tpe match
+            case AnnotatedType(parent, annot) if annot.symbol.info.isInstanceOf[ClassInfo] =>
+              flatten(parent, annot +: annots)
+            case other => (other, annots)
+
+          val (parent, annots) = flatten(ann, List.empty)
+          val sparent = loop(parent)
+          val sannots = annots.map(a =>
+            s.Annotation(loop(a.symbol.info.asInstanceOf[ClassInfo].selfType))
+          )
+          s.AnnotatedType(sannots, sparent)
+
+        case AppliedType(tycon, args) if tycon == defn.RepeatedParamType && args.length == 1 =>
+          val stpe = loop(args(0))
+          s.RepeatedType(stpe)
+
+        case app @ AppliedType(tycon, args) =>
+          val targs = args.map { arg =>
+            arg match
+              // For wildcard type C[_ <: T], it's internal type representation will be
+              // `AppliedType(TypeBounds(lo = <Nothing>, hi = <T>))`.
+              //
+              // As scalameta for Scala2 does, we'll convert the wildcard type to
+              // `ExistentialType(TypeRef(NoPrefix, C, <local0>), Scope(hardlinks = List(<local0>)))`
+              // where `<local0>` has
+              // display_name: "_" and,
+              // signature: type_signature(..., lo = <Nothing>, hi = <T>)
+              case bounds: TypeBounds =>
+                val wildcardSym = WildcardTypeSymbol(sym, bounds)
+                // DO NOT register the wildcard symbol to symbol section here
+                // since it's not a symbol definition
+                // registerFakeSymbol(wildcardSym)
+                val ssym = wildcardSym.symbolName
+                (Some(wildcardSym), s.TypeRef(s.Type.Empty, ssym, Seq.empty))
+              case other =>
+                val sarg = loop(other)
+                (None, sarg)
+          }
+          val wildcardSyms = targs.flatMap(_._1)
+          val sargs = targs.map(_._2)
+
+          val applied = loop(tycon) match
+            case ref @ s.TypeRef(_, _, targs) =>
+              // For curried applied type `F[T][U]` and tycon is also an `AppliedType`
+              // Convert it to TypeRef(..., targs = List(T, U))
+              ref.copy(typeArguments = targs ++ sargs)
+            case _ =>
+              s.Type.Empty
+
+          if (wildcardSyms.isEmpty) applied
+          else s.ExistentialType(
+            applied,
+            wildcardSyms.sscopeOpt(using LinkMode.HardlinkChildren)
+          )
+
+        case and: AndType =>
+          def flatten(child: Type): List[Type] = child match
+            case AndType(ct1, ct2) => flatten(ct1) ++ flatten(ct2)
+            case other => List(other)
+          val stpes = flatten(and).map(loop)
+          s.IntersectionType(stpes)
+
+        case or: OrType =>
+          def flatten(child: Type): List[Type] = child match
+            case OrType(ct1, ct2) => flatten(ct1) ++ flatten(ct2)
+            case other => List(other)
+          val stpes = flatten(or).map(loop)
+          s.UnionType(stpes)
+
+        case l: LazyRef =>
+          loop(l.ref)
+
+        case NoPrefix =>
+          s.Type.Empty
+
+        // Not yet supported
+        case _: HKTypeLambda =>
+          s.Type.Empty
+
+        case tvar: TypeVar =>
+          loop(tvar.stripped)
+
+        case _ =>
+          s.Type.Empty
+      }
+      loop(tpe)
+
+    /** Return true if the prefix is like `_root_.this` */
+    private def hasTrivialPrefix(using Context): Boolean =
+      def checkTrivialPrefix(pre: Type, sym: Symbol)(using Context): Boolean =
+        pre =:= sym.owner.thisType
+      tpe match {
+        case TypeRef(pre, sym: Symbol) =>
+          checkTrivialPrefix(pre, sym)
+        case tr @ TypeRef(pre, _) if tr.symbol != NoSymbol =>
+          checkTrivialPrefix(pre, tr.symbol)
+        case TermRef(pre, sym: Symbol) =>
+          checkTrivialPrefix(pre, sym)
+        case tr @ TermRef(pre, _) if tr.symbol != NoSymbol =>
+          checkTrivialPrefix(pre, tr.symbol)
+        case _ => false
+      }
+
+
+object SymbolScopeOps:
+  import Scala3.{_, given}
+  extension (syms: List[SemanticSymbol])
+    def sscope(using linkMode: LinkMode)(using SemanticSymbolBuilder, TypeOps, Context): s.Scope =
+      linkMode match
+        case LinkMode.SymlinkChildren =>
+          s.Scope(symlinks = syms.map(_.symbolName))
+        case LinkMode.HardlinkChildren =>
+          s.Scope(hardlinks = syms.map(_.symbolInfo(Set.empty)))
+
+    def sscopeOpt(using LinkMode, SemanticSymbolBuilder, TypeOps, Context): Option[s.Scope] =
+      if syms.nonEmpty then Some(syms.sscope) else None
diff --git a/tests/pos-with-compiler-cc/dotc/semanticdb/generated/Access.scala b/tests/pos-with-compiler-cc/dotc/semanticdb/generated/Access.scala
new file mode 100644
index 000000000000..c646e67b69ad
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/semanticdb/generated/Access.scala
@@ -0,0 +1,654 @@
+// Generated by https://github.com/tanishiking/semanticdb-for-scala3
+// Generated by the Scala Plugin for the Protocol Buffer Compiler.
+// Do not edit!
+//
+// Protofile syntax: PROTO3
+
+package dotty.tools.dotc.semanticdb
+import dotty.tools.dotc.semanticdb.internal._
+import scala.annotation.internal.sharable
+
+sealed trait Access  extends SemanticdbGeneratedSealedOneof  derives CanEqual {
+  type MessageType = dotty.tools.dotc.semanticdb.AccessMessage
+  final def isEmpty = this.isInstanceOf[dotty.tools.dotc.semanticdb.Access.Empty.type]
+  final def isDefined = !isEmpty
+  final def asMessage: dotty.tools.dotc.semanticdb.AccessMessage = dotty.tools.dotc.semanticdb.Access.AccessTypeMapper.toBase(this)
+  final def asNonEmpty: Option[dotty.tools.dotc.semanticdb.Access.NonEmpty] = if (isEmpty) None else Some(this.asInstanceOf[dotty.tools.dotc.semanticdb.Access.NonEmpty])
+}
+
+object Access {
+  case object Empty extends dotty.tools.dotc.semanticdb.Access
+  
+  sealed trait NonEmpty extends dotty.tools.dotc.semanticdb.Access
+  def defaultInstance: dotty.tools.dotc.semanticdb.Access = Empty
+  
+  implicit val AccessTypeMapper: SemanticdbTypeMapper[dotty.tools.dotc.semanticdb.AccessMessage, dotty.tools.dotc.semanticdb.Access] = new SemanticdbTypeMapper[dotty.tools.dotc.semanticdb.AccessMessage, dotty.tools.dotc.semanticdb.Access] {
+    override def toCustom(__base: dotty.tools.dotc.semanticdb.AccessMessage): dotty.tools.dotc.semanticdb.Access = __base.sealedValue match {
+      case __v: dotty.tools.dotc.semanticdb.AccessMessage.SealedValue.PrivateAccess => __v.value
+      case __v: dotty.tools.dotc.semanticdb.AccessMessage.SealedValue.PrivateThisAccess => __v.value
+      case __v: dotty.tools.dotc.semanticdb.AccessMessage.SealedValue.PrivateWithinAccess => __v.value
+      case __v: dotty.tools.dotc.semanticdb.AccessMessage.SealedValue.ProtectedAccess => __v.value
+      case __v: dotty.tools.dotc.semanticdb.AccessMessage.SealedValue.ProtectedThisAccess => __v.value
+      case __v: dotty.tools.dotc.semanticdb.AccessMessage.SealedValue.ProtectedWithinAccess => __v.value
+      case __v: dotty.tools.dotc.semanticdb.AccessMessage.SealedValue.PublicAccess => __v.value
+      case dotty.tools.dotc.semanticdb.AccessMessage.SealedValue.Empty => Empty
+    }
+    override def toBase(__custom: dotty.tools.dotc.semanticdb.Access): dotty.tools.dotc.semanticdb.AccessMessage = dotty.tools.dotc.semanticdb.AccessMessage(__custom match {
+      case __v: dotty.tools.dotc.semanticdb.PrivateAccess => dotty.tools.dotc.semanticdb.AccessMessage.SealedValue.PrivateAccess(__v)
+      case __v: dotty.tools.dotc.semanticdb.PrivateThisAccess => dotty.tools.dotc.semanticdb.AccessMessage.SealedValue.PrivateThisAccess(__v)
+      case __v: dotty.tools.dotc.semanticdb.PrivateWithinAccess => dotty.tools.dotc.semanticdb.AccessMessage.SealedValue.PrivateWithinAccess(__v)
+      case __v: dotty.tools.dotc.semanticdb.ProtectedAccess => dotty.tools.dotc.semanticdb.AccessMessage.SealedValue.ProtectedAccess(__v)
+      case __v: dotty.tools.dotc.semanticdb.ProtectedThisAccess => dotty.tools.dotc.semanticdb.AccessMessage.SealedValue.ProtectedThisAccess(__v)
+      case __v: dotty.tools.dotc.semanticdb.ProtectedWithinAccess => dotty.tools.dotc.semanticdb.AccessMessage.SealedValue.ProtectedWithinAccess(__v)
+      case __v: dotty.tools.dotc.semanticdb.PublicAccess => dotty.tools.dotc.semanticdb.AccessMessage.SealedValue.PublicAccess(__v)
+      case Empty => dotty.tools.dotc.semanticdb.AccessMessage.SealedValue.Empty
+    })
+  }
+}
+@SerialVersionUID(0L)
+final case class AccessMessage(
+    sealedValue: dotty.tools.dotc.semanticdb.AccessMessage.SealedValue = dotty.tools.dotc.semanticdb.AccessMessage.SealedValue.Empty
+    )  extends SemanticdbGeneratedMessage  derives CanEqual {
+    @transient @sharable
+    private[this] var __serializedSizeMemoized: _root_.scala.Int = 0
+    private[this] def __computeSerializedSize(): _root_.scala.Int = {
+      var __size = 0
+      if (sealedValue.privateAccess.isDefined) {
+        val __value = sealedValue.privateAccess.get
+        __size += 1 + SemanticdbOutputStream.computeUInt32SizeNoTag(__value.serializedSize) + __value.serializedSize
+      };
+      if (sealedValue.privateThisAccess.isDefined) {
+        val __value = sealedValue.privateThisAccess.get
+        __size += 1 + SemanticdbOutputStream.computeUInt32SizeNoTag(__value.serializedSize) + __value.serializedSize
+      };
+      if (sealedValue.privateWithinAccess.isDefined) {
+        val __value = sealedValue.privateWithinAccess.get
+        __size += 1 + SemanticdbOutputStream.computeUInt32SizeNoTag(__value.serializedSize) + __value.serializedSize
+      };
+      if (sealedValue.protectedAccess.isDefined) {
+        val __value = sealedValue.protectedAccess.get
+        __size += 1 + SemanticdbOutputStream.computeUInt32SizeNoTag(__value.serializedSize) + __value.serializedSize
+      };
+      if (sealedValue.protectedThisAccess.isDefined) {
+        val __value = sealedValue.protectedThisAccess.get
+        __size += 1 + SemanticdbOutputStream.computeUInt32SizeNoTag(__value.serializedSize) + __value.serializedSize
+      };
+      if (sealedValue.protectedWithinAccess.isDefined) {
+        val __value = sealedValue.protectedWithinAccess.get
+        __size += 1 + SemanticdbOutputStream.computeUInt32SizeNoTag(__value.serializedSize) + __value.serializedSize
+      };
+      if (sealedValue.publicAccess.isDefined) {
+        val __value = sealedValue.publicAccess.get
+        __size += 1 + SemanticdbOutputStream.computeUInt32SizeNoTag(__value.serializedSize) + __value.serializedSize
+      };
+      __size
+    }
+    override def serializedSize: _root_.scala.Int = {
+      var __size = __serializedSizeMemoized
+      if (__size == 0) {
+        __size = __computeSerializedSize() + 1
+        __serializedSizeMemoized = __size
+      }
+      __size - 1
+      
+    }
+    def writeTo(`_output__`: SemanticdbOutputStream): _root_.scala.Unit = {
+      sealedValue.privateAccess.foreach { __v =>
+        val __m = __v
+        _output__.writeTag(1, 2)
+        _output__.writeUInt32NoTag(__m.serializedSize)
+        __m.writeTo(_output__)
+      };
+      sealedValue.privateThisAccess.foreach { __v =>
+        val __m = __v
+        _output__.writeTag(2, 2)
+        _output__.writeUInt32NoTag(__m.serializedSize)
+        __m.writeTo(_output__)
+      };
+      sealedValue.privateWithinAccess.foreach { __v =>
+        val __m = __v
+        _output__.writeTag(3, 2)
+        _output__.writeUInt32NoTag(__m.serializedSize)
+        __m.writeTo(_output__)
+      };
+      sealedValue.protectedAccess.foreach { __v =>
+        val __m = __v
+        _output__.writeTag(4, 2)
+        _output__.writeUInt32NoTag(__m.serializedSize)
+        __m.writeTo(_output__)
+      };
+      sealedValue.protectedThisAccess.foreach { __v =>
+        val __m = __v
+        _output__.writeTag(5, 2)
+        _output__.writeUInt32NoTag(__m.serializedSize)
+        __m.writeTo(_output__)
+      };
+      sealedValue.protectedWithinAccess.foreach { __v =>
+        val __m = __v
+        _output__.writeTag(6, 2)
+        _output__.writeUInt32NoTag(__m.serializedSize)
+        __m.writeTo(_output__)
+      };
+      sealedValue.publicAccess.foreach { __v =>
+        val __m = __v
+        _output__.writeTag(7, 2)
+        _output__.writeUInt32NoTag(__m.serializedSize)
+        __m.writeTo(_output__)
+      };
+    }
+    def getPrivateAccess: dotty.tools.dotc.semanticdb.PrivateAccess = sealedValue.privateAccess.getOrElse(dotty.tools.dotc.semanticdb.PrivateAccess.defaultInstance)
+    def withPrivateAccess(__v: dotty.tools.dotc.semanticdb.PrivateAccess): AccessMessage = copy(sealedValue = dotty.tools.dotc.semanticdb.AccessMessage.SealedValue.PrivateAccess(__v))
+    def getPrivateThisAccess: dotty.tools.dotc.semanticdb.PrivateThisAccess = sealedValue.privateThisAccess.getOrElse(dotty.tools.dotc.semanticdb.PrivateThisAccess.defaultInstance)
+    def withPrivateThisAccess(__v: dotty.tools.dotc.semanticdb.PrivateThisAccess): AccessMessage = copy(sealedValue = dotty.tools.dotc.semanticdb.AccessMessage.SealedValue.PrivateThisAccess(__v))
+    def getPrivateWithinAccess: dotty.tools.dotc.semanticdb.PrivateWithinAccess = sealedValue.privateWithinAccess.getOrElse(dotty.tools.dotc.semanticdb.PrivateWithinAccess.defaultInstance)
+    def withPrivateWithinAccess(__v: dotty.tools.dotc.semanticdb.PrivateWithinAccess): AccessMessage = copy(sealedValue = dotty.tools.dotc.semanticdb.AccessMessage.SealedValue.PrivateWithinAccess(__v))
+    def getProtectedAccess: dotty.tools.dotc.semanticdb.ProtectedAccess = sealedValue.protectedAccess.getOrElse(dotty.tools.dotc.semanticdb.ProtectedAccess.defaultInstance)
+    def withProtectedAccess(__v: dotty.tools.dotc.semanticdb.ProtectedAccess): AccessMessage = copy(sealedValue = dotty.tools.dotc.semanticdb.AccessMessage.SealedValue.ProtectedAccess(__v))
+    def getProtectedThisAccess: dotty.tools.dotc.semanticdb.ProtectedThisAccess = sealedValue.protectedThisAccess.getOrElse(dotty.tools.dotc.semanticdb.ProtectedThisAccess.defaultInstance)
+    def withProtectedThisAccess(__v: dotty.tools.dotc.semanticdb.ProtectedThisAccess): AccessMessage = copy(sealedValue = dotty.tools.dotc.semanticdb.AccessMessage.SealedValue.ProtectedThisAccess(__v))
+    def getProtectedWithinAccess: dotty.tools.dotc.semanticdb.ProtectedWithinAccess = sealedValue.protectedWithinAccess.getOrElse(dotty.tools.dotc.semanticdb.ProtectedWithinAccess.defaultInstance)
+    def withProtectedWithinAccess(__v: dotty.tools.dotc.semanticdb.ProtectedWithinAccess): AccessMessage = copy(sealedValue = dotty.tools.dotc.semanticdb.AccessMessage.SealedValue.ProtectedWithinAccess(__v))
+    def getPublicAccess: dotty.tools.dotc.semanticdb.PublicAccess = sealedValue.publicAccess.getOrElse(dotty.tools.dotc.semanticdb.PublicAccess.defaultInstance)
+    def withPublicAccess(__v: dotty.tools.dotc.semanticdb.PublicAccess): AccessMessage = copy(sealedValue = dotty.tools.dotc.semanticdb.AccessMessage.SealedValue.PublicAccess(__v))
+    def clearSealedValue: AccessMessage = copy(sealedValue = dotty.tools.dotc.semanticdb.AccessMessage.SealedValue.Empty)
+    def withSealedValue(__v: dotty.tools.dotc.semanticdb.AccessMessage.SealedValue): AccessMessage = copy(sealedValue = __v)
+    
+    
+    
+    
+    def toAccess: dotty.tools.dotc.semanticdb.Access = dotty.tools.dotc.semanticdb.Access.AccessTypeMapper.toCustom(this)
+    // @@protoc_insertion_point(GeneratedMessage[dotty.tools.dotc.semanticdb.Access])
+}
+
+object AccessMessage  extends SemanticdbGeneratedMessageCompanion[dotty.tools.dotc.semanticdb.AccessMessage] {
+  implicit def messageCompanion: SemanticdbGeneratedMessageCompanion[dotty.tools.dotc.semanticdb.AccessMessage] = this
+  def parseFrom(`_input__`: SemanticdbInputStream): dotty.tools.dotc.semanticdb.AccessMessage = {
+    var __sealedValue: dotty.tools.dotc.semanticdb.AccessMessage.SealedValue = dotty.tools.dotc.semanticdb.AccessMessage.SealedValue.Empty
+    var _done__ = false
+    while (!_done__) {
+      val _tag__ = _input__.readTag()
+      _tag__ match {
+        case 0 => _done__ = true
+        case 10 =>
+          __sealedValue = dotty.tools.dotc.semanticdb.AccessMessage.SealedValue.PrivateAccess(__sealedValue.privateAccess.fold(LiteParser.readMessage[dotty.tools.dotc.semanticdb.PrivateAccess](_input__))(LiteParser.readMessage(_input__, _)))
+        case 18 =>
+          __sealedValue = dotty.tools.dotc.semanticdb.AccessMessage.SealedValue.PrivateThisAccess(__sealedValue.privateThisAccess.fold(LiteParser.readMessage[dotty.tools.dotc.semanticdb.PrivateThisAccess](_input__))(LiteParser.readMessage(_input__, _)))
+        case 26 =>
+          __sealedValue = dotty.tools.dotc.semanticdb.AccessMessage.SealedValue.PrivateWithinAccess(__sealedValue.privateWithinAccess.fold(LiteParser.readMessage[dotty.tools.dotc.semanticdb.PrivateWithinAccess](_input__))(LiteParser.readMessage(_input__, _)))
+        case 34 =>
+          __sealedValue = dotty.tools.dotc.semanticdb.AccessMessage.SealedValue.ProtectedAccess(__sealedValue.protectedAccess.fold(LiteParser.readMessage[dotty.tools.dotc.semanticdb.ProtectedAccess](_input__))(LiteParser.readMessage(_input__, _)))
+        case 42 =>
+          __sealedValue = dotty.tools.dotc.semanticdb.AccessMessage.SealedValue.ProtectedThisAccess(__sealedValue.protectedThisAccess.fold(LiteParser.readMessage[dotty.tools.dotc.semanticdb.ProtectedThisAccess](_input__))(LiteParser.readMessage(_input__, _)))
+        case 50 =>
+          __sealedValue = dotty.tools.dotc.semanticdb.AccessMessage.SealedValue.ProtectedWithinAccess(__sealedValue.protectedWithinAccess.fold(LiteParser.readMessage[dotty.tools.dotc.semanticdb.ProtectedWithinAccess](_input__))(LiteParser.readMessage(_input__, _)))
+        case 58 =>
+          __sealedValue = dotty.tools.dotc.semanticdb.AccessMessage.SealedValue.PublicAccess(__sealedValue.publicAccess.fold(LiteParser.readMessage[dotty.tools.dotc.semanticdb.PublicAccess](_input__))(LiteParser.readMessage(_input__, _)))
+        case tag => _input__.skipField(tag)
+      }
+    }
+    dotty.tools.dotc.semanticdb.AccessMessage(
+        sealedValue = __sealedValue
+    )
+  }
+  
+  
+  
+  
+  
+  
+  lazy val defaultInstance = dotty.tools.dotc.semanticdb.AccessMessage(
+    sealedValue = dotty.tools.dotc.semanticdb.AccessMessage.SealedValue.Empty
+  )
+  sealed trait SealedValue  extends SemanticdbGeneratedOneof  derives CanEqual {
+    def isEmpty: _root_.scala.Boolean = false
+    def isDefined: _root_.scala.Boolean = true
+    def isPrivateAccess: _root_.scala.Boolean = false
+    def isPrivateThisAccess: _root_.scala.Boolean = false
+    def isPrivateWithinAccess: _root_.scala.Boolean = false
+    def isProtectedAccess: _root_.scala.Boolean = false
+    def isProtectedThisAccess: _root_.scala.Boolean = false
+    def isProtectedWithinAccess: _root_.scala.Boolean = false
+    def isPublicAccess: _root_.scala.Boolean = false
+    def privateAccess: _root_.scala.Option[dotty.tools.dotc.semanticdb.PrivateAccess] = _root_.scala.None
+    def privateThisAccess: _root_.scala.Option[dotty.tools.dotc.semanticdb.PrivateThisAccess] = _root_.scala.None
+    def privateWithinAccess: _root_.scala.Option[dotty.tools.dotc.semanticdb.PrivateWithinAccess] = _root_.scala.None
+    def protectedAccess: _root_.scala.Option[dotty.tools.dotc.semanticdb.ProtectedAccess] = _root_.scala.None
+    def protectedThisAccess: _root_.scala.Option[dotty.tools.dotc.semanticdb.ProtectedThisAccess] = _root_.scala.None
+    def protectedWithinAccess: _root_.scala.Option[dotty.tools.dotc.semanticdb.ProtectedWithinAccess] = _root_.scala.None
+    def publicAccess: _root_.scala.Option[dotty.tools.dotc.semanticdb.PublicAccess] = _root_.scala.None
+  }
+  object SealedValue {
+    @SerialVersionUID(0L)
+    case object Empty extends dotty.tools.dotc.semanticdb.AccessMessage.SealedValue {
+      type ValueType = _root_.scala.Nothing
+      override def isEmpty: _root_.scala.Boolean = true
+      override def isDefined: _root_.scala.Boolean = false
+      override def number: _root_.scala.Int = 0
+      override def value: _root_.scala.Nothing = throw new java.util.NoSuchElementException("Empty.value")
+    }
+  
+    @SerialVersionUID(0L)
+    final case class PrivateAccess(value: dotty.tools.dotc.semanticdb.PrivateAccess) extends dotty.tools.dotc.semanticdb.AccessMessage.SealedValue  derives CanEqual {
+      type ValueType = dotty.tools.dotc.semanticdb.PrivateAccess
+      override def isPrivateAccess: _root_.scala.Boolean = true
+      override def privateAccess: _root_.scala.Option[dotty.tools.dotc.semanticdb.PrivateAccess] = Some(value)
+      override def number: _root_.scala.Int = 1
+    }
+    @SerialVersionUID(0L)
+    final case class PrivateThisAccess(value: dotty.tools.dotc.semanticdb.PrivateThisAccess) extends dotty.tools.dotc.semanticdb.AccessMessage.SealedValue  derives CanEqual {
+      type ValueType = dotty.tools.dotc.semanticdb.PrivateThisAccess
+      override def isPrivateThisAccess: _root_.scala.Boolean = true
+      override def privateThisAccess: _root_.scala.Option[dotty.tools.dotc.semanticdb.PrivateThisAccess] = Some(value)
+      override def number: _root_.scala.Int = 2
+    }
+    @SerialVersionUID(0L)
+    final case class PrivateWithinAccess(value: dotty.tools.dotc.semanticdb.PrivateWithinAccess) extends dotty.tools.dotc.semanticdb.AccessMessage.SealedValue  derives CanEqual {
+      type ValueType = dotty.tools.dotc.semanticdb.PrivateWithinAccess
+      override def isPrivateWithinAccess: _root_.scala.Boolean = true
+      override def privateWithinAccess: _root_.scala.Option[dotty.tools.dotc.semanticdb.PrivateWithinAccess] = Some(value)
+      override def number: _root_.scala.Int = 3
+    }
+    @SerialVersionUID(0L)
+    final case class ProtectedAccess(value: dotty.tools.dotc.semanticdb.ProtectedAccess) extends dotty.tools.dotc.semanticdb.AccessMessage.SealedValue  derives CanEqual {
+      type ValueType = dotty.tools.dotc.semanticdb.ProtectedAccess
+      override def isProtectedAccess: _root_.scala.Boolean = true
+      override def protectedAccess: _root_.scala.Option[dotty.tools.dotc.semanticdb.ProtectedAccess] = Some(value)
+      override def number: _root_.scala.Int = 4
+    }
+    @SerialVersionUID(0L)
+    final case class ProtectedThisAccess(value: dotty.tools.dotc.semanticdb.ProtectedThisAccess) extends dotty.tools.dotc.semanticdb.AccessMessage.SealedValue  derives CanEqual {
+      type ValueType = dotty.tools.dotc.semanticdb.ProtectedThisAccess
+      override def isProtectedThisAccess: _root_.scala.Boolean = true
+      override def protectedThisAccess: _root_.scala.Option[dotty.tools.dotc.semanticdb.ProtectedThisAccess] = Some(value)
+      override def number: _root_.scala.Int = 5
+    }
+    @SerialVersionUID(0L)
+    final case class ProtectedWithinAccess(value: dotty.tools.dotc.semanticdb.ProtectedWithinAccess) extends dotty.tools.dotc.semanticdb.AccessMessage.SealedValue  derives CanEqual {
+      type ValueType = dotty.tools.dotc.semanticdb.ProtectedWithinAccess
+      override def isProtectedWithinAccess: _root_.scala.Boolean = true
+      override def protectedWithinAccess: _root_.scala.Option[dotty.tools.dotc.semanticdb.ProtectedWithinAccess] = Some(value)
+      override def number: _root_.scala.Int = 6
+    }
+    @SerialVersionUID(0L)
+    final case class PublicAccess(value: dotty.tools.dotc.semanticdb.PublicAccess) extends dotty.tools.dotc.semanticdb.AccessMessage.SealedValue  derives CanEqual {
+      type ValueType = dotty.tools.dotc.semanticdb.PublicAccess
+      override def isPublicAccess: _root_.scala.Boolean = true
+      override def publicAccess: _root_.scala.Option[dotty.tools.dotc.semanticdb.PublicAccess] = Some(value)
+      override def number: _root_.scala.Int = 7
+    }
+  }
+  final val PRIVATE_ACCESS_FIELD_NUMBER = 1
+  final val PRIVATE_THIS_ACCESS_FIELD_NUMBER = 2
+  final val PRIVATE_WITHIN_ACCESS_FIELD_NUMBER = 3
+  final val PROTECTED_ACCESS_FIELD_NUMBER = 4
+  final val PROTECTED_THIS_ACCESS_FIELD_NUMBER = 5
+  final val PROTECTED_WITHIN_ACCESS_FIELD_NUMBER = 6
+  final val PUBLIC_ACCESS_FIELD_NUMBER = 7
+  def of(
+    sealedValue: dotty.tools.dotc.semanticdb.AccessMessage.SealedValue
+  ): _root_.dotty.tools.dotc.semanticdb.AccessMessage = _root_.dotty.tools.dotc.semanticdb.AccessMessage(
+    sealedValue
+  )
+  // @@protoc_insertion_point(GeneratedMessageCompanion[dotty.tools.dotc.semanticdb.Access])
+}
+
+@SerialVersionUID(0L)
+final case class PrivateAccess(
+    )  extends dotty.tools.dotc.semanticdb.Access.NonEmpty with SemanticdbGeneratedMessage  derives CanEqual {
+    final override def serializedSize: _root_.scala.Int = 0
+    def writeTo(`_output__`: SemanticdbOutputStream): _root_.scala.Unit = {
+    }
+    
+    
+    
+    
+    // @@protoc_insertion_point(GeneratedMessage[dotty.tools.dotc.semanticdb.PrivateAccess])
+}
+
+object PrivateAccess  extends SemanticdbGeneratedMessageCompanion[dotty.tools.dotc.semanticdb.PrivateAccess] {
+  implicit def messageCompanion: SemanticdbGeneratedMessageCompanion[dotty.tools.dotc.semanticdb.PrivateAccess] = this
+  def parseFrom(`_input__`: SemanticdbInputStream): dotty.tools.dotc.semanticdb.PrivateAccess = {
+    var _done__ = false
+    while (!_done__) {
+      val _tag__ = _input__.readTag()
+      _tag__ match {
+        case 0 => _done__ = true
+        case tag => _input__.skipField(tag)
+      }
+    }
+    dotty.tools.dotc.semanticdb.PrivateAccess(
+    )
+  }
+  
+  
+  
+  
+  
+  
+  lazy val defaultInstance = dotty.tools.dotc.semanticdb.PrivateAccess(
+  )
+  def of(
+  ): _root_.dotty.tools.dotc.semanticdb.PrivateAccess = _root_.dotty.tools.dotc.semanticdb.PrivateAccess(
+  )
+  // @@protoc_insertion_point(GeneratedMessageCompanion[dotty.tools.dotc.semanticdb.PrivateAccess])
+}
+
+@SerialVersionUID(0L)
+final case class PrivateThisAccess(
+    )  extends dotty.tools.dotc.semanticdb.Access.NonEmpty with SemanticdbGeneratedMessage  derives CanEqual {
+    final override def serializedSize: _root_.scala.Int = 0
+    def writeTo(`_output__`: SemanticdbOutputStream): _root_.scala.Unit = {
+    }
+    
+    
+    
+    
+    // @@protoc_insertion_point(GeneratedMessage[dotty.tools.dotc.semanticdb.PrivateThisAccess])
+}
+
+object PrivateThisAccess  extends SemanticdbGeneratedMessageCompanion[dotty.tools.dotc.semanticdb.PrivateThisAccess] {
+  implicit def messageCompanion: SemanticdbGeneratedMessageCompanion[dotty.tools.dotc.semanticdb.PrivateThisAccess] = this
+  def parseFrom(`_input__`: SemanticdbInputStream): dotty.tools.dotc.semanticdb.PrivateThisAccess = {
+    var _done__ = false
+    while (!_done__) {
+      val _tag__ = _input__.readTag()
+      _tag__ match {
+        case 0 => _done__ = true
+        case tag => _input__.skipField(tag)
+      }
+    }
+    dotty.tools.dotc.semanticdb.PrivateThisAccess(
+    )
+  }
+  
+  
+  
+  
+  
+  
+  lazy val defaultInstance = dotty.tools.dotc.semanticdb.PrivateThisAccess(
+  )
+  def of(
+  ): _root_.dotty.tools.dotc.semanticdb.PrivateThisAccess = _root_.dotty.tools.dotc.semanticdb.PrivateThisAccess(
+  )
+  // @@protoc_insertion_point(GeneratedMessageCompanion[dotty.tools.dotc.semanticdb.PrivateThisAccess])
+}
+
+@SerialVersionUID(0L)
+final case class PrivateWithinAccess(
+    symbol: _root_.scala.Predef.String = ""
+    )  extends dotty.tools.dotc.semanticdb.Access.NonEmpty with SemanticdbGeneratedMessage  derives CanEqual {
+    @transient @sharable
+    private[this] var __serializedSizeMemoized: _root_.scala.Int = 0
+    private[this] def __computeSerializedSize(): _root_.scala.Int = {
+      var __size = 0
+      
+      {
+        val __value = symbol
+        if (!__value.isEmpty) {
+          __size += SemanticdbOutputStream.computeStringSize(1, __value)
+        }
+      };
+      __size
+    }
+    override def serializedSize: _root_.scala.Int = {
+      var __size = __serializedSizeMemoized
+      if (__size == 0) {
+        __size = __computeSerializedSize() + 1
+        __serializedSizeMemoized = __size
+      }
+      __size - 1
+      
+    }
+    def writeTo(`_output__`: SemanticdbOutputStream): _root_.scala.Unit = {
+      {
+        val __v = symbol
+        if (!__v.isEmpty) {
+          _output__.writeString(1, __v)
+        }
+      };
+    }
+    def withSymbol(__v: _root_.scala.Predef.String): PrivateWithinAccess = copy(symbol = __v)
+    
+    
+    
+    
+    // @@protoc_insertion_point(GeneratedMessage[dotty.tools.dotc.semanticdb.PrivateWithinAccess])
+}
+
+object PrivateWithinAccess  extends SemanticdbGeneratedMessageCompanion[dotty.tools.dotc.semanticdb.PrivateWithinAccess] {
+  implicit def messageCompanion: SemanticdbGeneratedMessageCompanion[dotty.tools.dotc.semanticdb.PrivateWithinAccess] = this
+  def parseFrom(`_input__`: SemanticdbInputStream): dotty.tools.dotc.semanticdb.PrivateWithinAccess = {
+    var __symbol: _root_.scala.Predef.String = ""
+    var _done__ = false
+    while (!_done__) {
+      val _tag__ = _input__.readTag()
+      _tag__ match {
+        case 0 => _done__ = true
+        case 10 =>
+          __symbol = _input__.readStringRequireUtf8()
+        case tag => _input__.skipField(tag)
+      }
+    }
+    dotty.tools.dotc.semanticdb.PrivateWithinAccess(
+        symbol = __symbol
+    )
+  }
+  
+  
+  
+  
+  
+  
+  lazy val defaultInstance = dotty.tools.dotc.semanticdb.PrivateWithinAccess(
+    symbol = ""
+  )
+  final val SYMBOL_FIELD_NUMBER = 1
+  def of(
+    symbol: _root_.scala.Predef.String
+  ): _root_.dotty.tools.dotc.semanticdb.PrivateWithinAccess = _root_.dotty.tools.dotc.semanticdb.PrivateWithinAccess(
+    symbol
+  )
+  // @@protoc_insertion_point(GeneratedMessageCompanion[dotty.tools.dotc.semanticdb.PrivateWithinAccess])
+}
+
+@SerialVersionUID(0L)
+final case class ProtectedAccess(
+    )  extends dotty.tools.dotc.semanticdb.Access.NonEmpty with SemanticdbGeneratedMessage  derives CanEqual {
+    final override def serializedSize: _root_.scala.Int = 0
+    def writeTo(`_output__`: SemanticdbOutputStream): _root_.scala.Unit = {
+    }
+    
+    
+    
+    
+    // @@protoc_insertion_point(GeneratedMessage[dotty.tools.dotc.semanticdb.ProtectedAccess])
+}
+
+object ProtectedAccess  extends SemanticdbGeneratedMessageCompanion[dotty.tools.dotc.semanticdb.ProtectedAccess] {
+  implicit def messageCompanion: SemanticdbGeneratedMessageCompanion[dotty.tools.dotc.semanticdb.ProtectedAccess] = this
+  def parseFrom(`_input__`: SemanticdbInputStream): dotty.tools.dotc.semanticdb.ProtectedAccess = {
+    var _done__ = false
+    while (!_done__) {
+      val _tag__ = _input__.readTag()
+      _tag__ match {
+        case 0 => _done__ = true
+        case tag => _input__.skipField(tag)
+      }
+    }
+    dotty.tools.dotc.semanticdb.ProtectedAccess(
+    )
+  }
+  
+  
+  
+  
+  
+  
+  lazy val defaultInstance = dotty.tools.dotc.semanticdb.ProtectedAccess(
+  )
+  def of(
+  ): _root_.dotty.tools.dotc.semanticdb.ProtectedAccess = _root_.dotty.tools.dotc.semanticdb.ProtectedAccess(
+  )
+  // @@protoc_insertion_point(GeneratedMessageCompanion[dotty.tools.dotc.semanticdb.ProtectedAccess])
+}
+
+@SerialVersionUID(0L)
+final case class ProtectedThisAccess(
+    )  extends dotty.tools.dotc.semanticdb.Access.NonEmpty with SemanticdbGeneratedMessage  derives CanEqual {
+    final override def serializedSize: _root_.scala.Int = 0
+    def writeTo(`_output__`: SemanticdbOutputStream): _root_.scala.Unit = {
+    }
+    
+    
+    
+    
+    // @@protoc_insertion_point(GeneratedMessage[dotty.tools.dotc.semanticdb.ProtectedThisAccess])
+}
+
+object ProtectedThisAccess  extends SemanticdbGeneratedMessageCompanion[dotty.tools.dotc.semanticdb.ProtectedThisAccess] {
+  implicit def messageCompanion: SemanticdbGeneratedMessageCompanion[dotty.tools.dotc.semanticdb.ProtectedThisAccess] = this
+  def parseFrom(`_input__`: SemanticdbInputStream): dotty.tools.dotc.semanticdb.ProtectedThisAccess = {
+    var _done__ = false
+    while (!_done__) {
+      val _tag__ = _input__.readTag()
+      _tag__ match {
+        case 0 => _done__ = true
+        case tag => _input__.skipField(tag)
+      }
+    }
+    dotty.tools.dotc.semanticdb.ProtectedThisAccess(
+    )
+  }
+  
+  
+  
+  
+  
+  
+  lazy val defaultInstance = dotty.tools.dotc.semanticdb.ProtectedThisAccess(
+  )
+  def of(
+  ): _root_.dotty.tools.dotc.semanticdb.ProtectedThisAccess = _root_.dotty.tools.dotc.semanticdb.ProtectedThisAccess(
+  )
+  // @@protoc_insertion_point(GeneratedMessageCompanion[dotty.tools.dotc.semanticdb.ProtectedThisAccess])
+}
+
+@SerialVersionUID(0L)
+final case class ProtectedWithinAccess(
+    symbol: _root_.scala.Predef.String = ""
+    )  extends dotty.tools.dotc.semanticdb.Access.NonEmpty with SemanticdbGeneratedMessage  derives CanEqual {
+    @transient @sharable
+    private[this] var __serializedSizeMemoized: _root_.scala.Int = 0
+    private[this] def __computeSerializedSize(): _root_.scala.Int = {
+      var __size = 0
+      
+      {
+        val __value = symbol
+        if (!__value.isEmpty) {
+          __size += SemanticdbOutputStream.computeStringSize(1, __value)
+        }
+      };
+      __size
+    }
+    override def serializedSize: _root_.scala.Int = {
+      var __size = __serializedSizeMemoized
+      if (__size == 0) {
+        __size = __computeSerializedSize() + 1
+        __serializedSizeMemoized = __size
+      }
+      __size - 1
+      
+    }
+    def writeTo(`_output__`: SemanticdbOutputStream): _root_.scala.Unit = {
+      {
+        val __v = symbol
+        if (!__v.isEmpty) {
+          _output__.writeString(1, __v)
+        }
+      };
+    }
+    def withSymbol(__v: _root_.scala.Predef.String): ProtectedWithinAccess = copy(symbol = __v)
+    
+    
+    
+    
+    // @@protoc_insertion_point(GeneratedMessage[dotty.tools.dotc.semanticdb.ProtectedWithinAccess])
+}
+
+object ProtectedWithinAccess  extends SemanticdbGeneratedMessageCompanion[dotty.tools.dotc.semanticdb.ProtectedWithinAccess] {
+  implicit def messageCompanion: SemanticdbGeneratedMessageCompanion[dotty.tools.dotc.semanticdb.ProtectedWithinAccess] = this
+  def parseFrom(`_input__`: SemanticdbInputStream): dotty.tools.dotc.semanticdb.ProtectedWithinAccess = {
+    var __symbol: _root_.scala.Predef.String = ""
+    var _done__ = false
+    while (!_done__) {
+      val _tag__ = _input__.readTag()
+      _tag__ match {
+        case 0 => _done__ = true
+        case 10 =>
+          __symbol = _input__.readStringRequireUtf8()
+        case tag => _input__.skipField(tag)
+      }
+    }
+    dotty.tools.dotc.semanticdb.ProtectedWithinAccess(
+        symbol = __symbol
+    )
+  }
+  
+  
+  
+  
+  
+  
+  lazy val defaultInstance = dotty.tools.dotc.semanticdb.ProtectedWithinAccess(
+    symbol = ""
+  )
+  final val SYMBOL_FIELD_NUMBER = 1
+  def of(
+    symbol: _root_.scala.Predef.String
+  ): _root_.dotty.tools.dotc.semanticdb.ProtectedWithinAccess = _root_.dotty.tools.dotc.semanticdb.ProtectedWithinAccess(
+    symbol
+  )
+  // @@protoc_insertion_point(GeneratedMessageCompanion[dotty.tools.dotc.semanticdb.ProtectedWithinAccess])
+}
+
+@SerialVersionUID(0L)
+final case class PublicAccess(
+    )  extends dotty.tools.dotc.semanticdb.Access.NonEmpty with SemanticdbGeneratedMessage  derives CanEqual {
+    final override def serializedSize: _root_.scala.Int = 0
+    def writeTo(`_output__`: SemanticdbOutputStream): _root_.scala.Unit = {
+    }
+    
+    
+    
+    
+    // @@protoc_insertion_point(GeneratedMessage[dotty.tools.dotc.semanticdb.PublicAccess])
+}
+
+object PublicAccess  extends SemanticdbGeneratedMessageCompanion[dotty.tools.dotc.semanticdb.PublicAccess] {
+  implicit def messageCompanion: SemanticdbGeneratedMessageCompanion[dotty.tools.dotc.semanticdb.PublicAccess] = this
+  def parseFrom(`_input__`: SemanticdbInputStream): dotty.tools.dotc.semanticdb.PublicAccess = {
+    var _done__ = false
+    while (!_done__) {
+      val _tag__ = _input__.readTag()
+      _tag__ match {
+        case 0 => _done__ = true
+        case tag => _input__.skipField(tag)
+      }
+    }
+    dotty.tools.dotc.semanticdb.PublicAccess(
+    )
+  }
+  
+  
+  
+  
+  
+  
+  lazy val defaultInstance = dotty.tools.dotc.semanticdb.PublicAccess(
+  )
+  def of(
+  ): _root_.dotty.tools.dotc.semanticdb.PublicAccess = _root_.dotty.tools.dotc.semanticdb.PublicAccess(
+  )
+  // @@protoc_insertion_point(GeneratedMessageCompanion[dotty.tools.dotc.semanticdb.PublicAccess])
+}
diff --git a/tests/pos-with-compiler-cc/dotc/semanticdb/generated/Annotation.scala b/tests/pos-with-compiler-cc/dotc/semanticdb/generated/Annotation.scala
new file mode 100644
index 000000000000..2cb478d89e2d
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/semanticdb/generated/Annotation.scala
@@ -0,0 +1,91 @@
+// Generated by https://github.com/tanishiking/semanticdb-for-scala3
+// Generated by the Scala Plugin for the Protocol Buffer Compiler.
+// Do not edit!
+//
+// Protofile syntax: PROTO3
+
+package dotty.tools.dotc.semanticdb
+import dotty.tools.dotc.semanticdb.internal._
+import scala.annotation.internal.sharable
+
+@SerialVersionUID(0L)
+final case class Annotation(
+    tpe: dotty.tools.dotc.semanticdb.Type = dotty.tools.dotc.semanticdb.Annotation._typemapper_tpe.toCustom(dotty.tools.dotc.semanticdb.TypeMessage.defaultInstance)
+    )  extends SemanticdbGeneratedMessage  derives CanEqual {
+    @transient @sharable
+    private[this] var __serializedSizeMemoized: _root_.scala.Int = 0
+    private[this] def __computeSerializedSize(): _root_.scala.Int = {
+      var __size = 0
+      
+      {
+        val __value = dotty.tools.dotc.semanticdb.Annotation._typemapper_tpe.toBase(tpe)
+        if (__value.serializedSize != 0) {
+          __size += 1 + SemanticdbOutputStream.computeUInt32SizeNoTag(__value.serializedSize) + __value.serializedSize
+        }
+      };
+      __size
+    }
+    override def serializedSize: _root_.scala.Int = {
+      var __size = __serializedSizeMemoized
+      if (__size == 0) {
+        __size = __computeSerializedSize() + 1
+        __serializedSizeMemoized = __size
+      }
+      __size - 1
+      
+    }
+    def writeTo(`_output__`: SemanticdbOutputStream): _root_.scala.Unit = {
+      {
+        val __v = dotty.tools.dotc.semanticdb.Annotation._typemapper_tpe.toBase(tpe)
+        if (__v.serializedSize != 0) {
+          _output__.writeTag(1, 2)
+          _output__.writeUInt32NoTag(__v.serializedSize)
+          __v.writeTo(_output__)
+        }
+      };
+    }
+    def withTpe(__v: dotty.tools.dotc.semanticdb.Type): Annotation = copy(tpe = __v)
+    
+    
+    
+    
+    // @@protoc_insertion_point(GeneratedMessage[dotty.tools.dotc.semanticdb.Annotation])
+}
+
+object Annotation  extends SemanticdbGeneratedMessageCompanion[dotty.tools.dotc.semanticdb.Annotation] {
+  implicit def messageCompanion: SemanticdbGeneratedMessageCompanion[dotty.tools.dotc.semanticdb.Annotation] = this
+  def parseFrom(`_input__`: SemanticdbInputStream): dotty.tools.dotc.semanticdb.Annotation = {
+    var __tpe: _root_.scala.Option[dotty.tools.dotc.semanticdb.TypeMessage] = _root_.scala.None
+    var _done__ = false
+    while (!_done__) {
+      val _tag__ = _input__.readTag()
+      _tag__ match {
+        case 0 => _done__ = true
+        case 10 =>
+          __tpe = _root_.scala.Some(__tpe.fold(LiteParser.readMessage[dotty.tools.dotc.semanticdb.TypeMessage](_input__))(LiteParser.readMessage(_input__, _)))
+        case tag => _input__.skipField(tag)
+      }
+    }
+    dotty.tools.dotc.semanticdb.Annotation(
+        tpe = dotty.tools.dotc.semanticdb.Annotation._typemapper_tpe.toCustom(__tpe.getOrElse(dotty.tools.dotc.semanticdb.TypeMessage.defaultInstance))
+    )
+  }
+  
+  
+  
+  
+  
+  
+  lazy val defaultInstance = dotty.tools.dotc.semanticdb.Annotation(
+    tpe = dotty.tools.dotc.semanticdb.Annotation._typemapper_tpe.toCustom(dotty.tools.dotc.semanticdb.TypeMessage.defaultInstance)
+  )
+  final val TPE_FIELD_NUMBER = 1
+  @transient @sharable
+  private[semanticdb] val _typemapper_tpe: SemanticdbTypeMapper[dotty.tools.dotc.semanticdb.TypeMessage, dotty.tools.dotc.semanticdb.Type] = implicitly[SemanticdbTypeMapper[dotty.tools.dotc.semanticdb.TypeMessage, dotty.tools.dotc.semanticdb.Type]]
+  def of(
+    tpe: dotty.tools.dotc.semanticdb.Type
+  ): _root_.dotty.tools.dotc.semanticdb.Annotation = _root_.dotty.tools.dotc.semanticdb.Annotation(
+    tpe
+  )
+  // @@protoc_insertion_point(GeneratedMessageCompanion[dotty.tools.dotc.semanticdb.Annotation])
+}
diff --git a/tests/pos-with-compiler-cc/dotc/semanticdb/generated/Constant.scala b/tests/pos-with-compiler-cc/dotc/semanticdb/generated/Constant.scala
new file mode 100644
index 000000000000..0ca96d9ae8c6
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/semanticdb/generated/Constant.scala
@@ -0,0 +1,1181 @@
+// Generated by https://github.com/tanishiking/semanticdb-for-scala3
+// Generated by the Scala Plugin for the Protocol Buffer Compiler.
+// Do not edit!
+//
+// Protofile syntax: PROTO3
+
+package dotty.tools.dotc.semanticdb
+import dotty.tools.dotc.semanticdb.internal._
+import scala.annotation.internal.sharable
+
+sealed trait Constant  extends SemanticdbGeneratedSealedOneof  derives CanEqual {
+  type MessageType = dotty.tools.dotc.semanticdb.ConstantMessage
+  final def isEmpty = this.isInstanceOf[dotty.tools.dotc.semanticdb.Constant.Empty.type]
+  final def isDefined = !isEmpty
+  final def asMessage: dotty.tools.dotc.semanticdb.ConstantMessage = dotty.tools.dotc.semanticdb.Constant.ConstantTypeMapper.toBase(this)
+  final def asNonEmpty: Option[dotty.tools.dotc.semanticdb.Constant.NonEmpty] = if (isEmpty) None else Some(this.asInstanceOf[dotty.tools.dotc.semanticdb.Constant.NonEmpty])
+}
+
+object Constant {
+  case object Empty extends dotty.tools.dotc.semanticdb.Constant
+  
+  sealed trait NonEmpty extends dotty.tools.dotc.semanticdb.Constant
+  def defaultInstance: dotty.tools.dotc.semanticdb.Constant = Empty
+  
+  implicit val ConstantTypeMapper: SemanticdbTypeMapper[dotty.tools.dotc.semanticdb.ConstantMessage, dotty.tools.dotc.semanticdb.Constant] = new SemanticdbTypeMapper[dotty.tools.dotc.semanticdb.ConstantMessage, dotty.tools.dotc.semanticdb.Constant] {
+    override def toCustom(__base: dotty.tools.dotc.semanticdb.ConstantMessage): dotty.tools.dotc.semanticdb.Constant = __base.sealedValue match {
+      case __v: dotty.tools.dotc.semanticdb.ConstantMessage.SealedValue.UnitConstant => __v.value
+      case __v: dotty.tools.dotc.semanticdb.ConstantMessage.SealedValue.BooleanConstant => __v.value
+      case __v: dotty.tools.dotc.semanticdb.ConstantMessage.SealedValue.ByteConstant => __v.value
+      case __v: dotty.tools.dotc.semanticdb.ConstantMessage.SealedValue.ShortConstant => __v.value
+      case __v: dotty.tools.dotc.semanticdb.ConstantMessage.SealedValue.CharConstant => __v.value
+      case __v: dotty.tools.dotc.semanticdb.ConstantMessage.SealedValue.IntConstant => __v.value
+      case __v: dotty.tools.dotc.semanticdb.ConstantMessage.SealedValue.LongConstant => __v.value
+      case __v: dotty.tools.dotc.semanticdb.ConstantMessage.SealedValue.FloatConstant => __v.value
+      case __v: dotty.tools.dotc.semanticdb.ConstantMessage.SealedValue.DoubleConstant => __v.value
+      case __v: dotty.tools.dotc.semanticdb.ConstantMessage.SealedValue.StringConstant => __v.value
+      case __v: dotty.tools.dotc.semanticdb.ConstantMessage.SealedValue.NullConstant => __v.value
+      case dotty.tools.dotc.semanticdb.ConstantMessage.SealedValue.Empty => Empty
+    }
+    override def toBase(__custom: dotty.tools.dotc.semanticdb.Constant): dotty.tools.dotc.semanticdb.ConstantMessage = dotty.tools.dotc.semanticdb.ConstantMessage(__custom match {
+      case __v: dotty.tools.dotc.semanticdb.UnitConstant => dotty.tools.dotc.semanticdb.ConstantMessage.SealedValue.UnitConstant(__v)
+      case __v: dotty.tools.dotc.semanticdb.BooleanConstant => dotty.tools.dotc.semanticdb.ConstantMessage.SealedValue.BooleanConstant(__v)
+      case __v: dotty.tools.dotc.semanticdb.ByteConstant => dotty.tools.dotc.semanticdb.ConstantMessage.SealedValue.ByteConstant(__v)
+      case __v: dotty.tools.dotc.semanticdb.ShortConstant => dotty.tools.dotc.semanticdb.ConstantMessage.SealedValue.ShortConstant(__v)
+      case __v: dotty.tools.dotc.semanticdb.CharConstant => dotty.tools.dotc.semanticdb.ConstantMessage.SealedValue.CharConstant(__v)
+      case __v: dotty.tools.dotc.semanticdb.IntConstant => dotty.tools.dotc.semanticdb.ConstantMessage.SealedValue.IntConstant(__v)
+      case __v: dotty.tools.dotc.semanticdb.LongConstant => dotty.tools.dotc.semanticdb.ConstantMessage.SealedValue.LongConstant(__v)
+      case __v: dotty.tools.dotc.semanticdb.FloatConstant => dotty.tools.dotc.semanticdb.ConstantMessage.SealedValue.FloatConstant(__v)
+      case __v: dotty.tools.dotc.semanticdb.DoubleConstant => dotty.tools.dotc.semanticdb.ConstantMessage.SealedValue.DoubleConstant(__v)
+      case __v: dotty.tools.dotc.semanticdb.StringConstant => dotty.tools.dotc.semanticdb.ConstantMessage.SealedValue.StringConstant(__v)
+      case __v: dotty.tools.dotc.semanticdb.NullConstant => dotty.tools.dotc.semanticdb.ConstantMessage.SealedValue.NullConstant(__v)
+      case Empty => dotty.tools.dotc.semanticdb.ConstantMessage.SealedValue.Empty
+    })
+  }
+}
+@SerialVersionUID(0L)
+final case class ConstantMessage(
+    sealedValue: dotty.tools.dotc.semanticdb.ConstantMessage.SealedValue = dotty.tools.dotc.semanticdb.ConstantMessage.SealedValue.Empty
+    )  extends SemanticdbGeneratedMessage  derives CanEqual {
+    @transient @sharable
+    private[this] var __serializedSizeMemoized: _root_.scala.Int = 0
+    private[this] def __computeSerializedSize(): _root_.scala.Int = {
+      var __size = 0
+      if (sealedValue.unitConstant.isDefined) {
+        val __value = sealedValue.unitConstant.get
+        __size += 1 + SemanticdbOutputStream.computeUInt32SizeNoTag(__value.serializedSize) + __value.serializedSize
+      };
+      if (sealedValue.booleanConstant.isDefined) {
+        val __value = sealedValue.booleanConstant.get
+        __size += 1 + SemanticdbOutputStream.computeUInt32SizeNoTag(__value.serializedSize) + __value.serializedSize
+      };
+      if (sealedValue.byteConstant.isDefined) {
+        val __value = sealedValue.byteConstant.get
+        __size += 1 + SemanticdbOutputStream.computeUInt32SizeNoTag(__value.serializedSize) + __value.serializedSize
+      };
+      if (sealedValue.shortConstant.isDefined) {
+        val __value = sealedValue.shortConstant.get
+        __size += 1 + SemanticdbOutputStream.computeUInt32SizeNoTag(__value.serializedSize) + __value.serializedSize
+      };
+      if (sealedValue.charConstant.isDefined) {
+        val __value = sealedValue.charConstant.get
+        __size += 1 + SemanticdbOutputStream.computeUInt32SizeNoTag(__value.serializedSize) + __value.serializedSize
+      };
+      if (sealedValue.intConstant.isDefined) {
+        val __value = sealedValue.intConstant.get
+        __size += 1 + SemanticdbOutputStream.computeUInt32SizeNoTag(__value.serializedSize) + __value.serializedSize
+      };
+      if (sealedValue.longConstant.isDefined) {
+        val __value = sealedValue.longConstant.get
+        __size += 1 + SemanticdbOutputStream.computeUInt32SizeNoTag(__value.serializedSize) + __value.serializedSize
+      };
+      if (sealedValue.floatConstant.isDefined) {
+        val __value = sealedValue.floatConstant.get
+        __size += 1 + SemanticdbOutputStream.computeUInt32SizeNoTag(__value.serializedSize) + __value.serializedSize
+      };
+      if (sealedValue.doubleConstant.isDefined) {
+        val __value = sealedValue.doubleConstant.get
+        __size += 1 + SemanticdbOutputStream.computeUInt32SizeNoTag(__value.serializedSize) + __value.serializedSize
+      };
+      if (sealedValue.stringConstant.isDefined) {
+        val __value = sealedValue.stringConstant.get
+        __size += 1 + SemanticdbOutputStream.computeUInt32SizeNoTag(__value.serializedSize) + __value.serializedSize
+      };
+      if (sealedValue.nullConstant.isDefined) {
+        val __value = sealedValue.nullConstant.get
+        __size += 1 + SemanticdbOutputStream.computeUInt32SizeNoTag(__value.serializedSize) + __value.serializedSize
+      };
+      __size
+    }
+    override def serializedSize: _root_.scala.Int = {
+      var __size = __serializedSizeMemoized
+      if (__size == 0) {
+        __size = __computeSerializedSize() + 1
+        __serializedSizeMemoized = __size
+      }
+      __size - 1
+      
+    }
+    def writeTo(`_output__`: SemanticdbOutputStream): _root_.scala.Unit = {
+      sealedValue.unitConstant.foreach { __v =>
+        val __m = __v
+        _output__.writeTag(1, 2)
+        _output__.writeUInt32NoTag(__m.serializedSize)
+        __m.writeTo(_output__)
+      };
+      sealedValue.booleanConstant.foreach { __v =>
+        val __m = __v
+        _output__.writeTag(2, 2)
+        _output__.writeUInt32NoTag(__m.serializedSize)
+        __m.writeTo(_output__)
+      };
+      sealedValue.byteConstant.foreach { __v =>
+        val __m = __v
+        _output__.writeTag(3, 2)
+        _output__.writeUInt32NoTag(__m.serializedSize)
+        __m.writeTo(_output__)
+      };
+      sealedValue.shortConstant.foreach { __v =>
+        val __m = __v
+        _output__.writeTag(4, 2)
+        _output__.writeUInt32NoTag(__m.serializedSize)
+        __m.writeTo(_output__)
+      };
+      sealedValue.charConstant.foreach { __v =>
+        val __m = __v
+        _output__.writeTag(5, 2)
+        _output__.writeUInt32NoTag(__m.serializedSize)
+        __m.writeTo(_output__)
+      };
+      sealedValue.intConstant.foreach { __v =>
+        val __m = __v
+        _output__.writeTag(6, 2)
+        _output__.writeUInt32NoTag(__m.serializedSize)
+        __m.writeTo(_output__)
+      };
+      sealedValue.longConstant.foreach { __v =>
+        val __m = __v
+        _output__.writeTag(7, 2)
+        _output__.writeUInt32NoTag(__m.serializedSize)
+        __m.writeTo(_output__)
+      };
+      sealedValue.floatConstant.foreach { __v =>
+        val __m = __v
+        _output__.writeTag(8, 2)
+        _output__.writeUInt32NoTag(__m.serializedSize)
+        __m.writeTo(_output__)
+      };
+      sealedValue.doubleConstant.foreach { __v =>
+        val __m = __v
+        _output__.writeTag(9, 2)
+        _output__.writeUInt32NoTag(__m.serializedSize)
+        __m.writeTo(_output__)
+      };
+      sealedValue.stringConstant.foreach { __v =>
+        val __m = __v
+        _output__.writeTag(10, 2)
+        _output__.writeUInt32NoTag(__m.serializedSize)
+        __m.writeTo(_output__)
+      };
+      sealedValue.nullConstant.foreach { __v =>
+        val __m = __v
+        _output__.writeTag(11, 2)
+        _output__.writeUInt32NoTag(__m.serializedSize)
+        __m.writeTo(_output__)
+      };
+    }
+    def getUnitConstant: dotty.tools.dotc.semanticdb.UnitConstant = sealedValue.unitConstant.getOrElse(dotty.tools.dotc.semanticdb.UnitConstant.defaultInstance)
+    def withUnitConstant(__v: dotty.tools.dotc.semanticdb.UnitConstant): ConstantMessage = copy(sealedValue = dotty.tools.dotc.semanticdb.ConstantMessage.SealedValue.UnitConstant(__v))
+    def getBooleanConstant: dotty.tools.dotc.semanticdb.BooleanConstant = sealedValue.booleanConstant.getOrElse(dotty.tools.dotc.semanticdb.BooleanConstant.defaultInstance)
+    def withBooleanConstant(__v: dotty.tools.dotc.semanticdb.BooleanConstant): ConstantMessage = copy(sealedValue = dotty.tools.dotc.semanticdb.ConstantMessage.SealedValue.BooleanConstant(__v))
+    def getByteConstant: dotty.tools.dotc.semanticdb.ByteConstant = sealedValue.byteConstant.getOrElse(dotty.tools.dotc.semanticdb.ByteConstant.defaultInstance)
+    def withByteConstant(__v: dotty.tools.dotc.semanticdb.ByteConstant): ConstantMessage = copy(sealedValue = dotty.tools.dotc.semanticdb.ConstantMessage.SealedValue.ByteConstant(__v))
+    def getShortConstant: dotty.tools.dotc.semanticdb.ShortConstant = sealedValue.shortConstant.getOrElse(dotty.tools.dotc.semanticdb.ShortConstant.defaultInstance)
+    def withShortConstant(__v: dotty.tools.dotc.semanticdb.ShortConstant): ConstantMessage = copy(sealedValue = dotty.tools.dotc.semanticdb.ConstantMessage.SealedValue.ShortConstant(__v))
+    def getCharConstant: dotty.tools.dotc.semanticdb.CharConstant = sealedValue.charConstant.getOrElse(dotty.tools.dotc.semanticdb.CharConstant.defaultInstance)
+    def withCharConstant(__v: dotty.tools.dotc.semanticdb.CharConstant): ConstantMessage = copy(sealedValue = dotty.tools.dotc.semanticdb.ConstantMessage.SealedValue.CharConstant(__v))
+    def getIntConstant: dotty.tools.dotc.semanticdb.IntConstant = sealedValue.intConstant.getOrElse(dotty.tools.dotc.semanticdb.IntConstant.defaultInstance)
+    def withIntConstant(__v: dotty.tools.dotc.semanticdb.IntConstant): ConstantMessage = copy(sealedValue = dotty.tools.dotc.semanticdb.ConstantMessage.SealedValue.IntConstant(__v))
+    def getLongConstant: dotty.tools.dotc.semanticdb.LongConstant = sealedValue.longConstant.getOrElse(dotty.tools.dotc.semanticdb.LongConstant.defaultInstance)
+    def withLongConstant(__v: dotty.tools.dotc.semanticdb.LongConstant): ConstantMessage = copy(sealedValue = dotty.tools.dotc.semanticdb.ConstantMessage.SealedValue.LongConstant(__v))
+    def getFloatConstant: dotty.tools.dotc.semanticdb.FloatConstant = sealedValue.floatConstant.getOrElse(dotty.tools.dotc.semanticdb.FloatConstant.defaultInstance)
+    def withFloatConstant(__v: dotty.tools.dotc.semanticdb.FloatConstant): ConstantMessage = copy(sealedValue = dotty.tools.dotc.semanticdb.ConstantMessage.SealedValue.FloatConstant(__v))
+    def getDoubleConstant: dotty.tools.dotc.semanticdb.DoubleConstant = sealedValue.doubleConstant.getOrElse(dotty.tools.dotc.semanticdb.DoubleConstant.defaultInstance)
+    def withDoubleConstant(__v: dotty.tools.dotc.semanticdb.DoubleConstant): ConstantMessage = copy(sealedValue = dotty.tools.dotc.semanticdb.ConstantMessage.SealedValue.DoubleConstant(__v))
+    def getStringConstant: dotty.tools.dotc.semanticdb.StringConstant = sealedValue.stringConstant.getOrElse(dotty.tools.dotc.semanticdb.StringConstant.defaultInstance)
+    def withStringConstant(__v: dotty.tools.dotc.semanticdb.StringConstant): ConstantMessage = copy(sealedValue = dotty.tools.dotc.semanticdb.ConstantMessage.SealedValue.StringConstant(__v))
+    def getNullConstant: dotty.tools.dotc.semanticdb.NullConstant = sealedValue.nullConstant.getOrElse(dotty.tools.dotc.semanticdb.NullConstant.defaultInstance)
+    def withNullConstant(__v: dotty.tools.dotc.semanticdb.NullConstant): ConstantMessage = copy(sealedValue = dotty.tools.dotc.semanticdb.ConstantMessage.SealedValue.NullConstant(__v))
+    def clearSealedValue: ConstantMessage = copy(sealedValue = dotty.tools.dotc.semanticdb.ConstantMessage.SealedValue.Empty)
+    def withSealedValue(__v: dotty.tools.dotc.semanticdb.ConstantMessage.SealedValue): ConstantMessage = copy(sealedValue = __v)
+    
+    
+    
+    
+    def toConstant: dotty.tools.dotc.semanticdb.Constant = dotty.tools.dotc.semanticdb.Constant.ConstantTypeMapper.toCustom(this)
+    // @@protoc_insertion_point(GeneratedMessage[dotty.tools.dotc.semanticdb.Constant])
+}
+
+object ConstantMessage  extends SemanticdbGeneratedMessageCompanion[dotty.tools.dotc.semanticdb.ConstantMessage] {
+  implicit def messageCompanion: SemanticdbGeneratedMessageCompanion[dotty.tools.dotc.semanticdb.ConstantMessage] = this
+  def parseFrom(`_input__`: SemanticdbInputStream): dotty.tools.dotc.semanticdb.ConstantMessage = {
+    var __sealedValue: dotty.tools.dotc.semanticdb.ConstantMessage.SealedValue = dotty.tools.dotc.semanticdb.ConstantMessage.SealedValue.Empty
+    var _done__ = false
+    while (!_done__) {
+      val _tag__ = _input__.readTag()
+      _tag__ match {
+        case 0 => _done__ = true
+        case 10 =>
+          __sealedValue = dotty.tools.dotc.semanticdb.ConstantMessage.SealedValue.UnitConstant(__sealedValue.unitConstant.fold(LiteParser.readMessage[dotty.tools.dotc.semanticdb.UnitConstant](_input__))(LiteParser.readMessage(_input__, _)))
+        case 18 =>
+          __sealedValue = dotty.tools.dotc.semanticdb.ConstantMessage.SealedValue.BooleanConstant(__sealedValue.booleanConstant.fold(LiteParser.readMessage[dotty.tools.dotc.semanticdb.BooleanConstant](_input__))(LiteParser.readMessage(_input__, _)))
+        case 26 =>
+          __sealedValue = dotty.tools.dotc.semanticdb.ConstantMessage.SealedValue.ByteConstant(__sealedValue.byteConstant.fold(LiteParser.readMessage[dotty.tools.dotc.semanticdb.ByteConstant](_input__))(LiteParser.readMessage(_input__, _)))
+        case 34 =>
+          __sealedValue = dotty.tools.dotc.semanticdb.ConstantMessage.SealedValue.ShortConstant(__sealedValue.shortConstant.fold(LiteParser.readMessage[dotty.tools.dotc.semanticdb.ShortConstant](_input__))(LiteParser.readMessage(_input__, _)))
+        case 42 =>
+          __sealedValue = dotty.tools.dotc.semanticdb.ConstantMessage.SealedValue.CharConstant(__sealedValue.charConstant.fold(LiteParser.readMessage[dotty.tools.dotc.semanticdb.CharConstant](_input__))(LiteParser.readMessage(_input__, _)))
+        case 50 =>
+          __sealedValue = dotty.tools.dotc.semanticdb.ConstantMessage.SealedValue.IntConstant(__sealedValue.intConstant.fold(LiteParser.readMessage[dotty.tools.dotc.semanticdb.IntConstant](_input__))(LiteParser.readMessage(_input__, _)))
+        case 58 =>
+          __sealedValue = dotty.tools.dotc.semanticdb.ConstantMessage.SealedValue.LongConstant(__sealedValue.longConstant.fold(LiteParser.readMessage[dotty.tools.dotc.semanticdb.LongConstant](_input__))(LiteParser.readMessage(_input__, _)))
+        case 66 =>
+          __sealedValue = dotty.tools.dotc.semanticdb.ConstantMessage.SealedValue.FloatConstant(__sealedValue.floatConstant.fold(LiteParser.readMessage[dotty.tools.dotc.semanticdb.FloatConstant](_input__))(LiteParser.readMessage(_input__, _)))
+        case 74 =>
+          __sealedValue = dotty.tools.dotc.semanticdb.ConstantMessage.SealedValue.DoubleConstant(__sealedValue.doubleConstant.fold(LiteParser.readMessage[dotty.tools.dotc.semanticdb.DoubleConstant](_input__))(LiteParser.readMessage(_input__, _)))
+        case 82 =>
+          __sealedValue = dotty.tools.dotc.semanticdb.ConstantMessage.SealedValue.StringConstant(__sealedValue.stringConstant.fold(LiteParser.readMessage[dotty.tools.dotc.semanticdb.StringConstant](_input__))(LiteParser.readMessage(_input__, _)))
+        case 90 =>
+          __sealedValue = dotty.tools.dotc.semanticdb.ConstantMessage.SealedValue.NullConstant(__sealedValue.nullConstant.fold(LiteParser.readMessage[dotty.tools.dotc.semanticdb.NullConstant](_input__))(LiteParser.readMessage(_input__, _)))
+        case tag => _input__.skipField(tag)
+      }
+    }
+    dotty.tools.dotc.semanticdb.ConstantMessage(
+        sealedValue = __sealedValue
+    )
+  }
+  
+  
+  
+  
+  
+  
+  lazy val defaultInstance = dotty.tools.dotc.semanticdb.ConstantMessage(
+    sealedValue = dotty.tools.dotc.semanticdb.ConstantMessage.SealedValue.Empty
+  )
+  sealed trait SealedValue  extends SemanticdbGeneratedOneof  derives CanEqual {
+    def isEmpty: _root_.scala.Boolean = false
+    def isDefined: _root_.scala.Boolean = true
+    def isUnitConstant: _root_.scala.Boolean = false
+    def isBooleanConstant: _root_.scala.Boolean = false
+    def isByteConstant: _root_.scala.Boolean = false
+    def isShortConstant: _root_.scala.Boolean = false
+    def isCharConstant: _root_.scala.Boolean = false
+    def isIntConstant: _root_.scala.Boolean = false
+    def isLongConstant: _root_.scala.Boolean = false
+    def isFloatConstant: _root_.scala.Boolean = false
+    def isDoubleConstant: _root_.scala.Boolean = false
+    def isStringConstant: _root_.scala.Boolean = false
+    def isNullConstant: _root_.scala.Boolean = false
+    def unitConstant: _root_.scala.Option[dotty.tools.dotc.semanticdb.UnitConstant] = _root_.scala.None
+    def booleanConstant: _root_.scala.Option[dotty.tools.dotc.semanticdb.BooleanConstant] = _root_.scala.None
+    def byteConstant: _root_.scala.Option[dotty.tools.dotc.semanticdb.ByteConstant] = _root_.scala.None
+    def shortConstant: _root_.scala.Option[dotty.tools.dotc.semanticdb.ShortConstant] = _root_.scala.None
+    def charConstant: _root_.scala.Option[dotty.tools.dotc.semanticdb.CharConstant] = _root_.scala.None
+    def intConstant: _root_.scala.Option[dotty.tools.dotc.semanticdb.IntConstant] = _root_.scala.None
+    def longConstant: _root_.scala.Option[dotty.tools.dotc.semanticdb.LongConstant] = _root_.scala.None
+    def floatConstant: _root_.scala.Option[dotty.tools.dotc.semanticdb.FloatConstant] = _root_.scala.None
+    def doubleConstant: _root_.scala.Option[dotty.tools.dotc.semanticdb.DoubleConstant] = _root_.scala.None
+    def stringConstant: _root_.scala.Option[dotty.tools.dotc.semanticdb.StringConstant] = _root_.scala.None
+    def nullConstant: _root_.scala.Option[dotty.tools.dotc.semanticdb.NullConstant] = _root_.scala.None
+  }
+  object SealedValue {
+    @SerialVersionUID(0L)
+    case object Empty extends dotty.tools.dotc.semanticdb.ConstantMessage.SealedValue {
+      type ValueType = _root_.scala.Nothing
+      override def isEmpty: _root_.scala.Boolean = true
+      override def isDefined: _root_.scala.Boolean = false
+      override def number: _root_.scala.Int = 0
+      override def value: _root_.scala.Nothing = throw new java.util.NoSuchElementException("Empty.value")
+    }
+  
+    @SerialVersionUID(0L)
+    final case class UnitConstant(value: dotty.tools.dotc.semanticdb.UnitConstant) extends dotty.tools.dotc.semanticdb.ConstantMessage.SealedValue  derives CanEqual {
+      type ValueType = dotty.tools.dotc.semanticdb.UnitConstant
+      override def isUnitConstant: _root_.scala.Boolean = true
+      override def unitConstant: _root_.scala.Option[dotty.tools.dotc.semanticdb.UnitConstant] = Some(value)
+      override def number: _root_.scala.Int = 1
+    }
+    @SerialVersionUID(0L)
+    final case class BooleanConstant(value: dotty.tools.dotc.semanticdb.BooleanConstant) extends dotty.tools.dotc.semanticdb.ConstantMessage.SealedValue  derives CanEqual {
+      type ValueType = dotty.tools.dotc.semanticdb.BooleanConstant
+      override def isBooleanConstant: _root_.scala.Boolean = true
+      override def booleanConstant: _root_.scala.Option[dotty.tools.dotc.semanticdb.BooleanConstant] = Some(value)
+      override def number: _root_.scala.Int = 2
+    }
+    @SerialVersionUID(0L)
+    final case class ByteConstant(value: dotty.tools.dotc.semanticdb.ByteConstant) extends dotty.tools.dotc.semanticdb.ConstantMessage.SealedValue  derives CanEqual {
+      type ValueType = dotty.tools.dotc.semanticdb.ByteConstant
+      override def isByteConstant: _root_.scala.Boolean = true
+      override def byteConstant: _root_.scala.Option[dotty.tools.dotc.semanticdb.ByteConstant] = Some(value)
+      override def number: _root_.scala.Int = 3
+    }
+    @SerialVersionUID(0L)
+    final case class ShortConstant(value: dotty.tools.dotc.semanticdb.ShortConstant) extends dotty.tools.dotc.semanticdb.ConstantMessage.SealedValue  derives CanEqual {
+      type ValueType = dotty.tools.dotc.semanticdb.ShortConstant
+      override def isShortConstant: _root_.scala.Boolean = true
+      override def shortConstant: _root_.scala.Option[dotty.tools.dotc.semanticdb.ShortConstant] = Some(value)
+      override def number: _root_.scala.Int = 4
+    }
+    @SerialVersionUID(0L)
+    final case class CharConstant(value: dotty.tools.dotc.semanticdb.CharConstant) extends dotty.tools.dotc.semanticdb.ConstantMessage.SealedValue  derives CanEqual {
+      type ValueType = dotty.tools.dotc.semanticdb.CharConstant
+      override def isCharConstant: _root_.scala.Boolean = true
+      override def charConstant: _root_.scala.Option[dotty.tools.dotc.semanticdb.CharConstant] = Some(value)
+      override def number: _root_.scala.Int = 5
+    }
+    @SerialVersionUID(0L)
+    final case class IntConstant(value: dotty.tools.dotc.semanticdb.IntConstant) extends dotty.tools.dotc.semanticdb.ConstantMessage.SealedValue  derives CanEqual {
+      type ValueType = dotty.tools.dotc.semanticdb.IntConstant
+      override def isIntConstant: _root_.scala.Boolean = true
+      override def intConstant: _root_.scala.Option[dotty.tools.dotc.semanticdb.IntConstant] = Some(value)
+      override def number: _root_.scala.Int = 6
+    }
+    @SerialVersionUID(0L)
+    final case class LongConstant(value: dotty.tools.dotc.semanticdb.LongConstant) extends dotty.tools.dotc.semanticdb.ConstantMessage.SealedValue  derives CanEqual {
+      type ValueType = dotty.tools.dotc.semanticdb.LongConstant
+      override def isLongConstant: _root_.scala.Boolean = true
+      override def longConstant: _root_.scala.Option[dotty.tools.dotc.semanticdb.LongConstant] = Some(value)
+      override def number: _root_.scala.Int = 7
+    }
+    @SerialVersionUID(0L)
+    final case class FloatConstant(value: dotty.tools.dotc.semanticdb.FloatConstant) extends dotty.tools.dotc.semanticdb.ConstantMessage.SealedValue  derives CanEqual {
+      type ValueType = dotty.tools.dotc.semanticdb.FloatConstant
+      override def isFloatConstant: _root_.scala.Boolean = true
+      override def floatConstant: _root_.scala.Option[dotty.tools.dotc.semanticdb.FloatConstant] = Some(value)
+      override def number: _root_.scala.Int = 8
+    }
+    @SerialVersionUID(0L)
+    final case class DoubleConstant(value: dotty.tools.dotc.semanticdb.DoubleConstant) extends dotty.tools.dotc.semanticdb.ConstantMessage.SealedValue  derives CanEqual {
+      type ValueType = dotty.tools.dotc.semanticdb.DoubleConstant
+      override def isDoubleConstant: _root_.scala.Boolean = true
+      override def doubleConstant: _root_.scala.Option[dotty.tools.dotc.semanticdb.DoubleConstant] = Some(value)
+      override def number: _root_.scala.Int = 9
+    }
+    @SerialVersionUID(0L)
+    final case class StringConstant(value: dotty.tools.dotc.semanticdb.StringConstant) extends dotty.tools.dotc.semanticdb.ConstantMessage.SealedValue  derives CanEqual {
+      type ValueType = dotty.tools.dotc.semanticdb.StringConstant
+      override def isStringConstant: _root_.scala.Boolean = true
+      override def stringConstant: _root_.scala.Option[dotty.tools.dotc.semanticdb.StringConstant] = Some(value)
+      override def number: _root_.scala.Int = 10
+    }
+    @SerialVersionUID(0L)
+    final case class NullConstant(value: dotty.tools.dotc.semanticdb.NullConstant) extends dotty.tools.dotc.semanticdb.ConstantMessage.SealedValue  derives CanEqual {
+      type ValueType = dotty.tools.dotc.semanticdb.NullConstant
+      override def isNullConstant: _root_.scala.Boolean = true
+      override def nullConstant: _root_.scala.Option[dotty.tools.dotc.semanticdb.NullConstant] = Some(value)
+      override def number: _root_.scala.Int = 11
+    }
+  }
+  final val UNIT_CONSTANT_FIELD_NUMBER = 1
+  final val BOOLEAN_CONSTANT_FIELD_NUMBER = 2
+  final val BYTE_CONSTANT_FIELD_NUMBER = 3
+  final val SHORT_CONSTANT_FIELD_NUMBER = 4
+  final val CHAR_CONSTANT_FIELD_NUMBER = 5
+  final val INT_CONSTANT_FIELD_NUMBER = 6
+  final val LONG_CONSTANT_FIELD_NUMBER = 7
+  final val FLOAT_CONSTANT_FIELD_NUMBER = 8
+  final val DOUBLE_CONSTANT_FIELD_NUMBER = 9
+  final val STRING_CONSTANT_FIELD_NUMBER = 10
+  final val NULL_CONSTANT_FIELD_NUMBER = 11
+  def of(
+    sealedValue: dotty.tools.dotc.semanticdb.ConstantMessage.SealedValue
+  ): _root_.dotty.tools.dotc.semanticdb.ConstantMessage = _root_.dotty.tools.dotc.semanticdb.ConstantMessage(
+    sealedValue
+  )
+  // @@protoc_insertion_point(GeneratedMessageCompanion[dotty.tools.dotc.semanticdb.Constant])
+}
+
+@SerialVersionUID(0L)
+final case class UnitConstant(
+    )  extends dotty.tools.dotc.semanticdb.Constant.NonEmpty with SemanticdbGeneratedMessage  derives CanEqual {
+    final override def serializedSize: _root_.scala.Int = 0
+    def writeTo(`_output__`: SemanticdbOutputStream): _root_.scala.Unit = {
+    }
+    
+    
+    
+    
+    // @@protoc_insertion_point(GeneratedMessage[dotty.tools.dotc.semanticdb.UnitConstant])
+}
+
+object UnitConstant  extends SemanticdbGeneratedMessageCompanion[dotty.tools.dotc.semanticdb.UnitConstant] {
+  implicit def messageCompanion: SemanticdbGeneratedMessageCompanion[dotty.tools.dotc.semanticdb.UnitConstant] = this
+  def parseFrom(`_input__`: SemanticdbInputStream): dotty.tools.dotc.semanticdb.UnitConstant = {
+    var _done__ = false
+    while (!_done__) {
+      val _tag__ = _input__.readTag()
+      _tag__ match {
+        case 0 => _done__ = true
+        case tag => _input__.skipField(tag)
+      }
+    }
+    dotty.tools.dotc.semanticdb.UnitConstant(
+    )
+  }
+  
+  
+  
+  
+  
+  
+  lazy val defaultInstance = dotty.tools.dotc.semanticdb.UnitConstant(
+  )
+  def of(
+  ): _root_.dotty.tools.dotc.semanticdb.UnitConstant = _root_.dotty.tools.dotc.semanticdb.UnitConstant(
+  )
+  // @@protoc_insertion_point(GeneratedMessageCompanion[dotty.tools.dotc.semanticdb.UnitConstant])
+}
+
+@SerialVersionUID(0L)
+final case class BooleanConstant(
+    value: _root_.scala.Boolean = false
+    )  extends dotty.tools.dotc.semanticdb.Constant.NonEmpty with SemanticdbGeneratedMessage  derives CanEqual {
+    @transient @sharable
+    private[this] var __serializedSizeMemoized: _root_.scala.Int = 0
+    private[this] def __computeSerializedSize(): _root_.scala.Int = {
+      var __size = 0
+      
+      {
+        val __value = value
+        if (__value != false) {
+          __size += SemanticdbOutputStream.computeBoolSize(1, __value)
+        }
+      };
+      __size
+    }
+    override def serializedSize: _root_.scala.Int = {
+      var __size = __serializedSizeMemoized
+      if (__size == 0) {
+        __size = __computeSerializedSize() + 1
+        __serializedSizeMemoized = __size
+      }
+      __size - 1
+      
+    }
+    def writeTo(`_output__`: SemanticdbOutputStream): _root_.scala.Unit = {
+      {
+        val __v = value
+        if (__v != false) {
+          _output__.writeBool(1, __v)
+        }
+      };
+    }
+    def withValue(__v: _root_.scala.Boolean): BooleanConstant = copy(value = __v)
+    
+    
+    
+    
+    // @@protoc_insertion_point(GeneratedMessage[dotty.tools.dotc.semanticdb.BooleanConstant])
+}
+
+object BooleanConstant  extends SemanticdbGeneratedMessageCompanion[dotty.tools.dotc.semanticdb.BooleanConstant] {
+  implicit def messageCompanion: SemanticdbGeneratedMessageCompanion[dotty.tools.dotc.semanticdb.BooleanConstant] = this
+  def parseFrom(`_input__`: SemanticdbInputStream): dotty.tools.dotc.semanticdb.BooleanConstant = {
+    var __value: _root_.scala.Boolean = false
+    var _done__ = false
+    while (!_done__) {
+      val _tag__ = _input__.readTag()
+      _tag__ match {
+        case 0 => _done__ = true
+        case 8 =>
+          __value = _input__.readBool()
+        case tag => _input__.skipField(tag)
+      }
+    }
+    dotty.tools.dotc.semanticdb.BooleanConstant(
+        value = __value
+    )
+  }
+  
+  
+  
+  
+  
+  
+  lazy val defaultInstance = dotty.tools.dotc.semanticdb.BooleanConstant(
+    value = false
+  )
+  final val VALUE_FIELD_NUMBER = 1
+  def of(
+    value: _root_.scala.Boolean
+  ): _root_.dotty.tools.dotc.semanticdb.BooleanConstant = _root_.dotty.tools.dotc.semanticdb.BooleanConstant(
+    value
+  )
+  // @@protoc_insertion_point(GeneratedMessageCompanion[dotty.tools.dotc.semanticdb.BooleanConstant])
+}
+
+@SerialVersionUID(0L)
+final case class ByteConstant(
+    value: _root_.scala.Int = 0
+    )  extends dotty.tools.dotc.semanticdb.Constant.NonEmpty with SemanticdbGeneratedMessage  derives CanEqual {
+    @transient @sharable
+    private[this] var __serializedSizeMemoized: _root_.scala.Int = 0
+    private[this] def __computeSerializedSize(): _root_.scala.Int = {
+      var __size = 0
+      
+      {
+        val __value = value
+        if (__value != 0) {
+          __size += SemanticdbOutputStream.computeInt32Size(1, __value)
+        }
+      };
+      __size
+    }
+    override def serializedSize: _root_.scala.Int = {
+      var __size = __serializedSizeMemoized
+      if (__size == 0) {
+        __size = __computeSerializedSize() + 1
+        __serializedSizeMemoized = __size
+      }
+      __size - 1
+      
+    }
+    def writeTo(`_output__`: SemanticdbOutputStream): _root_.scala.Unit = {
+      {
+        val __v = value
+        if (__v != 0) {
+          _output__.writeInt32(1, __v)
+        }
+      };
+    }
+    def withValue(__v: _root_.scala.Int): ByteConstant = copy(value = __v)
+    
+    
+    
+    
+    // @@protoc_insertion_point(GeneratedMessage[dotty.tools.dotc.semanticdb.ByteConstant])
+}
+
+object ByteConstant  extends SemanticdbGeneratedMessageCompanion[dotty.tools.dotc.semanticdb.ByteConstant] {
+  implicit def messageCompanion: SemanticdbGeneratedMessageCompanion[dotty.tools.dotc.semanticdb.ByteConstant] = this
+  def parseFrom(`_input__`: SemanticdbInputStream): dotty.tools.dotc.semanticdb.ByteConstant = {
+    var __value: _root_.scala.Int = 0
+    var _done__ = false
+    while (!_done__) {
+      val _tag__ = _input__.readTag()
+      _tag__ match {
+        case 0 => _done__ = true
+        case 8 =>
+          __value = _input__.readInt32()
+        case tag => _input__.skipField(tag)
+      }
+    }
+    dotty.tools.dotc.semanticdb.ByteConstant(
+        value = __value
+    )
+  }
+  
+  
+  
+  
+  
+  
+  lazy val defaultInstance = dotty.tools.dotc.semanticdb.ByteConstant(
+    value = 0
+  )
+  final val VALUE_FIELD_NUMBER = 1
+  def of(
+    value: _root_.scala.Int
+  ): _root_.dotty.tools.dotc.semanticdb.ByteConstant = _root_.dotty.tools.dotc.semanticdb.ByteConstant(
+    value
+  )
+  // @@protoc_insertion_point(GeneratedMessageCompanion[dotty.tools.dotc.semanticdb.ByteConstant])
+}
+
+@SerialVersionUID(0L)
+final case class ShortConstant(
+    value: _root_.scala.Int = 0
+    )  extends dotty.tools.dotc.semanticdb.Constant.NonEmpty with SemanticdbGeneratedMessage  derives CanEqual {
+    @transient @sharable
+    private[this] var __serializedSizeMemoized: _root_.scala.Int = 0
+    private[this] def __computeSerializedSize(): _root_.scala.Int = {
+      var __size = 0
+      
+      {
+        val __value = value
+        if (__value != 0) {
+          __size += SemanticdbOutputStream.computeInt32Size(1, __value)
+        }
+      };
+      __size
+    }
+    override def serializedSize: _root_.scala.Int = {
+      var __size = __serializedSizeMemoized
+      if (__size == 0) {
+        __size = __computeSerializedSize() + 1
+        __serializedSizeMemoized = __size
+      }
+      __size - 1
+      
+    }
+    def writeTo(`_output__`: SemanticdbOutputStream): _root_.scala.Unit = {
+      {
+        val __v = value
+        if (__v != 0) {
+          _output__.writeInt32(1, __v)
+        }
+      };
+    }
+    def withValue(__v: _root_.scala.Int): ShortConstant = copy(value = __v)
+    
+    
+    
+    
+    // @@protoc_insertion_point(GeneratedMessage[dotty.tools.dotc.semanticdb.ShortConstant])
+}
+
+object ShortConstant  extends SemanticdbGeneratedMessageCompanion[dotty.tools.dotc.semanticdb.ShortConstant] {
+  implicit def messageCompanion: SemanticdbGeneratedMessageCompanion[dotty.tools.dotc.semanticdb.ShortConstant] = this
+  def parseFrom(`_input__`: SemanticdbInputStream): dotty.tools.dotc.semanticdb.ShortConstant = {
+    var __value: _root_.scala.Int = 0
+    var _done__ = false
+    while (!_done__) {
+      val _tag__ = _input__.readTag()
+      _tag__ match {
+        case 0 => _done__ = true
+        case 8 =>
+          __value = _input__.readInt32()
+        case tag => _input__.skipField(tag)
+      }
+    }
+    dotty.tools.dotc.semanticdb.ShortConstant(
+        value = __value
+    )
+  }
+  
+  
+  
+  
+  
+  
+  lazy val defaultInstance = dotty.tools.dotc.semanticdb.ShortConstant(
+    value = 0
+  )
+  final val VALUE_FIELD_NUMBER = 1
+  def of(
+    value: _root_.scala.Int
+  ): _root_.dotty.tools.dotc.semanticdb.ShortConstant = _root_.dotty.tools.dotc.semanticdb.ShortConstant(
+    value
+  )
+  // @@protoc_insertion_point(GeneratedMessageCompanion[dotty.tools.dotc.semanticdb.ShortConstant])
+}
+
+@SerialVersionUID(0L)
+final case class CharConstant(
+    value: _root_.scala.Int = 0
+    )  extends dotty.tools.dotc.semanticdb.Constant.NonEmpty with SemanticdbGeneratedMessage  derives CanEqual {
+    @transient @sharable
+    private[this] var __serializedSizeMemoized: _root_.scala.Int = 0
+    private[this] def __computeSerializedSize(): _root_.scala.Int = {
+      var __size = 0
+      
+      {
+        val __value = value
+        if (__value != 0) {
+          __size += SemanticdbOutputStream.computeInt32Size(1, __value)
+        }
+      };
+      __size
+    }
+    override def serializedSize: _root_.scala.Int = {
+      var __size = __serializedSizeMemoized
+      if (__size == 0) {
+        __size = __computeSerializedSize() + 1
+        __serializedSizeMemoized = __size
+      }
+      __size - 1
+      
+    }
+    def writeTo(`_output__`: SemanticdbOutputStream): _root_.scala.Unit = {
+      {
+        val __v = value
+        if (__v != 0) {
+          _output__.writeInt32(1, __v)
+        }
+      };
+    }
+    def withValue(__v: _root_.scala.Int): CharConstant = copy(value = __v)
+    
+    
+    
+    
+    // @@protoc_insertion_point(GeneratedMessage[dotty.tools.dotc.semanticdb.CharConstant])
+}
+
+object CharConstant  extends SemanticdbGeneratedMessageCompanion[dotty.tools.dotc.semanticdb.CharConstant] {
+  implicit def messageCompanion: SemanticdbGeneratedMessageCompanion[dotty.tools.dotc.semanticdb.CharConstant] = this
+  def parseFrom(`_input__`: SemanticdbInputStream): dotty.tools.dotc.semanticdb.CharConstant = {
+    var __value: _root_.scala.Int = 0
+    var _done__ = false
+    while (!_done__) {
+      val _tag__ = _input__.readTag()
+      _tag__ match {
+        case 0 => _done__ = true
+        case 8 =>
+          __value = _input__.readInt32()
+        case tag => _input__.skipField(tag)
+      }
+    }
+    dotty.tools.dotc.semanticdb.CharConstant(
+        value = __value
+    )
+  }
+  
+  
+  
+  
+  
+  
+  lazy val defaultInstance = dotty.tools.dotc.semanticdb.CharConstant(
+    value = 0
+  )
+  final val VALUE_FIELD_NUMBER = 1
+  def of(
+    value: _root_.scala.Int
+  ): _root_.dotty.tools.dotc.semanticdb.CharConstant = _root_.dotty.tools.dotc.semanticdb.CharConstant(
+    value
+  )
+  // @@protoc_insertion_point(GeneratedMessageCompanion[dotty.tools.dotc.semanticdb.CharConstant])
+}
+
+@SerialVersionUID(0L)
+final case class IntConstant(
+    value: _root_.scala.Int = 0
+    )  extends dotty.tools.dotc.semanticdb.Constant.NonEmpty with SemanticdbGeneratedMessage  derives CanEqual {
+    @transient @sharable
+    private[this] var __serializedSizeMemoized: _root_.scala.Int = 0
+    private[this] def __computeSerializedSize(): _root_.scala.Int = {
+      var __size = 0
+      
+      {
+        val __value = value
+        if (__value != 0) {
+          __size += SemanticdbOutputStream.computeInt32Size(1, __value)
+        }
+      };
+      __size
+    }
+    override def serializedSize: _root_.scala.Int = {
+      var __size = __serializedSizeMemoized
+      if (__size == 0) {
+        __size = __computeSerializedSize() + 1
+        __serializedSizeMemoized = __size
+      }
+      __size - 1
+      
+    }
+    def writeTo(`_output__`: SemanticdbOutputStream): _root_.scala.Unit = {
+      {
+        val __v = value
+        if (__v != 0) {
+          _output__.writeInt32(1, __v)
+        }
+      };
+    }
+    def withValue(__v: _root_.scala.Int): IntConstant = copy(value = __v)
+    
+    
+    
+    
+    // @@protoc_insertion_point(GeneratedMessage[dotty.tools.dotc.semanticdb.IntConstant])
+}
+
+object IntConstant  extends SemanticdbGeneratedMessageCompanion[dotty.tools.dotc.semanticdb.IntConstant] {
+  implicit def messageCompanion: SemanticdbGeneratedMessageCompanion[dotty.tools.dotc.semanticdb.IntConstant] = this
+  def parseFrom(`_input__`: SemanticdbInputStream): dotty.tools.dotc.semanticdb.IntConstant = {
+    var __value: _root_.scala.Int = 0
+    var _done__ = false
+    while (!_done__) {
+      val _tag__ = _input__.readTag()
+      _tag__ match {
+        case 0 => _done__ = true
+        case 8 =>
+          __value = _input__.readInt32()
+        case tag => _input__.skipField(tag)
+      }
+    }
+    dotty.tools.dotc.semanticdb.IntConstant(
+        value = __value
+    )
+  }
+  
+  
+  
+  
+  
+  
+  lazy val defaultInstance = dotty.tools.dotc.semanticdb.IntConstant(
+    value = 0
+  )
+  final val VALUE_FIELD_NUMBER = 1
+  def of(
+    value: _root_.scala.Int
+  ): _root_.dotty.tools.dotc.semanticdb.IntConstant = _root_.dotty.tools.dotc.semanticdb.IntConstant(
+    value
+  )
+  // @@protoc_insertion_point(GeneratedMessageCompanion[dotty.tools.dotc.semanticdb.IntConstant])
+}
+
+@SerialVersionUID(0L)
+final case class LongConstant(
+    value: _root_.scala.Long = 0L
+    )  extends dotty.tools.dotc.semanticdb.Constant.NonEmpty with SemanticdbGeneratedMessage  derives CanEqual {
+    @transient @sharable
+    private[this] var __serializedSizeMemoized: _root_.scala.Int = 0
+    private[this] def __computeSerializedSize(): _root_.scala.Int = {
+      var __size = 0
+      
+      {
+        val __value = value
+        if (__value != 0L) {
+          __size += SemanticdbOutputStream.computeInt64Size(1, __value)
+        }
+      };
+      __size
+    }
+    override def serializedSize: _root_.scala.Int = {
+      var __size = __serializedSizeMemoized
+      if (__size == 0) {
+        __size = __computeSerializedSize() + 1
+        __serializedSizeMemoized = __size
+      }
+      __size - 1
+      
+    }
+    def writeTo(`_output__`: SemanticdbOutputStream): _root_.scala.Unit = {
+      {
+        val __v = value
+        if (__v != 0L) {
+          _output__.writeInt64(1, __v)
+        }
+      };
+    }
+    def withValue(__v: _root_.scala.Long): LongConstant = copy(value = __v)
+    
+    
+    
+    
+    // @@protoc_insertion_point(GeneratedMessage[dotty.tools.dotc.semanticdb.LongConstant])
+}
+
+object LongConstant  extends SemanticdbGeneratedMessageCompanion[dotty.tools.dotc.semanticdb.LongConstant] {
+  implicit def messageCompanion: SemanticdbGeneratedMessageCompanion[dotty.tools.dotc.semanticdb.LongConstant] = this
+  def parseFrom(`_input__`: SemanticdbInputStream): dotty.tools.dotc.semanticdb.LongConstant = {
+    var __value: _root_.scala.Long = 0L
+    var _done__ = false
+    while (!_done__) {
+      val _tag__ = _input__.readTag()
+      _tag__ match {
+        case 0 => _done__ = true
+        case 8 =>
+          __value = _input__.readInt64()
+        case tag => _input__.skipField(tag)
+      }
+    }
+    dotty.tools.dotc.semanticdb.LongConstant(
+        value = __value
+    )
+  }
+  
+  
+  
+  
+  
+  
+  lazy val defaultInstance = dotty.tools.dotc.semanticdb.LongConstant(
+    value = 0L
+  )
+  final val VALUE_FIELD_NUMBER = 1
+  def of(
+    value: _root_.scala.Long
+  ): _root_.dotty.tools.dotc.semanticdb.LongConstant = _root_.dotty.tools.dotc.semanticdb.LongConstant(
+    value
+  )
+  // @@protoc_insertion_point(GeneratedMessageCompanion[dotty.tools.dotc.semanticdb.LongConstant])
+}
+
+@SerialVersionUID(0L)
+final case class FloatConstant(
+    value: _root_.scala.Float = 0.0f
+    )  extends dotty.tools.dotc.semanticdb.Constant.NonEmpty with SemanticdbGeneratedMessage  derives CanEqual {
+    @transient @sharable
+    private[this] var __serializedSizeMemoized: _root_.scala.Int = 0
+    private[this] def __computeSerializedSize(): _root_.scala.Int = {
+      var __size = 0
+      
+      {
+        val __value = value
+        if (__value != 0.0f) {
+          __size += SemanticdbOutputStream.computeFloatSize(1, __value)
+        }
+      };
+      __size
+    }
+    override def serializedSize: _root_.scala.Int = {
+      var __size = __serializedSizeMemoized
+      if (__size == 0) {
+        __size = __computeSerializedSize() + 1
+        __serializedSizeMemoized = __size
+      }
+      __size - 1
+      
+    }
+    def writeTo(`_output__`: SemanticdbOutputStream): _root_.scala.Unit = {
+      {
+        val __v = value
+        if (__v != 0.0f) {
+          _output__.writeFloat(1, __v)
+        }
+      };
+    }
+    def withValue(__v: _root_.scala.Float): FloatConstant = copy(value = __v)
+    
+    
+    
+    
+    // @@protoc_insertion_point(GeneratedMessage[dotty.tools.dotc.semanticdb.FloatConstant])
+}
+
+object FloatConstant  extends SemanticdbGeneratedMessageCompanion[dotty.tools.dotc.semanticdb.FloatConstant] {
+  implicit def messageCompanion: SemanticdbGeneratedMessageCompanion[dotty.tools.dotc.semanticdb.FloatConstant] = this
+  def parseFrom(`_input__`: SemanticdbInputStream): dotty.tools.dotc.semanticdb.FloatConstant = {
+    var __value: _root_.scala.Float = 0.0f
+    var _done__ = false
+    while (!_done__) {
+      val _tag__ = _input__.readTag()
+      _tag__ match {
+        case 0 => _done__ = true
+        case 13 =>
+          __value = _input__.readFloat()
+        case tag => _input__.skipField(tag)
+      }
+    }
+    dotty.tools.dotc.semanticdb.FloatConstant(
+        value = __value
+    )
+  }
+  
+  
+  
+  
+  
+  
+  lazy val defaultInstance = dotty.tools.dotc.semanticdb.FloatConstant(
+    value = 0.0f
+  )
+  final val VALUE_FIELD_NUMBER = 1
+  def of(
+    value: _root_.scala.Float
+  ): _root_.dotty.tools.dotc.semanticdb.FloatConstant = _root_.dotty.tools.dotc.semanticdb.FloatConstant(
+    value
+  )
+  // @@protoc_insertion_point(GeneratedMessageCompanion[dotty.tools.dotc.semanticdb.FloatConstant])
+}
+
+@SerialVersionUID(0L)
+final case class DoubleConstant(
+    value: _root_.scala.Double = 0.0
+    )  extends dotty.tools.dotc.semanticdb.Constant.NonEmpty with SemanticdbGeneratedMessage  derives CanEqual {
+    @transient @sharable
+    private[this] var __serializedSizeMemoized: _root_.scala.Int = 0
+    private[this] def __computeSerializedSize(): _root_.scala.Int = {
+      var __size = 0
+      
+      {
+        val __value = value
+        if (__value != 0.0) {
+          __size += SemanticdbOutputStream.computeDoubleSize(1, __value)
+        }
+      };
+      __size
+    }
+    override def serializedSize: _root_.scala.Int = {
+      var __size = __serializedSizeMemoized
+      if (__size == 0) {
+        __size = __computeSerializedSize() + 1
+        __serializedSizeMemoized = __size
+      }
+      __size - 1
+      
+    }
+    def writeTo(`_output__`: SemanticdbOutputStream): _root_.scala.Unit = {
+      {
+        val __v = value
+        if (__v != 0.0) {
+          _output__.writeDouble(1, __v)
+        }
+      };
+    }
+    def withValue(__v: _root_.scala.Double): DoubleConstant = copy(value = __v)
+    
+    
+    
+    
+    // @@protoc_insertion_point(GeneratedMessage[dotty.tools.dotc.semanticdb.DoubleConstant])
+}
+
+object DoubleConstant  extends SemanticdbGeneratedMessageCompanion[dotty.tools.dotc.semanticdb.DoubleConstant] {
+  implicit def messageCompanion: SemanticdbGeneratedMessageCompanion[dotty.tools.dotc.semanticdb.DoubleConstant] = this
+  def parseFrom(`_input__`: SemanticdbInputStream): dotty.tools.dotc.semanticdb.DoubleConstant = {
+    var __value: _root_.scala.Double = 0.0
+    var _done__ = false
+    while (!_done__) {
+      val _tag__ = _input__.readTag()
+      _tag__ match {
+        case 0 => _done__ = true
+        case 9 =>
+          __value = _input__.readDouble()
+        case tag => _input__.skipField(tag)
+      }
+    }
+    dotty.tools.dotc.semanticdb.DoubleConstant(
+        value = __value
+    )
+  }
+  
+  
+  
+  
+  
+  
+  lazy val defaultInstance = dotty.tools.dotc.semanticdb.DoubleConstant(
+    value = 0.0
+  )
+  final val VALUE_FIELD_NUMBER = 1
+  def of(
+    value: _root_.scala.Double
+  ): _root_.dotty.tools.dotc.semanticdb.DoubleConstant = _root_.dotty.tools.dotc.semanticdb.DoubleConstant(
+    value
+  )
+  // @@protoc_insertion_point(GeneratedMessageCompanion[dotty.tools.dotc.semanticdb.DoubleConstant])
+}
+
+@SerialVersionUID(0L)
+final case class StringConstant(
+    value: _root_.scala.Predef.String = ""
+    )  extends dotty.tools.dotc.semanticdb.Constant.NonEmpty with SemanticdbGeneratedMessage  derives CanEqual {
+    @transient @sharable
+    private[this] var __serializedSizeMemoized: _root_.scala.Int = 0
+    private[this] def __computeSerializedSize(): _root_.scala.Int = {
+      var __size = 0
+      
+      {
+        val __value = value
+        if (!__value.isEmpty) {
+          __size += SemanticdbOutputStream.computeStringSize(1, __value)
+        }
+      };
+      __size
+    }
+    override def serializedSize: _root_.scala.Int = {
+      var __size = __serializedSizeMemoized
+      if (__size == 0) {
+        __size = __computeSerializedSize() + 1
+        __serializedSizeMemoized = __size
+      }
+      __size - 1
+      
+    }
+    def writeTo(`_output__`: SemanticdbOutputStream): _root_.scala.Unit = {
+      {
+        val __v = value
+        if (!__v.isEmpty) {
+          _output__.writeString(1, __v)
+        }
+      };
+    }
+    def withValue(__v: _root_.scala.Predef.String): StringConstant = copy(value = __v)
+    
+    
+    
+    
+    // @@protoc_insertion_point(GeneratedMessage[dotty.tools.dotc.semanticdb.StringConstant])
+}
+
+object StringConstant  extends SemanticdbGeneratedMessageCompanion[dotty.tools.dotc.semanticdb.StringConstant] {
+  implicit def messageCompanion: SemanticdbGeneratedMessageCompanion[dotty.tools.dotc.semanticdb.StringConstant] = this
+  def parseFrom(`_input__`: SemanticdbInputStream): dotty.tools.dotc.semanticdb.StringConstant = {
+    var __value: _root_.scala.Predef.String = ""
+    var _done__ = false
+    while (!_done__) {
+      val _tag__ = _input__.readTag()
+      _tag__ match {
+        case 0 => _done__ = true
+        case 10 =>
+          __value = _input__.readStringRequireUtf8()
+        case tag => _input__.skipField(tag)
+      }
+    }
+    dotty.tools.dotc.semanticdb.StringConstant(
+        value = __value
+    )
+  }
+  
+  
+  
+  
+  
+  
+  lazy val defaultInstance = dotty.tools.dotc.semanticdb.StringConstant(
+    value = ""
+  )
+  final val VALUE_FIELD_NUMBER = 1
+  def of(
+    value: _root_.scala.Predef.String
+  ): _root_.dotty.tools.dotc.semanticdb.StringConstant = _root_.dotty.tools.dotc.semanticdb.StringConstant(
+    value
+  )
+  // @@protoc_insertion_point(GeneratedMessageCompanion[dotty.tools.dotc.semanticdb.StringConstant])
+}
+
+@SerialVersionUID(0L)
+final case class NullConstant(
+    )  extends dotty.tools.dotc.semanticdb.Constant.NonEmpty with SemanticdbGeneratedMessage  derives CanEqual {
+    final override def serializedSize: _root_.scala.Int = 0
+    def writeTo(`_output__`: SemanticdbOutputStream): _root_.scala.Unit = {
+    }
+    
+    
+    
+    
+    // @@protoc_insertion_point(GeneratedMessage[dotty.tools.dotc.semanticdb.NullConstant])
+}
+
+object NullConstant  extends SemanticdbGeneratedMessageCompanion[dotty.tools.dotc.semanticdb.NullConstant] {
+  implicit def messageCompanion: SemanticdbGeneratedMessageCompanion[dotty.tools.dotc.semanticdb.NullConstant] = this
+  def parseFrom(`_input__`: SemanticdbInputStream): dotty.tools.dotc.semanticdb.NullConstant = {
+    var _done__ = false
+    while (!_done__) {
+      val _tag__ = _input__.readTag()
+      _tag__ match {
+        case 0 => _done__ = true
+        case tag => _input__.skipField(tag)
+      }
+    }
+    dotty.tools.dotc.semanticdb.NullConstant(
+    )
+  }
+  
+  
+  
+  
+  
+  
+  lazy val defaultInstance = dotty.tools.dotc.semanticdb.NullConstant(
+  )
+  def of(
+  ): _root_.dotty.tools.dotc.semanticdb.NullConstant = _root_.dotty.tools.dotc.semanticdb.NullConstant(
+  )
+  // @@protoc_insertion_point(GeneratedMessageCompanion[dotty.tools.dotc.semanticdb.NullConstant])
+}
diff --git a/tests/pos-with-compiler-cc/dotc/semanticdb/generated/Diagnostic.scala b/tests/pos-with-compiler-cc/dotc/semanticdb/generated/Diagnostic.scala
new file mode 100644
index 000000000000..cc8aa82bf8ea
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/semanticdb/generated/Diagnostic.scala
@@ -0,0 +1,196 @@
+// Generated by https://github.com/tanishiking/semanticdb-for-scala3
+// Generated by the Scala Plugin for the Protocol Buffer Compiler.
+// Do not edit!
+//
+// Protofile syntax: PROTO3
+
+package dotty.tools.dotc.semanticdb
+import dotty.tools.dotc.semanticdb.internal._
+import scala.annotation.internal.sharable
+
+@SerialVersionUID(0L)
+final case class Diagnostic(
+    range: _root_.scala.Option[dotty.tools.dotc.semanticdb.Range] = _root_.scala.None,
+    severity: dotty.tools.dotc.semanticdb.Diagnostic.Severity = dotty.tools.dotc.semanticdb.Diagnostic.Severity.UNKNOWN_SEVERITY,
+    message: _root_.scala.Predef.String = ""
+    )  extends SemanticdbGeneratedMessage  derives CanEqual {
+    @transient @sharable
+    private[this] var __serializedSizeMemoized: _root_.scala.Int = 0
+    private[this] def __computeSerializedSize(): _root_.scala.Int = {
+      var __size = 0
+      if (range.isDefined) {
+        val __value = range.get
+        __size += 1 + SemanticdbOutputStream.computeUInt32SizeNoTag(__value.serializedSize) + __value.serializedSize
+      };
+      
+      {
+        val __value = severity.value
+        if (__value != 0) {
+          __size += SemanticdbOutputStream.computeEnumSize(2, __value)
+        }
+      };
+      
+      {
+        val __value = message
+        if (!__value.isEmpty) {
+          __size += SemanticdbOutputStream.computeStringSize(3, __value)
+        }
+      };
+      __size
+    }
+    override def serializedSize: _root_.scala.Int = {
+      var __size = __serializedSizeMemoized
+      if (__size == 0) {
+        __size = __computeSerializedSize() + 1
+        __serializedSizeMemoized = __size
+      }
+      __size - 1
+      
+    }
+    def writeTo(`_output__`: SemanticdbOutputStream): _root_.scala.Unit = {
+      range.foreach { __v =>
+        val __m = __v
+        _output__.writeTag(1, 2)
+        _output__.writeUInt32NoTag(__m.serializedSize)
+        __m.writeTo(_output__)
+      };
+      {
+        val __v = severity.value
+        if (__v != 0) {
+          _output__.writeEnum(2, __v)
+        }
+      };
+      {
+        val __v = message
+        if (!__v.isEmpty) {
+          _output__.writeString(3, __v)
+        }
+      };
+    }
+    def getRange: dotty.tools.dotc.semanticdb.Range = range.getOrElse(dotty.tools.dotc.semanticdb.Range.defaultInstance)
+    def clearRange: Diagnostic = copy(range = _root_.scala.None)
+    def withRange(__v: dotty.tools.dotc.semanticdb.Range): Diagnostic = copy(range = Option(__v))
+    def withSeverity(__v: dotty.tools.dotc.semanticdb.Diagnostic.Severity): Diagnostic = copy(severity = __v)
+    def withMessage(__v: _root_.scala.Predef.String): Diagnostic = copy(message = __v)
+    
+    
+    
+    
+    // @@protoc_insertion_point(GeneratedMessage[dotty.tools.dotc.semanticdb.Diagnostic])
+}
+
+object Diagnostic  extends SemanticdbGeneratedMessageCompanion[dotty.tools.dotc.semanticdb.Diagnostic] {
+  implicit def messageCompanion: SemanticdbGeneratedMessageCompanion[dotty.tools.dotc.semanticdb.Diagnostic] = this
+  def parseFrom(`_input__`: SemanticdbInputStream): dotty.tools.dotc.semanticdb.Diagnostic = {
+    var __range: _root_.scala.Option[dotty.tools.dotc.semanticdb.Range] = _root_.scala.None
+    var __severity: dotty.tools.dotc.semanticdb.Diagnostic.Severity = dotty.tools.dotc.semanticdb.Diagnostic.Severity.UNKNOWN_SEVERITY
+    var __message: _root_.scala.Predef.String = ""
+    var _done__ = false
+    while (!_done__) {
+      val _tag__ = _input__.readTag()
+      _tag__ match {
+        case 0 => _done__ = true
+        case 10 =>
+          __range = Option(__range.fold(LiteParser.readMessage[dotty.tools.dotc.semanticdb.Range](_input__))(LiteParser.readMessage(_input__, _)))
+        case 16 =>
+          __severity = dotty.tools.dotc.semanticdb.Diagnostic.Severity.fromValue(_input__.readEnum())
+        case 26 =>
+          __message = _input__.readStringRequireUtf8()
+        case tag => _input__.skipField(tag)
+      }
+    }
+    dotty.tools.dotc.semanticdb.Diagnostic(
+        range = __range,
+        severity = __severity,
+        message = __message
+    )
+  }
+  
+  
+  
+  
+  
+  
+  lazy val defaultInstance = dotty.tools.dotc.semanticdb.Diagnostic(
+    range = _root_.scala.None,
+    severity = dotty.tools.dotc.semanticdb.Diagnostic.Severity.UNKNOWN_SEVERITY,
+    message = ""
+  )
+  sealed abstract class Severity(val value: _root_.scala.Int)  extends SemanticdbGeneratedEnum  derives CanEqual {
+    type EnumType = Severity
+    def isUnknownSeverity: _root_.scala.Boolean = false
+    def isError: _root_.scala.Boolean = false
+    def isWarning: _root_.scala.Boolean = false
+    def isInformation: _root_.scala.Boolean = false
+    def isHint: _root_.scala.Boolean = false
+    
+    final def asRecognized: _root_.scala.Option[dotty.tools.dotc.semanticdb.Diagnostic.Severity.Recognized] = if (isUnrecognized) _root_.scala.None else _root_.scala.Some(this.asInstanceOf[dotty.tools.dotc.semanticdb.Diagnostic.Severity.Recognized])
+  }
+  
+  object Severity  {
+    sealed trait Recognized extends Severity
+    
+    
+    @SerialVersionUID(0L)
+    case object UNKNOWN_SEVERITY extends Severity(0) with Severity.Recognized {
+      val index = 0
+      val name = "UNKNOWN_SEVERITY"
+      override def isUnknownSeverity: _root_.scala.Boolean = true
+    }
+    
+    @SerialVersionUID(0L)
+    case object ERROR extends Severity(1) with Severity.Recognized {
+      val index = 1
+      val name = "ERROR"
+      override def isError: _root_.scala.Boolean = true
+    }
+    
+    @SerialVersionUID(0L)
+    case object WARNING extends Severity(2) with Severity.Recognized {
+      val index = 2
+      val name = "WARNING"
+      override def isWarning: _root_.scala.Boolean = true
+    }
+    
+    @SerialVersionUID(0L)
+    case object INFORMATION extends Severity(3) with Severity.Recognized {
+      val index = 3
+      val name = "INFORMATION"
+      override def isInformation: _root_.scala.Boolean = true
+    }
+    
+    @SerialVersionUID(0L)
+    case object HINT extends Severity(4) with Severity.Recognized {
+      val index = 4
+      val name = "HINT"
+      override def isHint: _root_.scala.Boolean = true
+    }
+    
+    @SerialVersionUID(0L)
+    final case class Unrecognized(unrecognizedValue: _root_.scala.Int)  extends Severity(unrecognizedValue) with SemanticdbUnrecognizedEnum
+    lazy val values = scala.collection.immutable.Seq(UNKNOWN_SEVERITY, ERROR, WARNING, INFORMATION, HINT)
+    def fromValue(__value: _root_.scala.Int): Severity = __value match {
+      case 0 => UNKNOWN_SEVERITY
+      case 1 => ERROR
+      case 2 => WARNING
+      case 3 => INFORMATION
+      case 4 => HINT
+      case __other => Unrecognized(__other)
+    }
+    
+    
+  }
+  final val RANGE_FIELD_NUMBER = 1
+  final val SEVERITY_FIELD_NUMBER = 2
+  final val MESSAGE_FIELD_NUMBER = 3
+  def of(
+    range: _root_.scala.Option[dotty.tools.dotc.semanticdb.Range],
+    severity: dotty.tools.dotc.semanticdb.Diagnostic.Severity,
+    message: _root_.scala.Predef.String
+  ): _root_.dotty.tools.dotc.semanticdb.Diagnostic = _root_.dotty.tools.dotc.semanticdb.Diagnostic(
+    range,
+    severity,
+    message
+  )
+  // @@protoc_insertion_point(GeneratedMessageCompanion[dotty.tools.dotc.semanticdb.Diagnostic])
+}
diff --git a/tests/pos-with-compiler-cc/dotc/semanticdb/generated/Documentation.scala b/tests/pos-with-compiler-cc/dotc/semanticdb/generated/Documentation.scala
new file mode 100644
index 000000000000..07fbda4991af
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/semanticdb/generated/Documentation.scala
@@ -0,0 +1,174 @@
+// Generated by https://github.com/tanishiking/semanticdb-for-scala3
+// Generated by the Scala Plugin for the Protocol Buffer Compiler.
+// Do not edit!
+//
+// Protofile syntax: PROTO3
+
+package dotty.tools.dotc.semanticdb
+import dotty.tools.dotc.semanticdb.internal._
+import scala.annotation.internal.sharable
+
+@SerialVersionUID(0L)
+final case class Documentation(
+    message: _root_.scala.Predef.String = "",
+    format: dotty.tools.dotc.semanticdb.Documentation.Format = dotty.tools.dotc.semanticdb.Documentation.Format.HTML
+    )  extends SemanticdbGeneratedMessage  derives CanEqual {
+    @transient @sharable
+    private[this] var __serializedSizeMemoized: _root_.scala.Int = 0
+    private[this] def __computeSerializedSize(): _root_.scala.Int = {
+      var __size = 0
+      
+      {
+        val __value = message
+        if (!__value.isEmpty) {
+          __size += SemanticdbOutputStream.computeStringSize(1, __value)
+        }
+      };
+      
+      {
+        val __value = format.value
+        if (__value != 0) {
+          __size += SemanticdbOutputStream.computeEnumSize(2, __value)
+        }
+      };
+      __size
+    }
+    override def serializedSize: _root_.scala.Int = {
+      var __size = __serializedSizeMemoized
+      if (__size == 0) {
+        __size = __computeSerializedSize() + 1
+        __serializedSizeMemoized = __size
+      }
+      __size - 1
+      
+    }
+    def writeTo(`_output__`: SemanticdbOutputStream): _root_.scala.Unit = {
+      {
+        val __v = message
+        if (!__v.isEmpty) {
+          _output__.writeString(1, __v)
+        }
+      };
+      {
+        val __v = format.value
+        if (__v != 0) {
+          _output__.writeEnum(2, __v)
+        }
+      };
+    }
+    def withMessage(__v: _root_.scala.Predef.String): Documentation = copy(message = __v)
+    def withFormat(__v: dotty.tools.dotc.semanticdb.Documentation.Format): Documentation = copy(format = __v)
+    
+    
+    
+    
+    // @@protoc_insertion_point(GeneratedMessage[dotty.tools.dotc.semanticdb.Documentation])
+}
+
+object Documentation  extends SemanticdbGeneratedMessageCompanion[dotty.tools.dotc.semanticdb.Documentation] {
+  implicit def messageCompanion: SemanticdbGeneratedMessageCompanion[dotty.tools.dotc.semanticdb.Documentation] = this
+  def parseFrom(`_input__`: SemanticdbInputStream): dotty.tools.dotc.semanticdb.Documentation = {
+    var __message: _root_.scala.Predef.String = ""
+    var __format: dotty.tools.dotc.semanticdb.Documentation.Format = dotty.tools.dotc.semanticdb.Documentation.Format.HTML
+    var _done__ = false
+    while (!_done__) {
+      val _tag__ = _input__.readTag()
+      _tag__ match {
+        case 0 => _done__ = true
+        case 10 =>
+          __message = _input__.readStringRequireUtf8()
+        case 16 =>
+          __format = dotty.tools.dotc.semanticdb.Documentation.Format.fromValue(_input__.readEnum())
+        case tag => _input__.skipField(tag)
+      }
+    }
+    dotty.tools.dotc.semanticdb.Documentation(
+        message = __message,
+        format = __format
+    )
+  }
+  
+  
+  
+  
+  
+  
+  lazy val defaultInstance = dotty.tools.dotc.semanticdb.Documentation(
+    message = "",
+    format = dotty.tools.dotc.semanticdb.Documentation.Format.HTML
+  )
+  sealed abstract class Format(val value: _root_.scala.Int)  extends SemanticdbGeneratedEnum  derives CanEqual {
+    type EnumType = Format
+    def isHtml: _root_.scala.Boolean = false
+    def isMarkdown: _root_.scala.Boolean = false
+    def isJavadoc: _root_.scala.Boolean = false
+    def isScaladoc: _root_.scala.Boolean = false
+    def isKdoc: _root_.scala.Boolean = false
+    
+    final def asRecognized: _root_.scala.Option[dotty.tools.dotc.semanticdb.Documentation.Format.Recognized] = if (isUnrecognized) _root_.scala.None else _root_.scala.Some(this.asInstanceOf[dotty.tools.dotc.semanticdb.Documentation.Format.Recognized])
+  }
+  
+  object Format  {
+    sealed trait Recognized extends Format
+    
+    
+    @SerialVersionUID(0L)
+    case object HTML extends Format(0) with Format.Recognized {
+      val index = 0
+      val name = "HTML"
+      override def isHtml: _root_.scala.Boolean = true
+    }
+    
+    @SerialVersionUID(0L)
+    case object MARKDOWN extends Format(1) with Format.Recognized {
+      val index = 1
+      val name = "MARKDOWN"
+      override def isMarkdown: _root_.scala.Boolean = true
+    }
+    
+    @SerialVersionUID(0L)
+    case object JAVADOC extends Format(2) with Format.Recognized {
+      val index = 2
+      val name = "JAVADOC"
+      override def isJavadoc: _root_.scala.Boolean = true
+    }
+    
+    @SerialVersionUID(0L)
+    case object SCALADOC extends Format(3) with Format.Recognized {
+      val index = 3
+      val name = "SCALADOC"
+      override def isScaladoc: _root_.scala.Boolean = true
+    }
+    
+    @SerialVersionUID(0L)
+    case object KDOC extends Format(4) with Format.Recognized {
+      val index = 4
+      val name = "KDOC"
+      override def isKdoc: _root_.scala.Boolean = true
+    }
+    
+    @SerialVersionUID(0L)
+    final case class Unrecognized(unrecognizedValue: _root_.scala.Int)  extends Format(unrecognizedValue) with SemanticdbUnrecognizedEnum
+    lazy val values = scala.collection.immutable.Seq(HTML, MARKDOWN, JAVADOC, SCALADOC, KDOC)
+    def fromValue(__value: _root_.scala.Int): Format = __value match {
+      case 0 => HTML
+      case 1 => MARKDOWN
+      case 2 => JAVADOC
+      case 3 => SCALADOC
+      case 4 => KDOC
+      case __other => Unrecognized(__other)
+    }
+    
+    
+  }
+  final val MESSAGE_FIELD_NUMBER = 1
+  final val FORMAT_FIELD_NUMBER = 2
+  def of(
+    message: _root_.scala.Predef.String,
+    format: dotty.tools.dotc.semanticdb.Documentation.Format
+  ): _root_.dotty.tools.dotc.semanticdb.Documentation = _root_.dotty.tools.dotc.semanticdb.Documentation(
+    message,
+    format
+  )
+  // @@protoc_insertion_point(GeneratedMessageCompanion[dotty.tools.dotc.semanticdb.Documentation])
+}
diff --git a/tests/pos-with-compiler-cc/dotc/semanticdb/generated/Language.scala b/tests/pos-with-compiler-cc/dotc/semanticdb/generated/Language.scala
new file mode 100644
index 000000000000..c57a3d3cddc3
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/semanticdb/generated/Language.scala
@@ -0,0 +1,56 @@
+// Generated by https://github.com/tanishiking/semanticdb-for-scala3
+// Generated by the Scala Plugin for the Protocol Buffer Compiler.
+// Do not edit!
+//
+// Protofile syntax: PROTO3
+
+package dotty.tools.dotc.semanticdb
+import dotty.tools.dotc.semanticdb.internal._
+import scala.annotation.internal.sharable
+
+sealed abstract class Language(val value: _root_.scala.Int)  extends SemanticdbGeneratedEnum  derives CanEqual {
+  type EnumType = Language
+  def isUnknownLanguage: _root_.scala.Boolean = false
+  def isScala: _root_.scala.Boolean = false
+  def isJava: _root_.scala.Boolean = false
+  
+  final def asRecognized: _root_.scala.Option[dotty.tools.dotc.semanticdb.Language.Recognized] = if (isUnrecognized) _root_.scala.None else _root_.scala.Some(this.asInstanceOf[dotty.tools.dotc.semanticdb.Language.Recognized])
+}
+
+object Language  {
+  sealed trait Recognized extends Language
+  
+  
+  @SerialVersionUID(0L)
+  case object UNKNOWN_LANGUAGE extends Language(0) with Language.Recognized {
+    val index = 0
+    val name = "UNKNOWN_LANGUAGE"
+    override def isUnknownLanguage: _root_.scala.Boolean = true
+  }
+  
+  @SerialVersionUID(0L)
+  case object SCALA extends Language(1) with Language.Recognized {
+    val index = 1
+    val name = "SCALA"
+    override def isScala: _root_.scala.Boolean = true
+  }
+  
+  @SerialVersionUID(0L)
+  case object JAVA extends Language(2) with Language.Recognized {
+    val index = 2
+    val name = "JAVA"
+    override def isJava: _root_.scala.Boolean = true
+  }
+  
+  @SerialVersionUID(0L)
+  final case class Unrecognized(unrecognizedValue: _root_.scala.Int)  extends Language(unrecognizedValue) with SemanticdbUnrecognizedEnum
+  lazy val values = scala.collection.immutable.Seq(UNKNOWN_LANGUAGE, SCALA, JAVA)
+  def fromValue(__value: _root_.scala.Int): Language = __value match {
+    case 0 => UNKNOWN_LANGUAGE
+    case 1 => SCALA
+    case 2 => JAVA
+    case __other => Unrecognized(__other)
+  }
+  
+  
+}
\ No newline at end of file
diff --git a/tests/pos-with-compiler-cc/dotc/semanticdb/generated/Location.scala b/tests/pos-with-compiler-cc/dotc/semanticdb/generated/Location.scala
new file mode 100644
index 000000000000..a3667e944ae4
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/semanticdb/generated/Location.scala
@@ -0,0 +1,109 @@
+// Generated by https://github.com/tanishiking/semanticdb-for-scala3
+// Generated by the Scala Plugin for the Protocol Buffer Compiler.
+// Do not edit!
+//
+// Protofile syntax: PROTO3
+
+package dotty.tools.dotc.semanticdb
+import dotty.tools.dotc.semanticdb.internal._
+import scala.annotation.internal.sharable
+
+@SerialVersionUID(0L)
+final case class Location(
+    uri: _root_.scala.Predef.String = "",
+    range: _root_.scala.Option[dotty.tools.dotc.semanticdb.Range] = _root_.scala.None
+    )  extends SemanticdbGeneratedMessage  derives CanEqual {
+    @transient @sharable
+    private[this] var __serializedSizeMemoized: _root_.scala.Int = 0
+    private[this] def __computeSerializedSize(): _root_.scala.Int = {
+      var __size = 0
+      
+      {
+        val __value = uri
+        if (!__value.isEmpty) {
+          __size += SemanticdbOutputStream.computeStringSize(1, __value)
+        }
+      };
+      if (range.isDefined) {
+        val __value = range.get
+        __size += 1 + SemanticdbOutputStream.computeUInt32SizeNoTag(__value.serializedSize) + __value.serializedSize
+      };
+      __size
+    }
+    override def serializedSize: _root_.scala.Int = {
+      var __size = __serializedSizeMemoized
+      if (__size == 0) {
+        __size = __computeSerializedSize() + 1
+        __serializedSizeMemoized = __size
+      }
+      __size - 1
+      
+    }
+    def writeTo(`_output__`: SemanticdbOutputStream): _root_.scala.Unit = {
+      {
+        val __v = uri
+        if (!__v.isEmpty) {
+          _output__.writeString(1, __v)
+        }
+      };
+      range.foreach { __v =>
+        val __m = __v
+        _output__.writeTag(2, 2)
+        _output__.writeUInt32NoTag(__m.serializedSize)
+        __m.writeTo(_output__)
+      };
+    }
+    def withUri(__v: _root_.scala.Predef.String): Location = copy(uri = __v)
+    def getRange: dotty.tools.dotc.semanticdb.Range = range.getOrElse(dotty.tools.dotc.semanticdb.Range.defaultInstance)
+    def clearRange: Location = copy(range = _root_.scala.None)
+    def withRange(__v: dotty.tools.dotc.semanticdb.Range): Location = copy(range = Option(__v))
+    
+    
+    
+    
+    // @@protoc_insertion_point(GeneratedMessage[dotty.tools.dotc.semanticdb.Location])
+}
+
+object Location  extends SemanticdbGeneratedMessageCompanion[dotty.tools.dotc.semanticdb.Location] {
+  implicit def messageCompanion: SemanticdbGeneratedMessageCompanion[dotty.tools.dotc.semanticdb.Location] = this
+  def parseFrom(`_input__`: SemanticdbInputStream): dotty.tools.dotc.semanticdb.Location = {
+    var __uri: _root_.scala.Predef.String = ""
+    var __range: _root_.scala.Option[dotty.tools.dotc.semanticdb.Range] = _root_.scala.None
+    var _done__ = false
+    while (!_done__) {
+      val _tag__ = _input__.readTag()
+      _tag__ match {
+        case 0 => _done__ = true
+        case 10 =>
+          __uri = _input__.readStringRequireUtf8()
+        case 18 =>
+          __range = Option(__range.fold(LiteParser.readMessage[dotty.tools.dotc.semanticdb.Range](_input__))(LiteParser.readMessage(_input__, _)))
+        case tag => _input__.skipField(tag)
+      }
+    }
+    dotty.tools.dotc.semanticdb.Location(
+        uri = __uri,
+        range = __range
+    )
+  }
+  
+  
+  
+  
+  
+  
+  lazy val defaultInstance = dotty.tools.dotc.semanticdb.Location(
+    uri = "",
+    range = _root_.scala.None
+  )
+  final val URI_FIELD_NUMBER = 1
+  final val RANGE_FIELD_NUMBER = 2
+  def of(
+    uri: _root_.scala.Predef.String,
+    range: _root_.scala.Option[dotty.tools.dotc.semanticdb.Range]
+  ): _root_.dotty.tools.dotc.semanticdb.Location = _root_.dotty.tools.dotc.semanticdb.Location(
+    uri,
+    range
+  )
+  // @@protoc_insertion_point(GeneratedMessageCompanion[dotty.tools.dotc.semanticdb.Location])
+}
diff --git a/tests/pos-with-compiler-cc/dotc/semanticdb/generated/Range.scala b/tests/pos-with-compiler-cc/dotc/semanticdb/generated/Range.scala
new file mode 100644
index 000000000000..d273664bdf6a
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/semanticdb/generated/Range.scala
@@ -0,0 +1,156 @@
+// Generated by https://github.com/tanishiking/semanticdb-for-scala3
+// Generated by the Scala Plugin for the Protocol Buffer Compiler.
+// Do not edit!
+//
+// Protofile syntax: PROTO3
+
+package dotty.tools.dotc.semanticdb
+import dotty.tools.dotc.semanticdb.internal._
+import scala.annotation.internal.sharable
+
+@SerialVersionUID(0L)
+final case class Range(
+    startLine: _root_.scala.Int = 0,
+    startCharacter: _root_.scala.Int = 0,
+    endLine: _root_.scala.Int = 0,
+    endCharacter: _root_.scala.Int = 0
+    )  extends SemanticdbGeneratedMessage  derives CanEqual {
+    @transient @sharable
+    private[this] var __serializedSizeMemoized: _root_.scala.Int = 0
+    private[this] def __computeSerializedSize(): _root_.scala.Int = {
+      var __size = 0
+      
+      {
+        val __value = startLine
+        if (__value != 0) {
+          __size += SemanticdbOutputStream.computeInt32Size(1, __value)
+        }
+      };
+      
+      {
+        val __value = startCharacter
+        if (__value != 0) {
+          __size += SemanticdbOutputStream.computeInt32Size(2, __value)
+        }
+      };
+      
+      {
+        val __value = endLine
+        if (__value != 0) {
+          __size += SemanticdbOutputStream.computeInt32Size(3, __value)
+        }
+      };
+      
+      {
+        val __value = endCharacter
+        if (__value != 0) {
+          __size += SemanticdbOutputStream.computeInt32Size(4, __value)
+        }
+      };
+      __size
+    }
+    override def serializedSize: _root_.scala.Int = {
+      var __size = __serializedSizeMemoized
+      if (__size == 0) {
+        __size = __computeSerializedSize() + 1
+        __serializedSizeMemoized = __size
+      }
+      __size - 1
+      
+    }
+    def writeTo(`_output__`: SemanticdbOutputStream): _root_.scala.Unit = {
+      {
+        val __v = startLine
+        if (__v != 0) {
+          _output__.writeInt32(1, __v)
+        }
+      };
+      {
+        val __v = startCharacter
+        if (__v != 0) {
+          _output__.writeInt32(2, __v)
+        }
+      };
+      {
+        val __v = endLine
+        if (__v != 0) {
+          _output__.writeInt32(3, __v)
+        }
+      };
+      {
+        val __v = endCharacter
+        if (__v != 0) {
+          _output__.writeInt32(4, __v)
+        }
+      };
+    }
+    def withStartLine(__v: _root_.scala.Int): Range = copy(startLine = __v)
+    def withStartCharacter(__v: _root_.scala.Int): Range = copy(startCharacter = __v)
+    def withEndLine(__v: _root_.scala.Int): Range = copy(endLine = __v)
+    def withEndCharacter(__v: _root_.scala.Int): Range = copy(endCharacter = __v)
+    
+    
+    
+    
+    // @@protoc_insertion_point(GeneratedMessage[dotty.tools.dotc.semanticdb.Range])
+}
+
+object Range  extends SemanticdbGeneratedMessageCompanion[dotty.tools.dotc.semanticdb.Range] {
+  implicit def messageCompanion: SemanticdbGeneratedMessageCompanion[dotty.tools.dotc.semanticdb.Range] = this
+  def parseFrom(`_input__`: SemanticdbInputStream): dotty.tools.dotc.semanticdb.Range = {
+    var __startLine: _root_.scala.Int = 0
+    var __startCharacter: _root_.scala.Int = 0
+    var __endLine: _root_.scala.Int = 0
+    var __endCharacter: _root_.scala.Int = 0
+    var _done__ = false
+    while (!_done__) {
+      val _tag__ = _input__.readTag()
+      _tag__ match {
+        case 0 => _done__ = true
+        case 8 =>
+          __startLine = _input__.readInt32()
+        case 16 =>
+          __startCharacter = _input__.readInt32()
+        case 24 =>
+          __endLine = _input__.readInt32()
+        case 32 =>
+          __endCharacter = _input__.readInt32()
+        case tag => _input__.skipField(tag)
+      }
+    }
+    dotty.tools.dotc.semanticdb.Range(
+        startLine = __startLine,
+        startCharacter = __startCharacter,
+        endLine = __endLine,
+        endCharacter = __endCharacter
+    )
+  }
+  
+  
+  
+  
+  
+  
+  lazy val defaultInstance = dotty.tools.dotc.semanticdb.Range(
+    startLine = 0,
+    startCharacter = 0,
+    endLine = 0,
+    endCharacter = 0
+  )
+  final val START_LINE_FIELD_NUMBER = 1
+  final val START_CHARACTER_FIELD_NUMBER = 2
+  final val END_LINE_FIELD_NUMBER = 3
+  final val END_CHARACTER_FIELD_NUMBER = 4
+  def of(
+    startLine: _root_.scala.Int,
+    startCharacter: _root_.scala.Int,
+    endLine: _root_.scala.Int,
+    endCharacter: _root_.scala.Int
+  ): _root_.dotty.tools.dotc.semanticdb.Range = _root_.dotty.tools.dotc.semanticdb.Range(
+    startLine,
+    startCharacter,
+    endLine,
+    endCharacter
+  )
+  // @@protoc_insertion_point(GeneratedMessageCompanion[dotty.tools.dotc.semanticdb.Range])
+}
diff --git a/tests/pos-with-compiler-cc/dotc/semanticdb/generated/Schema.scala b/tests/pos-with-compiler-cc/dotc/semanticdb/generated/Schema.scala
new file mode 100644
index 000000000000..841e69166feb
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/semanticdb/generated/Schema.scala
@@ -0,0 +1,56 @@
+// Generated by https://github.com/tanishiking/semanticdb-for-scala3
+// Generated by the Scala Plugin for the Protocol Buffer Compiler.
+// Do not edit!
+//
+// Protofile syntax: PROTO3
+
+package dotty.tools.dotc.semanticdb
+import dotty.tools.dotc.semanticdb.internal._
+import scala.annotation.internal.sharable
+
+sealed abstract class Schema(val value: _root_.scala.Int)  extends SemanticdbGeneratedEnum  derives CanEqual {
+  type EnumType = Schema
+  def isLegacy: _root_.scala.Boolean = false
+  def isSemanticdb3: _root_.scala.Boolean = false
+  def isSemanticdb4: _root_.scala.Boolean = false
+  
+  final def asRecognized: _root_.scala.Option[dotty.tools.dotc.semanticdb.Schema.Recognized] = if (isUnrecognized) _root_.scala.None else _root_.scala.Some(this.asInstanceOf[dotty.tools.dotc.semanticdb.Schema.Recognized])
+}
+
+object Schema  {
+  sealed trait Recognized extends Schema
+  
+  
+  @SerialVersionUID(0L)
+  case object LEGACY extends Schema(0) with Schema.Recognized {
+    val index = 0
+    val name = "LEGACY"
+    override def isLegacy: _root_.scala.Boolean = true
+  }
+  
+  @SerialVersionUID(0L)
+  case object SEMANTICDB3 extends Schema(3) with Schema.Recognized {
+    val index = 1
+    val name = "SEMANTICDB3"
+    override def isSemanticdb3: _root_.scala.Boolean = true
+  }
+  
+  @SerialVersionUID(0L)
+  case object SEMANTICDB4 extends Schema(4) with Schema.Recognized {
+    val index = 2
+    val name = "SEMANTICDB4"
+    override def isSemanticdb4: _root_.scala.Boolean = true
+  }
+  
+  @SerialVersionUID(0L)
+  final case class Unrecognized(unrecognizedValue: _root_.scala.Int)  extends Schema(unrecognizedValue) with SemanticdbUnrecognizedEnum
+  lazy val values = scala.collection.immutable.Seq(LEGACY, SEMANTICDB3, SEMANTICDB4)
+  def fromValue(__value: _root_.scala.Int): Schema = __value match {
+    case 0 => LEGACY
+    case 3 => SEMANTICDB3
+    case 4 => SEMANTICDB4
+    case __other => Unrecognized(__other)
+  }
+  
+  
+}
\ No newline at end of file
diff --git a/tests/pos-with-compiler-cc/dotc/semanticdb/generated/Scope.scala b/tests/pos-with-compiler-cc/dotc/semanticdb/generated/Scope.scala
new file mode 100644
index 000000000000..655ebe75185e
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/semanticdb/generated/Scope.scala
@@ -0,0 +1,108 @@
+// Generated by https://github.com/tanishiking/semanticdb-for-scala3
+// Generated by the Scala Plugin for the Protocol Buffer Compiler.
+// Do not edit!
+//
+// Protofile syntax: PROTO3
+
+package dotty.tools.dotc.semanticdb
+import dotty.tools.dotc.semanticdb.internal._
+import scala.annotation.internal.sharable
+
+@SerialVersionUID(0L)
+final case class Scope(
+    symlinks: _root_.scala.Seq[_root_.scala.Predef.String] = _root_.scala.Seq.empty,
+    hardlinks: _root_.scala.Seq[dotty.tools.dotc.semanticdb.SymbolInformation] = _root_.scala.Seq.empty
+    )  extends SemanticdbGeneratedMessage  derives CanEqual {
+    @transient @sharable
+    private[this] var __serializedSizeMemoized: _root_.scala.Int = 0
+    private[this] def __computeSerializedSize(): _root_.scala.Int = {
+      var __size = 0
+      symlinks.foreach { __item =>
+        val __value = __item
+        __size += SemanticdbOutputStream.computeStringSize(1, __value)
+      }
+      hardlinks.foreach { __item =>
+        val __value = __item
+        __size += 1 + SemanticdbOutputStream.computeUInt32SizeNoTag(__value.serializedSize) + __value.serializedSize
+      }
+      __size
+    }
+    override def serializedSize: _root_.scala.Int = {
+      var __size = __serializedSizeMemoized
+      if (__size == 0) {
+        __size = __computeSerializedSize() + 1
+        __serializedSizeMemoized = __size
+      }
+      __size - 1
+      
+    }
+    def writeTo(`_output__`: SemanticdbOutputStream): _root_.scala.Unit = {
+      symlinks.foreach { __v =>
+        val __m = __v
+        _output__.writeString(1, __m)
+      };
+      hardlinks.foreach { __v =>
+        val __m = __v
+        _output__.writeTag(2, 2)
+        _output__.writeUInt32NoTag(__m.serializedSize)
+        __m.writeTo(_output__)
+      };
+    }
+    def clearSymlinks = copy(symlinks = _root_.scala.Seq.empty)
+    def addSymlinks(__vs: _root_.scala.Predef.String *): Scope = addAllSymlinks(__vs)
+    def addAllSymlinks(__vs: Iterable[_root_.scala.Predef.String]): Scope = copy(symlinks = symlinks ++ __vs)
+    def withSymlinks(__v: _root_.scala.Seq[_root_.scala.Predef.String]): Scope = copy(symlinks = __v)
+    def clearHardlinks = copy(hardlinks = _root_.scala.Seq.empty)
+    def addHardlinks(__vs: dotty.tools.dotc.semanticdb.SymbolInformation *): Scope = addAllHardlinks(__vs)
+    def addAllHardlinks(__vs: Iterable[dotty.tools.dotc.semanticdb.SymbolInformation]): Scope = copy(hardlinks = hardlinks ++ __vs)
+    def withHardlinks(__v: _root_.scala.Seq[dotty.tools.dotc.semanticdb.SymbolInformation]): Scope = copy(hardlinks = __v)
+    
+    
+    
+    
+    // @@protoc_insertion_point(GeneratedMessage[dotty.tools.dotc.semanticdb.Scope])
+}
+
+object Scope  extends SemanticdbGeneratedMessageCompanion[dotty.tools.dotc.semanticdb.Scope] {
+  implicit def messageCompanion: SemanticdbGeneratedMessageCompanion[dotty.tools.dotc.semanticdb.Scope] = this
+  def parseFrom(`_input__`: SemanticdbInputStream): dotty.tools.dotc.semanticdb.Scope = {
+    val __symlinks: _root_.scala.collection.immutable.VectorBuilder[_root_.scala.Predef.String] = new _root_.scala.collection.immutable.VectorBuilder[_root_.scala.Predef.String]
+    val __hardlinks: _root_.scala.collection.immutable.VectorBuilder[dotty.tools.dotc.semanticdb.SymbolInformation] = new _root_.scala.collection.immutable.VectorBuilder[dotty.tools.dotc.semanticdb.SymbolInformation]
+    var _done__ = false
+    while (!_done__) {
+      val _tag__ = _input__.readTag()
+      _tag__ match {
+        case 0 => _done__ = true
+        case 10 =>
+          __symlinks += _input__.readStringRequireUtf8()
+        case 18 =>
+          __hardlinks += LiteParser.readMessage[dotty.tools.dotc.semanticdb.SymbolInformation](_input__)
+        case tag => _input__.skipField(tag)
+      }
+    }
+    dotty.tools.dotc.semanticdb.Scope(
+        symlinks = __symlinks.result(),
+        hardlinks = __hardlinks.result()
+    )
+  }
+  
+  
+  
+  
+  
+  
+  lazy val defaultInstance = dotty.tools.dotc.semanticdb.Scope(
+    symlinks = _root_.scala.Seq.empty,
+    hardlinks = _root_.scala.Seq.empty
+  )
+  final val SYMLINKS_FIELD_NUMBER = 1
+  final val HARDLINKS_FIELD_NUMBER = 2
+  def of(
+    symlinks: _root_.scala.Seq[_root_.scala.Predef.String],
+    hardlinks: _root_.scala.Seq[dotty.tools.dotc.semanticdb.SymbolInformation]
+  ): _root_.dotty.tools.dotc.semanticdb.Scope = _root_.dotty.tools.dotc.semanticdb.Scope(
+    symlinks,
+    hardlinks
+  )
+  // @@protoc_insertion_point(GeneratedMessageCompanion[dotty.tools.dotc.semanticdb.Scope])
+}
diff --git a/tests/pos-with-compiler-cc/dotc/semanticdb/generated/Signature.scala b/tests/pos-with-compiler-cc/dotc/semanticdb/generated/Signature.scala
new file mode 100644
index 000000000000..228e2f02349b
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/semanticdb/generated/Signature.scala
@@ -0,0 +1,706 @@
+// Generated by https://github.com/tanishiking/semanticdb-for-scala3
+// Generated by the Scala Plugin for the Protocol Buffer Compiler.
+// Do not edit!
+//
+// Protofile syntax: PROTO3
+
+package dotty.tools.dotc.semanticdb
+import dotty.tools.dotc.semanticdb.internal._
+import scala.annotation.internal.sharable
+
+sealed trait Signature  extends SemanticdbGeneratedSealedOneof  derives CanEqual {
+  type MessageType = dotty.tools.dotc.semanticdb.SignatureMessage
+  final def isEmpty = this.isInstanceOf[dotty.tools.dotc.semanticdb.Signature.Empty.type]
+  final def isDefined = !isEmpty
+  final def asMessage: dotty.tools.dotc.semanticdb.SignatureMessage = dotty.tools.dotc.semanticdb.Signature.SignatureTypeMapper.toBase(this)
+  final def asNonEmpty: Option[dotty.tools.dotc.semanticdb.Signature.NonEmpty] = if (isEmpty) None else Some(this.asInstanceOf[dotty.tools.dotc.semanticdb.Signature.NonEmpty])
+}
+
+object Signature {
+  case object Empty extends dotty.tools.dotc.semanticdb.Signature
+  
+  sealed trait NonEmpty extends dotty.tools.dotc.semanticdb.Signature
+  def defaultInstance: dotty.tools.dotc.semanticdb.Signature = Empty
+  
+  implicit val SignatureTypeMapper: SemanticdbTypeMapper[dotty.tools.dotc.semanticdb.SignatureMessage, dotty.tools.dotc.semanticdb.Signature] = new SemanticdbTypeMapper[dotty.tools.dotc.semanticdb.SignatureMessage, dotty.tools.dotc.semanticdb.Signature] {
+    override def toCustom(__base: dotty.tools.dotc.semanticdb.SignatureMessage): dotty.tools.dotc.semanticdb.Signature = __base.sealedValue match {
+      case __v: dotty.tools.dotc.semanticdb.SignatureMessage.SealedValue.ClassSignature => __v.value
+      case __v: dotty.tools.dotc.semanticdb.SignatureMessage.SealedValue.MethodSignature => __v.value
+      case __v: dotty.tools.dotc.semanticdb.SignatureMessage.SealedValue.TypeSignature => __v.value
+      case __v: dotty.tools.dotc.semanticdb.SignatureMessage.SealedValue.ValueSignature => __v.value
+      case dotty.tools.dotc.semanticdb.SignatureMessage.SealedValue.Empty => Empty
+    }
+    override def toBase(__custom: dotty.tools.dotc.semanticdb.Signature): dotty.tools.dotc.semanticdb.SignatureMessage = dotty.tools.dotc.semanticdb.SignatureMessage(__custom match {
+      case __v: dotty.tools.dotc.semanticdb.ClassSignature => dotty.tools.dotc.semanticdb.SignatureMessage.SealedValue.ClassSignature(__v)
+      case __v: dotty.tools.dotc.semanticdb.MethodSignature => dotty.tools.dotc.semanticdb.SignatureMessage.SealedValue.MethodSignature(__v)
+      case __v: dotty.tools.dotc.semanticdb.TypeSignature => dotty.tools.dotc.semanticdb.SignatureMessage.SealedValue.TypeSignature(__v)
+      case __v: dotty.tools.dotc.semanticdb.ValueSignature => dotty.tools.dotc.semanticdb.SignatureMessage.SealedValue.ValueSignature(__v)
+      case Empty => dotty.tools.dotc.semanticdb.SignatureMessage.SealedValue.Empty
+    })
+  }
+}
+@SerialVersionUID(0L)
+final case class SignatureMessage(
+    sealedValue: dotty.tools.dotc.semanticdb.SignatureMessage.SealedValue = dotty.tools.dotc.semanticdb.SignatureMessage.SealedValue.Empty
+    )  extends SemanticdbGeneratedMessage  derives CanEqual {
+    @transient @sharable
+    private[this] var __serializedSizeMemoized: _root_.scala.Int = 0
+    private[this] def __computeSerializedSize(): _root_.scala.Int = {
+      var __size = 0
+      if (sealedValue.classSignature.isDefined) {
+        val __value = sealedValue.classSignature.get
+        __size += 1 + SemanticdbOutputStream.computeUInt32SizeNoTag(__value.serializedSize) + __value.serializedSize
+      };
+      if (sealedValue.methodSignature.isDefined) {
+        val __value = sealedValue.methodSignature.get
+        __size += 1 + SemanticdbOutputStream.computeUInt32SizeNoTag(__value.serializedSize) + __value.serializedSize
+      };
+      if (sealedValue.typeSignature.isDefined) {
+        val __value = sealedValue.typeSignature.get
+        __size += 1 + SemanticdbOutputStream.computeUInt32SizeNoTag(__value.serializedSize) + __value.serializedSize
+      };
+      if (sealedValue.valueSignature.isDefined) {
+        val __value = sealedValue.valueSignature.get
+        __size += 1 + SemanticdbOutputStream.computeUInt32SizeNoTag(__value.serializedSize) + __value.serializedSize
+      };
+      __size
+    }
+    override def serializedSize: _root_.scala.Int = {
+      var __size = __serializedSizeMemoized
+      if (__size == 0) {
+        __size = __computeSerializedSize() + 1
+        __serializedSizeMemoized = __size
+      }
+      __size - 1
+      
+    }
+    def writeTo(`_output__`: SemanticdbOutputStream): _root_.scala.Unit = {
+      sealedValue.classSignature.foreach { __v =>
+        val __m = __v
+        _output__.writeTag(1, 2)
+        _output__.writeUInt32NoTag(__m.serializedSize)
+        __m.writeTo(_output__)
+      };
+      sealedValue.methodSignature.foreach { __v =>
+        val __m = __v
+        _output__.writeTag(2, 2)
+        _output__.writeUInt32NoTag(__m.serializedSize)
+        __m.writeTo(_output__)
+      };
+      sealedValue.typeSignature.foreach { __v =>
+        val __m = __v
+        _output__.writeTag(3, 2)
+        _output__.writeUInt32NoTag(__m.serializedSize)
+        __m.writeTo(_output__)
+      };
+      sealedValue.valueSignature.foreach { __v =>
+        val __m = __v
+        _output__.writeTag(4, 2)
+        _output__.writeUInt32NoTag(__m.serializedSize)
+        __m.writeTo(_output__)
+      };
+    }
+    def getClassSignature: dotty.tools.dotc.semanticdb.ClassSignature = sealedValue.classSignature.getOrElse(dotty.tools.dotc.semanticdb.ClassSignature.defaultInstance)
+    def withClassSignature(__v: dotty.tools.dotc.semanticdb.ClassSignature): SignatureMessage = copy(sealedValue = dotty.tools.dotc.semanticdb.SignatureMessage.SealedValue.ClassSignature(__v))
+    def getMethodSignature: dotty.tools.dotc.semanticdb.MethodSignature = sealedValue.methodSignature.getOrElse(dotty.tools.dotc.semanticdb.MethodSignature.defaultInstance)
+    def withMethodSignature(__v: dotty.tools.dotc.semanticdb.MethodSignature): SignatureMessage = copy(sealedValue = dotty.tools.dotc.semanticdb.SignatureMessage.SealedValue.MethodSignature(__v))
+    def getTypeSignature: dotty.tools.dotc.semanticdb.TypeSignature = sealedValue.typeSignature.getOrElse(dotty.tools.dotc.semanticdb.TypeSignature.defaultInstance)
+    def withTypeSignature(__v: dotty.tools.dotc.semanticdb.TypeSignature): SignatureMessage = copy(sealedValue = dotty.tools.dotc.semanticdb.SignatureMessage.SealedValue.TypeSignature(__v))
+    def getValueSignature: dotty.tools.dotc.semanticdb.ValueSignature = sealedValue.valueSignature.getOrElse(dotty.tools.dotc.semanticdb.ValueSignature.defaultInstance)
+    def withValueSignature(__v: dotty.tools.dotc.semanticdb.ValueSignature): SignatureMessage = copy(sealedValue = dotty.tools.dotc.semanticdb.SignatureMessage.SealedValue.ValueSignature(__v))
+    def clearSealedValue: SignatureMessage = copy(sealedValue = dotty.tools.dotc.semanticdb.SignatureMessage.SealedValue.Empty)
+    def withSealedValue(__v: dotty.tools.dotc.semanticdb.SignatureMessage.SealedValue): SignatureMessage = copy(sealedValue = __v)
+    
+    
+    
+    
+    def toSignature: dotty.tools.dotc.semanticdb.Signature = dotty.tools.dotc.semanticdb.Signature.SignatureTypeMapper.toCustom(this)
+    // @@protoc_insertion_point(GeneratedMessage[dotty.tools.dotc.semanticdb.Signature])
+}
+
+object SignatureMessage  extends SemanticdbGeneratedMessageCompanion[dotty.tools.dotc.semanticdb.SignatureMessage] {
+  implicit def messageCompanion: SemanticdbGeneratedMessageCompanion[dotty.tools.dotc.semanticdb.SignatureMessage] = this
+  def parseFrom(`_input__`: SemanticdbInputStream): dotty.tools.dotc.semanticdb.SignatureMessage = {
+    var __sealedValue: dotty.tools.dotc.semanticdb.SignatureMessage.SealedValue = dotty.tools.dotc.semanticdb.SignatureMessage.SealedValue.Empty
+    var _done__ = false
+    while (!_done__) {
+      val _tag__ = _input__.readTag()
+      _tag__ match {
+        case 0 => _done__ = true
+        case 10 =>
+          __sealedValue = dotty.tools.dotc.semanticdb.SignatureMessage.SealedValue.ClassSignature(__sealedValue.classSignature.fold(LiteParser.readMessage[dotty.tools.dotc.semanticdb.ClassSignature](_input__))(LiteParser.readMessage(_input__, _)))
+        case 18 =>
+          __sealedValue = dotty.tools.dotc.semanticdb.SignatureMessage.SealedValue.MethodSignature(__sealedValue.methodSignature.fold(LiteParser.readMessage[dotty.tools.dotc.semanticdb.MethodSignature](_input__))(LiteParser.readMessage(_input__, _)))
+        case 26 =>
+          __sealedValue = dotty.tools.dotc.semanticdb.SignatureMessage.SealedValue.TypeSignature(__sealedValue.typeSignature.fold(LiteParser.readMessage[dotty.tools.dotc.semanticdb.TypeSignature](_input__))(LiteParser.readMessage(_input__, _)))
+        case 34 =>
+          __sealedValue = dotty.tools.dotc.semanticdb.SignatureMessage.SealedValue.ValueSignature(__sealedValue.valueSignature.fold(LiteParser.readMessage[dotty.tools.dotc.semanticdb.ValueSignature](_input__))(LiteParser.readMessage(_input__, _)))
+        case tag => _input__.skipField(tag)
+      }
+    }
+    dotty.tools.dotc.semanticdb.SignatureMessage(
+        sealedValue = __sealedValue
+    )
+  }
+  
+  
+  
+  
+  
+  
+  lazy val defaultInstance = dotty.tools.dotc.semanticdb.SignatureMessage(
+    sealedValue = dotty.tools.dotc.semanticdb.SignatureMessage.SealedValue.Empty
+  )
+  sealed trait SealedValue  extends SemanticdbGeneratedOneof  derives CanEqual {
+    def isEmpty: _root_.scala.Boolean = false
+    def isDefined: _root_.scala.Boolean = true
+    def isClassSignature: _root_.scala.Boolean = false
+    def isMethodSignature: _root_.scala.Boolean = false
+    def isTypeSignature: _root_.scala.Boolean = false
+    def isValueSignature: _root_.scala.Boolean = false
+    def classSignature: _root_.scala.Option[dotty.tools.dotc.semanticdb.ClassSignature] = _root_.scala.None
+    def methodSignature: _root_.scala.Option[dotty.tools.dotc.semanticdb.MethodSignature] = _root_.scala.None
+    def typeSignature: _root_.scala.Option[dotty.tools.dotc.semanticdb.TypeSignature] = _root_.scala.None
+    def valueSignature: _root_.scala.Option[dotty.tools.dotc.semanticdb.ValueSignature] = _root_.scala.None
+  }
+  object SealedValue {
+    @SerialVersionUID(0L)
+    case object Empty extends dotty.tools.dotc.semanticdb.SignatureMessage.SealedValue {
+      type ValueType = _root_.scala.Nothing
+      override def isEmpty: _root_.scala.Boolean = true
+      override def isDefined: _root_.scala.Boolean = false
+      override def number: _root_.scala.Int = 0
+      override def value: _root_.scala.Nothing = throw new java.util.NoSuchElementException("Empty.value")
+    }
+  
+    @SerialVersionUID(0L)
+    final case class ClassSignature(value: dotty.tools.dotc.semanticdb.ClassSignature) extends dotty.tools.dotc.semanticdb.SignatureMessage.SealedValue  derives CanEqual {
+      type ValueType = dotty.tools.dotc.semanticdb.ClassSignature
+      override def isClassSignature: _root_.scala.Boolean = true
+      override def classSignature: _root_.scala.Option[dotty.tools.dotc.semanticdb.ClassSignature] = Some(value)
+      override def number: _root_.scala.Int = 1
+    }
+    @SerialVersionUID(0L)
+    final case class MethodSignature(value: dotty.tools.dotc.semanticdb.MethodSignature) extends dotty.tools.dotc.semanticdb.SignatureMessage.SealedValue  derives CanEqual {
+      type ValueType = dotty.tools.dotc.semanticdb.MethodSignature
+      override def isMethodSignature: _root_.scala.Boolean = true
+      override def methodSignature: _root_.scala.Option[dotty.tools.dotc.semanticdb.MethodSignature] = Some(value)
+      override def number: _root_.scala.Int = 2
+    }
+    @SerialVersionUID(0L)
+    final case class TypeSignature(value: dotty.tools.dotc.semanticdb.TypeSignature) extends dotty.tools.dotc.semanticdb.SignatureMessage.SealedValue  derives CanEqual {
+      type ValueType = dotty.tools.dotc.semanticdb.TypeSignature
+      override def isTypeSignature: _root_.scala.Boolean = true
+      override def typeSignature: _root_.scala.Option[dotty.tools.dotc.semanticdb.TypeSignature] = Some(value)
+      override def number: _root_.scala.Int = 3
+    }
+    @SerialVersionUID(0L)
+    final case class ValueSignature(value: dotty.tools.dotc.semanticdb.ValueSignature) extends dotty.tools.dotc.semanticdb.SignatureMessage.SealedValue  derives CanEqual {
+      type ValueType = dotty.tools.dotc.semanticdb.ValueSignature
+      override def isValueSignature: _root_.scala.Boolean = true
+      override def valueSignature: _root_.scala.Option[dotty.tools.dotc.semanticdb.ValueSignature] = Some(value)
+      override def number: _root_.scala.Int = 4
+    }
+  }
+  final val CLASS_SIGNATURE_FIELD_NUMBER = 1
+  final val METHOD_SIGNATURE_FIELD_NUMBER = 2
+  final val TYPE_SIGNATURE_FIELD_NUMBER = 3
+  final val VALUE_SIGNATURE_FIELD_NUMBER = 4
+  def of(
+    sealedValue: dotty.tools.dotc.semanticdb.SignatureMessage.SealedValue
+  ): _root_.dotty.tools.dotc.semanticdb.SignatureMessage = _root_.dotty.tools.dotc.semanticdb.SignatureMessage(
+    sealedValue
+  )
+  // @@protoc_insertion_point(GeneratedMessageCompanion[dotty.tools.dotc.semanticdb.Signature])
+}
+
+@SerialVersionUID(0L)
+final case class ClassSignature(
+    typeParameters: _root_.scala.Option[dotty.tools.dotc.semanticdb.Scope] = _root_.scala.None,
+    parents: _root_.scala.Seq[dotty.tools.dotc.semanticdb.Type] = _root_.scala.Seq.empty,
+    self: dotty.tools.dotc.semanticdb.Type = dotty.tools.dotc.semanticdb.ClassSignature._typemapper_self.toCustom(dotty.tools.dotc.semanticdb.TypeMessage.defaultInstance),
+    declarations: _root_.scala.Option[dotty.tools.dotc.semanticdb.Scope] = _root_.scala.None
+    )  extends dotty.tools.dotc.semanticdb.Signature.NonEmpty with SemanticdbGeneratedMessage  derives CanEqual {
+    @transient @sharable
+    private[this] var __serializedSizeMemoized: _root_.scala.Int = 0
+    private[this] def __computeSerializedSize(): _root_.scala.Int = {
+      var __size = 0
+      if (typeParameters.isDefined) {
+        val __value = typeParameters.get
+        __size += 1 + SemanticdbOutputStream.computeUInt32SizeNoTag(__value.serializedSize) + __value.serializedSize
+      };
+      parents.foreach { __item =>
+        val __value = dotty.tools.dotc.semanticdb.ClassSignature._typemapper_parents.toBase(__item)
+        __size += 1 + SemanticdbOutputStream.computeUInt32SizeNoTag(__value.serializedSize) + __value.serializedSize
+      }
+      
+      {
+        val __value = dotty.tools.dotc.semanticdb.ClassSignature._typemapper_self.toBase(self)
+        if (__value.serializedSize != 0) {
+          __size += 1 + SemanticdbOutputStream.computeUInt32SizeNoTag(__value.serializedSize) + __value.serializedSize
+        }
+      };
+      if (declarations.isDefined) {
+        val __value = declarations.get
+        __size += 1 + SemanticdbOutputStream.computeUInt32SizeNoTag(__value.serializedSize) + __value.serializedSize
+      };
+      __size
+    }
+    override def serializedSize: _root_.scala.Int = {
+      var __size = __serializedSizeMemoized
+      if (__size == 0) {
+        __size = __computeSerializedSize() + 1
+        __serializedSizeMemoized = __size
+      }
+      __size - 1
+      
+    }
+    def writeTo(`_output__`: SemanticdbOutputStream): _root_.scala.Unit = {
+      typeParameters.foreach { __v =>
+        val __m = __v
+        _output__.writeTag(1, 2)
+        _output__.writeUInt32NoTag(__m.serializedSize)
+        __m.writeTo(_output__)
+      };
+      parents.foreach { __v =>
+        val __m = dotty.tools.dotc.semanticdb.ClassSignature._typemapper_parents.toBase(__v)
+        _output__.writeTag(2, 2)
+        _output__.writeUInt32NoTag(__m.serializedSize)
+        __m.writeTo(_output__)
+      };
+      {
+        val __v = dotty.tools.dotc.semanticdb.ClassSignature._typemapper_self.toBase(self)
+        if (__v.serializedSize != 0) {
+          _output__.writeTag(3, 2)
+          _output__.writeUInt32NoTag(__v.serializedSize)
+          __v.writeTo(_output__)
+        }
+      };
+      declarations.foreach { __v =>
+        val __m = __v
+        _output__.writeTag(4, 2)
+        _output__.writeUInt32NoTag(__m.serializedSize)
+        __m.writeTo(_output__)
+      };
+    }
+    def getTypeParameters: dotty.tools.dotc.semanticdb.Scope = typeParameters.getOrElse(dotty.tools.dotc.semanticdb.Scope.defaultInstance)
+    def clearTypeParameters: ClassSignature = copy(typeParameters = _root_.scala.None)
+    def withTypeParameters(__v: dotty.tools.dotc.semanticdb.Scope): ClassSignature = copy(typeParameters = Option(__v))
+    def clearParents = copy(parents = _root_.scala.Seq.empty)
+    def addParents(__vs: dotty.tools.dotc.semanticdb.Type *): ClassSignature = addAllParents(__vs)
+    def addAllParents(__vs: Iterable[dotty.tools.dotc.semanticdb.Type]): ClassSignature = copy(parents = parents ++ __vs)
+    def withParents(__v: _root_.scala.Seq[dotty.tools.dotc.semanticdb.Type]): ClassSignature = copy(parents = __v)
+    def withSelf(__v: dotty.tools.dotc.semanticdb.Type): ClassSignature = copy(self = __v)
+    def getDeclarations: dotty.tools.dotc.semanticdb.Scope = declarations.getOrElse(dotty.tools.dotc.semanticdb.Scope.defaultInstance)
+    def clearDeclarations: ClassSignature = copy(declarations = _root_.scala.None)
+    def withDeclarations(__v: dotty.tools.dotc.semanticdb.Scope): ClassSignature = copy(declarations = Option(__v))
+    
+    
+    
+    
+    // @@protoc_insertion_point(GeneratedMessage[dotty.tools.dotc.semanticdb.ClassSignature])
+}
+
+object ClassSignature  extends SemanticdbGeneratedMessageCompanion[dotty.tools.dotc.semanticdb.ClassSignature] {
+  implicit def messageCompanion: SemanticdbGeneratedMessageCompanion[dotty.tools.dotc.semanticdb.ClassSignature] = this
+  def parseFrom(`_input__`: SemanticdbInputStream): dotty.tools.dotc.semanticdb.ClassSignature = {
+    var __typeParameters: _root_.scala.Option[dotty.tools.dotc.semanticdb.Scope] = _root_.scala.None
+    val __parents: _root_.scala.collection.immutable.VectorBuilder[dotty.tools.dotc.semanticdb.Type] = new _root_.scala.collection.immutable.VectorBuilder[dotty.tools.dotc.semanticdb.Type]
+    var __self: _root_.scala.Option[dotty.tools.dotc.semanticdb.TypeMessage] = _root_.scala.None
+    var __declarations: _root_.scala.Option[dotty.tools.dotc.semanticdb.Scope] = _root_.scala.None
+    var _done__ = false
+    while (!_done__) {
+      val _tag__ = _input__.readTag()
+      _tag__ match {
+        case 0 => _done__ = true
+        case 10 =>
+          __typeParameters = Option(__typeParameters.fold(LiteParser.readMessage[dotty.tools.dotc.semanticdb.Scope](_input__))(LiteParser.readMessage(_input__, _)))
+        case 18 =>
+          __parents += dotty.tools.dotc.semanticdb.ClassSignature._typemapper_parents.toCustom(LiteParser.readMessage[dotty.tools.dotc.semanticdb.TypeMessage](_input__))
+        case 26 =>
+          __self = _root_.scala.Some(__self.fold(LiteParser.readMessage[dotty.tools.dotc.semanticdb.TypeMessage](_input__))(LiteParser.readMessage(_input__, _)))
+        case 34 =>
+          __declarations = Option(__declarations.fold(LiteParser.readMessage[dotty.tools.dotc.semanticdb.Scope](_input__))(LiteParser.readMessage(_input__, _)))
+        case tag => _input__.skipField(tag)
+      }
+    }
+    dotty.tools.dotc.semanticdb.ClassSignature(
+        typeParameters = __typeParameters,
+        parents = __parents.result(),
+        self = dotty.tools.dotc.semanticdb.ClassSignature._typemapper_self.toCustom(__self.getOrElse(dotty.tools.dotc.semanticdb.TypeMessage.defaultInstance)),
+        declarations = __declarations
+    )
+  }
+  
+  
+  
+  
+  
+  
+  lazy val defaultInstance = dotty.tools.dotc.semanticdb.ClassSignature(
+    typeParameters = _root_.scala.None,
+    parents = _root_.scala.Seq.empty,
+    self = dotty.tools.dotc.semanticdb.ClassSignature._typemapper_self.toCustom(dotty.tools.dotc.semanticdb.TypeMessage.defaultInstance),
+    declarations = _root_.scala.None
+  )
+  final val TYPE_PARAMETERS_FIELD_NUMBER = 1
+  final val PARENTS_FIELD_NUMBER = 2
+  final val SELF_FIELD_NUMBER = 3
+  final val DECLARATIONS_FIELD_NUMBER = 4
+  @transient @sharable
+  private[semanticdb] val _typemapper_parents: SemanticdbTypeMapper[dotty.tools.dotc.semanticdb.TypeMessage, dotty.tools.dotc.semanticdb.Type] = implicitly[SemanticdbTypeMapper[dotty.tools.dotc.semanticdb.TypeMessage, dotty.tools.dotc.semanticdb.Type]]
+  @transient @sharable
+  private[semanticdb] val _typemapper_self: SemanticdbTypeMapper[dotty.tools.dotc.semanticdb.TypeMessage, dotty.tools.dotc.semanticdb.Type] = implicitly[SemanticdbTypeMapper[dotty.tools.dotc.semanticdb.TypeMessage, dotty.tools.dotc.semanticdb.Type]]
+  def of(
+    typeParameters: _root_.scala.Option[dotty.tools.dotc.semanticdb.Scope],
+    parents: _root_.scala.Seq[dotty.tools.dotc.semanticdb.Type],
+    self: dotty.tools.dotc.semanticdb.Type,
+    declarations: _root_.scala.Option[dotty.tools.dotc.semanticdb.Scope]
+  ): _root_.dotty.tools.dotc.semanticdb.ClassSignature = _root_.dotty.tools.dotc.semanticdb.ClassSignature(
+    typeParameters,
+    parents,
+    self,
+    declarations
+  )
+  // @@protoc_insertion_point(GeneratedMessageCompanion[dotty.tools.dotc.semanticdb.ClassSignature])
+}
+
+@SerialVersionUID(0L)
+final case class MethodSignature(
+    typeParameters: _root_.scala.Option[dotty.tools.dotc.semanticdb.Scope] = _root_.scala.None,
+    parameterLists: _root_.scala.Seq[dotty.tools.dotc.semanticdb.Scope] = _root_.scala.Seq.empty,
+    returnType: dotty.tools.dotc.semanticdb.Type = dotty.tools.dotc.semanticdb.MethodSignature._typemapper_returnType.toCustom(dotty.tools.dotc.semanticdb.TypeMessage.defaultInstance)
+    )  extends dotty.tools.dotc.semanticdb.Signature.NonEmpty with SemanticdbGeneratedMessage  derives CanEqual {
+    @transient @sharable
+    private[this] var __serializedSizeMemoized: _root_.scala.Int = 0
+    private[this] def __computeSerializedSize(): _root_.scala.Int = {
+      var __size = 0
+      if (typeParameters.isDefined) {
+        val __value = typeParameters.get
+        __size += 1 + SemanticdbOutputStream.computeUInt32SizeNoTag(__value.serializedSize) + __value.serializedSize
+      };
+      parameterLists.foreach { __item =>
+        val __value = __item
+        __size += 1 + SemanticdbOutputStream.computeUInt32SizeNoTag(__value.serializedSize) + __value.serializedSize
+      }
+      
+      {
+        val __value = dotty.tools.dotc.semanticdb.MethodSignature._typemapper_returnType.toBase(returnType)
+        if (__value.serializedSize != 0) {
+          __size += 1 + SemanticdbOutputStream.computeUInt32SizeNoTag(__value.serializedSize) + __value.serializedSize
+        }
+      };
+      __size
+    }
+    override def serializedSize: _root_.scala.Int = {
+      var __size = __serializedSizeMemoized
+      if (__size == 0) {
+        __size = __computeSerializedSize() + 1
+        __serializedSizeMemoized = __size
+      }
+      __size - 1
+      
+    }
+    def writeTo(`_output__`: SemanticdbOutputStream): _root_.scala.Unit = {
+      typeParameters.foreach { __v =>
+        val __m = __v
+        _output__.writeTag(1, 2)
+        _output__.writeUInt32NoTag(__m.serializedSize)
+        __m.writeTo(_output__)
+      };
+      parameterLists.foreach { __v =>
+        val __m = __v
+        _output__.writeTag(2, 2)
+        _output__.writeUInt32NoTag(__m.serializedSize)
+        __m.writeTo(_output__)
+      };
+      {
+        val __v = dotty.tools.dotc.semanticdb.MethodSignature._typemapper_returnType.toBase(returnType)
+        if (__v.serializedSize != 0) {
+          _output__.writeTag(3, 2)
+          _output__.writeUInt32NoTag(__v.serializedSize)
+          __v.writeTo(_output__)
+        }
+      };
+    }
+    def getTypeParameters: dotty.tools.dotc.semanticdb.Scope = typeParameters.getOrElse(dotty.tools.dotc.semanticdb.Scope.defaultInstance)
+    def clearTypeParameters: MethodSignature = copy(typeParameters = _root_.scala.None)
+    def withTypeParameters(__v: dotty.tools.dotc.semanticdb.Scope): MethodSignature = copy(typeParameters = Option(__v))
+    def clearParameterLists = copy(parameterLists = _root_.scala.Seq.empty)
+    def addParameterLists(__vs: dotty.tools.dotc.semanticdb.Scope *): MethodSignature = addAllParameterLists(__vs)
+    def addAllParameterLists(__vs: Iterable[dotty.tools.dotc.semanticdb.Scope]): MethodSignature = copy(parameterLists = parameterLists ++ __vs)
+    def withParameterLists(__v: _root_.scala.Seq[dotty.tools.dotc.semanticdb.Scope]): MethodSignature = copy(parameterLists = __v)
+    def withReturnType(__v: dotty.tools.dotc.semanticdb.Type): MethodSignature = copy(returnType = __v)
+    
+    
+    
+    
+    // @@protoc_insertion_point(GeneratedMessage[dotty.tools.dotc.semanticdb.MethodSignature])
+}
+
+object MethodSignature  extends SemanticdbGeneratedMessageCompanion[dotty.tools.dotc.semanticdb.MethodSignature] {
+  implicit def messageCompanion: SemanticdbGeneratedMessageCompanion[dotty.tools.dotc.semanticdb.MethodSignature] = this
+  def parseFrom(`_input__`: SemanticdbInputStream): dotty.tools.dotc.semanticdb.MethodSignature = {
+    var __typeParameters: _root_.scala.Option[dotty.tools.dotc.semanticdb.Scope] = _root_.scala.None
+    val __parameterLists: _root_.scala.collection.immutable.VectorBuilder[dotty.tools.dotc.semanticdb.Scope] = new _root_.scala.collection.immutable.VectorBuilder[dotty.tools.dotc.semanticdb.Scope]
+    var __returnType: _root_.scala.Option[dotty.tools.dotc.semanticdb.TypeMessage] = _root_.scala.None
+    var _done__ = false
+    while (!_done__) {
+      val _tag__ = _input__.readTag()
+      _tag__ match {
+        case 0 => _done__ = true
+        case 10 =>
+          __typeParameters = Option(__typeParameters.fold(LiteParser.readMessage[dotty.tools.dotc.semanticdb.Scope](_input__))(LiteParser.readMessage(_input__, _)))
+        case 18 =>
+          __parameterLists += LiteParser.readMessage[dotty.tools.dotc.semanticdb.Scope](_input__)
+        case 26 =>
+          __returnType = _root_.scala.Some(__returnType.fold(LiteParser.readMessage[dotty.tools.dotc.semanticdb.TypeMessage](_input__))(LiteParser.readMessage(_input__, _)))
+        case tag => _input__.skipField(tag)
+      }
+    }
+    dotty.tools.dotc.semanticdb.MethodSignature(
+        typeParameters = __typeParameters,
+        parameterLists = __parameterLists.result(),
+        returnType = dotty.tools.dotc.semanticdb.MethodSignature._typemapper_returnType.toCustom(__returnType.getOrElse(dotty.tools.dotc.semanticdb.TypeMessage.defaultInstance))
+    )
+  }
+  
+  
+  
+  
+  
+  
+  lazy val defaultInstance = dotty.tools.dotc.semanticdb.MethodSignature(
+    typeParameters = _root_.scala.None,
+    parameterLists = _root_.scala.Seq.empty,
+    returnType = dotty.tools.dotc.semanticdb.MethodSignature._typemapper_returnType.toCustom(dotty.tools.dotc.semanticdb.TypeMessage.defaultInstance)
+  )
+  final val TYPE_PARAMETERS_FIELD_NUMBER = 1
+  final val PARAMETER_LISTS_FIELD_NUMBER = 2
+  final val RETURN_TYPE_FIELD_NUMBER = 3
+  @transient @sharable
+  private[semanticdb] val _typemapper_returnType: SemanticdbTypeMapper[dotty.tools.dotc.semanticdb.TypeMessage, dotty.tools.dotc.semanticdb.Type] = implicitly[SemanticdbTypeMapper[dotty.tools.dotc.semanticdb.TypeMessage, dotty.tools.dotc.semanticdb.Type]]
+  def of(
+    typeParameters: _root_.scala.Option[dotty.tools.dotc.semanticdb.Scope],
+    parameterLists: _root_.scala.Seq[dotty.tools.dotc.semanticdb.Scope],
+    returnType: dotty.tools.dotc.semanticdb.Type
+  ): _root_.dotty.tools.dotc.semanticdb.MethodSignature = _root_.dotty.tools.dotc.semanticdb.MethodSignature(
+    typeParameters,
+    parameterLists,
+    returnType
+  )
+  // @@protoc_insertion_point(GeneratedMessageCompanion[dotty.tools.dotc.semanticdb.MethodSignature])
+}
+
+@SerialVersionUID(0L)
+final case class TypeSignature(
+    typeParameters: _root_.scala.Option[dotty.tools.dotc.semanticdb.Scope] = _root_.scala.None,
+    lowerBound: dotty.tools.dotc.semanticdb.Type = dotty.tools.dotc.semanticdb.TypeSignature._typemapper_lowerBound.toCustom(dotty.tools.dotc.semanticdb.TypeMessage.defaultInstance),
+    upperBound: dotty.tools.dotc.semanticdb.Type = dotty.tools.dotc.semanticdb.TypeSignature._typemapper_upperBound.toCustom(dotty.tools.dotc.semanticdb.TypeMessage.defaultInstance)
+    )  extends dotty.tools.dotc.semanticdb.Signature.NonEmpty with SemanticdbGeneratedMessage  derives CanEqual {
+    @transient @sharable
+    private[this] var __serializedSizeMemoized: _root_.scala.Int = 0
+    private[this] def __computeSerializedSize(): _root_.scala.Int = {
+      var __size = 0
+      if (typeParameters.isDefined) {
+        val __value = typeParameters.get
+        __size += 1 + SemanticdbOutputStream.computeUInt32SizeNoTag(__value.serializedSize) + __value.serializedSize
+      };
+      
+      {
+        val __value = dotty.tools.dotc.semanticdb.TypeSignature._typemapper_lowerBound.toBase(lowerBound)
+        if (__value.serializedSize != 0) {
+          __size += 1 + SemanticdbOutputStream.computeUInt32SizeNoTag(__value.serializedSize) + __value.serializedSize
+        }
+      };
+      
+      {
+        val __value = dotty.tools.dotc.semanticdb.TypeSignature._typemapper_upperBound.toBase(upperBound)
+        if (__value.serializedSize != 0) {
+          __size += 1 + SemanticdbOutputStream.computeUInt32SizeNoTag(__value.serializedSize) + __value.serializedSize
+        }
+      };
+      __size
+    }
+    override def serializedSize: _root_.scala.Int = {
+      var __size = __serializedSizeMemoized
+      if (__size == 0) {
+        __size = __computeSerializedSize() + 1
+        __serializedSizeMemoized = __size
+      }
+      __size - 1
+      
+    }
+    def writeTo(`_output__`: SemanticdbOutputStream): _root_.scala.Unit = {
+      typeParameters.foreach { __v =>
+        val __m = __v
+        _output__.writeTag(1, 2)
+        _output__.writeUInt32NoTag(__m.serializedSize)
+        __m.writeTo(_output__)
+      };
+      {
+        val __v = dotty.tools.dotc.semanticdb.TypeSignature._typemapper_lowerBound.toBase(lowerBound)
+        if (__v.serializedSize != 0) {
+          _output__.writeTag(2, 2)
+          _output__.writeUInt32NoTag(__v.serializedSize)
+          __v.writeTo(_output__)
+        }
+      };
+      {
+        val __v = dotty.tools.dotc.semanticdb.TypeSignature._typemapper_upperBound.toBase(upperBound)
+        if (__v.serializedSize != 0) {
+          _output__.writeTag(3, 2)
+          _output__.writeUInt32NoTag(__v.serializedSize)
+          __v.writeTo(_output__)
+        }
+      };
+    }
+    def getTypeParameters: dotty.tools.dotc.semanticdb.Scope = typeParameters.getOrElse(dotty.tools.dotc.semanticdb.Scope.defaultInstance)
+    def clearTypeParameters: TypeSignature = copy(typeParameters = _root_.scala.None)
+    def withTypeParameters(__v: dotty.tools.dotc.semanticdb.Scope): TypeSignature = copy(typeParameters = Option(__v))
+    def withLowerBound(__v: dotty.tools.dotc.semanticdb.Type): TypeSignature = copy(lowerBound = __v)
+    def withUpperBound(__v: dotty.tools.dotc.semanticdb.Type): TypeSignature = copy(upperBound = __v)
+    
+    
+    
+    
+    // @@protoc_insertion_point(GeneratedMessage[dotty.tools.dotc.semanticdb.TypeSignature])
+}
+
+object TypeSignature  extends SemanticdbGeneratedMessageCompanion[dotty.tools.dotc.semanticdb.TypeSignature] {
+  implicit def messageCompanion: SemanticdbGeneratedMessageCompanion[dotty.tools.dotc.semanticdb.TypeSignature] = this
+  def parseFrom(`_input__`: SemanticdbInputStream): dotty.tools.dotc.semanticdb.TypeSignature = {
+    var __typeParameters: _root_.scala.Option[dotty.tools.dotc.semanticdb.Scope] = _root_.scala.None
+    var __lowerBound: _root_.scala.Option[dotty.tools.dotc.semanticdb.TypeMessage] = _root_.scala.None
+    var __upperBound: _root_.scala.Option[dotty.tools.dotc.semanticdb.TypeMessage] = _root_.scala.None
+    var _done__ = false
+    while (!_done__) {
+      val _tag__ = _input__.readTag()
+      _tag__ match {
+        case 0 => _done__ = true
+        case 10 =>
+          __typeParameters = Option(__typeParameters.fold(LiteParser.readMessage[dotty.tools.dotc.semanticdb.Scope](_input__))(LiteParser.readMessage(_input__, _)))
+        case 18 =>
+          __lowerBound = _root_.scala.Some(__lowerBound.fold(LiteParser.readMessage[dotty.tools.dotc.semanticdb.TypeMessage](_input__))(LiteParser.readMessage(_input__, _)))
+        case 26 =>
+          __upperBound = _root_.scala.Some(__upperBound.fold(LiteParser.readMessage[dotty.tools.dotc.semanticdb.TypeMessage](_input__))(LiteParser.readMessage(_input__, _)))
+        case tag => _input__.skipField(tag)
+      }
+    }
+    dotty.tools.dotc.semanticdb.TypeSignature(
+        typeParameters = __typeParameters,
+        lowerBound = dotty.tools.dotc.semanticdb.TypeSignature._typemapper_lowerBound.toCustom(__lowerBound.getOrElse(dotty.tools.dotc.semanticdb.TypeMessage.defaultInstance)),
+        upperBound = dotty.tools.dotc.semanticdb.TypeSignature._typemapper_upperBound.toCustom(__upperBound.getOrElse(dotty.tools.dotc.semanticdb.TypeMessage.defaultInstance))
+    )
+  }
+  
+  
+  
+  
+  
+  
+  lazy val defaultInstance = dotty.tools.dotc.semanticdb.TypeSignature(
+    typeParameters = _root_.scala.None,
+    lowerBound = dotty.tools.dotc.semanticdb.TypeSignature._typemapper_lowerBound.toCustom(dotty.tools.dotc.semanticdb.TypeMessage.defaultInstance),
+    upperBound = dotty.tools.dotc.semanticdb.TypeSignature._typemapper_upperBound.toCustom(dotty.tools.dotc.semanticdb.TypeMessage.defaultInstance)
+  )
+  final val TYPE_PARAMETERS_FIELD_NUMBER = 1
+  final val LOWER_BOUND_FIELD_NUMBER = 2
+  final val UPPER_BOUND_FIELD_NUMBER = 3
+  @transient @sharable
+  private[semanticdb] val _typemapper_lowerBound: SemanticdbTypeMapper[dotty.tools.dotc.semanticdb.TypeMessage, dotty.tools.dotc.semanticdb.Type] = implicitly[SemanticdbTypeMapper[dotty.tools.dotc.semanticdb.TypeMessage, dotty.tools.dotc.semanticdb.Type]]
+  @transient @sharable
+  private[semanticdb] val _typemapper_upperBound: SemanticdbTypeMapper[dotty.tools.dotc.semanticdb.TypeMessage, dotty.tools.dotc.semanticdb.Type] = implicitly[SemanticdbTypeMapper[dotty.tools.dotc.semanticdb.TypeMessage, dotty.tools.dotc.semanticdb.Type]]
+  def of(
+    typeParameters: _root_.scala.Option[dotty.tools.dotc.semanticdb.Scope],
+    lowerBound: dotty.tools.dotc.semanticdb.Type,
+    upperBound: dotty.tools.dotc.semanticdb.Type
+  ): _root_.dotty.tools.dotc.semanticdb.TypeSignature = _root_.dotty.tools.dotc.semanticdb.TypeSignature(
+    typeParameters,
+    lowerBound,
+    upperBound
+  )
+  // @@protoc_insertion_point(GeneratedMessageCompanion[dotty.tools.dotc.semanticdb.TypeSignature])
+}
+
+@SerialVersionUID(0L)
+final case class ValueSignature(
+    tpe: dotty.tools.dotc.semanticdb.Type = dotty.tools.dotc.semanticdb.ValueSignature._typemapper_tpe.toCustom(dotty.tools.dotc.semanticdb.TypeMessage.defaultInstance)
+    )  extends dotty.tools.dotc.semanticdb.Signature.NonEmpty with SemanticdbGeneratedMessage  derives CanEqual {
+    @transient @sharable
+    private[this] var __serializedSizeMemoized: _root_.scala.Int = 0
+    private[this] def __computeSerializedSize(): _root_.scala.Int = {
+      var __size = 0
+      
+      {
+        val __value = dotty.tools.dotc.semanticdb.ValueSignature._typemapper_tpe.toBase(tpe)
+        if (__value.serializedSize != 0) {
+          __size += 1 + SemanticdbOutputStream.computeUInt32SizeNoTag(__value.serializedSize) + __value.serializedSize
+        }
+      };
+      __size
+    }
+    override def serializedSize: _root_.scala.Int = {
+      var __size = __serializedSizeMemoized
+      if (__size == 0) {
+        __size = __computeSerializedSize() + 1
+        __serializedSizeMemoized = __size
+      }
+      __size - 1
+      
+    }
+    def writeTo(`_output__`: SemanticdbOutputStream): _root_.scala.Unit = {
+      {
+        val __v = dotty.tools.dotc.semanticdb.ValueSignature._typemapper_tpe.toBase(tpe)
+        if (__v.serializedSize != 0) {
+          _output__.writeTag(1, 2)
+          _output__.writeUInt32NoTag(__v.serializedSize)
+          __v.writeTo(_output__)
+        }
+      };
+    }
+    def withTpe(__v: dotty.tools.dotc.semanticdb.Type): ValueSignature = copy(tpe = __v)
+    
+    
+    
+    
+    // @@protoc_insertion_point(GeneratedMessage[dotty.tools.dotc.semanticdb.ValueSignature])
+}
+
+object ValueSignature  extends SemanticdbGeneratedMessageCompanion[dotty.tools.dotc.semanticdb.ValueSignature] {
+  implicit def messageCompanion: SemanticdbGeneratedMessageCompanion[dotty.tools.dotc.semanticdb.ValueSignature] = this
+  def parseFrom(`_input__`: SemanticdbInputStream): dotty.tools.dotc.semanticdb.ValueSignature = {
+    var __tpe: _root_.scala.Option[dotty.tools.dotc.semanticdb.TypeMessage] = _root_.scala.None
+    var _done__ = false
+    while (!_done__) {
+      val _tag__ = _input__.readTag()
+      _tag__ match {
+        case 0 => _done__ = true
+        case 10 =>
+          __tpe = _root_.scala.Some(__tpe.fold(LiteParser.readMessage[dotty.tools.dotc.semanticdb.TypeMessage](_input__))(LiteParser.readMessage(_input__, _)))
+        case tag => _input__.skipField(tag)
+      }
+    }
+    dotty.tools.dotc.semanticdb.ValueSignature(
+        tpe = dotty.tools.dotc.semanticdb.ValueSignature._typemapper_tpe.toCustom(__tpe.getOrElse(dotty.tools.dotc.semanticdb.TypeMessage.defaultInstance))
+    )
+  }
+  
+  
+  
+  
+  
+  
+  lazy val defaultInstance = dotty.tools.dotc.semanticdb.ValueSignature(
+    tpe = dotty.tools.dotc.semanticdb.ValueSignature._typemapper_tpe.toCustom(dotty.tools.dotc.semanticdb.TypeMessage.defaultInstance)
+  )
+  final val TPE_FIELD_NUMBER = 1
+  @transient @sharable
+  private[semanticdb] val _typemapper_tpe: SemanticdbTypeMapper[dotty.tools.dotc.semanticdb.TypeMessage, dotty.tools.dotc.semanticdb.Type] = implicitly[SemanticdbTypeMapper[dotty.tools.dotc.semanticdb.TypeMessage, dotty.tools.dotc.semanticdb.Type]]
+  def of(
+    tpe: dotty.tools.dotc.semanticdb.Type
+  ): _root_.dotty.tools.dotc.semanticdb.ValueSignature = _root_.dotty.tools.dotc.semanticdb.ValueSignature(
+    tpe
+  )
+  // @@protoc_insertion_point(GeneratedMessageCompanion[dotty.tools.dotc.semanticdb.ValueSignature])
+}
diff --git a/tests/pos-with-compiler-cc/dotc/semanticdb/generated/SymbolInformation.scala b/tests/pos-with-compiler-cc/dotc/semanticdb/generated/SymbolInformation.scala
new file mode 100644
index 000000000000..93fbb207c4f6
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/semanticdb/generated/SymbolInformation.scala
@@ -0,0 +1,670 @@
+// Generated by https://github.com/tanishiking/semanticdb-for-scala3
+// Generated by the Scala Plugin for the Protocol Buffer Compiler.
+// Do not edit!
+//
+// Protofile syntax: PROTO3
+
+package dotty.tools.dotc.semanticdb
+import dotty.tools.dotc.semanticdb.internal._
+import scala.annotation.internal.sharable
+
+@SerialVersionUID(0L)
+final case class SymbolInformation(
+    symbol: _root_.scala.Predef.String = "",
+    language: dotty.tools.dotc.semanticdb.Language = dotty.tools.dotc.semanticdb.Language.UNKNOWN_LANGUAGE,
+    kind: dotty.tools.dotc.semanticdb.SymbolInformation.Kind = dotty.tools.dotc.semanticdb.SymbolInformation.Kind.UNKNOWN_KIND,
+    properties: _root_.scala.Int = 0,
+    displayName: _root_.scala.Predef.String = "",
+    signature: dotty.tools.dotc.semanticdb.Signature = dotty.tools.dotc.semanticdb.SymbolInformation._typemapper_signature.toCustom(dotty.tools.dotc.semanticdb.SignatureMessage.defaultInstance),
+    annotations: _root_.scala.Seq[dotty.tools.dotc.semanticdb.Annotation] = _root_.scala.Seq.empty,
+    access: dotty.tools.dotc.semanticdb.Access = dotty.tools.dotc.semanticdb.SymbolInformation._typemapper_access.toCustom(dotty.tools.dotc.semanticdb.AccessMessage.defaultInstance),
+    overriddenSymbols: _root_.scala.Seq[_root_.scala.Predef.String] = _root_.scala.Seq.empty,
+    documentation: _root_.scala.Option[dotty.tools.dotc.semanticdb.Documentation] = _root_.scala.None
+    )  extends SemanticdbGeneratedMessage  derives CanEqual {
+    @transient @sharable
+    private[this] var __serializedSizeMemoized: _root_.scala.Int = 0
+    private[this] def __computeSerializedSize(): _root_.scala.Int = {
+      var __size = 0
+      
+      {
+        val __value = symbol
+        if (!__value.isEmpty) {
+          __size += SemanticdbOutputStream.computeStringSize(1, __value)
+        }
+      };
+      
+      {
+        val __value = language.value
+        if (__value != 0) {
+          __size += SemanticdbOutputStream.computeEnumSize(16, __value)
+        }
+      };
+      
+      {
+        val __value = kind.value
+        if (__value != 0) {
+          __size += SemanticdbOutputStream.computeEnumSize(3, __value)
+        }
+      };
+      
+      {
+        val __value = properties
+        if (__value != 0) {
+          __size += SemanticdbOutputStream.computeInt32Size(4, __value)
+        }
+      };
+      
+      {
+        val __value = displayName
+        if (!__value.isEmpty) {
+          __size += SemanticdbOutputStream.computeStringSize(5, __value)
+        }
+      };
+      
+      {
+        val __value = dotty.tools.dotc.semanticdb.SymbolInformation._typemapper_signature.toBase(signature)
+        if (__value.serializedSize != 0) {
+          __size += 2 + SemanticdbOutputStream.computeUInt32SizeNoTag(__value.serializedSize) + __value.serializedSize
+        }
+      };
+      annotations.foreach { __item =>
+        val __value = __item
+        __size += 1 + SemanticdbOutputStream.computeUInt32SizeNoTag(__value.serializedSize) + __value.serializedSize
+      }
+      
+      {
+        val __value = dotty.tools.dotc.semanticdb.SymbolInformation._typemapper_access.toBase(access)
+        if (__value.serializedSize != 0) {
+          __size += 2 + SemanticdbOutputStream.computeUInt32SizeNoTag(__value.serializedSize) + __value.serializedSize
+        }
+      };
+      overriddenSymbols.foreach { __item =>
+        val __value = __item
+        __size += SemanticdbOutputStream.computeStringSize(19, __value)
+      }
+      if (documentation.isDefined) {
+        val __value = documentation.get
+        __size += 2 + SemanticdbOutputStream.computeUInt32SizeNoTag(__value.serializedSize) + __value.serializedSize
+      };
+      __size
+    }
+    override def serializedSize: _root_.scala.Int = {
+      var __size = __serializedSizeMemoized
+      if (__size == 0) {
+        __size = __computeSerializedSize() + 1
+        __serializedSizeMemoized = __size
+      }
+      __size - 1
+      
+    }
+    def writeTo(`_output__`: SemanticdbOutputStream): _root_.scala.Unit = {
+      {
+        val __v = symbol
+        if (!__v.isEmpty) {
+          _output__.writeString(1, __v)
+        }
+      };
+      {
+        val __v = kind.value
+        if (__v != 0) {
+          _output__.writeEnum(3, __v)
+        }
+      };
+      {
+        val __v = properties
+        if (__v != 0) {
+          _output__.writeInt32(4, __v)
+        }
+      };
+      {
+        val __v = displayName
+        if (!__v.isEmpty) {
+          _output__.writeString(5, __v)
+        }
+      };
+      annotations.foreach { __v =>
+        val __m = __v
+        _output__.writeTag(13, 2)
+        _output__.writeUInt32NoTag(__m.serializedSize)
+        __m.writeTo(_output__)
+      };
+      {
+        val __v = language.value
+        if (__v != 0) {
+          _output__.writeEnum(16, __v)
+        }
+      };
+      {
+        val __v = dotty.tools.dotc.semanticdb.SymbolInformation._typemapper_signature.toBase(signature)
+        if (__v.serializedSize != 0) {
+          _output__.writeTag(17, 2)
+          _output__.writeUInt32NoTag(__v.serializedSize)
+          __v.writeTo(_output__)
+        }
+      };
+      {
+        val __v = dotty.tools.dotc.semanticdb.SymbolInformation._typemapper_access.toBase(access)
+        if (__v.serializedSize != 0) {
+          _output__.writeTag(18, 2)
+          _output__.writeUInt32NoTag(__v.serializedSize)
+          __v.writeTo(_output__)
+        }
+      };
+      overriddenSymbols.foreach { __v =>
+        val __m = __v
+        _output__.writeString(19, __m)
+      };
+      documentation.foreach { __v =>
+        val __m = __v
+        _output__.writeTag(20, 2)
+        _output__.writeUInt32NoTag(__m.serializedSize)
+        __m.writeTo(_output__)
+      };
+    }
+    def withSymbol(__v: _root_.scala.Predef.String): SymbolInformation = copy(symbol = __v)
+    def withLanguage(__v: dotty.tools.dotc.semanticdb.Language): SymbolInformation = copy(language = __v)
+    def withKind(__v: dotty.tools.dotc.semanticdb.SymbolInformation.Kind): SymbolInformation = copy(kind = __v)
+    def withProperties(__v: _root_.scala.Int): SymbolInformation = copy(properties = __v)
+    def withDisplayName(__v: _root_.scala.Predef.String): SymbolInformation = copy(displayName = __v)
+    def withSignature(__v: dotty.tools.dotc.semanticdb.Signature): SymbolInformation = copy(signature = __v)
+    def clearAnnotations = copy(annotations = _root_.scala.Seq.empty)
+    def addAnnotations(__vs: dotty.tools.dotc.semanticdb.Annotation *): SymbolInformation = addAllAnnotations(__vs)
+    def addAllAnnotations(__vs: Iterable[dotty.tools.dotc.semanticdb.Annotation]): SymbolInformation = copy(annotations = annotations ++ __vs)
+    def withAnnotations(__v: _root_.scala.Seq[dotty.tools.dotc.semanticdb.Annotation]): SymbolInformation = copy(annotations = __v)
+    def withAccess(__v: dotty.tools.dotc.semanticdb.Access): SymbolInformation = copy(access = __v)
+    def clearOverriddenSymbols = copy(overriddenSymbols = _root_.scala.Seq.empty)
+    def addOverriddenSymbols(__vs: _root_.scala.Predef.String *): SymbolInformation = addAllOverriddenSymbols(__vs)
+    def addAllOverriddenSymbols(__vs: Iterable[_root_.scala.Predef.String]): SymbolInformation = copy(overriddenSymbols = overriddenSymbols ++ __vs)
+    def withOverriddenSymbols(__v: _root_.scala.Seq[_root_.scala.Predef.String]): SymbolInformation = copy(overriddenSymbols = __v)
+    def getDocumentation: dotty.tools.dotc.semanticdb.Documentation = documentation.getOrElse(dotty.tools.dotc.semanticdb.Documentation.defaultInstance)
+    def clearDocumentation: SymbolInformation = copy(documentation = _root_.scala.None)
+    def withDocumentation(__v: dotty.tools.dotc.semanticdb.Documentation): SymbolInformation = copy(documentation = Option(__v))
+    
+    
+    
+    
+    // @@protoc_insertion_point(GeneratedMessage[dotty.tools.dotc.semanticdb.SymbolInformation])
+}
+
+object SymbolInformation  extends SemanticdbGeneratedMessageCompanion[dotty.tools.dotc.semanticdb.SymbolInformation] {
+  implicit def messageCompanion: SemanticdbGeneratedMessageCompanion[dotty.tools.dotc.semanticdb.SymbolInformation] = this
+  def parseFrom(`_input__`: SemanticdbInputStream): dotty.tools.dotc.semanticdb.SymbolInformation = {
+    var __symbol: _root_.scala.Predef.String = ""
+    var __language: dotty.tools.dotc.semanticdb.Language = dotty.tools.dotc.semanticdb.Language.UNKNOWN_LANGUAGE
+    var __kind: dotty.tools.dotc.semanticdb.SymbolInformation.Kind = dotty.tools.dotc.semanticdb.SymbolInformation.Kind.UNKNOWN_KIND
+    var __properties: _root_.scala.Int = 0
+    var __displayName: _root_.scala.Predef.String = ""
+    var __signature: _root_.scala.Option[dotty.tools.dotc.semanticdb.SignatureMessage] = _root_.scala.None
+    val __annotations: _root_.scala.collection.immutable.VectorBuilder[dotty.tools.dotc.semanticdb.Annotation] = new _root_.scala.collection.immutable.VectorBuilder[dotty.tools.dotc.semanticdb.Annotation]
+    var __access: _root_.scala.Option[dotty.tools.dotc.semanticdb.AccessMessage] = _root_.scala.None
+    val __overriddenSymbols: _root_.scala.collection.immutable.VectorBuilder[_root_.scala.Predef.String] = new _root_.scala.collection.immutable.VectorBuilder[_root_.scala.Predef.String]
+    var __documentation: _root_.scala.Option[dotty.tools.dotc.semanticdb.Documentation] = _root_.scala.None
+    var _done__ = false
+    while (!_done__) {
+      val _tag__ = _input__.readTag()
+      _tag__ match {
+        case 0 => _done__ = true
+        case 10 =>
+          __symbol = _input__.readStringRequireUtf8()
+        case 128 =>
+          __language = dotty.tools.dotc.semanticdb.Language.fromValue(_input__.readEnum())
+        case 24 =>
+          __kind = dotty.tools.dotc.semanticdb.SymbolInformation.Kind.fromValue(_input__.readEnum())
+        case 32 =>
+          __properties = _input__.readInt32()
+        case 42 =>
+          __displayName = _input__.readStringRequireUtf8()
+        case 138 =>
+          __signature = _root_.scala.Some(__signature.fold(LiteParser.readMessage[dotty.tools.dotc.semanticdb.SignatureMessage](_input__))(LiteParser.readMessage(_input__, _)))
+        case 106 =>
+          __annotations += LiteParser.readMessage[dotty.tools.dotc.semanticdb.Annotation](_input__)
+        case 146 =>
+          __access = _root_.scala.Some(__access.fold(LiteParser.readMessage[dotty.tools.dotc.semanticdb.AccessMessage](_input__))(LiteParser.readMessage(_input__, _)))
+        case 154 =>
+          __overriddenSymbols += _input__.readStringRequireUtf8()
+        case 162 =>
+          __documentation = Option(__documentation.fold(LiteParser.readMessage[dotty.tools.dotc.semanticdb.Documentation](_input__))(LiteParser.readMessage(_input__, _)))
+        case tag => _input__.skipField(tag)
+      }
+    }
+    dotty.tools.dotc.semanticdb.SymbolInformation(
+        symbol = __symbol,
+        language = __language,
+        kind = __kind,
+        properties = __properties,
+        displayName = __displayName,
+        signature = dotty.tools.dotc.semanticdb.SymbolInformation._typemapper_signature.toCustom(__signature.getOrElse(dotty.tools.dotc.semanticdb.SignatureMessage.defaultInstance)),
+        annotations = __annotations.result(),
+        access = dotty.tools.dotc.semanticdb.SymbolInformation._typemapper_access.toCustom(__access.getOrElse(dotty.tools.dotc.semanticdb.AccessMessage.defaultInstance)),
+        overriddenSymbols = __overriddenSymbols.result(),
+        documentation = __documentation
+    )
+  }
+  
+  
+  
+  
+  
+  
+  lazy val defaultInstance = dotty.tools.dotc.semanticdb.SymbolInformation(
+    symbol = "",
+    language = dotty.tools.dotc.semanticdb.Language.UNKNOWN_LANGUAGE,
+    kind = dotty.tools.dotc.semanticdb.SymbolInformation.Kind.UNKNOWN_KIND,
+    properties = 0,
+    displayName = "",
+    signature = dotty.tools.dotc.semanticdb.SymbolInformation._typemapper_signature.toCustom(dotty.tools.dotc.semanticdb.SignatureMessage.defaultInstance),
+    annotations = _root_.scala.Seq.empty,
+    access = dotty.tools.dotc.semanticdb.SymbolInformation._typemapper_access.toCustom(dotty.tools.dotc.semanticdb.AccessMessage.defaultInstance),
+    overriddenSymbols = _root_.scala.Seq.empty,
+    documentation = _root_.scala.None
+  )
+  sealed abstract class Kind(val value: _root_.scala.Int)  extends SemanticdbGeneratedEnum  derives CanEqual {
+    type EnumType = Kind
+    def isUnknownKind: _root_.scala.Boolean = false
+    def isLocal: _root_.scala.Boolean = false
+    def isField: _root_.scala.Boolean = false
+    def isMethod: _root_.scala.Boolean = false
+    def isConstructor: _root_.scala.Boolean = false
+    def isMacro: _root_.scala.Boolean = false
+    def isType: _root_.scala.Boolean = false
+    def isParameter: _root_.scala.Boolean = false
+    def isSelfParameter: _root_.scala.Boolean = false
+    def isTypeParameter: _root_.scala.Boolean = false
+    def isObject: _root_.scala.Boolean = false
+    def isPackage: _root_.scala.Boolean = false
+    def isPackageObject: _root_.scala.Boolean = false
+    def isClass: _root_.scala.Boolean = false
+    def isTrait: _root_.scala.Boolean = false
+    def isInterface: _root_.scala.Boolean = false
+    
+    final def asRecognized: _root_.scala.Option[dotty.tools.dotc.semanticdb.SymbolInformation.Kind.Recognized] = if (isUnrecognized) _root_.scala.None else _root_.scala.Some(this.asInstanceOf[dotty.tools.dotc.semanticdb.SymbolInformation.Kind.Recognized])
+  }
+  
+  object Kind  {
+    sealed trait Recognized extends Kind
+    
+    
+    @SerialVersionUID(0L)
+    case object UNKNOWN_KIND extends Kind(0) with Kind.Recognized {
+      val index = 0
+      val name = "UNKNOWN_KIND"
+      override def isUnknownKind: _root_.scala.Boolean = true
+    }
+    
+    @SerialVersionUID(0L)
+    case object LOCAL extends Kind(19) with Kind.Recognized {
+      val index = 1
+      val name = "LOCAL"
+      override def isLocal: _root_.scala.Boolean = true
+    }
+    
+    @SerialVersionUID(0L)
+    case object FIELD extends Kind(20) with Kind.Recognized {
+      val index = 2
+      val name = "FIELD"
+      override def isField: _root_.scala.Boolean = true
+    }
+    
+    @SerialVersionUID(0L)
+    case object METHOD extends Kind(3) with Kind.Recognized {
+      val index = 3
+      val name = "METHOD"
+      override def isMethod: _root_.scala.Boolean = true
+    }
+    
+    @SerialVersionUID(0L)
+    case object CONSTRUCTOR extends Kind(21) with Kind.Recognized {
+      val index = 4
+      val name = "CONSTRUCTOR"
+      override def isConstructor: _root_.scala.Boolean = true
+    }
+    
+    @SerialVersionUID(0L)
+    case object MACRO extends Kind(6) with Kind.Recognized {
+      val index = 5
+      val name = "MACRO"
+      override def isMacro: _root_.scala.Boolean = true
+    }
+    
+    @SerialVersionUID(0L)
+    case object TYPE extends Kind(7) with Kind.Recognized {
+      val index = 6
+      val name = "TYPE"
+      override def isType: _root_.scala.Boolean = true
+    }
+    
+    @SerialVersionUID(0L)
+    case object PARAMETER extends Kind(8) with Kind.Recognized {
+      val index = 7
+      val name = "PARAMETER"
+      override def isParameter: _root_.scala.Boolean = true
+    }
+    
+    @SerialVersionUID(0L)
+    case object SELF_PARAMETER extends Kind(17) with Kind.Recognized {
+      val index = 8
+      val name = "SELF_PARAMETER"
+      override def isSelfParameter: _root_.scala.Boolean = true
+    }
+    
+    @SerialVersionUID(0L)
+    case object TYPE_PARAMETER extends Kind(9) with Kind.Recognized {
+      val index = 9
+      val name = "TYPE_PARAMETER"
+      override def isTypeParameter: _root_.scala.Boolean = true
+    }
+    
+    @SerialVersionUID(0L)
+    case object OBJECT extends Kind(10) with Kind.Recognized {
+      val index = 10
+      val name = "OBJECT"
+      override def isObject: _root_.scala.Boolean = true
+    }
+    
+    @SerialVersionUID(0L)
+    case object PACKAGE extends Kind(11) with Kind.Recognized {
+      val index = 11
+      val name = "PACKAGE"
+      override def isPackage: _root_.scala.Boolean = true
+    }
+    
+    @SerialVersionUID(0L)
+    case object PACKAGE_OBJECT extends Kind(12) with Kind.Recognized {
+      val index = 12
+      val name = "PACKAGE_OBJECT"
+      override def isPackageObject: _root_.scala.Boolean = true
+    }
+    
+    @SerialVersionUID(0L)
+    case object CLASS extends Kind(13) with Kind.Recognized {
+      val index = 13
+      val name = "CLASS"
+      override def isClass: _root_.scala.Boolean = true
+    }
+    
+    @SerialVersionUID(0L)
+    case object TRAIT extends Kind(14) with Kind.Recognized {
+      val index = 14
+      val name = "TRAIT"
+      override def isTrait: _root_.scala.Boolean = true
+    }
+    
+    @SerialVersionUID(0L)
+    case object INTERFACE extends Kind(18) with Kind.Recognized {
+      val index = 15
+      val name = "INTERFACE"
+      override def isInterface: _root_.scala.Boolean = true
+    }
+    
+    @SerialVersionUID(0L)
+    final case class Unrecognized(unrecognizedValue: _root_.scala.Int)  extends Kind(unrecognizedValue) with SemanticdbUnrecognizedEnum
+    lazy val values = scala.collection.immutable.Seq(UNKNOWN_KIND, LOCAL, FIELD, METHOD, CONSTRUCTOR, MACRO, TYPE, PARAMETER, SELF_PARAMETER, TYPE_PARAMETER, OBJECT, PACKAGE, PACKAGE_OBJECT, CLASS, TRAIT, INTERFACE)
+    def fromValue(__value: _root_.scala.Int): Kind = __value match {
+      case 0 => UNKNOWN_KIND
+      case 3 => METHOD
+      case 6 => MACRO
+      case 7 => TYPE
+      case 8 => PARAMETER
+      case 9 => TYPE_PARAMETER
+      case 10 => OBJECT
+      case 11 => PACKAGE
+      case 12 => PACKAGE_OBJECT
+      case 13 => CLASS
+      case 14 => TRAIT
+      case 17 => SELF_PARAMETER
+      case 18 => INTERFACE
+      case 19 => LOCAL
+      case 20 => FIELD
+      case 21 => CONSTRUCTOR
+      case __other => Unrecognized(__other)
+    }
+    
+    
+  }
+  sealed abstract class Property(val value: _root_.scala.Int)  extends SemanticdbGeneratedEnum  derives CanEqual {
+    type EnumType = Property
+    def isUnknownProperty: _root_.scala.Boolean = false
+    def isAbstract: _root_.scala.Boolean = false
+    def isFinal: _root_.scala.Boolean = false
+    def isSealed: _root_.scala.Boolean = false
+    def isImplicit: _root_.scala.Boolean = false
+    def isLazy: _root_.scala.Boolean = false
+    def isCase: _root_.scala.Boolean = false
+    def isCovariant: _root_.scala.Boolean = false
+    def isContravariant: _root_.scala.Boolean = false
+    def isVal: _root_.scala.Boolean = false
+    def isVar: _root_.scala.Boolean = false
+    def isStatic: _root_.scala.Boolean = false
+    def isPrimary: _root_.scala.Boolean = false
+    def isEnum: _root_.scala.Boolean = false
+    def isDefault: _root_.scala.Boolean = false
+    def isGiven: _root_.scala.Boolean = false
+    def isInline: _root_.scala.Boolean = false
+    def isOpen: _root_.scala.Boolean = false
+    def isTransparent: _root_.scala.Boolean = false
+    def isInfix: _root_.scala.Boolean = false
+    def isOpaque: _root_.scala.Boolean = false
+    
+    final def asRecognized: _root_.scala.Option[dotty.tools.dotc.semanticdb.SymbolInformation.Property.Recognized] = if (isUnrecognized) _root_.scala.None else _root_.scala.Some(this.asInstanceOf[dotty.tools.dotc.semanticdb.SymbolInformation.Property.Recognized])
+  }
+  
+  object Property  {
+    sealed trait Recognized extends Property
+    
+    
+    @SerialVersionUID(0L)
+    case object UNKNOWN_PROPERTY extends Property(0) with Property.Recognized {
+      val index = 0
+      val name = "UNKNOWN_PROPERTY"
+      override def isUnknownProperty: _root_.scala.Boolean = true
+    }
+    
+    @SerialVersionUID(0L)
+    case object ABSTRACT extends Property(4) with Property.Recognized {
+      val index = 1
+      val name = "ABSTRACT"
+      override def isAbstract: _root_.scala.Boolean = true
+    }
+    
+    @SerialVersionUID(0L)
+    case object FINAL extends Property(8) with Property.Recognized {
+      val index = 2
+      val name = "FINAL"
+      override def isFinal: _root_.scala.Boolean = true
+    }
+    
+    @SerialVersionUID(0L)
+    case object SEALED extends Property(16) with Property.Recognized {
+      val index = 3
+      val name = "SEALED"
+      override def isSealed: _root_.scala.Boolean = true
+    }
+    
+    @SerialVersionUID(0L)
+    case object IMPLICIT extends Property(32) with Property.Recognized {
+      val index = 4
+      val name = "IMPLICIT"
+      override def isImplicit: _root_.scala.Boolean = true
+    }
+    
+    @SerialVersionUID(0L)
+    case object LAZY extends Property(64) with Property.Recognized {
+      val index = 5
+      val name = "LAZY"
+      override def isLazy: _root_.scala.Boolean = true
+    }
+    
+    @SerialVersionUID(0L)
+    case object CASE extends Property(128) with Property.Recognized {
+      val index = 6
+      val name = "CASE"
+      override def isCase: _root_.scala.Boolean = true
+    }
+    
+    @SerialVersionUID(0L)
+    case object COVARIANT extends Property(256) with Property.Recognized {
+      val index = 7
+      val name = "COVARIANT"
+      override def isCovariant: _root_.scala.Boolean = true
+    }
+    
+    @SerialVersionUID(0L)
+    case object CONTRAVARIANT extends Property(512) with Property.Recognized {
+      val index = 8
+      val name = "CONTRAVARIANT"
+      override def isContravariant: _root_.scala.Boolean = true
+    }
+    
+    @SerialVersionUID(0L)
+    case object VAL extends Property(1024) with Property.Recognized {
+      val index = 9
+      val name = "VAL"
+      override def isVal: _root_.scala.Boolean = true
+    }
+    
+    @SerialVersionUID(0L)
+    case object VAR extends Property(2048) with Property.Recognized {
+      val index = 10
+      val name = "VAR"
+      override def isVar: _root_.scala.Boolean = true
+    }
+    
+    @SerialVersionUID(0L)
+    case object STATIC extends Property(4096) with Property.Recognized {
+      val index = 11
+      val name = "STATIC"
+      override def isStatic: _root_.scala.Boolean = true
+    }
+    
+    @SerialVersionUID(0L)
+    case object PRIMARY extends Property(8192) with Property.Recognized {
+      val index = 12
+      val name = "PRIMARY"
+      override def isPrimary: _root_.scala.Boolean = true
+    }
+    
+    @SerialVersionUID(0L)
+    case object ENUM extends Property(16384) with Property.Recognized {
+      val index = 13
+      val name = "ENUM"
+      override def isEnum: _root_.scala.Boolean = true
+    }
+    
+    @SerialVersionUID(0L)
+    case object DEFAULT extends Property(32768) with Property.Recognized {
+      val index = 14
+      val name = "DEFAULT"
+      override def isDefault: _root_.scala.Boolean = true
+    }
+    
+    @SerialVersionUID(0L)
+    case object GIVEN extends Property(65536) with Property.Recognized {
+      val index = 15
+      val name = "GIVEN"
+      override def isGiven: _root_.scala.Boolean = true
+    }
+    
+    @SerialVersionUID(0L)
+    case object INLINE extends Property(131072) with Property.Recognized {
+      val index = 16
+      val name = "INLINE"
+      override def isInline: _root_.scala.Boolean = true
+    }
+    
+    @SerialVersionUID(0L)
+    case object OPEN extends Property(262144) with Property.Recognized {
+      val index = 17
+      val name = "OPEN"
+      override def isOpen: _root_.scala.Boolean = true
+    }
+    
+    @SerialVersionUID(0L)
+    case object TRANSPARENT extends Property(524288) with Property.Recognized {
+      val index = 18
+      val name = "TRANSPARENT"
+      override def isTransparent: _root_.scala.Boolean = true
+    }
+    
+    @SerialVersionUID(0L)
+    case object INFIX extends Property(1048576) with Property.Recognized {
+      val index = 19
+      val name = "INFIX"
+      override def isInfix: _root_.scala.Boolean = true
+    }
+    
+    @SerialVersionUID(0L)
+    case object OPAQUE extends Property(2097152) with Property.Recognized {
+      val index = 20
+      val name = "OPAQUE"
+      override def isOpaque: _root_.scala.Boolean = true
+    }
+    
+    @SerialVersionUID(0L)
+    final case class Unrecognized(unrecognizedValue: _root_.scala.Int)  extends Property(unrecognizedValue) with SemanticdbUnrecognizedEnum
+    lazy val values = scala.collection.immutable.Seq(UNKNOWN_PROPERTY, ABSTRACT, FINAL, SEALED, IMPLICIT, LAZY, CASE, COVARIANT, CONTRAVARIANT, VAL, VAR, STATIC, PRIMARY, ENUM, DEFAULT, GIVEN, INLINE, OPEN, TRANSPARENT, INFIX, OPAQUE)
+    def fromValue(__value: _root_.scala.Int): Property = __value match {
+      case 0 => UNKNOWN_PROPERTY
+      case 4 => ABSTRACT
+      case 8 => FINAL
+      case 16 => SEALED
+      case 32 => IMPLICIT
+      case 64 => LAZY
+      case 128 => CASE
+      case 256 => COVARIANT
+      case 512 => CONTRAVARIANT
+      case 1024 => VAL
+      case 2048 => VAR
+      case 4096 => STATIC
+      case 8192 => PRIMARY
+      case 16384 => ENUM
+      case 32768 => DEFAULT
+      case 65536 => GIVEN
+      case 131072 => INLINE
+      case 262144 => OPEN
+      case 524288 => TRANSPARENT
+      case 1048576 => INFIX
+      case 2097152 => OPAQUE
+      case __other => Unrecognized(__other)
+    }
+    
+    
+  }
+  final val SYMBOL_FIELD_NUMBER = 1
+  final val LANGUAGE_FIELD_NUMBER = 16
+  final val KIND_FIELD_NUMBER = 3
+  final val PROPERTIES_FIELD_NUMBER = 4
+  final val DISPLAY_NAME_FIELD_NUMBER = 5
+  final val SIGNATURE_FIELD_NUMBER = 17
+  final val ANNOTATIONS_FIELD_NUMBER = 13
+  final val ACCESS_FIELD_NUMBER = 18
+  final val OVERRIDDEN_SYMBOLS_FIELD_NUMBER = 19
+  final val DOCUMENTATION_FIELD_NUMBER = 20
+  @transient @sharable
+  private[semanticdb] val _typemapper_signature: SemanticdbTypeMapper[dotty.tools.dotc.semanticdb.SignatureMessage, dotty.tools.dotc.semanticdb.Signature] = implicitly[SemanticdbTypeMapper[dotty.tools.dotc.semanticdb.SignatureMessage, dotty.tools.dotc.semanticdb.Signature]]
+  @transient @sharable
+  private[semanticdb] val _typemapper_access: SemanticdbTypeMapper[dotty.tools.dotc.semanticdb.AccessMessage, dotty.tools.dotc.semanticdb.Access] = implicitly[SemanticdbTypeMapper[dotty.tools.dotc.semanticdb.AccessMessage, dotty.tools.dotc.semanticdb.Access]]
+  def of(
+    symbol: _root_.scala.Predef.String,
+    language: dotty.tools.dotc.semanticdb.Language,
+    kind: dotty.tools.dotc.semanticdb.SymbolInformation.Kind,
+    properties: _root_.scala.Int,
+    displayName: _root_.scala.Predef.String,
+    signature: dotty.tools.dotc.semanticdb.Signature,
+    annotations: _root_.scala.Seq[dotty.tools.dotc.semanticdb.Annotation],
+    access: dotty.tools.dotc.semanticdb.Access,
+    overriddenSymbols: _root_.scala.Seq[_root_.scala.Predef.String],
+    documentation: _root_.scala.Option[dotty.tools.dotc.semanticdb.Documentation]
+  ): _root_.dotty.tools.dotc.semanticdb.SymbolInformation = _root_.dotty.tools.dotc.semanticdb.SymbolInformation(
+    symbol,
+    language,
+    kind,
+    properties,
+    displayName,
+    signature,
+    annotations,
+    access,
+    overriddenSymbols,
+    documentation
+  )
+  // @@protoc_insertion_point(GeneratedMessageCompanion[dotty.tools.dotc.semanticdb.SymbolInformation])
+}
diff --git a/tests/pos-with-compiler-cc/dotc/semanticdb/generated/SymbolOccurrence.scala b/tests/pos-with-compiler-cc/dotc/semanticdb/generated/SymbolOccurrence.scala
new file mode 100644
index 000000000000..5d7670dfdd32
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/semanticdb/generated/SymbolOccurrence.scala
@@ -0,0 +1,178 @@
+// Generated by https://github.com/tanishiking/semanticdb-for-scala3
+// Generated by the Scala Plugin for the Protocol Buffer Compiler.
+// Do not edit!
+//
+// Protofile syntax: PROTO3
+
+package dotty.tools.dotc.semanticdb
+import dotty.tools.dotc.semanticdb.internal._
+import scala.annotation.internal.sharable
+
+@SerialVersionUID(0L)
+final case class SymbolOccurrence(
+    range: _root_.scala.Option[dotty.tools.dotc.semanticdb.Range] = _root_.scala.None,
+    symbol: _root_.scala.Predef.String = "",
+    role: dotty.tools.dotc.semanticdb.SymbolOccurrence.Role = dotty.tools.dotc.semanticdb.SymbolOccurrence.Role.UNKNOWN_ROLE
+    )  extends SemanticdbGeneratedMessage  derives CanEqual {
+    @transient @sharable
+    private[this] var __serializedSizeMemoized: _root_.scala.Int = 0
+    private[this] def __computeSerializedSize(): _root_.scala.Int = {
+      var __size = 0
+      if (range.isDefined) {
+        val __value = range.get
+        __size += 1 + SemanticdbOutputStream.computeUInt32SizeNoTag(__value.serializedSize) + __value.serializedSize
+      };
+      
+      {
+        val __value = symbol
+        if (!__value.isEmpty) {
+          __size += SemanticdbOutputStream.computeStringSize(2, __value)
+        }
+      };
+      
+      {
+        val __value = role.value
+        if (__value != 0) {
+          __size += SemanticdbOutputStream.computeEnumSize(3, __value)
+        }
+      };
+      __size
+    }
+    override def serializedSize: _root_.scala.Int = {
+      var __size = __serializedSizeMemoized
+      if (__size == 0) {
+        __size = __computeSerializedSize() + 1
+        __serializedSizeMemoized = __size
+      }
+      __size - 1
+      
+    }
+    def writeTo(`_output__`: SemanticdbOutputStream): _root_.scala.Unit = {
+      range.foreach { __v =>
+        val __m = __v
+        _output__.writeTag(1, 2)
+        _output__.writeUInt32NoTag(__m.serializedSize)
+        __m.writeTo(_output__)
+      };
+      {
+        val __v = symbol
+        if (!__v.isEmpty) {
+          _output__.writeString(2, __v)
+        }
+      };
+      {
+        val __v = role.value
+        if (__v != 0) {
+          _output__.writeEnum(3, __v)
+        }
+      };
+    }
+    def getRange: dotty.tools.dotc.semanticdb.Range = range.getOrElse(dotty.tools.dotc.semanticdb.Range.defaultInstance)
+    def clearRange: SymbolOccurrence = copy(range = _root_.scala.None)
+    def withRange(__v: dotty.tools.dotc.semanticdb.Range): SymbolOccurrence = copy(range = Option(__v))
+    def withSymbol(__v: _root_.scala.Predef.String): SymbolOccurrence = copy(symbol = __v)
+    def withRole(__v: dotty.tools.dotc.semanticdb.SymbolOccurrence.Role): SymbolOccurrence = copy(role = __v)
+    
+    
+    
+    
+    // @@protoc_insertion_point(GeneratedMessage[dotty.tools.dotc.semanticdb.SymbolOccurrence])
+}
+
+object SymbolOccurrence  extends SemanticdbGeneratedMessageCompanion[dotty.tools.dotc.semanticdb.SymbolOccurrence] {
+  implicit def messageCompanion: SemanticdbGeneratedMessageCompanion[dotty.tools.dotc.semanticdb.SymbolOccurrence] = this
+  def parseFrom(`_input__`: SemanticdbInputStream): dotty.tools.dotc.semanticdb.SymbolOccurrence = {
+    var __range: _root_.scala.Option[dotty.tools.dotc.semanticdb.Range] = _root_.scala.None
+    var __symbol: _root_.scala.Predef.String = ""
+    var __role: dotty.tools.dotc.semanticdb.SymbolOccurrence.Role = dotty.tools.dotc.semanticdb.SymbolOccurrence.Role.UNKNOWN_ROLE
+    var _done__ = false
+    while (!_done__) {
+      val _tag__ = _input__.readTag()
+      _tag__ match {
+        case 0 => _done__ = true
+        case 10 =>
+          __range = Option(__range.fold(LiteParser.readMessage[dotty.tools.dotc.semanticdb.Range](_input__))(LiteParser.readMessage(_input__, _)))
+        case 18 =>
+          __symbol = _input__.readStringRequireUtf8()
+        case 24 =>
+          __role = dotty.tools.dotc.semanticdb.SymbolOccurrence.Role.fromValue(_input__.readEnum())
+        case tag => _input__.skipField(tag)
+      }
+    }
+    dotty.tools.dotc.semanticdb.SymbolOccurrence(
+        range = __range,
+        symbol = __symbol,
+        role = __role
+    )
+  }
+  
+  
+  
+  
+  
+  
+  lazy val defaultInstance = dotty.tools.dotc.semanticdb.SymbolOccurrence(
+    range = _root_.scala.None,
+    symbol = "",
+    role = dotty.tools.dotc.semanticdb.SymbolOccurrence.Role.UNKNOWN_ROLE
+  )
+  sealed abstract class Role(val value: _root_.scala.Int)  extends SemanticdbGeneratedEnum  derives CanEqual {
+    type EnumType = Role
+    def isUnknownRole: _root_.scala.Boolean = false
+    def isReference: _root_.scala.Boolean = false
+    def isDefinition: _root_.scala.Boolean = false
+    
+    final def asRecognized: _root_.scala.Option[dotty.tools.dotc.semanticdb.SymbolOccurrence.Role.Recognized] = if (isUnrecognized) _root_.scala.None else _root_.scala.Some(this.asInstanceOf[dotty.tools.dotc.semanticdb.SymbolOccurrence.Role.Recognized])
+  }
+  
+  object Role  {
+    sealed trait Recognized extends Role
+    
+    
+    @SerialVersionUID(0L)
+    case object UNKNOWN_ROLE extends Role(0) with Role.Recognized {
+      val index = 0
+      val name = "UNKNOWN_ROLE"
+      override def isUnknownRole: _root_.scala.Boolean = true
+    }
+    
+    @SerialVersionUID(0L)
+    case object REFERENCE extends Role(1) with Role.Recognized {
+      val index = 1
+      val name = "REFERENCE"
+      override def isReference: _root_.scala.Boolean = true
+    }
+    
+    @SerialVersionUID(0L)
+    case object DEFINITION extends Role(2) with Role.Recognized {
+      val index = 2
+      val name = "DEFINITION"
+      override def isDefinition: _root_.scala.Boolean = true
+    }
+    
+    @SerialVersionUID(0L)
+    final case class Unrecognized(unrecognizedValue: _root_.scala.Int)  extends Role(unrecognizedValue) with SemanticdbUnrecognizedEnum
+    lazy val values = scala.collection.immutable.Seq(UNKNOWN_ROLE, REFERENCE, DEFINITION)
+    def fromValue(__value: _root_.scala.Int): Role = __value match {
+      case 0 => UNKNOWN_ROLE
+      case 1 => REFERENCE
+      case 2 => DEFINITION
+      case __other => Unrecognized(__other)
+    }
+    
+    
+  }
+  final val RANGE_FIELD_NUMBER = 1
+  final val SYMBOL_FIELD_NUMBER = 2
+  final val ROLE_FIELD_NUMBER = 3
+  def of(
+    range: _root_.scala.Option[dotty.tools.dotc.semanticdb.Range],
+    symbol: _root_.scala.Predef.String,
+    role: dotty.tools.dotc.semanticdb.SymbolOccurrence.Role
+  ): _root_.dotty.tools.dotc.semanticdb.SymbolOccurrence = _root_.dotty.tools.dotc.semanticdb.SymbolOccurrence(
+    range,
+    symbol,
+    role
+  )
+  // @@protoc_insertion_point(GeneratedMessageCompanion[dotty.tools.dotc.semanticdb.SymbolOccurrence])
+}
diff --git a/tests/pos-with-compiler-cc/dotc/semanticdb/generated/Synthetic.scala b/tests/pos-with-compiler-cc/dotc/semanticdb/generated/Synthetic.scala
new file mode 100644
index 000000000000..3c6fcfbf4c6a
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/semanticdb/generated/Synthetic.scala
@@ -0,0 +1,113 @@
+// Generated by https://github.com/tanishiking/semanticdb-for-scala3
+// Generated by the Scala Plugin for the Protocol Buffer Compiler.
+// Do not edit!
+//
+// Protofile syntax: PROTO3
+
+package dotty.tools.dotc.semanticdb
+import dotty.tools.dotc.semanticdb.internal._
+import scala.annotation.internal.sharable
+
+@SerialVersionUID(0L)
+final case class Synthetic(
+    range: _root_.scala.Option[dotty.tools.dotc.semanticdb.Range] = _root_.scala.None,
+    tree: dotty.tools.dotc.semanticdb.Tree = dotty.tools.dotc.semanticdb.Synthetic._typemapper_tree.toCustom(dotty.tools.dotc.semanticdb.TreeMessage.defaultInstance)
+    )  extends SemanticdbGeneratedMessage  derives CanEqual {
+    @transient @sharable
+    private[this] var __serializedSizeMemoized: _root_.scala.Int = 0
+    private[this] def __computeSerializedSize(): _root_.scala.Int = {
+      var __size = 0
+      if (range.isDefined) {
+        val __value = range.get
+        __size += 1 + SemanticdbOutputStream.computeUInt32SizeNoTag(__value.serializedSize) + __value.serializedSize
+      };
+      
+      {
+        val __value = dotty.tools.dotc.semanticdb.Synthetic._typemapper_tree.toBase(tree)
+        if (__value.serializedSize != 0) {
+          __size += 1 + SemanticdbOutputStream.computeUInt32SizeNoTag(__value.serializedSize) + __value.serializedSize
+        }
+      };
+      __size
+    }
+    override def serializedSize: _root_.scala.Int = {
+      var __size = __serializedSizeMemoized
+      if (__size == 0) {
+        __size = __computeSerializedSize() + 1
+        __serializedSizeMemoized = __size
+      }
+      __size - 1
+      
+    }
+    def writeTo(`_output__`: SemanticdbOutputStream): _root_.scala.Unit = {
+      range.foreach { __v =>
+        val __m = __v
+        _output__.writeTag(1, 2)
+        _output__.writeUInt32NoTag(__m.serializedSize)
+        __m.writeTo(_output__)
+      };
+      {
+        val __v = dotty.tools.dotc.semanticdb.Synthetic._typemapper_tree.toBase(tree)
+        if (__v.serializedSize != 0) {
+          _output__.writeTag(2, 2)
+          _output__.writeUInt32NoTag(__v.serializedSize)
+          __v.writeTo(_output__)
+        }
+      };
+    }
+    def getRange: dotty.tools.dotc.semanticdb.Range = range.getOrElse(dotty.tools.dotc.semanticdb.Range.defaultInstance)
+    def clearRange: Synthetic = copy(range = _root_.scala.None)
+    def withRange(__v: dotty.tools.dotc.semanticdb.Range): Synthetic = copy(range = Option(__v))
+    def withTree(__v: dotty.tools.dotc.semanticdb.Tree): Synthetic = copy(tree = __v)
+    
+    
+    
+    
+    // @@protoc_insertion_point(GeneratedMessage[dotty.tools.dotc.semanticdb.Synthetic])
+}
+
+object Synthetic  extends SemanticdbGeneratedMessageCompanion[dotty.tools.dotc.semanticdb.Synthetic] {
+  implicit def messageCompanion: SemanticdbGeneratedMessageCompanion[dotty.tools.dotc.semanticdb.Synthetic] = this
+  def parseFrom(`_input__`: SemanticdbInputStream): dotty.tools.dotc.semanticdb.Synthetic = {
+    var __range: _root_.scala.Option[dotty.tools.dotc.semanticdb.Range] = _root_.scala.None
+    var __tree: _root_.scala.Option[dotty.tools.dotc.semanticdb.TreeMessage] = _root_.scala.None
+    var _done__ = false
+    while (!_done__) {
+      val _tag__ = _input__.readTag()
+      _tag__ match {
+        case 0 => _done__ = true
+        case 10 =>
+          __range = Option(__range.fold(LiteParser.readMessage[dotty.tools.dotc.semanticdb.Range](_input__))(LiteParser.readMessage(_input__, _)))
+        case 18 =>
+          __tree = _root_.scala.Some(__tree.fold(LiteParser.readMessage[dotty.tools.dotc.semanticdb.TreeMessage](_input__))(LiteParser.readMessage(_input__, _)))
+        case tag => _input__.skipField(tag)
+      }
+    }
+    dotty.tools.dotc.semanticdb.Synthetic(
+        range = __range,
+        tree = dotty.tools.dotc.semanticdb.Synthetic._typemapper_tree.toCustom(__tree.getOrElse(dotty.tools.dotc.semanticdb.TreeMessage.defaultInstance))
+    )
+  }
+  
+  
+  
+  
+  
+  
+  lazy val defaultInstance = dotty.tools.dotc.semanticdb.Synthetic(
+    range = _root_.scala.None,
+    tree = dotty.tools.dotc.semanticdb.Synthetic._typemapper_tree.toCustom(dotty.tools.dotc.semanticdb.TreeMessage.defaultInstance)
+  )
+  final val RANGE_FIELD_NUMBER = 1
+  final val TREE_FIELD_NUMBER = 2
+  @transient @sharable
+  private[semanticdb] val _typemapper_tree: SemanticdbTypeMapper[dotty.tools.dotc.semanticdb.TreeMessage, dotty.tools.dotc.semanticdb.Tree] = implicitly[SemanticdbTypeMapper[dotty.tools.dotc.semanticdb.TreeMessage, dotty.tools.dotc.semanticdb.Tree]]
+  def of(
+    range: _root_.scala.Option[dotty.tools.dotc.semanticdb.Range],
+    tree: dotty.tools.dotc.semanticdb.Tree
+  ): _root_.dotty.tools.dotc.semanticdb.Synthetic = _root_.dotty.tools.dotc.semanticdb.Synthetic(
+    range,
+    tree
+  )
+  // @@protoc_insertion_point(GeneratedMessageCompanion[dotty.tools.dotc.semanticdb.Synthetic])
+}
diff --git a/tests/pos-with-compiler-cc/dotc/semanticdb/generated/TextDocument.scala b/tests/pos-with-compiler-cc/dotc/semanticdb/generated/TextDocument.scala
new file mode 100644
index 000000000000..f0347e86d9e3
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/semanticdb/generated/TextDocument.scala
@@ -0,0 +1,271 @@
+// Generated by https://github.com/tanishiking/semanticdb-for-scala3
+// Generated by the Scala Plugin for the Protocol Buffer Compiler.
+// Do not edit!
+//
+// Protofile syntax: PROTO3
+
+package dotty.tools.dotc.semanticdb
+import dotty.tools.dotc.semanticdb.internal._
+import scala.annotation.internal.sharable
+
+@SerialVersionUID(0L)
+final case class TextDocument(
+    schema: dotty.tools.dotc.semanticdb.Schema = dotty.tools.dotc.semanticdb.Schema.LEGACY,
+    uri: _root_.scala.Predef.String = "",
+    text: _root_.scala.Predef.String = "",
+    md5: _root_.scala.Predef.String = "",
+    language: dotty.tools.dotc.semanticdb.Language = dotty.tools.dotc.semanticdb.Language.UNKNOWN_LANGUAGE,
+    symbols: _root_.scala.Seq[dotty.tools.dotc.semanticdb.SymbolInformation] = _root_.scala.Seq.empty,
+    occurrences: _root_.scala.Seq[dotty.tools.dotc.semanticdb.SymbolOccurrence] = _root_.scala.Seq.empty,
+    diagnostics: _root_.scala.Seq[dotty.tools.dotc.semanticdb.Diagnostic] = _root_.scala.Seq.empty,
+    synthetics: _root_.scala.Seq[dotty.tools.dotc.semanticdb.Synthetic] = _root_.scala.Seq.empty
+    )  extends SemanticdbGeneratedMessage  derives CanEqual {
+    @transient @sharable
+    private[this] var __serializedSizeMemoized: _root_.scala.Int = 0
+    private[this] def __computeSerializedSize(): _root_.scala.Int = {
+      var __size = 0
+      
+      {
+        val __value = schema.value
+        if (__value != 0) {
+          __size += SemanticdbOutputStream.computeEnumSize(1, __value)
+        }
+      };
+      
+      {
+        val __value = uri
+        if (!__value.isEmpty) {
+          __size += SemanticdbOutputStream.computeStringSize(2, __value)
+        }
+      };
+      
+      {
+        val __value = text
+        if (!__value.isEmpty) {
+          __size += SemanticdbOutputStream.computeStringSize(3, __value)
+        }
+      };
+      
+      {
+        val __value = md5
+        if (!__value.isEmpty) {
+          __size += SemanticdbOutputStream.computeStringSize(11, __value)
+        }
+      };
+      
+      {
+        val __value = language.value
+        if (__value != 0) {
+          __size += SemanticdbOutputStream.computeEnumSize(10, __value)
+        }
+      };
+      symbols.foreach { __item =>
+        val __value = __item
+        __size += 1 + SemanticdbOutputStream.computeUInt32SizeNoTag(__value.serializedSize) + __value.serializedSize
+      }
+      occurrences.foreach { __item =>
+        val __value = __item
+        __size += 1 + SemanticdbOutputStream.computeUInt32SizeNoTag(__value.serializedSize) + __value.serializedSize
+      }
+      diagnostics.foreach { __item =>
+        val __value = __item
+        __size += 1 + SemanticdbOutputStream.computeUInt32SizeNoTag(__value.serializedSize) + __value.serializedSize
+      }
+      synthetics.foreach { __item =>
+        val __value = __item
+        __size += 1 + SemanticdbOutputStream.computeUInt32SizeNoTag(__value.serializedSize) + __value.serializedSize
+      }
+      __size
+    }
+    override def serializedSize: _root_.scala.Int = {
+      var __size = __serializedSizeMemoized
+      if (__size == 0) {
+        __size = __computeSerializedSize() + 1
+        __serializedSizeMemoized = __size
+      }
+      __size - 1
+      
+    }
+    def writeTo(`_output__`: SemanticdbOutputStream): _root_.scala.Unit = {
+      {
+        val __v = schema.value
+        if (__v != 0) {
+          _output__.writeEnum(1, __v)
+        }
+      };
+      {
+        val __v = uri
+        if (!__v.isEmpty) {
+          _output__.writeString(2, __v)
+        }
+      };
+      {
+        val __v = text
+        if (!__v.isEmpty) {
+          _output__.writeString(3, __v)
+        }
+      };
+      symbols.foreach { __v =>
+        val __m = __v
+        _output__.writeTag(5, 2)
+        _output__.writeUInt32NoTag(__m.serializedSize)
+        __m.writeTo(_output__)
+      };
+      occurrences.foreach { __v =>
+        val __m = __v
+        _output__.writeTag(6, 2)
+        _output__.writeUInt32NoTag(__m.serializedSize)
+        __m.writeTo(_output__)
+      };
+      diagnostics.foreach { __v =>
+        val __m = __v
+        _output__.writeTag(7, 2)
+        _output__.writeUInt32NoTag(__m.serializedSize)
+        __m.writeTo(_output__)
+      };
+      {
+        val __v = language.value
+        if (__v != 0) {
+          _output__.writeEnum(10, __v)
+        }
+      };
+      {
+        val __v = md5
+        if (!__v.isEmpty) {
+          _output__.writeString(11, __v)
+        }
+      };
+      synthetics.foreach { __v =>
+        val __m = __v
+        _output__.writeTag(12, 2)
+        _output__.writeUInt32NoTag(__m.serializedSize)
+        __m.writeTo(_output__)
+      };
+    }
+    def withSchema(__v: dotty.tools.dotc.semanticdb.Schema): TextDocument = copy(schema = __v)
+    def withUri(__v: _root_.scala.Predef.String): TextDocument = copy(uri = __v)
+    def withText(__v: _root_.scala.Predef.String): TextDocument = copy(text = __v)
+    def withMd5(__v: _root_.scala.Predef.String): TextDocument = copy(md5 = __v)
+    def withLanguage(__v: dotty.tools.dotc.semanticdb.Language): TextDocument = copy(language = __v)
+    def clearSymbols = copy(symbols = _root_.scala.Seq.empty)
+    def addSymbols(__vs: dotty.tools.dotc.semanticdb.SymbolInformation *): TextDocument = addAllSymbols(__vs)
+    def addAllSymbols(__vs: Iterable[dotty.tools.dotc.semanticdb.SymbolInformation]): TextDocument = copy(symbols = symbols ++ __vs)
+    def withSymbols(__v: _root_.scala.Seq[dotty.tools.dotc.semanticdb.SymbolInformation]): TextDocument = copy(symbols = __v)
+    def clearOccurrences = copy(occurrences = _root_.scala.Seq.empty)
+    def addOccurrences(__vs: dotty.tools.dotc.semanticdb.SymbolOccurrence *): TextDocument = addAllOccurrences(__vs)
+    def addAllOccurrences(__vs: Iterable[dotty.tools.dotc.semanticdb.SymbolOccurrence]): TextDocument = copy(occurrences = occurrences ++ __vs)
+    def withOccurrences(__v: _root_.scala.Seq[dotty.tools.dotc.semanticdb.SymbolOccurrence]): TextDocument = copy(occurrences = __v)
+    def clearDiagnostics = copy(diagnostics = _root_.scala.Seq.empty)
+    def addDiagnostics(__vs: dotty.tools.dotc.semanticdb.Diagnostic *): TextDocument = addAllDiagnostics(__vs)
+    def addAllDiagnostics(__vs: Iterable[dotty.tools.dotc.semanticdb.Diagnostic]): TextDocument = copy(diagnostics = diagnostics ++ __vs)
+    def withDiagnostics(__v: _root_.scala.Seq[dotty.tools.dotc.semanticdb.Diagnostic]): TextDocument = copy(diagnostics = __v)
+    def clearSynthetics = copy(synthetics = _root_.scala.Seq.empty)
+    def addSynthetics(__vs: dotty.tools.dotc.semanticdb.Synthetic *): TextDocument = addAllSynthetics(__vs)
+    def addAllSynthetics(__vs: Iterable[dotty.tools.dotc.semanticdb.Synthetic]): TextDocument = copy(synthetics = synthetics ++ __vs)
+    def withSynthetics(__v: _root_.scala.Seq[dotty.tools.dotc.semanticdb.Synthetic]): TextDocument = copy(synthetics = __v)
+    
+    
+    
+    
+    // @@protoc_insertion_point(GeneratedMessage[dotty.tools.dotc.semanticdb.TextDocument])
+}
+
+object TextDocument  extends SemanticdbGeneratedMessageCompanion[dotty.tools.dotc.semanticdb.TextDocument] {
+  implicit def messageCompanion: SemanticdbGeneratedMessageCompanion[dotty.tools.dotc.semanticdb.TextDocument] = this
+  def parseFrom(`_input__`: SemanticdbInputStream): dotty.tools.dotc.semanticdb.TextDocument = {
+    var __schema: dotty.tools.dotc.semanticdb.Schema = dotty.tools.dotc.semanticdb.Schema.LEGACY
+    var __uri: _root_.scala.Predef.String = ""
+    var __text: _root_.scala.Predef.String = ""
+    var __md5: _root_.scala.Predef.String = ""
+    var __language: dotty.tools.dotc.semanticdb.Language = dotty.tools.dotc.semanticdb.Language.UNKNOWN_LANGUAGE
+    val __symbols: _root_.scala.collection.immutable.VectorBuilder[dotty.tools.dotc.semanticdb.SymbolInformation] = new _root_.scala.collection.immutable.VectorBuilder[dotty.tools.dotc.semanticdb.SymbolInformation]
+    val __occurrences: _root_.scala.collection.immutable.VectorBuilder[dotty.tools.dotc.semanticdb.SymbolOccurrence] = new _root_.scala.collection.immutable.VectorBuilder[dotty.tools.dotc.semanticdb.SymbolOccurrence]
+    val __diagnostics: _root_.scala.collection.immutable.VectorBuilder[dotty.tools.dotc.semanticdb.Diagnostic] = new _root_.scala.collection.immutable.VectorBuilder[dotty.tools.dotc.semanticdb.Diagnostic]
+    val __synthetics: _root_.scala.collection.immutable.VectorBuilder[dotty.tools.dotc.semanticdb.Synthetic] = new _root_.scala.collection.immutable.VectorBuilder[dotty.tools.dotc.semanticdb.Synthetic]
+    var _done__ = false
+    while (!_done__) {
+      val _tag__ = _input__.readTag()
+      _tag__ match {
+        case 0 => _done__ = true
+        case 8 =>
+          __schema = dotty.tools.dotc.semanticdb.Schema.fromValue(_input__.readEnum())
+        case 18 =>
+          __uri = _input__.readStringRequireUtf8()
+        case 26 =>
+          __text = _input__.readStringRequireUtf8()
+        case 90 =>
+          __md5 = _input__.readStringRequireUtf8()
+        case 80 =>
+          __language = dotty.tools.dotc.semanticdb.Language.fromValue(_input__.readEnum())
+        case 42 =>
+          __symbols += LiteParser.readMessage[dotty.tools.dotc.semanticdb.SymbolInformation](_input__)
+        case 50 =>
+          __occurrences += LiteParser.readMessage[dotty.tools.dotc.semanticdb.SymbolOccurrence](_input__)
+        case 58 =>
+          __diagnostics += LiteParser.readMessage[dotty.tools.dotc.semanticdb.Diagnostic](_input__)
+        case 98 =>
+          __synthetics += LiteParser.readMessage[dotty.tools.dotc.semanticdb.Synthetic](_input__)
+        case tag => _input__.skipField(tag)
+      }
+    }
+    dotty.tools.dotc.semanticdb.TextDocument(
+        schema = __schema,
+        uri = __uri,
+        text = __text,
+        md5 = __md5,
+        language = __language,
+        symbols = __symbols.result(),
+        occurrences = __occurrences.result(),
+        diagnostics = __diagnostics.result(),
+        synthetics = __synthetics.result()
+    )
+  }
+  
+  
+  
+  
+  
+  
+  lazy val defaultInstance = dotty.tools.dotc.semanticdb.TextDocument(
+    schema = dotty.tools.dotc.semanticdb.Schema.LEGACY,
+    uri = "",
+    text = "",
+    md5 = "",
+    language = dotty.tools.dotc.semanticdb.Language.UNKNOWN_LANGUAGE,
+    symbols = _root_.scala.Seq.empty,
+    occurrences = _root_.scala.Seq.empty,
+    diagnostics = _root_.scala.Seq.empty,
+    synthetics = _root_.scala.Seq.empty
+  )
+  final val SCHEMA_FIELD_NUMBER = 1
+  final val URI_FIELD_NUMBER = 2
+  final val TEXT_FIELD_NUMBER = 3
+  final val MD5_FIELD_NUMBER = 11
+  final val LANGUAGE_FIELD_NUMBER = 10
+  final val SYMBOLS_FIELD_NUMBER = 5
+  final val OCCURRENCES_FIELD_NUMBER = 6
+  final val DIAGNOSTICS_FIELD_NUMBER = 7
+  final val SYNTHETICS_FIELD_NUMBER = 12
+  def of(
+    schema: dotty.tools.dotc.semanticdb.Schema,
+    uri: _root_.scala.Predef.String,
+    text: _root_.scala.Predef.String,
+    md5: _root_.scala.Predef.String,
+    language: dotty.tools.dotc.semanticdb.Language,
+    symbols: _root_.scala.Seq[dotty.tools.dotc.semanticdb.SymbolInformation],
+    occurrences: _root_.scala.Seq[dotty.tools.dotc.semanticdb.SymbolOccurrence],
+    diagnostics: _root_.scala.Seq[dotty.tools.dotc.semanticdb.Diagnostic],
+    synthetics: _root_.scala.Seq[dotty.tools.dotc.semanticdb.Synthetic]
+  ): _root_.dotty.tools.dotc.semanticdb.TextDocument = _root_.dotty.tools.dotc.semanticdb.TextDocument(
+    schema,
+    uri,
+    text,
+    md5,
+    language,
+    symbols,
+    occurrences,
+    diagnostics,
+    synthetics
+  )
+  // @@protoc_insertion_point(GeneratedMessageCompanion[dotty.tools.dotc.semanticdb.TextDocument])
+}
diff --git a/tests/pos-with-compiler-cc/dotc/semanticdb/generated/TextDocuments.scala b/tests/pos-with-compiler-cc/dotc/semanticdb/generated/TextDocuments.scala
new file mode 100644
index 000000000000..41b8e1b3f491
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/semanticdb/generated/TextDocuments.scala
@@ -0,0 +1,87 @@
+// Generated by https://github.com/tanishiking/semanticdb-for-scala3
+// Generated by the Scala Plugin for the Protocol Buffer Compiler.
+// Do not edit!
+//
+// Protofile syntax: PROTO3
+
+package dotty.tools.dotc.semanticdb
+import dotty.tools.dotc.semanticdb.internal._
+import scala.annotation.internal.sharable
+
+@SerialVersionUID(0L)
+final case class TextDocuments(
+    documents: _root_.scala.Seq[dotty.tools.dotc.semanticdb.TextDocument] = _root_.scala.Seq.empty
+    )  extends SemanticdbGeneratedMessage  derives CanEqual {
+    @transient @sharable
+    private[this] var __serializedSizeMemoized: _root_.scala.Int = 0
+    private[this] def __computeSerializedSize(): _root_.scala.Int = {
+      var __size = 0
+      documents.foreach { __item =>
+        val __value = __item
+        __size += 1 + SemanticdbOutputStream.computeUInt32SizeNoTag(__value.serializedSize) + __value.serializedSize
+      }
+      __size
+    }
+    override def serializedSize: _root_.scala.Int = {
+      var __size = __serializedSizeMemoized
+      if (__size == 0) {
+        __size = __computeSerializedSize() + 1
+        __serializedSizeMemoized = __size
+      }
+      __size - 1
+      
+    }
+    def writeTo(`_output__`: SemanticdbOutputStream): _root_.scala.Unit = {
+      documents.foreach { __v =>
+        val __m = __v
+        _output__.writeTag(1, 2)
+        _output__.writeUInt32NoTag(__m.serializedSize)
+        __m.writeTo(_output__)
+      };
+    }
+    def clearDocuments = copy(documents = _root_.scala.Seq.empty)
+    def addDocuments(__vs: dotty.tools.dotc.semanticdb.TextDocument *): TextDocuments = addAllDocuments(__vs)
+    def addAllDocuments(__vs: Iterable[dotty.tools.dotc.semanticdb.TextDocument]): TextDocuments = copy(documents = documents ++ __vs)
+    def withDocuments(__v: _root_.scala.Seq[dotty.tools.dotc.semanticdb.TextDocument]): TextDocuments = copy(documents = __v)
+    
+    
+    
+    
+    // @@protoc_insertion_point(GeneratedMessage[dotty.tools.dotc.semanticdb.TextDocuments])
+}
+
+object TextDocuments  extends SemanticdbGeneratedMessageCompanion[dotty.tools.dotc.semanticdb.TextDocuments] {
+  implicit def messageCompanion: SemanticdbGeneratedMessageCompanion[dotty.tools.dotc.semanticdb.TextDocuments] = this
+  def parseFrom(`_input__`: SemanticdbInputStream): dotty.tools.dotc.semanticdb.TextDocuments = {
+    val __documents: _root_.scala.collection.immutable.VectorBuilder[dotty.tools.dotc.semanticdb.TextDocument] = new _root_.scala.collection.immutable.VectorBuilder[dotty.tools.dotc.semanticdb.TextDocument]
+    var _done__ = false
+    while (!_done__) {
+      val _tag__ = _input__.readTag()
+      _tag__ match {
+        case 0 => _done__ = true
+        case 10 =>
+          __documents += LiteParser.readMessage[dotty.tools.dotc.semanticdb.TextDocument](_input__)
+        case tag => _input__.skipField(tag)
+      }
+    }
+    dotty.tools.dotc.semanticdb.TextDocuments(
+        documents = __documents.result()
+    )
+  }
+  
+  
+  
+  
+  
+  
+  lazy val defaultInstance = dotty.tools.dotc.semanticdb.TextDocuments(
+    documents = _root_.scala.Seq.empty
+  )
+  final val DOCUMENTS_FIELD_NUMBER = 1
+  def of(
+    documents: _root_.scala.Seq[dotty.tools.dotc.semanticdb.TextDocument]
+  ): _root_.dotty.tools.dotc.semanticdb.TextDocuments = _root_.dotty.tools.dotc.semanticdb.TextDocuments(
+    documents
+  )
+  // @@protoc_insertion_point(GeneratedMessageCompanion[dotty.tools.dotc.semanticdb.TextDocuments])
+}
diff --git a/tests/pos-with-compiler-cc/dotc/semanticdb/generated/Tree.scala b/tests/pos-with-compiler-cc/dotc/semanticdb/generated/Tree.scala
new file mode 100644
index 000000000000..ed84d9b2f2d0
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/semanticdb/generated/Tree.scala
@@ -0,0 +1,1088 @@
+// Generated by https://github.com/tanishiking/semanticdb-for-scala3
+// Generated by the Scala Plugin for the Protocol Buffer Compiler.
+// Do not edit!
+//
+// Protofile syntax: PROTO3
+
+package dotty.tools.dotc.semanticdb
+import dotty.tools.dotc.semanticdb.internal._
+import scala.annotation.internal.sharable
+
+sealed trait Tree  extends SemanticdbGeneratedSealedOneof  derives CanEqual {
+  type MessageType = dotty.tools.dotc.semanticdb.TreeMessage
+  final def isEmpty = this.isInstanceOf[dotty.tools.dotc.semanticdb.Tree.Empty.type]
+  final def isDefined = !isEmpty
+  final def asMessage: dotty.tools.dotc.semanticdb.TreeMessage = dotty.tools.dotc.semanticdb.Tree.TreeTypeMapper.toBase(this)
+  final def asNonEmpty: Option[dotty.tools.dotc.semanticdb.Tree.NonEmpty] = if (isEmpty) None else Some(this.asInstanceOf[dotty.tools.dotc.semanticdb.Tree.NonEmpty])
+}
+
+object Tree {
+  case object Empty extends dotty.tools.dotc.semanticdb.Tree
+  
+  sealed trait NonEmpty extends dotty.tools.dotc.semanticdb.Tree
+  def defaultInstance: dotty.tools.dotc.semanticdb.Tree = Empty
+  
+  implicit val TreeTypeMapper: SemanticdbTypeMapper[dotty.tools.dotc.semanticdb.TreeMessage, dotty.tools.dotc.semanticdb.Tree] = new SemanticdbTypeMapper[dotty.tools.dotc.semanticdb.TreeMessage, dotty.tools.dotc.semanticdb.Tree] {
+    override def toCustom(__base: dotty.tools.dotc.semanticdb.TreeMessage): dotty.tools.dotc.semanticdb.Tree = __base.sealedValue match {
+      case __v: dotty.tools.dotc.semanticdb.TreeMessage.SealedValue.ApplyTree => __v.value
+      case __v: dotty.tools.dotc.semanticdb.TreeMessage.SealedValue.FunctionTree => __v.value
+      case __v: dotty.tools.dotc.semanticdb.TreeMessage.SealedValue.IdTree => __v.value
+      case __v: dotty.tools.dotc.semanticdb.TreeMessage.SealedValue.LiteralTree => __v.value
+      case __v: dotty.tools.dotc.semanticdb.TreeMessage.SealedValue.MacroExpansionTree => __v.value
+      case __v: dotty.tools.dotc.semanticdb.TreeMessage.SealedValue.OriginalTree => __v.value
+      case __v: dotty.tools.dotc.semanticdb.TreeMessage.SealedValue.SelectTree => __v.value
+      case __v: dotty.tools.dotc.semanticdb.TreeMessage.SealedValue.TypeApplyTree => __v.value
+      case dotty.tools.dotc.semanticdb.TreeMessage.SealedValue.Empty => Empty
+    }
+    override def toBase(__custom: dotty.tools.dotc.semanticdb.Tree): dotty.tools.dotc.semanticdb.TreeMessage = dotty.tools.dotc.semanticdb.TreeMessage(__custom match {
+      case __v: dotty.tools.dotc.semanticdb.ApplyTree => dotty.tools.dotc.semanticdb.TreeMessage.SealedValue.ApplyTree(__v)
+      case __v: dotty.tools.dotc.semanticdb.FunctionTree => dotty.tools.dotc.semanticdb.TreeMessage.SealedValue.FunctionTree(__v)
+      case __v: dotty.tools.dotc.semanticdb.IdTree => dotty.tools.dotc.semanticdb.TreeMessage.SealedValue.IdTree(__v)
+      case __v: dotty.tools.dotc.semanticdb.LiteralTree => dotty.tools.dotc.semanticdb.TreeMessage.SealedValue.LiteralTree(__v)
+      case __v: dotty.tools.dotc.semanticdb.MacroExpansionTree => dotty.tools.dotc.semanticdb.TreeMessage.SealedValue.MacroExpansionTree(__v)
+      case __v: dotty.tools.dotc.semanticdb.OriginalTree => dotty.tools.dotc.semanticdb.TreeMessage.SealedValue.OriginalTree(__v)
+      case __v: dotty.tools.dotc.semanticdb.SelectTree => dotty.tools.dotc.semanticdb.TreeMessage.SealedValue.SelectTree(__v)
+      case __v: dotty.tools.dotc.semanticdb.TypeApplyTree => dotty.tools.dotc.semanticdb.TreeMessage.SealedValue.TypeApplyTree(__v)
+      case Empty => dotty.tools.dotc.semanticdb.TreeMessage.SealedValue.Empty
+    })
+  }
+}
+@SerialVersionUID(0L)
+final case class TreeMessage(
+    sealedValue: dotty.tools.dotc.semanticdb.TreeMessage.SealedValue = dotty.tools.dotc.semanticdb.TreeMessage.SealedValue.Empty
+    )  extends SemanticdbGeneratedMessage  derives CanEqual {
+    @transient @sharable
+    private[this] var __serializedSizeMemoized: _root_.scala.Int = 0
+    private[this] def __computeSerializedSize(): _root_.scala.Int = {
+      var __size = 0
+      if (sealedValue.applyTree.isDefined) {
+        val __value = sealedValue.applyTree.get
+        __size += 1 + SemanticdbOutputStream.computeUInt32SizeNoTag(__value.serializedSize) + __value.serializedSize
+      };
+      if (sealedValue.functionTree.isDefined) {
+        val __value = sealedValue.functionTree.get
+        __size += 1 + SemanticdbOutputStream.computeUInt32SizeNoTag(__value.serializedSize) + __value.serializedSize
+      };
+      if (sealedValue.idTree.isDefined) {
+        val __value = sealedValue.idTree.get
+        __size += 1 + SemanticdbOutputStream.computeUInt32SizeNoTag(__value.serializedSize) + __value.serializedSize
+      };
+      if (sealedValue.literalTree.isDefined) {
+        val __value = sealedValue.literalTree.get
+        __size += 1 + SemanticdbOutputStream.computeUInt32SizeNoTag(__value.serializedSize) + __value.serializedSize
+      };
+      if (sealedValue.macroExpansionTree.isDefined) {
+        val __value = sealedValue.macroExpansionTree.get
+        __size += 1 + SemanticdbOutputStream.computeUInt32SizeNoTag(__value.serializedSize) + __value.serializedSize
+      };
+      if (sealedValue.originalTree.isDefined) {
+        val __value = sealedValue.originalTree.get
+        __size += 1 + SemanticdbOutputStream.computeUInt32SizeNoTag(__value.serializedSize) + __value.serializedSize
+      };
+      if (sealedValue.selectTree.isDefined) {
+        val __value = sealedValue.selectTree.get
+        __size += 1 + SemanticdbOutputStream.computeUInt32SizeNoTag(__value.serializedSize) + __value.serializedSize
+      };
+      if (sealedValue.typeApplyTree.isDefined) {
+        val __value = sealedValue.typeApplyTree.get
+        __size += 1 + SemanticdbOutputStream.computeUInt32SizeNoTag(__value.serializedSize) + __value.serializedSize
+      };
+      __size
+    }
+    override def serializedSize: _root_.scala.Int = {
+      var __size = __serializedSizeMemoized
+      if (__size == 0) {
+        __size = __computeSerializedSize() + 1
+        __serializedSizeMemoized = __size
+      }
+      __size - 1
+      
+    }
+    def writeTo(`_output__`: SemanticdbOutputStream): _root_.scala.Unit = {
+      sealedValue.applyTree.foreach { __v =>
+        val __m = __v
+        _output__.writeTag(1, 2)
+        _output__.writeUInt32NoTag(__m.serializedSize)
+        __m.writeTo(_output__)
+      };
+      sealedValue.functionTree.foreach { __v =>
+        val __m = __v
+        _output__.writeTag(2, 2)
+        _output__.writeUInt32NoTag(__m.serializedSize)
+        __m.writeTo(_output__)
+      };
+      sealedValue.idTree.foreach { __v =>
+        val __m = __v
+        _output__.writeTag(3, 2)
+        _output__.writeUInt32NoTag(__m.serializedSize)
+        __m.writeTo(_output__)
+      };
+      sealedValue.literalTree.foreach { __v =>
+        val __m = __v
+        _output__.writeTag(4, 2)
+        _output__.writeUInt32NoTag(__m.serializedSize)
+        __m.writeTo(_output__)
+      };
+      sealedValue.macroExpansionTree.foreach { __v =>
+        val __m = __v
+        _output__.writeTag(5, 2)
+        _output__.writeUInt32NoTag(__m.serializedSize)
+        __m.writeTo(_output__)
+      };
+      sealedValue.originalTree.foreach { __v =>
+        val __m = __v
+        _output__.writeTag(6, 2)
+        _output__.writeUInt32NoTag(__m.serializedSize)
+        __m.writeTo(_output__)
+      };
+      sealedValue.selectTree.foreach { __v =>
+        val __m = __v
+        _output__.writeTag(7, 2)
+        _output__.writeUInt32NoTag(__m.serializedSize)
+        __m.writeTo(_output__)
+      };
+      sealedValue.typeApplyTree.foreach { __v =>
+        val __m = __v
+        _output__.writeTag(8, 2)
+        _output__.writeUInt32NoTag(__m.serializedSize)
+        __m.writeTo(_output__)
+      };
+    }
+    def getApplyTree: dotty.tools.dotc.semanticdb.ApplyTree = sealedValue.applyTree.getOrElse(dotty.tools.dotc.semanticdb.ApplyTree.defaultInstance)
+    def withApplyTree(__v: dotty.tools.dotc.semanticdb.ApplyTree): TreeMessage = copy(sealedValue = dotty.tools.dotc.semanticdb.TreeMessage.SealedValue.ApplyTree(__v))
+    def getFunctionTree: dotty.tools.dotc.semanticdb.FunctionTree = sealedValue.functionTree.getOrElse(dotty.tools.dotc.semanticdb.FunctionTree.defaultInstance)
+    def withFunctionTree(__v: dotty.tools.dotc.semanticdb.FunctionTree): TreeMessage = copy(sealedValue = dotty.tools.dotc.semanticdb.TreeMessage.SealedValue.FunctionTree(__v))
+    def getIdTree: dotty.tools.dotc.semanticdb.IdTree = sealedValue.idTree.getOrElse(dotty.tools.dotc.semanticdb.IdTree.defaultInstance)
+    def withIdTree(__v: dotty.tools.dotc.semanticdb.IdTree): TreeMessage = copy(sealedValue = dotty.tools.dotc.semanticdb.TreeMessage.SealedValue.IdTree(__v))
+    def getLiteralTree: dotty.tools.dotc.semanticdb.LiteralTree = sealedValue.literalTree.getOrElse(dotty.tools.dotc.semanticdb.LiteralTree.defaultInstance)
+    def withLiteralTree(__v: dotty.tools.dotc.semanticdb.LiteralTree): TreeMessage = copy(sealedValue = dotty.tools.dotc.semanticdb.TreeMessage.SealedValue.LiteralTree(__v))
+    def getMacroExpansionTree: dotty.tools.dotc.semanticdb.MacroExpansionTree = sealedValue.macroExpansionTree.getOrElse(dotty.tools.dotc.semanticdb.MacroExpansionTree.defaultInstance)
+    def withMacroExpansionTree(__v: dotty.tools.dotc.semanticdb.MacroExpansionTree): TreeMessage = copy(sealedValue = dotty.tools.dotc.semanticdb.TreeMessage.SealedValue.MacroExpansionTree(__v))
+    def getOriginalTree: dotty.tools.dotc.semanticdb.OriginalTree = sealedValue.originalTree.getOrElse(dotty.tools.dotc.semanticdb.OriginalTree.defaultInstance)
+    def withOriginalTree(__v: dotty.tools.dotc.semanticdb.OriginalTree): TreeMessage = copy(sealedValue = dotty.tools.dotc.semanticdb.TreeMessage.SealedValue.OriginalTree(__v))
+    def getSelectTree: dotty.tools.dotc.semanticdb.SelectTree = sealedValue.selectTree.getOrElse(dotty.tools.dotc.semanticdb.SelectTree.defaultInstance)
+    def withSelectTree(__v: dotty.tools.dotc.semanticdb.SelectTree): TreeMessage = copy(sealedValue = dotty.tools.dotc.semanticdb.TreeMessage.SealedValue.SelectTree(__v))
+    def getTypeApplyTree: dotty.tools.dotc.semanticdb.TypeApplyTree = sealedValue.typeApplyTree.getOrElse(dotty.tools.dotc.semanticdb.TypeApplyTree.defaultInstance)
+    def withTypeApplyTree(__v: dotty.tools.dotc.semanticdb.TypeApplyTree): TreeMessage = copy(sealedValue = dotty.tools.dotc.semanticdb.TreeMessage.SealedValue.TypeApplyTree(__v))
+    def clearSealedValue: TreeMessage = copy(sealedValue = dotty.tools.dotc.semanticdb.TreeMessage.SealedValue.Empty)
+    def withSealedValue(__v: dotty.tools.dotc.semanticdb.TreeMessage.SealedValue): TreeMessage = copy(sealedValue = __v)
+    
+    
+    
+    
+    def toTree: dotty.tools.dotc.semanticdb.Tree = dotty.tools.dotc.semanticdb.Tree.TreeTypeMapper.toCustom(this)
+    // @@protoc_insertion_point(GeneratedMessage[dotty.tools.dotc.semanticdb.Tree])
+}
+
+object TreeMessage  extends SemanticdbGeneratedMessageCompanion[dotty.tools.dotc.semanticdb.TreeMessage] {
+  implicit def messageCompanion: SemanticdbGeneratedMessageCompanion[dotty.tools.dotc.semanticdb.TreeMessage] = this
+  def parseFrom(`_input__`: SemanticdbInputStream): dotty.tools.dotc.semanticdb.TreeMessage = {
+    var __sealedValue: dotty.tools.dotc.semanticdb.TreeMessage.SealedValue = dotty.tools.dotc.semanticdb.TreeMessage.SealedValue.Empty
+    var _done__ = false
+    while (!_done__) {
+      val _tag__ = _input__.readTag()
+      _tag__ match {
+        case 0 => _done__ = true
+        case 10 =>
+          __sealedValue = dotty.tools.dotc.semanticdb.TreeMessage.SealedValue.ApplyTree(__sealedValue.applyTree.fold(LiteParser.readMessage[dotty.tools.dotc.semanticdb.ApplyTree](_input__))(LiteParser.readMessage(_input__, _)))
+        case 18 =>
+          __sealedValue = dotty.tools.dotc.semanticdb.TreeMessage.SealedValue.FunctionTree(__sealedValue.functionTree.fold(LiteParser.readMessage[dotty.tools.dotc.semanticdb.FunctionTree](_input__))(LiteParser.readMessage(_input__, _)))
+        case 26 =>
+          __sealedValue = dotty.tools.dotc.semanticdb.TreeMessage.SealedValue.IdTree(__sealedValue.idTree.fold(LiteParser.readMessage[dotty.tools.dotc.semanticdb.IdTree](_input__))(LiteParser.readMessage(_input__, _)))
+        case 34 =>
+          __sealedValue = dotty.tools.dotc.semanticdb.TreeMessage.SealedValue.LiteralTree(__sealedValue.literalTree.fold(LiteParser.readMessage[dotty.tools.dotc.semanticdb.LiteralTree](_input__))(LiteParser.readMessage(_input__, _)))
+        case 42 =>
+          __sealedValue = dotty.tools.dotc.semanticdb.TreeMessage.SealedValue.MacroExpansionTree(__sealedValue.macroExpansionTree.fold(LiteParser.readMessage[dotty.tools.dotc.semanticdb.MacroExpansionTree](_input__))(LiteParser.readMessage(_input__, _)))
+        case 50 =>
+          __sealedValue = dotty.tools.dotc.semanticdb.TreeMessage.SealedValue.OriginalTree(__sealedValue.originalTree.fold(LiteParser.readMessage[dotty.tools.dotc.semanticdb.OriginalTree](_input__))(LiteParser.readMessage(_input__, _)))
+        case 58 =>
+          __sealedValue = dotty.tools.dotc.semanticdb.TreeMessage.SealedValue.SelectTree(__sealedValue.selectTree.fold(LiteParser.readMessage[dotty.tools.dotc.semanticdb.SelectTree](_input__))(LiteParser.readMessage(_input__, _)))
+        case 66 =>
+          __sealedValue = dotty.tools.dotc.semanticdb.TreeMessage.SealedValue.TypeApplyTree(__sealedValue.typeApplyTree.fold(LiteParser.readMessage[dotty.tools.dotc.semanticdb.TypeApplyTree](_input__))(LiteParser.readMessage(_input__, _)))
+        case tag => _input__.skipField(tag)
+      }
+    }
+    dotty.tools.dotc.semanticdb.TreeMessage(
+        sealedValue = __sealedValue
+    )
+  }
+  
+  
+  
+  
+  
+  
+  lazy val defaultInstance = dotty.tools.dotc.semanticdb.TreeMessage(
+    sealedValue = dotty.tools.dotc.semanticdb.TreeMessage.SealedValue.Empty
+  )
+  sealed trait SealedValue  extends SemanticdbGeneratedOneof  derives CanEqual {
+    def isEmpty: _root_.scala.Boolean = false
+    def isDefined: _root_.scala.Boolean = true
+    def isApplyTree: _root_.scala.Boolean = false
+    def isFunctionTree: _root_.scala.Boolean = false
+    def isIdTree: _root_.scala.Boolean = false
+    def isLiteralTree: _root_.scala.Boolean = false
+    def isMacroExpansionTree: _root_.scala.Boolean = false
+    def isOriginalTree: _root_.scala.Boolean = false
+    def isSelectTree: _root_.scala.Boolean = false
+    def isTypeApplyTree: _root_.scala.Boolean = false
+    def applyTree: _root_.scala.Option[dotty.tools.dotc.semanticdb.ApplyTree] = _root_.scala.None
+    def functionTree: _root_.scala.Option[dotty.tools.dotc.semanticdb.FunctionTree] = _root_.scala.None
+    def idTree: _root_.scala.Option[dotty.tools.dotc.semanticdb.IdTree] = _root_.scala.None
+    def literalTree: _root_.scala.Option[dotty.tools.dotc.semanticdb.LiteralTree] = _root_.scala.None
+    def macroExpansionTree: _root_.scala.Option[dotty.tools.dotc.semanticdb.MacroExpansionTree] = _root_.scala.None
+    def originalTree: _root_.scala.Option[dotty.tools.dotc.semanticdb.OriginalTree] = _root_.scala.None
+    def selectTree: _root_.scala.Option[dotty.tools.dotc.semanticdb.SelectTree] = _root_.scala.None
+    def typeApplyTree: _root_.scala.Option[dotty.tools.dotc.semanticdb.TypeApplyTree] = _root_.scala.None
+  }
+  object SealedValue {
+    @SerialVersionUID(0L)
+    case object Empty extends dotty.tools.dotc.semanticdb.TreeMessage.SealedValue {
+      type ValueType = _root_.scala.Nothing
+      override def isEmpty: _root_.scala.Boolean = true
+      override def isDefined: _root_.scala.Boolean = false
+      override def number: _root_.scala.Int = 0
+      override def value: _root_.scala.Nothing = throw new java.util.NoSuchElementException("Empty.value")
+    }
+  
+    @SerialVersionUID(0L)
+    final case class ApplyTree(value: dotty.tools.dotc.semanticdb.ApplyTree) extends dotty.tools.dotc.semanticdb.TreeMessage.SealedValue  derives CanEqual {
+      type ValueType = dotty.tools.dotc.semanticdb.ApplyTree
+      override def isApplyTree: _root_.scala.Boolean = true
+      override def applyTree: _root_.scala.Option[dotty.tools.dotc.semanticdb.ApplyTree] = Some(value)
+      override def number: _root_.scala.Int = 1
+    }
+    @SerialVersionUID(0L)
+    final case class FunctionTree(value: dotty.tools.dotc.semanticdb.FunctionTree) extends dotty.tools.dotc.semanticdb.TreeMessage.SealedValue  derives CanEqual {
+      type ValueType = dotty.tools.dotc.semanticdb.FunctionTree
+      override def isFunctionTree: _root_.scala.Boolean = true
+      override def functionTree: _root_.scala.Option[dotty.tools.dotc.semanticdb.FunctionTree] = Some(value)
+      override def number: _root_.scala.Int = 2
+    }
+    @SerialVersionUID(0L)
+    final case class IdTree(value: dotty.tools.dotc.semanticdb.IdTree) extends dotty.tools.dotc.semanticdb.TreeMessage.SealedValue  derives CanEqual {
+      type ValueType = dotty.tools.dotc.semanticdb.IdTree
+      override def isIdTree: _root_.scala.Boolean = true
+      override def idTree: _root_.scala.Option[dotty.tools.dotc.semanticdb.IdTree] = Some(value)
+      override def number: _root_.scala.Int = 3
+    }
+    @SerialVersionUID(0L)
+    final case class LiteralTree(value: dotty.tools.dotc.semanticdb.LiteralTree) extends dotty.tools.dotc.semanticdb.TreeMessage.SealedValue  derives CanEqual {
+      type ValueType = dotty.tools.dotc.semanticdb.LiteralTree
+      override def isLiteralTree: _root_.scala.Boolean = true
+      override def literalTree: _root_.scala.Option[dotty.tools.dotc.semanticdb.LiteralTree] = Some(value)
+      override def number: _root_.scala.Int = 4
+    }
+    @SerialVersionUID(0L)
+    final case class MacroExpansionTree(value: dotty.tools.dotc.semanticdb.MacroExpansionTree) extends dotty.tools.dotc.semanticdb.TreeMessage.SealedValue  derives CanEqual {
+      type ValueType = dotty.tools.dotc.semanticdb.MacroExpansionTree
+      override def isMacroExpansionTree: _root_.scala.Boolean = true
+      override def macroExpansionTree: _root_.scala.Option[dotty.tools.dotc.semanticdb.MacroExpansionTree] = Some(value)
+      override def number: _root_.scala.Int = 5
+    }
+    @SerialVersionUID(0L)
+    final case class OriginalTree(value: dotty.tools.dotc.semanticdb.OriginalTree) extends dotty.tools.dotc.semanticdb.TreeMessage.SealedValue  derives CanEqual {
+      type ValueType = dotty.tools.dotc.semanticdb.OriginalTree
+      override def isOriginalTree: _root_.scala.Boolean = true
+      override def originalTree: _root_.scala.Option[dotty.tools.dotc.semanticdb.OriginalTree] = Some(value)
+      override def number: _root_.scala.Int = 6
+    }
+    @SerialVersionUID(0L)
+    final case class SelectTree(value: dotty.tools.dotc.semanticdb.SelectTree) extends dotty.tools.dotc.semanticdb.TreeMessage.SealedValue  derives CanEqual {
+      type ValueType = dotty.tools.dotc.semanticdb.SelectTree
+      override def isSelectTree: _root_.scala.Boolean = true
+      override def selectTree: _root_.scala.Option[dotty.tools.dotc.semanticdb.SelectTree] = Some(value)
+      override def number: _root_.scala.Int = 7
+    }
+    @SerialVersionUID(0L)
+    final case class TypeApplyTree(value: dotty.tools.dotc.semanticdb.TypeApplyTree) extends dotty.tools.dotc.semanticdb.TreeMessage.SealedValue  derives CanEqual {
+      type ValueType = dotty.tools.dotc.semanticdb.TypeApplyTree
+      override def isTypeApplyTree: _root_.scala.Boolean = true
+      override def typeApplyTree: _root_.scala.Option[dotty.tools.dotc.semanticdb.TypeApplyTree] = Some(value)
+      override def number: _root_.scala.Int = 8
+    }
+  }
+  final val APPLY_TREE_FIELD_NUMBER = 1
+  final val FUNCTION_TREE_FIELD_NUMBER = 2
+  final val ID_TREE_FIELD_NUMBER = 3
+  final val LITERAL_TREE_FIELD_NUMBER = 4
+  final val MACRO_EXPANSION_TREE_FIELD_NUMBER = 5
+  final val ORIGINAL_TREE_FIELD_NUMBER = 6
+  final val SELECT_TREE_FIELD_NUMBER = 7
+  final val TYPE_APPLY_TREE_FIELD_NUMBER = 8
+  def of(
+    sealedValue: dotty.tools.dotc.semanticdb.TreeMessage.SealedValue
+  ): _root_.dotty.tools.dotc.semanticdb.TreeMessage = _root_.dotty.tools.dotc.semanticdb.TreeMessage(
+    sealedValue
+  )
+  // @@protoc_insertion_point(GeneratedMessageCompanion[dotty.tools.dotc.semanticdb.Tree])
+}
+
+@SerialVersionUID(0L)
+final case class ApplyTree(
+    function: dotty.tools.dotc.semanticdb.Tree = dotty.tools.dotc.semanticdb.ApplyTree._typemapper_function.toCustom(dotty.tools.dotc.semanticdb.TreeMessage.defaultInstance),
+    arguments: _root_.scala.Seq[dotty.tools.dotc.semanticdb.Tree] = _root_.scala.Seq.empty
+    )  extends dotty.tools.dotc.semanticdb.Tree.NonEmpty with SemanticdbGeneratedMessage  derives CanEqual {
+    @transient @sharable
+    private[this] var __serializedSizeMemoized: _root_.scala.Int = 0
+    private[this] def __computeSerializedSize(): _root_.scala.Int = {
+      var __size = 0
+      
+      {
+        val __value = dotty.tools.dotc.semanticdb.ApplyTree._typemapper_function.toBase(function)
+        if (__value.serializedSize != 0) {
+          __size += 1 + SemanticdbOutputStream.computeUInt32SizeNoTag(__value.serializedSize) + __value.serializedSize
+        }
+      };
+      arguments.foreach { __item =>
+        val __value = dotty.tools.dotc.semanticdb.ApplyTree._typemapper_arguments.toBase(__item)
+        __size += 1 + SemanticdbOutputStream.computeUInt32SizeNoTag(__value.serializedSize) + __value.serializedSize
+      }
+      __size
+    }
+    override def serializedSize: _root_.scala.Int = {
+      var __size = __serializedSizeMemoized
+      if (__size == 0) {
+        __size = __computeSerializedSize() + 1
+        __serializedSizeMemoized = __size
+      }
+      __size - 1
+      
+    }
+    def writeTo(`_output__`: SemanticdbOutputStream): _root_.scala.Unit = {
+      {
+        val __v = dotty.tools.dotc.semanticdb.ApplyTree._typemapper_function.toBase(function)
+        if (__v.serializedSize != 0) {
+          _output__.writeTag(1, 2)
+          _output__.writeUInt32NoTag(__v.serializedSize)
+          __v.writeTo(_output__)
+        }
+      };
+      arguments.foreach { __v =>
+        val __m = dotty.tools.dotc.semanticdb.ApplyTree._typemapper_arguments.toBase(__v)
+        _output__.writeTag(2, 2)
+        _output__.writeUInt32NoTag(__m.serializedSize)
+        __m.writeTo(_output__)
+      };
+    }
+    def withFunction(__v: dotty.tools.dotc.semanticdb.Tree): ApplyTree = copy(function = __v)
+    def clearArguments = copy(arguments = _root_.scala.Seq.empty)
+    def addArguments(__vs: dotty.tools.dotc.semanticdb.Tree *): ApplyTree = addAllArguments(__vs)
+    def addAllArguments(__vs: Iterable[dotty.tools.dotc.semanticdb.Tree]): ApplyTree = copy(arguments = arguments ++ __vs)
+    def withArguments(__v: _root_.scala.Seq[dotty.tools.dotc.semanticdb.Tree]): ApplyTree = copy(arguments = __v)
+    
+    
+    
+    
+    // @@protoc_insertion_point(GeneratedMessage[dotty.tools.dotc.semanticdb.ApplyTree])
+}
+
+object ApplyTree  extends SemanticdbGeneratedMessageCompanion[dotty.tools.dotc.semanticdb.ApplyTree] {
+  implicit def messageCompanion: SemanticdbGeneratedMessageCompanion[dotty.tools.dotc.semanticdb.ApplyTree] = this
+  def parseFrom(`_input__`: SemanticdbInputStream): dotty.tools.dotc.semanticdb.ApplyTree = {
+    var __function: _root_.scala.Option[dotty.tools.dotc.semanticdb.TreeMessage] = _root_.scala.None
+    val __arguments: _root_.scala.collection.immutable.VectorBuilder[dotty.tools.dotc.semanticdb.Tree] = new _root_.scala.collection.immutable.VectorBuilder[dotty.tools.dotc.semanticdb.Tree]
+    var _done__ = false
+    while (!_done__) {
+      val _tag__ = _input__.readTag()
+      _tag__ match {
+        case 0 => _done__ = true
+        case 10 =>
+          __function = _root_.scala.Some(__function.fold(LiteParser.readMessage[dotty.tools.dotc.semanticdb.TreeMessage](_input__))(LiteParser.readMessage(_input__, _)))
+        case 18 =>
+          __arguments += dotty.tools.dotc.semanticdb.ApplyTree._typemapper_arguments.toCustom(LiteParser.readMessage[dotty.tools.dotc.semanticdb.TreeMessage](_input__))
+        case tag => _input__.skipField(tag)
+      }
+    }
+    dotty.tools.dotc.semanticdb.ApplyTree(
+        function = dotty.tools.dotc.semanticdb.ApplyTree._typemapper_function.toCustom(__function.getOrElse(dotty.tools.dotc.semanticdb.TreeMessage.defaultInstance)),
+        arguments = __arguments.result()
+    )
+  }
+  
+  
+  
+  
+  
+  
+  lazy val defaultInstance = dotty.tools.dotc.semanticdb.ApplyTree(
+    function = dotty.tools.dotc.semanticdb.ApplyTree._typemapper_function.toCustom(dotty.tools.dotc.semanticdb.TreeMessage.defaultInstance),
+    arguments = _root_.scala.Seq.empty
+  )
+  final val FUNCTION_FIELD_NUMBER = 1
+  final val ARGUMENTS_FIELD_NUMBER = 2
+  @transient @sharable
+  private[semanticdb] val _typemapper_function: SemanticdbTypeMapper[dotty.tools.dotc.semanticdb.TreeMessage, dotty.tools.dotc.semanticdb.Tree] = implicitly[SemanticdbTypeMapper[dotty.tools.dotc.semanticdb.TreeMessage, dotty.tools.dotc.semanticdb.Tree]]
+  @transient @sharable
+  private[semanticdb] val _typemapper_arguments: SemanticdbTypeMapper[dotty.tools.dotc.semanticdb.TreeMessage, dotty.tools.dotc.semanticdb.Tree] = implicitly[SemanticdbTypeMapper[dotty.tools.dotc.semanticdb.TreeMessage, dotty.tools.dotc.semanticdb.Tree]]
+  def of(
+    function: dotty.tools.dotc.semanticdb.Tree,
+    arguments: _root_.scala.Seq[dotty.tools.dotc.semanticdb.Tree]
+  ): _root_.dotty.tools.dotc.semanticdb.ApplyTree = _root_.dotty.tools.dotc.semanticdb.ApplyTree(
+    function,
+    arguments
+  )
+  // @@protoc_insertion_point(GeneratedMessageCompanion[dotty.tools.dotc.semanticdb.ApplyTree])
+}
+
+@SerialVersionUID(0L)
+final case class FunctionTree(
+    parameters: _root_.scala.Seq[dotty.tools.dotc.semanticdb.IdTree] = _root_.scala.Seq.empty,
+    body: dotty.tools.dotc.semanticdb.Tree = dotty.tools.dotc.semanticdb.FunctionTree._typemapper_body.toCustom(dotty.tools.dotc.semanticdb.TreeMessage.defaultInstance)
+    )  extends dotty.tools.dotc.semanticdb.Tree.NonEmpty with SemanticdbGeneratedMessage  derives CanEqual {
+    @transient @sharable
+    private[this] var __serializedSizeMemoized: _root_.scala.Int = 0
+    private[this] def __computeSerializedSize(): _root_.scala.Int = {
+      var __size = 0
+      parameters.foreach { __item =>
+        val __value = __item
+        __size += 1 + SemanticdbOutputStream.computeUInt32SizeNoTag(__value.serializedSize) + __value.serializedSize
+      }
+      
+      {
+        val __value = dotty.tools.dotc.semanticdb.FunctionTree._typemapper_body.toBase(body)
+        if (__value.serializedSize != 0) {
+          __size += 1 + SemanticdbOutputStream.computeUInt32SizeNoTag(__value.serializedSize) + __value.serializedSize
+        }
+      };
+      __size
+    }
+    override def serializedSize: _root_.scala.Int = {
+      var __size = __serializedSizeMemoized
+      if (__size == 0) {
+        __size = __computeSerializedSize() + 1
+        __serializedSizeMemoized = __size
+      }
+      __size - 1
+      
+    }
+    def writeTo(`_output__`: SemanticdbOutputStream): _root_.scala.Unit = {
+      parameters.foreach { __v =>
+        val __m = __v
+        _output__.writeTag(1, 2)
+        _output__.writeUInt32NoTag(__m.serializedSize)
+        __m.writeTo(_output__)
+      };
+      {
+        val __v = dotty.tools.dotc.semanticdb.FunctionTree._typemapper_body.toBase(body)
+        if (__v.serializedSize != 0) {
+          _output__.writeTag(2, 2)
+          _output__.writeUInt32NoTag(__v.serializedSize)
+          __v.writeTo(_output__)
+        }
+      };
+    }
+    def clearParameters = copy(parameters = _root_.scala.Seq.empty)
+    def addParameters(__vs: dotty.tools.dotc.semanticdb.IdTree *): FunctionTree = addAllParameters(__vs)
+    def addAllParameters(__vs: Iterable[dotty.tools.dotc.semanticdb.IdTree]): FunctionTree = copy(parameters = parameters ++ __vs)
+    def withParameters(__v: _root_.scala.Seq[dotty.tools.dotc.semanticdb.IdTree]): FunctionTree = copy(parameters = __v)
+    def withBody(__v: dotty.tools.dotc.semanticdb.Tree): FunctionTree = copy(body = __v)
+    
+    
+    
+    
+    // @@protoc_insertion_point(GeneratedMessage[dotty.tools.dotc.semanticdb.FunctionTree])
+}
+
+object FunctionTree  extends SemanticdbGeneratedMessageCompanion[dotty.tools.dotc.semanticdb.FunctionTree] {
+  implicit def messageCompanion: SemanticdbGeneratedMessageCompanion[dotty.tools.dotc.semanticdb.FunctionTree] = this
+  def parseFrom(`_input__`: SemanticdbInputStream): dotty.tools.dotc.semanticdb.FunctionTree = {
+    val __parameters: _root_.scala.collection.immutable.VectorBuilder[dotty.tools.dotc.semanticdb.IdTree] = new _root_.scala.collection.immutable.VectorBuilder[dotty.tools.dotc.semanticdb.IdTree]
+    var __body: _root_.scala.Option[dotty.tools.dotc.semanticdb.TreeMessage] = _root_.scala.None
+    var _done__ = false
+    while (!_done__) {
+      val _tag__ = _input__.readTag()
+      _tag__ match {
+        case 0 => _done__ = true
+        case 10 =>
+          __parameters += LiteParser.readMessage[dotty.tools.dotc.semanticdb.IdTree](_input__)
+        case 18 =>
+          __body = _root_.scala.Some(__body.fold(LiteParser.readMessage[dotty.tools.dotc.semanticdb.TreeMessage](_input__))(LiteParser.readMessage(_input__, _)))
+        case tag => _input__.skipField(tag)
+      }
+    }
+    dotty.tools.dotc.semanticdb.FunctionTree(
+        parameters = __parameters.result(),
+        body = dotty.tools.dotc.semanticdb.FunctionTree._typemapper_body.toCustom(__body.getOrElse(dotty.tools.dotc.semanticdb.TreeMessage.defaultInstance))
+    )
+  }
+  
+  
+  
+  
+  
+  
+  lazy val defaultInstance = dotty.tools.dotc.semanticdb.FunctionTree(
+    parameters = _root_.scala.Seq.empty,
+    body = dotty.tools.dotc.semanticdb.FunctionTree._typemapper_body.toCustom(dotty.tools.dotc.semanticdb.TreeMessage.defaultInstance)
+  )
+  final val PARAMETERS_FIELD_NUMBER = 1
+  final val BODY_FIELD_NUMBER = 2
+  @transient @sharable
+  private[semanticdb] val _typemapper_body: SemanticdbTypeMapper[dotty.tools.dotc.semanticdb.TreeMessage, dotty.tools.dotc.semanticdb.Tree] = implicitly[SemanticdbTypeMapper[dotty.tools.dotc.semanticdb.TreeMessage, dotty.tools.dotc.semanticdb.Tree]]
+  def of(
+    parameters: _root_.scala.Seq[dotty.tools.dotc.semanticdb.IdTree],
+    body: dotty.tools.dotc.semanticdb.Tree
+  ): _root_.dotty.tools.dotc.semanticdb.FunctionTree = _root_.dotty.tools.dotc.semanticdb.FunctionTree(
+    parameters,
+    body
+  )
+  // @@protoc_insertion_point(GeneratedMessageCompanion[dotty.tools.dotc.semanticdb.FunctionTree])
+}
+
+@SerialVersionUID(0L)
+final case class IdTree(
+    symbol: _root_.scala.Predef.String = ""
+    )  extends dotty.tools.dotc.semanticdb.Tree.NonEmpty with SemanticdbGeneratedMessage  derives CanEqual {
+    @transient @sharable
+    private[this] var __serializedSizeMemoized: _root_.scala.Int = 0
+    private[this] def __computeSerializedSize(): _root_.scala.Int = {
+      var __size = 0
+      
+      {
+        val __value = symbol
+        if (!__value.isEmpty) {
+          __size += SemanticdbOutputStream.computeStringSize(1, __value)
+        }
+      };
+      __size
+    }
+    override def serializedSize: _root_.scala.Int = {
+      var __size = __serializedSizeMemoized
+      if (__size == 0) {
+        __size = __computeSerializedSize() + 1
+        __serializedSizeMemoized = __size
+      }
+      __size - 1
+      
+    }
+    def writeTo(`_output__`: SemanticdbOutputStream): _root_.scala.Unit = {
+      {
+        val __v = symbol
+        if (!__v.isEmpty) {
+          _output__.writeString(1, __v)
+        }
+      };
+    }
+    def withSymbol(__v: _root_.scala.Predef.String): IdTree = copy(symbol = __v)
+    
+    
+    
+    
+    // @@protoc_insertion_point(GeneratedMessage[dotty.tools.dotc.semanticdb.IdTree])
+}
+
+object IdTree  extends SemanticdbGeneratedMessageCompanion[dotty.tools.dotc.semanticdb.IdTree] {
+  implicit def messageCompanion: SemanticdbGeneratedMessageCompanion[dotty.tools.dotc.semanticdb.IdTree] = this
+  def parseFrom(`_input__`: SemanticdbInputStream): dotty.tools.dotc.semanticdb.IdTree = {
+    var __symbol: _root_.scala.Predef.String = ""
+    var _done__ = false
+    while (!_done__) {
+      val _tag__ = _input__.readTag()
+      _tag__ match {
+        case 0 => _done__ = true
+        case 10 =>
+          __symbol = _input__.readStringRequireUtf8()
+        case tag => _input__.skipField(tag)
+      }
+    }
+    dotty.tools.dotc.semanticdb.IdTree(
+        symbol = __symbol
+    )
+  }
+  
+  
+  
+  
+  
+  
+  lazy val defaultInstance = dotty.tools.dotc.semanticdb.IdTree(
+    symbol = ""
+  )
+  final val SYMBOL_FIELD_NUMBER = 1
+  def of(
+    symbol: _root_.scala.Predef.String
+  ): _root_.dotty.tools.dotc.semanticdb.IdTree = _root_.dotty.tools.dotc.semanticdb.IdTree(
+    symbol
+  )
+  // @@protoc_insertion_point(GeneratedMessageCompanion[dotty.tools.dotc.semanticdb.IdTree])
+}
+
+@SerialVersionUID(0L)
+final case class LiteralTree(
+    constant: dotty.tools.dotc.semanticdb.Constant = dotty.tools.dotc.semanticdb.LiteralTree._typemapper_constant.toCustom(dotty.tools.dotc.semanticdb.ConstantMessage.defaultInstance)
+    )  extends dotty.tools.dotc.semanticdb.Tree.NonEmpty with SemanticdbGeneratedMessage  derives CanEqual {
+    @transient @sharable
+    private[this] var __serializedSizeMemoized: _root_.scala.Int = 0
+    private[this] def __computeSerializedSize(): _root_.scala.Int = {
+      var __size = 0
+      
+      {
+        val __value = dotty.tools.dotc.semanticdb.LiteralTree._typemapper_constant.toBase(constant)
+        if (__value.serializedSize != 0) {
+          __size += 1 + SemanticdbOutputStream.computeUInt32SizeNoTag(__value.serializedSize) + __value.serializedSize
+        }
+      };
+      __size
+    }
+    override def serializedSize: _root_.scala.Int = {
+      var __size = __serializedSizeMemoized
+      if (__size == 0) {
+        __size = __computeSerializedSize() + 1
+        __serializedSizeMemoized = __size
+      }
+      __size - 1
+      
+    }
+    def writeTo(`_output__`: SemanticdbOutputStream): _root_.scala.Unit = {
+      {
+        val __v = dotty.tools.dotc.semanticdb.LiteralTree._typemapper_constant.toBase(constant)
+        if (__v.serializedSize != 0) {
+          _output__.writeTag(1, 2)
+          _output__.writeUInt32NoTag(__v.serializedSize)
+          __v.writeTo(_output__)
+        }
+      };
+    }
+    def withConstant(__v: dotty.tools.dotc.semanticdb.Constant): LiteralTree = copy(constant = __v)
+    
+    
+    
+    
+    // @@protoc_insertion_point(GeneratedMessage[dotty.tools.dotc.semanticdb.LiteralTree])
+}
+
+object LiteralTree  extends SemanticdbGeneratedMessageCompanion[dotty.tools.dotc.semanticdb.LiteralTree] {
+  implicit def messageCompanion: SemanticdbGeneratedMessageCompanion[dotty.tools.dotc.semanticdb.LiteralTree] = this
+  def parseFrom(`_input__`: SemanticdbInputStream): dotty.tools.dotc.semanticdb.LiteralTree = {
+    var __constant: _root_.scala.Option[dotty.tools.dotc.semanticdb.ConstantMessage] = _root_.scala.None
+    var _done__ = false
+    while (!_done__) {
+      val _tag__ = _input__.readTag()
+      _tag__ match {
+        case 0 => _done__ = true
+        case 10 =>
+          __constant = _root_.scala.Some(__constant.fold(LiteParser.readMessage[dotty.tools.dotc.semanticdb.ConstantMessage](_input__))(LiteParser.readMessage(_input__, _)))
+        case tag => _input__.skipField(tag)
+      }
+    }
+    dotty.tools.dotc.semanticdb.LiteralTree(
+        constant = dotty.tools.dotc.semanticdb.LiteralTree._typemapper_constant.toCustom(__constant.getOrElse(dotty.tools.dotc.semanticdb.ConstantMessage.defaultInstance))
+    )
+  }
+  
+  
+  
+  
+  
+  
+  lazy val defaultInstance = dotty.tools.dotc.semanticdb.LiteralTree(
+    constant = dotty.tools.dotc.semanticdb.LiteralTree._typemapper_constant.toCustom(dotty.tools.dotc.semanticdb.ConstantMessage.defaultInstance)
+  )
+  final val CONSTANT_FIELD_NUMBER = 1
+  @transient @sharable
+  private[semanticdb] val _typemapper_constant: SemanticdbTypeMapper[dotty.tools.dotc.semanticdb.ConstantMessage, dotty.tools.dotc.semanticdb.Constant] = implicitly[SemanticdbTypeMapper[dotty.tools.dotc.semanticdb.ConstantMessage, dotty.tools.dotc.semanticdb.Constant]]
+  def of(
+    constant: dotty.tools.dotc.semanticdb.Constant
+  ): _root_.dotty.tools.dotc.semanticdb.LiteralTree = _root_.dotty.tools.dotc.semanticdb.LiteralTree(
+    constant
+  )
+  // @@protoc_insertion_point(GeneratedMessageCompanion[dotty.tools.dotc.semanticdb.LiteralTree])
+}
+
+@SerialVersionUID(0L)
+final case class MacroExpansionTree(
+    beforeExpansion: dotty.tools.dotc.semanticdb.Tree = dotty.tools.dotc.semanticdb.MacroExpansionTree._typemapper_beforeExpansion.toCustom(dotty.tools.dotc.semanticdb.TreeMessage.defaultInstance),
+    tpe: dotty.tools.dotc.semanticdb.Type = dotty.tools.dotc.semanticdb.MacroExpansionTree._typemapper_tpe.toCustom(dotty.tools.dotc.semanticdb.TypeMessage.defaultInstance)
+    )  extends dotty.tools.dotc.semanticdb.Tree.NonEmpty with SemanticdbGeneratedMessage  derives CanEqual {
+    @transient @sharable
+    private[this] var __serializedSizeMemoized: _root_.scala.Int = 0
+    private[this] def __computeSerializedSize(): _root_.scala.Int = {
+      var __size = 0
+      
+      {
+        val __value = dotty.tools.dotc.semanticdb.MacroExpansionTree._typemapper_beforeExpansion.toBase(beforeExpansion)
+        if (__value.serializedSize != 0) {
+          __size += 1 + SemanticdbOutputStream.computeUInt32SizeNoTag(__value.serializedSize) + __value.serializedSize
+        }
+      };
+      
+      {
+        val __value = dotty.tools.dotc.semanticdb.MacroExpansionTree._typemapper_tpe.toBase(tpe)
+        if (__value.serializedSize != 0) {
+          __size += 1 + SemanticdbOutputStream.computeUInt32SizeNoTag(__value.serializedSize) + __value.serializedSize
+        }
+      };
+      __size
+    }
+    override def serializedSize: _root_.scala.Int = {
+      var __size = __serializedSizeMemoized
+      if (__size == 0) {
+        __size = __computeSerializedSize() + 1
+        __serializedSizeMemoized = __size
+      }
+      __size - 1
+      
+    }
+    def writeTo(`_output__`: SemanticdbOutputStream): _root_.scala.Unit = {
+      {
+        val __v = dotty.tools.dotc.semanticdb.MacroExpansionTree._typemapper_beforeExpansion.toBase(beforeExpansion)
+        if (__v.serializedSize != 0) {
+          _output__.writeTag(1, 2)
+          _output__.writeUInt32NoTag(__v.serializedSize)
+          __v.writeTo(_output__)
+        }
+      };
+      {
+        val __v = dotty.tools.dotc.semanticdb.MacroExpansionTree._typemapper_tpe.toBase(tpe)
+        if (__v.serializedSize != 0) {
+          _output__.writeTag(2, 2)
+          _output__.writeUInt32NoTag(__v.serializedSize)
+          __v.writeTo(_output__)
+        }
+      };
+    }
+    def withBeforeExpansion(__v: dotty.tools.dotc.semanticdb.Tree): MacroExpansionTree = copy(beforeExpansion = __v)
+    def withTpe(__v: dotty.tools.dotc.semanticdb.Type): MacroExpansionTree = copy(tpe = __v)
+    
+    
+    
+    
+    // @@protoc_insertion_point(GeneratedMessage[dotty.tools.dotc.semanticdb.MacroExpansionTree])
+}
+
+object MacroExpansionTree  extends SemanticdbGeneratedMessageCompanion[dotty.tools.dotc.semanticdb.MacroExpansionTree] {
+  implicit def messageCompanion: SemanticdbGeneratedMessageCompanion[dotty.tools.dotc.semanticdb.MacroExpansionTree] = this
+  def parseFrom(`_input__`: SemanticdbInputStream): dotty.tools.dotc.semanticdb.MacroExpansionTree = {
+    var __beforeExpansion: _root_.scala.Option[dotty.tools.dotc.semanticdb.TreeMessage] = _root_.scala.None
+    var __tpe: _root_.scala.Option[dotty.tools.dotc.semanticdb.TypeMessage] = _root_.scala.None
+    var _done__ = false
+    while (!_done__) {
+      val _tag__ = _input__.readTag()
+      _tag__ match {
+        case 0 => _done__ = true
+        case 10 =>
+          __beforeExpansion = _root_.scala.Some(__beforeExpansion.fold(LiteParser.readMessage[dotty.tools.dotc.semanticdb.TreeMessage](_input__))(LiteParser.readMessage(_input__, _)))
+        case 18 =>
+          __tpe = _root_.scala.Some(__tpe.fold(LiteParser.readMessage[dotty.tools.dotc.semanticdb.TypeMessage](_input__))(LiteParser.readMessage(_input__, _)))
+        case tag => _input__.skipField(tag)
+      }
+    }
+    dotty.tools.dotc.semanticdb.MacroExpansionTree(
+        beforeExpansion = dotty.tools.dotc.semanticdb.MacroExpansionTree._typemapper_beforeExpansion.toCustom(__beforeExpansion.getOrElse(dotty.tools.dotc.semanticdb.TreeMessage.defaultInstance)),
+        tpe = dotty.tools.dotc.semanticdb.MacroExpansionTree._typemapper_tpe.toCustom(__tpe.getOrElse(dotty.tools.dotc.semanticdb.TypeMessage.defaultInstance))
+    )
+  }
+  
+  
+  
+  
+  
+  
+  lazy val defaultInstance = dotty.tools.dotc.semanticdb.MacroExpansionTree(
+    beforeExpansion = dotty.tools.dotc.semanticdb.MacroExpansionTree._typemapper_beforeExpansion.toCustom(dotty.tools.dotc.semanticdb.TreeMessage.defaultInstance),
+    tpe = dotty.tools.dotc.semanticdb.MacroExpansionTree._typemapper_tpe.toCustom(dotty.tools.dotc.semanticdb.TypeMessage.defaultInstance)
+  )
+  final val BEFORE_EXPANSION_FIELD_NUMBER = 1
+  final val TPE_FIELD_NUMBER = 2
+  @transient @sharable
+  private[semanticdb] val _typemapper_beforeExpansion: SemanticdbTypeMapper[dotty.tools.dotc.semanticdb.TreeMessage, dotty.tools.dotc.semanticdb.Tree] = implicitly[SemanticdbTypeMapper[dotty.tools.dotc.semanticdb.TreeMessage, dotty.tools.dotc.semanticdb.Tree]]
+  @transient @sharable
+  private[semanticdb] val _typemapper_tpe: SemanticdbTypeMapper[dotty.tools.dotc.semanticdb.TypeMessage, dotty.tools.dotc.semanticdb.Type] = implicitly[SemanticdbTypeMapper[dotty.tools.dotc.semanticdb.TypeMessage, dotty.tools.dotc.semanticdb.Type]]
+  def of(
+    beforeExpansion: dotty.tools.dotc.semanticdb.Tree,
+    tpe: dotty.tools.dotc.semanticdb.Type
+  ): _root_.dotty.tools.dotc.semanticdb.MacroExpansionTree = _root_.dotty.tools.dotc.semanticdb.MacroExpansionTree(
+    beforeExpansion,
+    tpe
+  )
+  // @@protoc_insertion_point(GeneratedMessageCompanion[dotty.tools.dotc.semanticdb.MacroExpansionTree])
+}
+
+@SerialVersionUID(0L)
+final case class OriginalTree(
+    range: _root_.scala.Option[dotty.tools.dotc.semanticdb.Range] = _root_.scala.None
+    )  extends dotty.tools.dotc.semanticdb.Tree.NonEmpty with SemanticdbGeneratedMessage  derives CanEqual {
+    @transient @sharable
+    private[this] var __serializedSizeMemoized: _root_.scala.Int = 0
+    private[this] def __computeSerializedSize(): _root_.scala.Int = {
+      var __size = 0
+      if (range.isDefined) {
+        val __value = range.get
+        __size += 1 + SemanticdbOutputStream.computeUInt32SizeNoTag(__value.serializedSize) + __value.serializedSize
+      };
+      __size
+    }
+    override def serializedSize: _root_.scala.Int = {
+      var __size = __serializedSizeMemoized
+      if (__size == 0) {
+        __size = __computeSerializedSize() + 1
+        __serializedSizeMemoized = __size
+      }
+      __size - 1
+      
+    }
+    def writeTo(`_output__`: SemanticdbOutputStream): _root_.scala.Unit = {
+      range.foreach { __v =>
+        val __m = __v
+        _output__.writeTag(1, 2)
+        _output__.writeUInt32NoTag(__m.serializedSize)
+        __m.writeTo(_output__)
+      };
+    }
+    def getRange: dotty.tools.dotc.semanticdb.Range = range.getOrElse(dotty.tools.dotc.semanticdb.Range.defaultInstance)
+    def clearRange: OriginalTree = copy(range = _root_.scala.None)
+    def withRange(__v: dotty.tools.dotc.semanticdb.Range): OriginalTree = copy(range = Option(__v))
+    
+    
+    
+    
+    // @@protoc_insertion_point(GeneratedMessage[dotty.tools.dotc.semanticdb.OriginalTree])
+}
+
+object OriginalTree  extends SemanticdbGeneratedMessageCompanion[dotty.tools.dotc.semanticdb.OriginalTree] {
+  implicit def messageCompanion: SemanticdbGeneratedMessageCompanion[dotty.tools.dotc.semanticdb.OriginalTree] = this
+  def parseFrom(`_input__`: SemanticdbInputStream): dotty.tools.dotc.semanticdb.OriginalTree = {
+    var __range: _root_.scala.Option[dotty.tools.dotc.semanticdb.Range] = _root_.scala.None
+    var _done__ = false
+    while (!_done__) {
+      val _tag__ = _input__.readTag()
+      _tag__ match {
+        case 0 => _done__ = true
+        case 10 =>
+          __range = Option(__range.fold(LiteParser.readMessage[dotty.tools.dotc.semanticdb.Range](_input__))(LiteParser.readMessage(_input__, _)))
+        case tag => _input__.skipField(tag)
+      }
+    }
+    dotty.tools.dotc.semanticdb.OriginalTree(
+        range = __range
+    )
+  }
+  
+  
+  
+  
+  
+  
+  lazy val defaultInstance = dotty.tools.dotc.semanticdb.OriginalTree(
+    range = _root_.scala.None
+  )
+  final val RANGE_FIELD_NUMBER = 1
+  def of(
+    range: _root_.scala.Option[dotty.tools.dotc.semanticdb.Range]
+  ): _root_.dotty.tools.dotc.semanticdb.OriginalTree = _root_.dotty.tools.dotc.semanticdb.OriginalTree(
+    range
+  )
+  // @@protoc_insertion_point(GeneratedMessageCompanion[dotty.tools.dotc.semanticdb.OriginalTree])
+}
+
+@SerialVersionUID(0L)
+final case class SelectTree(
+    qualifier: dotty.tools.dotc.semanticdb.Tree = dotty.tools.dotc.semanticdb.SelectTree._typemapper_qualifier.toCustom(dotty.tools.dotc.semanticdb.TreeMessage.defaultInstance),
+    id: _root_.scala.Option[dotty.tools.dotc.semanticdb.IdTree] = _root_.scala.None
+    )  extends dotty.tools.dotc.semanticdb.Tree.NonEmpty with SemanticdbGeneratedMessage  derives CanEqual {
+    @transient @sharable
+    private[this] var __serializedSizeMemoized: _root_.scala.Int = 0
+    private[this] def __computeSerializedSize(): _root_.scala.Int = {
+      var __size = 0
+      
+      {
+        val __value = dotty.tools.dotc.semanticdb.SelectTree._typemapper_qualifier.toBase(qualifier)
+        if (__value.serializedSize != 0) {
+          __size += 1 + SemanticdbOutputStream.computeUInt32SizeNoTag(__value.serializedSize) + __value.serializedSize
+        }
+      };
+      if (id.isDefined) {
+        val __value = id.get
+        __size += 1 + SemanticdbOutputStream.computeUInt32SizeNoTag(__value.serializedSize) + __value.serializedSize
+      };
+      __size
+    }
+    override def serializedSize: _root_.scala.Int = {
+      var __size = __serializedSizeMemoized
+      if (__size == 0) {
+        __size = __computeSerializedSize() + 1
+        __serializedSizeMemoized = __size
+      }
+      __size - 1
+      
+    }
+    def writeTo(`_output__`: SemanticdbOutputStream): _root_.scala.Unit = {
+      {
+        val __v = dotty.tools.dotc.semanticdb.SelectTree._typemapper_qualifier.toBase(qualifier)
+        if (__v.serializedSize != 0) {
+          _output__.writeTag(1, 2)
+          _output__.writeUInt32NoTag(__v.serializedSize)
+          __v.writeTo(_output__)
+        }
+      };
+      id.foreach { __v =>
+        val __m = __v
+        _output__.writeTag(2, 2)
+        _output__.writeUInt32NoTag(__m.serializedSize)
+        __m.writeTo(_output__)
+      };
+    }
+    def withQualifier(__v: dotty.tools.dotc.semanticdb.Tree): SelectTree = copy(qualifier = __v)
+    def getId: dotty.tools.dotc.semanticdb.IdTree = id.getOrElse(dotty.tools.dotc.semanticdb.IdTree.defaultInstance)
+    def clearId: SelectTree = copy(id = _root_.scala.None)
+    def withId(__v: dotty.tools.dotc.semanticdb.IdTree): SelectTree = copy(id = Option(__v))
+    
+    
+    
+    
+    // @@protoc_insertion_point(GeneratedMessage[dotty.tools.dotc.semanticdb.SelectTree])
+}
+
+object SelectTree  extends SemanticdbGeneratedMessageCompanion[dotty.tools.dotc.semanticdb.SelectTree] {
+  implicit def messageCompanion: SemanticdbGeneratedMessageCompanion[dotty.tools.dotc.semanticdb.SelectTree] = this
+  def parseFrom(`_input__`: SemanticdbInputStream): dotty.tools.dotc.semanticdb.SelectTree = {
+    var __qualifier: _root_.scala.Option[dotty.tools.dotc.semanticdb.TreeMessage] = _root_.scala.None
+    var __id: _root_.scala.Option[dotty.tools.dotc.semanticdb.IdTree] = _root_.scala.None
+    var _done__ = false
+    while (!_done__) {
+      val _tag__ = _input__.readTag()
+      _tag__ match {
+        case 0 => _done__ = true
+        case 10 =>
+          __qualifier = _root_.scala.Some(__qualifier.fold(LiteParser.readMessage[dotty.tools.dotc.semanticdb.TreeMessage](_input__))(LiteParser.readMessage(_input__, _)))
+        case 18 =>
+          __id = Option(__id.fold(LiteParser.readMessage[dotty.tools.dotc.semanticdb.IdTree](_input__))(LiteParser.readMessage(_input__, _)))
+        case tag => _input__.skipField(tag)
+      }
+    }
+    dotty.tools.dotc.semanticdb.SelectTree(
+        qualifier = dotty.tools.dotc.semanticdb.SelectTree._typemapper_qualifier.toCustom(__qualifier.getOrElse(dotty.tools.dotc.semanticdb.TreeMessage.defaultInstance)),
+        id = __id
+    )
+  }
+  
+  
+  
+  
+  
+  
+  lazy val defaultInstance = dotty.tools.dotc.semanticdb.SelectTree(
+    qualifier = dotty.tools.dotc.semanticdb.SelectTree._typemapper_qualifier.toCustom(dotty.tools.dotc.semanticdb.TreeMessage.defaultInstance),
+    id = _root_.scala.None
+  )
+  final val QUALIFIER_FIELD_NUMBER = 1
+  final val ID_FIELD_NUMBER = 2
+  @transient @sharable
+  private[semanticdb] val _typemapper_qualifier: SemanticdbTypeMapper[dotty.tools.dotc.semanticdb.TreeMessage, dotty.tools.dotc.semanticdb.Tree] = implicitly[SemanticdbTypeMapper[dotty.tools.dotc.semanticdb.TreeMessage, dotty.tools.dotc.semanticdb.Tree]]
+  def of(
+    qualifier: dotty.tools.dotc.semanticdb.Tree,
+    id: _root_.scala.Option[dotty.tools.dotc.semanticdb.IdTree]
+  ): _root_.dotty.tools.dotc.semanticdb.SelectTree = _root_.dotty.tools.dotc.semanticdb.SelectTree(
+    qualifier,
+    id
+  )
+  // @@protoc_insertion_point(GeneratedMessageCompanion[dotty.tools.dotc.semanticdb.SelectTree])
+}
+
+@SerialVersionUID(0L)
+final case class TypeApplyTree(
+    function: dotty.tools.dotc.semanticdb.Tree = dotty.tools.dotc.semanticdb.TypeApplyTree._typemapper_function.toCustom(dotty.tools.dotc.semanticdb.TreeMessage.defaultInstance),
+    typeArguments: _root_.scala.Seq[dotty.tools.dotc.semanticdb.Type] = _root_.scala.Seq.empty
+    )  extends dotty.tools.dotc.semanticdb.Tree.NonEmpty with SemanticdbGeneratedMessage  derives CanEqual {
+    @transient @sharable
+    private[this] var __serializedSizeMemoized: _root_.scala.Int = 0
+    private[this] def __computeSerializedSize(): _root_.scala.Int = {
+      var __size = 0
+      
+      {
+        val __value = dotty.tools.dotc.semanticdb.TypeApplyTree._typemapper_function.toBase(function)
+        if (__value.serializedSize != 0) {
+          __size += 1 + SemanticdbOutputStream.computeUInt32SizeNoTag(__value.serializedSize) + __value.serializedSize
+        }
+      };
+      typeArguments.foreach { __item =>
+        val __value = dotty.tools.dotc.semanticdb.TypeApplyTree._typemapper_typeArguments.toBase(__item)
+        __size += 1 + SemanticdbOutputStream.computeUInt32SizeNoTag(__value.serializedSize) + __value.serializedSize
+      }
+      __size
+    }
+    override def serializedSize: _root_.scala.Int = {
+      var __size = __serializedSizeMemoized
+      if (__size == 0) {
+        __size = __computeSerializedSize() + 1
+        __serializedSizeMemoized = __size
+      }
+      __size - 1
+      
+    }
+    def writeTo(`_output__`: SemanticdbOutputStream): _root_.scala.Unit = {
+      {
+        val __v = dotty.tools.dotc.semanticdb.TypeApplyTree._typemapper_function.toBase(function)
+        if (__v.serializedSize != 0) {
+          _output__.writeTag(1, 2)
+          _output__.writeUInt32NoTag(__v.serializedSize)
+          __v.writeTo(_output__)
+        }
+      };
+      typeArguments.foreach { __v =>
+        val __m = dotty.tools.dotc.semanticdb.TypeApplyTree._typemapper_typeArguments.toBase(__v)
+        _output__.writeTag(2, 2)
+        _output__.writeUInt32NoTag(__m.serializedSize)
+        __m.writeTo(_output__)
+      };
+    }
+    def withFunction(__v: dotty.tools.dotc.semanticdb.Tree): TypeApplyTree = copy(function = __v)
+    def clearTypeArguments = copy(typeArguments = _root_.scala.Seq.empty)
+    def addTypeArguments(__vs: dotty.tools.dotc.semanticdb.Type *): TypeApplyTree = addAllTypeArguments(__vs)
+    def addAllTypeArguments(__vs: Iterable[dotty.tools.dotc.semanticdb.Type]): TypeApplyTree = copy(typeArguments = typeArguments ++ __vs)
+    def withTypeArguments(__v: _root_.scala.Seq[dotty.tools.dotc.semanticdb.Type]): TypeApplyTree = copy(typeArguments = __v)
+    
+    
+    
+    
+    // @@protoc_insertion_point(GeneratedMessage[dotty.tools.dotc.semanticdb.TypeApplyTree])
+}
+
+object TypeApplyTree  extends SemanticdbGeneratedMessageCompanion[dotty.tools.dotc.semanticdb.TypeApplyTree] {
+  implicit def messageCompanion: SemanticdbGeneratedMessageCompanion[dotty.tools.dotc.semanticdb.TypeApplyTree] = this
+  def parseFrom(`_input__`: SemanticdbInputStream): dotty.tools.dotc.semanticdb.TypeApplyTree = {
+    var __function: _root_.scala.Option[dotty.tools.dotc.semanticdb.TreeMessage] = _root_.scala.None
+    val __typeArguments: _root_.scala.collection.immutable.VectorBuilder[dotty.tools.dotc.semanticdb.Type] = new _root_.scala.collection.immutable.VectorBuilder[dotty.tools.dotc.semanticdb.Type]
+    var _done__ = false
+    while (!_done__) {
+      val _tag__ = _input__.readTag()
+      _tag__ match {
+        case 0 => _done__ = true
+        case 10 =>
+          __function = _root_.scala.Some(__function.fold(LiteParser.readMessage[dotty.tools.dotc.semanticdb.TreeMessage](_input__))(LiteParser.readMessage(_input__, _)))
+        case 18 =>
+          __typeArguments += dotty.tools.dotc.semanticdb.TypeApplyTree._typemapper_typeArguments.toCustom(LiteParser.readMessage[dotty.tools.dotc.semanticdb.TypeMessage](_input__))
+        case tag => _input__.skipField(tag)
+      }
+    }
+    dotty.tools.dotc.semanticdb.TypeApplyTree(
+        function = dotty.tools.dotc.semanticdb.TypeApplyTree._typemapper_function.toCustom(__function.getOrElse(dotty.tools.dotc.semanticdb.TreeMessage.defaultInstance)),
+        typeArguments = __typeArguments.result()
+    )
+  }
+  
+  
+  
+  
+  
+  
+  lazy val defaultInstance = dotty.tools.dotc.semanticdb.TypeApplyTree(
+    function = dotty.tools.dotc.semanticdb.TypeApplyTree._typemapper_function.toCustom(dotty.tools.dotc.semanticdb.TreeMessage.defaultInstance),
+    typeArguments = _root_.scala.Seq.empty
+  )
+  final val FUNCTION_FIELD_NUMBER = 1
+  final val TYPE_ARGUMENTS_FIELD_NUMBER = 2
+  @transient @sharable
+  private[semanticdb] val _typemapper_function: SemanticdbTypeMapper[dotty.tools.dotc.semanticdb.TreeMessage, dotty.tools.dotc.semanticdb.Tree] = implicitly[SemanticdbTypeMapper[dotty.tools.dotc.semanticdb.TreeMessage, dotty.tools.dotc.semanticdb.Tree]]
+  @transient @sharable
+  private[semanticdb] val _typemapper_typeArguments: SemanticdbTypeMapper[dotty.tools.dotc.semanticdb.TypeMessage, dotty.tools.dotc.semanticdb.Type] = implicitly[SemanticdbTypeMapper[dotty.tools.dotc.semanticdb.TypeMessage, dotty.tools.dotc.semanticdb.Type]]
+  def of(
+    function: dotty.tools.dotc.semanticdb.Tree,
+    typeArguments: _root_.scala.Seq[dotty.tools.dotc.semanticdb.Type]
+  ): _root_.dotty.tools.dotc.semanticdb.TypeApplyTree = _root_.dotty.tools.dotc.semanticdb.TypeApplyTree(
+    function,
+    typeArguments
+  )
+  // @@protoc_insertion_point(GeneratedMessageCompanion[dotty.tools.dotc.semanticdb.TypeApplyTree])
+}
diff --git a/tests/pos-with-compiler-cc/dotc/semanticdb/generated/Type.scala b/tests/pos-with-compiler-cc/dotc/semanticdb/generated/Type.scala
new file mode 100644
index 000000000000..da24b4847e19
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/semanticdb/generated/Type.scala
@@ -0,0 +1,2036 @@
+// Generated by https://github.com/tanishiking/semanticdb-for-scala3
+// Generated by the Scala Plugin for the Protocol Buffer Compiler.
+// Do not edit!
+//
+// Protofile syntax: PROTO3
+
+package dotty.tools.dotc.semanticdb
+import dotty.tools.dotc.semanticdb.internal._
+import scala.annotation.internal.sharable
+
+sealed trait Type  extends SemanticdbGeneratedSealedOneof  derives CanEqual {
+  type MessageType = dotty.tools.dotc.semanticdb.TypeMessage
+  final def isEmpty = this.isInstanceOf[dotty.tools.dotc.semanticdb.Type.Empty.type]
+  final def isDefined = !isEmpty
+  final def asMessage: dotty.tools.dotc.semanticdb.TypeMessage = dotty.tools.dotc.semanticdb.Type.TypeTypeMapper.toBase(this)
+  final def asNonEmpty: Option[dotty.tools.dotc.semanticdb.Type.NonEmpty] = if (isEmpty) None else Some(this.asInstanceOf[dotty.tools.dotc.semanticdb.Type.NonEmpty])
+}
+
+object Type {
+  case object Empty extends dotty.tools.dotc.semanticdb.Type
+  
+  sealed trait NonEmpty extends dotty.tools.dotc.semanticdb.Type
+  def defaultInstance: dotty.tools.dotc.semanticdb.Type = Empty
+  
+  implicit val TypeTypeMapper: SemanticdbTypeMapper[dotty.tools.dotc.semanticdb.TypeMessage, dotty.tools.dotc.semanticdb.Type] = new SemanticdbTypeMapper[dotty.tools.dotc.semanticdb.TypeMessage, dotty.tools.dotc.semanticdb.Type] {
+    override def toCustom(__base: dotty.tools.dotc.semanticdb.TypeMessage): dotty.tools.dotc.semanticdb.Type = __base.sealedValue match {
+      case __v: dotty.tools.dotc.semanticdb.TypeMessage.SealedValue.TypeRef => __v.value
+      case __v: dotty.tools.dotc.semanticdb.TypeMessage.SealedValue.SingleType => __v.value
+      case __v: dotty.tools.dotc.semanticdb.TypeMessage.SealedValue.ThisType => __v.value
+      case __v: dotty.tools.dotc.semanticdb.TypeMessage.SealedValue.SuperType => __v.value
+      case __v: dotty.tools.dotc.semanticdb.TypeMessage.SealedValue.ConstantType => __v.value
+      case __v: dotty.tools.dotc.semanticdb.TypeMessage.SealedValue.IntersectionType => __v.value
+      case __v: dotty.tools.dotc.semanticdb.TypeMessage.SealedValue.UnionType => __v.value
+      case __v: dotty.tools.dotc.semanticdb.TypeMessage.SealedValue.WithType => __v.value
+      case __v: dotty.tools.dotc.semanticdb.TypeMessage.SealedValue.StructuralType => __v.value
+      case __v: dotty.tools.dotc.semanticdb.TypeMessage.SealedValue.AnnotatedType => __v.value
+      case __v: dotty.tools.dotc.semanticdb.TypeMessage.SealedValue.ExistentialType => __v.value
+      case __v: dotty.tools.dotc.semanticdb.TypeMessage.SealedValue.UniversalType => __v.value
+      case __v: dotty.tools.dotc.semanticdb.TypeMessage.SealedValue.ByNameType => __v.value
+      case __v: dotty.tools.dotc.semanticdb.TypeMessage.SealedValue.RepeatedType => __v.value
+      case __v: dotty.tools.dotc.semanticdb.TypeMessage.SealedValue.MatchType => __v.value
+      case dotty.tools.dotc.semanticdb.TypeMessage.SealedValue.Empty => Empty
+    }
+    override def toBase(__custom: dotty.tools.dotc.semanticdb.Type): dotty.tools.dotc.semanticdb.TypeMessage = dotty.tools.dotc.semanticdb.TypeMessage(__custom match {
+      case __v: dotty.tools.dotc.semanticdb.TypeRef => dotty.tools.dotc.semanticdb.TypeMessage.SealedValue.TypeRef(__v)
+      case __v: dotty.tools.dotc.semanticdb.SingleType => dotty.tools.dotc.semanticdb.TypeMessage.SealedValue.SingleType(__v)
+      case __v: dotty.tools.dotc.semanticdb.ThisType => dotty.tools.dotc.semanticdb.TypeMessage.SealedValue.ThisType(__v)
+      case __v: dotty.tools.dotc.semanticdb.SuperType => dotty.tools.dotc.semanticdb.TypeMessage.SealedValue.SuperType(__v)
+      case __v: dotty.tools.dotc.semanticdb.ConstantType => dotty.tools.dotc.semanticdb.TypeMessage.SealedValue.ConstantType(__v)
+      case __v: dotty.tools.dotc.semanticdb.IntersectionType => dotty.tools.dotc.semanticdb.TypeMessage.SealedValue.IntersectionType(__v)
+      case __v: dotty.tools.dotc.semanticdb.UnionType => dotty.tools.dotc.semanticdb.TypeMessage.SealedValue.UnionType(__v)
+      case __v: dotty.tools.dotc.semanticdb.WithType => dotty.tools.dotc.semanticdb.TypeMessage.SealedValue.WithType(__v)
+      case __v: dotty.tools.dotc.semanticdb.StructuralType => dotty.tools.dotc.semanticdb.TypeMessage.SealedValue.StructuralType(__v)
+      case __v: dotty.tools.dotc.semanticdb.AnnotatedType => dotty.tools.dotc.semanticdb.TypeMessage.SealedValue.AnnotatedType(__v)
+      case __v: dotty.tools.dotc.semanticdb.ExistentialType => dotty.tools.dotc.semanticdb.TypeMessage.SealedValue.ExistentialType(__v)
+      case __v: dotty.tools.dotc.semanticdb.UniversalType => dotty.tools.dotc.semanticdb.TypeMessage.SealedValue.UniversalType(__v)
+      case __v: dotty.tools.dotc.semanticdb.ByNameType => dotty.tools.dotc.semanticdb.TypeMessage.SealedValue.ByNameType(__v)
+      case __v: dotty.tools.dotc.semanticdb.RepeatedType => dotty.tools.dotc.semanticdb.TypeMessage.SealedValue.RepeatedType(__v)
+      case __v: dotty.tools.dotc.semanticdb.MatchType => dotty.tools.dotc.semanticdb.TypeMessage.SealedValue.MatchType(__v)
+      case Empty => dotty.tools.dotc.semanticdb.TypeMessage.SealedValue.Empty
+    })
+  }
+}
+@SerialVersionUID(0L)
+final case class TypeMessage(
+    sealedValue: dotty.tools.dotc.semanticdb.TypeMessage.SealedValue = dotty.tools.dotc.semanticdb.TypeMessage.SealedValue.Empty
+    )  extends SemanticdbGeneratedMessage  derives CanEqual {
+    @transient @sharable
+    private[this] var __serializedSizeMemoized: _root_.scala.Int = 0
+    private[this] def __computeSerializedSize(): _root_.scala.Int = {
+      var __size = 0
+      if (sealedValue.typeRef.isDefined) {
+        val __value = sealedValue.typeRef.get
+        __size += 1 + SemanticdbOutputStream.computeUInt32SizeNoTag(__value.serializedSize) + __value.serializedSize
+      };
+      if (sealedValue.singleType.isDefined) {
+        val __value = sealedValue.singleType.get
+        __size += 2 + SemanticdbOutputStream.computeUInt32SizeNoTag(__value.serializedSize) + __value.serializedSize
+      };
+      if (sealedValue.thisType.isDefined) {
+        val __value = sealedValue.thisType.get
+        __size += 2 + SemanticdbOutputStream.computeUInt32SizeNoTag(__value.serializedSize) + __value.serializedSize
+      };
+      if (sealedValue.superType.isDefined) {
+        val __value = sealedValue.superType.get
+        __size += 2 + SemanticdbOutputStream.computeUInt32SizeNoTag(__value.serializedSize) + __value.serializedSize
+      };
+      if (sealedValue.constantType.isDefined) {
+        val __value = sealedValue.constantType.get
+        __size += 2 + SemanticdbOutputStream.computeUInt32SizeNoTag(__value.serializedSize) + __value.serializedSize
+      };
+      if (sealedValue.intersectionType.isDefined) {
+        val __value = sealedValue.intersectionType.get
+        __size += 2 + SemanticdbOutputStream.computeUInt32SizeNoTag(__value.serializedSize) + __value.serializedSize
+      };
+      if (sealedValue.unionType.isDefined) {
+        val __value = sealedValue.unionType.get
+        __size += 2 + SemanticdbOutputStream.computeUInt32SizeNoTag(__value.serializedSize) + __value.serializedSize
+      };
+      if (sealedValue.withType.isDefined) {
+        val __value = sealedValue.withType.get
+        __size += 2 + SemanticdbOutputStream.computeUInt32SizeNoTag(__value.serializedSize) + __value.serializedSize
+      };
+      if (sealedValue.structuralType.isDefined) {
+        val __value = sealedValue.structuralType.get
+        __size += 1 + SemanticdbOutputStream.computeUInt32SizeNoTag(__value.serializedSize) + __value.serializedSize
+      };
+      if (sealedValue.annotatedType.isDefined) {
+        val __value = sealedValue.annotatedType.get
+        __size += 1 + SemanticdbOutputStream.computeUInt32SizeNoTag(__value.serializedSize) + __value.serializedSize
+      };
+      if (sealedValue.existentialType.isDefined) {
+        val __value = sealedValue.existentialType.get
+        __size += 1 + SemanticdbOutputStream.computeUInt32SizeNoTag(__value.serializedSize) + __value.serializedSize
+      };
+      if (sealedValue.universalType.isDefined) {
+        val __value = sealedValue.universalType.get
+        __size += 1 + SemanticdbOutputStream.computeUInt32SizeNoTag(__value.serializedSize) + __value.serializedSize
+      };
+      if (sealedValue.byNameType.isDefined) {
+        val __value = sealedValue.byNameType.get
+        __size += 1 + SemanticdbOutputStream.computeUInt32SizeNoTag(__value.serializedSize) + __value.serializedSize
+      };
+      if (sealedValue.repeatedType.isDefined) {
+        val __value = sealedValue.repeatedType.get
+        __size += 1 + SemanticdbOutputStream.computeUInt32SizeNoTag(__value.serializedSize) + __value.serializedSize
+      };
+      if (sealedValue.matchType.isDefined) {
+        val __value = sealedValue.matchType.get
+        __size += 2 + SemanticdbOutputStream.computeUInt32SizeNoTag(__value.serializedSize) + __value.serializedSize
+      };
+      __size
+    }
+    override def serializedSize: _root_.scala.Int = {
+      var __size = __serializedSizeMemoized
+      if (__size == 0) {
+        __size = __computeSerializedSize() + 1
+        __serializedSizeMemoized = __size
+      }
+      __size - 1
+      
+    }
+    def writeTo(`_output__`: SemanticdbOutputStream): _root_.scala.Unit = {
+      sealedValue.typeRef.foreach { __v =>
+        val __m = __v
+        _output__.writeTag(2, 2)
+        _output__.writeUInt32NoTag(__m.serializedSize)
+        __m.writeTo(_output__)
+      };
+      sealedValue.structuralType.foreach { __v =>
+        val __m = __v
+        _output__.writeTag(7, 2)
+        _output__.writeUInt32NoTag(__m.serializedSize)
+        __m.writeTo(_output__)
+      };
+      sealedValue.annotatedType.foreach { __v =>
+        val __m = __v
+        _output__.writeTag(8, 2)
+        _output__.writeUInt32NoTag(__m.serializedSize)
+        __m.writeTo(_output__)
+      };
+      sealedValue.existentialType.foreach { __v =>
+        val __m = __v
+        _output__.writeTag(9, 2)
+        _output__.writeUInt32NoTag(__m.serializedSize)
+        __m.writeTo(_output__)
+      };
+      sealedValue.universalType.foreach { __v =>
+        val __m = __v
+        _output__.writeTag(10, 2)
+        _output__.writeUInt32NoTag(__m.serializedSize)
+        __m.writeTo(_output__)
+      };
+      sealedValue.byNameType.foreach { __v =>
+        val __m = __v
+        _output__.writeTag(13, 2)
+        _output__.writeUInt32NoTag(__m.serializedSize)
+        __m.writeTo(_output__)
+      };
+      sealedValue.repeatedType.foreach { __v =>
+        val __m = __v
+        _output__.writeTag(14, 2)
+        _output__.writeUInt32NoTag(__m.serializedSize)
+        __m.writeTo(_output__)
+      };
+      sealedValue.intersectionType.foreach { __v =>
+        val __m = __v
+        _output__.writeTag(17, 2)
+        _output__.writeUInt32NoTag(__m.serializedSize)
+        __m.writeTo(_output__)
+      };
+      sealedValue.unionType.foreach { __v =>
+        val __m = __v
+        _output__.writeTag(18, 2)
+        _output__.writeUInt32NoTag(__m.serializedSize)
+        __m.writeTo(_output__)
+      };
+      sealedValue.withType.foreach { __v =>
+        val __m = __v
+        _output__.writeTag(19, 2)
+        _output__.writeUInt32NoTag(__m.serializedSize)
+        __m.writeTo(_output__)
+      };
+      sealedValue.singleType.foreach { __v =>
+        val __m = __v
+        _output__.writeTag(20, 2)
+        _output__.writeUInt32NoTag(__m.serializedSize)
+        __m.writeTo(_output__)
+      };
+      sealedValue.thisType.foreach { __v =>
+        val __m = __v
+        _output__.writeTag(21, 2)
+        _output__.writeUInt32NoTag(__m.serializedSize)
+        __m.writeTo(_output__)
+      };
+      sealedValue.superType.foreach { __v =>
+        val __m = __v
+        _output__.writeTag(22, 2)
+        _output__.writeUInt32NoTag(__m.serializedSize)
+        __m.writeTo(_output__)
+      };
+      sealedValue.constantType.foreach { __v =>
+        val __m = __v
+        _output__.writeTag(23, 2)
+        _output__.writeUInt32NoTag(__m.serializedSize)
+        __m.writeTo(_output__)
+      };
+      sealedValue.matchType.foreach { __v =>
+        val __m = __v
+        _output__.writeTag(25, 2)
+        _output__.writeUInt32NoTag(__m.serializedSize)
+        __m.writeTo(_output__)
+      };
+    }
+    def getTypeRef: dotty.tools.dotc.semanticdb.TypeRef = sealedValue.typeRef.getOrElse(dotty.tools.dotc.semanticdb.TypeRef.defaultInstance)
+    def withTypeRef(__v: dotty.tools.dotc.semanticdb.TypeRef): TypeMessage = copy(sealedValue = dotty.tools.dotc.semanticdb.TypeMessage.SealedValue.TypeRef(__v))
+    def getSingleType: dotty.tools.dotc.semanticdb.SingleType = sealedValue.singleType.getOrElse(dotty.tools.dotc.semanticdb.SingleType.defaultInstance)
+    def withSingleType(__v: dotty.tools.dotc.semanticdb.SingleType): TypeMessage = copy(sealedValue = dotty.tools.dotc.semanticdb.TypeMessage.SealedValue.SingleType(__v))
+    def getThisType: dotty.tools.dotc.semanticdb.ThisType = sealedValue.thisType.getOrElse(dotty.tools.dotc.semanticdb.ThisType.defaultInstance)
+    def withThisType(__v: dotty.tools.dotc.semanticdb.ThisType): TypeMessage = copy(sealedValue = dotty.tools.dotc.semanticdb.TypeMessage.SealedValue.ThisType(__v))
+    def getSuperType: dotty.tools.dotc.semanticdb.SuperType = sealedValue.superType.getOrElse(dotty.tools.dotc.semanticdb.SuperType.defaultInstance)
+    def withSuperType(__v: dotty.tools.dotc.semanticdb.SuperType): TypeMessage = copy(sealedValue = dotty.tools.dotc.semanticdb.TypeMessage.SealedValue.SuperType(__v))
+    def getConstantType: dotty.tools.dotc.semanticdb.ConstantType = sealedValue.constantType.getOrElse(dotty.tools.dotc.semanticdb.ConstantType.defaultInstance)
+    def withConstantType(__v: dotty.tools.dotc.semanticdb.ConstantType): TypeMessage = copy(sealedValue = dotty.tools.dotc.semanticdb.TypeMessage.SealedValue.ConstantType(__v))
+    def getIntersectionType: dotty.tools.dotc.semanticdb.IntersectionType = sealedValue.intersectionType.getOrElse(dotty.tools.dotc.semanticdb.IntersectionType.defaultInstance)
+    def withIntersectionType(__v: dotty.tools.dotc.semanticdb.IntersectionType): TypeMessage = copy(sealedValue = dotty.tools.dotc.semanticdb.TypeMessage.SealedValue.IntersectionType(__v))
+    def getUnionType: dotty.tools.dotc.semanticdb.UnionType = sealedValue.unionType.getOrElse(dotty.tools.dotc.semanticdb.UnionType.defaultInstance)
+    def withUnionType(__v: dotty.tools.dotc.semanticdb.UnionType): TypeMessage = copy(sealedValue = dotty.tools.dotc.semanticdb.TypeMessage.SealedValue.UnionType(__v))
+    def getWithType: dotty.tools.dotc.semanticdb.WithType = sealedValue.withType.getOrElse(dotty.tools.dotc.semanticdb.WithType.defaultInstance)
+    def withWithType(__v: dotty.tools.dotc.semanticdb.WithType): TypeMessage = copy(sealedValue = dotty.tools.dotc.semanticdb.TypeMessage.SealedValue.WithType(__v))
+    def getStructuralType: dotty.tools.dotc.semanticdb.StructuralType = sealedValue.structuralType.getOrElse(dotty.tools.dotc.semanticdb.StructuralType.defaultInstance)
+    def withStructuralType(__v: dotty.tools.dotc.semanticdb.StructuralType): TypeMessage = copy(sealedValue = dotty.tools.dotc.semanticdb.TypeMessage.SealedValue.StructuralType(__v))
+    def getAnnotatedType: dotty.tools.dotc.semanticdb.AnnotatedType = sealedValue.annotatedType.getOrElse(dotty.tools.dotc.semanticdb.AnnotatedType.defaultInstance)
+    def withAnnotatedType(__v: dotty.tools.dotc.semanticdb.AnnotatedType): TypeMessage = copy(sealedValue = dotty.tools.dotc.semanticdb.TypeMessage.SealedValue.AnnotatedType(__v))
+    def getExistentialType: dotty.tools.dotc.semanticdb.ExistentialType = sealedValue.existentialType.getOrElse(dotty.tools.dotc.semanticdb.ExistentialType.defaultInstance)
+    def withExistentialType(__v: dotty.tools.dotc.semanticdb.ExistentialType): TypeMessage = copy(sealedValue = dotty.tools.dotc.semanticdb.TypeMessage.SealedValue.ExistentialType(__v))
+    def getUniversalType: dotty.tools.dotc.semanticdb.UniversalType = sealedValue.universalType.getOrElse(dotty.tools.dotc.semanticdb.UniversalType.defaultInstance)
+    def withUniversalType(__v: dotty.tools.dotc.semanticdb.UniversalType): TypeMessage = copy(sealedValue = dotty.tools.dotc.semanticdb.TypeMessage.SealedValue.UniversalType(__v))
+    def getByNameType: dotty.tools.dotc.semanticdb.ByNameType = sealedValue.byNameType.getOrElse(dotty.tools.dotc.semanticdb.ByNameType.defaultInstance)
+    def withByNameType(__v: dotty.tools.dotc.semanticdb.ByNameType): TypeMessage = copy(sealedValue = dotty.tools.dotc.semanticdb.TypeMessage.SealedValue.ByNameType(__v))
+    def getRepeatedType: dotty.tools.dotc.semanticdb.RepeatedType = sealedValue.repeatedType.getOrElse(dotty.tools.dotc.semanticdb.RepeatedType.defaultInstance)
+    def withRepeatedType(__v: dotty.tools.dotc.semanticdb.RepeatedType): TypeMessage = copy(sealedValue = dotty.tools.dotc.semanticdb.TypeMessage.SealedValue.RepeatedType(__v))
+    def getMatchType: dotty.tools.dotc.semanticdb.MatchType = sealedValue.matchType.getOrElse(dotty.tools.dotc.semanticdb.MatchType.defaultInstance)
+    def withMatchType(__v: dotty.tools.dotc.semanticdb.MatchType): TypeMessage = copy(sealedValue = dotty.tools.dotc.semanticdb.TypeMessage.SealedValue.MatchType(__v))
+    def clearSealedValue: TypeMessage = copy(sealedValue = dotty.tools.dotc.semanticdb.TypeMessage.SealedValue.Empty)
+    def withSealedValue(__v: dotty.tools.dotc.semanticdb.TypeMessage.SealedValue): TypeMessage = copy(sealedValue = __v)
+    
+    
+    
+    
+    def toType: dotty.tools.dotc.semanticdb.Type = dotty.tools.dotc.semanticdb.Type.TypeTypeMapper.toCustom(this)
+    // @@protoc_insertion_point(GeneratedMessage[dotty.tools.dotc.semanticdb.Type])
+}
+
+object TypeMessage  extends SemanticdbGeneratedMessageCompanion[dotty.tools.dotc.semanticdb.TypeMessage] {
+  implicit def messageCompanion: SemanticdbGeneratedMessageCompanion[dotty.tools.dotc.semanticdb.TypeMessage] = this
+  def parseFrom(`_input__`: SemanticdbInputStream): dotty.tools.dotc.semanticdb.TypeMessage = {
+    var __sealedValue: dotty.tools.dotc.semanticdb.TypeMessage.SealedValue = dotty.tools.dotc.semanticdb.TypeMessage.SealedValue.Empty
+    var _done__ = false
+    while (!_done__) {
+      val _tag__ = _input__.readTag()
+      _tag__ match {
+        case 0 => _done__ = true
+        case 18 =>
+          __sealedValue = dotty.tools.dotc.semanticdb.TypeMessage.SealedValue.TypeRef(__sealedValue.typeRef.fold(LiteParser.readMessage[dotty.tools.dotc.semanticdb.TypeRef](_input__))(LiteParser.readMessage(_input__, _)))
+        case 162 =>
+          __sealedValue = dotty.tools.dotc.semanticdb.TypeMessage.SealedValue.SingleType(__sealedValue.singleType.fold(LiteParser.readMessage[dotty.tools.dotc.semanticdb.SingleType](_input__))(LiteParser.readMessage(_input__, _)))
+        case 170 =>
+          __sealedValue = dotty.tools.dotc.semanticdb.TypeMessage.SealedValue.ThisType(__sealedValue.thisType.fold(LiteParser.readMessage[dotty.tools.dotc.semanticdb.ThisType](_input__))(LiteParser.readMessage(_input__, _)))
+        case 178 =>
+          __sealedValue = dotty.tools.dotc.semanticdb.TypeMessage.SealedValue.SuperType(__sealedValue.superType.fold(LiteParser.readMessage[dotty.tools.dotc.semanticdb.SuperType](_input__))(LiteParser.readMessage(_input__, _)))
+        case 186 =>
+          __sealedValue = dotty.tools.dotc.semanticdb.TypeMessage.SealedValue.ConstantType(__sealedValue.constantType.fold(LiteParser.readMessage[dotty.tools.dotc.semanticdb.ConstantType](_input__))(LiteParser.readMessage(_input__, _)))
+        case 138 =>
+          __sealedValue = dotty.tools.dotc.semanticdb.TypeMessage.SealedValue.IntersectionType(__sealedValue.intersectionType.fold(LiteParser.readMessage[dotty.tools.dotc.semanticdb.IntersectionType](_input__))(LiteParser.readMessage(_input__, _)))
+        case 146 =>
+          __sealedValue = dotty.tools.dotc.semanticdb.TypeMessage.SealedValue.UnionType(__sealedValue.unionType.fold(LiteParser.readMessage[dotty.tools.dotc.semanticdb.UnionType](_input__))(LiteParser.readMessage(_input__, _)))
+        case 154 =>
+          __sealedValue = dotty.tools.dotc.semanticdb.TypeMessage.SealedValue.WithType(__sealedValue.withType.fold(LiteParser.readMessage[dotty.tools.dotc.semanticdb.WithType](_input__))(LiteParser.readMessage(_input__, _)))
+        case 58 =>
+          __sealedValue = dotty.tools.dotc.semanticdb.TypeMessage.SealedValue.StructuralType(__sealedValue.structuralType.fold(LiteParser.readMessage[dotty.tools.dotc.semanticdb.StructuralType](_input__))(LiteParser.readMessage(_input__, _)))
+        case 66 =>
+          __sealedValue = dotty.tools.dotc.semanticdb.TypeMessage.SealedValue.AnnotatedType(__sealedValue.annotatedType.fold(LiteParser.readMessage[dotty.tools.dotc.semanticdb.AnnotatedType](_input__))(LiteParser.readMessage(_input__, _)))
+        case 74 =>
+          __sealedValue = dotty.tools.dotc.semanticdb.TypeMessage.SealedValue.ExistentialType(__sealedValue.existentialType.fold(LiteParser.readMessage[dotty.tools.dotc.semanticdb.ExistentialType](_input__))(LiteParser.readMessage(_input__, _)))
+        case 82 =>
+          __sealedValue = dotty.tools.dotc.semanticdb.TypeMessage.SealedValue.UniversalType(__sealedValue.universalType.fold(LiteParser.readMessage[dotty.tools.dotc.semanticdb.UniversalType](_input__))(LiteParser.readMessage(_input__, _)))
+        case 106 =>
+          __sealedValue = dotty.tools.dotc.semanticdb.TypeMessage.SealedValue.ByNameType(__sealedValue.byNameType.fold(LiteParser.readMessage[dotty.tools.dotc.semanticdb.ByNameType](_input__))(LiteParser.readMessage(_input__, _)))
+        case 114 =>
+          __sealedValue = dotty.tools.dotc.semanticdb.TypeMessage.SealedValue.RepeatedType(__sealedValue.repeatedType.fold(LiteParser.readMessage[dotty.tools.dotc.semanticdb.RepeatedType](_input__))(LiteParser.readMessage(_input__, _)))
+        case 202 =>
+          __sealedValue = dotty.tools.dotc.semanticdb.TypeMessage.SealedValue.MatchType(__sealedValue.matchType.fold(LiteParser.readMessage[dotty.tools.dotc.semanticdb.MatchType](_input__))(LiteParser.readMessage(_input__, _)))
+        case tag => _input__.skipField(tag)
+      }
+    }
+    dotty.tools.dotc.semanticdb.TypeMessage(
+        sealedValue = __sealedValue
+    )
+  }
+  
+  
+  
+  
+  
+  
+  lazy val defaultInstance = dotty.tools.dotc.semanticdb.TypeMessage(
+    sealedValue = dotty.tools.dotc.semanticdb.TypeMessage.SealedValue.Empty
+  )
+  sealed trait SealedValue  extends SemanticdbGeneratedOneof  derives CanEqual {
+    def isEmpty: _root_.scala.Boolean = false
+    def isDefined: _root_.scala.Boolean = true
+    def isTypeRef: _root_.scala.Boolean = false
+    def isSingleType: _root_.scala.Boolean = false
+    def isThisType: _root_.scala.Boolean = false
+    def isSuperType: _root_.scala.Boolean = false
+    def isConstantType: _root_.scala.Boolean = false
+    def isIntersectionType: _root_.scala.Boolean = false
+    def isUnionType: _root_.scala.Boolean = false
+    def isWithType: _root_.scala.Boolean = false
+    def isStructuralType: _root_.scala.Boolean = false
+    def isAnnotatedType: _root_.scala.Boolean = false
+    def isExistentialType: _root_.scala.Boolean = false
+    def isUniversalType: _root_.scala.Boolean = false
+    def isByNameType: _root_.scala.Boolean = false
+    def isRepeatedType: _root_.scala.Boolean = false
+    def isMatchType: _root_.scala.Boolean = false
+    def typeRef: _root_.scala.Option[dotty.tools.dotc.semanticdb.TypeRef] = _root_.scala.None
+    def singleType: _root_.scala.Option[dotty.tools.dotc.semanticdb.SingleType] = _root_.scala.None
+    def thisType: _root_.scala.Option[dotty.tools.dotc.semanticdb.ThisType] = _root_.scala.None
+    def superType: _root_.scala.Option[dotty.tools.dotc.semanticdb.SuperType] = _root_.scala.None
+    def constantType: _root_.scala.Option[dotty.tools.dotc.semanticdb.ConstantType] = _root_.scala.None
+    def intersectionType: _root_.scala.Option[dotty.tools.dotc.semanticdb.IntersectionType] = _root_.scala.None
+    def unionType: _root_.scala.Option[dotty.tools.dotc.semanticdb.UnionType] = _root_.scala.None
+    def withType: _root_.scala.Option[dotty.tools.dotc.semanticdb.WithType] = _root_.scala.None
+    def structuralType: _root_.scala.Option[dotty.tools.dotc.semanticdb.StructuralType] = _root_.scala.None
+    def annotatedType: _root_.scala.Option[dotty.tools.dotc.semanticdb.AnnotatedType] = _root_.scala.None
+    def existentialType: _root_.scala.Option[dotty.tools.dotc.semanticdb.ExistentialType] = _root_.scala.None
+    def universalType: _root_.scala.Option[dotty.tools.dotc.semanticdb.UniversalType] = _root_.scala.None
+    def byNameType: _root_.scala.Option[dotty.tools.dotc.semanticdb.ByNameType] = _root_.scala.None
+    def repeatedType: _root_.scala.Option[dotty.tools.dotc.semanticdb.RepeatedType] = _root_.scala.None
+    def matchType: _root_.scala.Option[dotty.tools.dotc.semanticdb.MatchType] = _root_.scala.None
+  }
+  object SealedValue {
+    @SerialVersionUID(0L)
+    case object Empty extends dotty.tools.dotc.semanticdb.TypeMessage.SealedValue {
+      type ValueType = _root_.scala.Nothing
+      override def isEmpty: _root_.scala.Boolean = true
+      override def isDefined: _root_.scala.Boolean = false
+      override def number: _root_.scala.Int = 0
+      override def value: _root_.scala.Nothing = throw new java.util.NoSuchElementException("Empty.value")
+    }
+  
+    @SerialVersionUID(0L)
+    final case class TypeRef(value: dotty.tools.dotc.semanticdb.TypeRef) extends dotty.tools.dotc.semanticdb.TypeMessage.SealedValue  derives CanEqual {
+      type ValueType = dotty.tools.dotc.semanticdb.TypeRef
+      override def isTypeRef: _root_.scala.Boolean = true
+      override def typeRef: _root_.scala.Option[dotty.tools.dotc.semanticdb.TypeRef] = Some(value)
+      override def number: _root_.scala.Int = 2
+    }
+    @SerialVersionUID(0L)
+    final case class SingleType(value: dotty.tools.dotc.semanticdb.SingleType) extends dotty.tools.dotc.semanticdb.TypeMessage.SealedValue  derives CanEqual {
+      type ValueType = dotty.tools.dotc.semanticdb.SingleType
+      override def isSingleType: _root_.scala.Boolean = true
+      override def singleType: _root_.scala.Option[dotty.tools.dotc.semanticdb.SingleType] = Some(value)
+      override def number: _root_.scala.Int = 20
+    }
+    @SerialVersionUID(0L)
+    final case class ThisType(value: dotty.tools.dotc.semanticdb.ThisType) extends dotty.tools.dotc.semanticdb.TypeMessage.SealedValue  derives CanEqual {
+      type ValueType = dotty.tools.dotc.semanticdb.ThisType
+      override def isThisType: _root_.scala.Boolean = true
+      override def thisType: _root_.scala.Option[dotty.tools.dotc.semanticdb.ThisType] = Some(value)
+      override def number: _root_.scala.Int = 21
+    }
+    @SerialVersionUID(0L)
+    final case class SuperType(value: dotty.tools.dotc.semanticdb.SuperType) extends dotty.tools.dotc.semanticdb.TypeMessage.SealedValue  derives CanEqual {
+      type ValueType = dotty.tools.dotc.semanticdb.SuperType
+      override def isSuperType: _root_.scala.Boolean = true
+      override def superType: _root_.scala.Option[dotty.tools.dotc.semanticdb.SuperType] = Some(value)
+      override def number: _root_.scala.Int = 22
+    }
+    @SerialVersionUID(0L)
+    final case class ConstantType(value: dotty.tools.dotc.semanticdb.ConstantType) extends dotty.tools.dotc.semanticdb.TypeMessage.SealedValue  derives CanEqual {
+      type ValueType = dotty.tools.dotc.semanticdb.ConstantType
+      override def isConstantType: _root_.scala.Boolean = true
+      override def constantType: _root_.scala.Option[dotty.tools.dotc.semanticdb.ConstantType] = Some(value)
+      override def number: _root_.scala.Int = 23
+    }
+    @SerialVersionUID(0L)
+    final case class IntersectionType(value: dotty.tools.dotc.semanticdb.IntersectionType) extends dotty.tools.dotc.semanticdb.TypeMessage.SealedValue  derives CanEqual {
+      type ValueType = dotty.tools.dotc.semanticdb.IntersectionType
+      override def isIntersectionType: _root_.scala.Boolean = true
+      override def intersectionType: _root_.scala.Option[dotty.tools.dotc.semanticdb.IntersectionType] = Some(value)
+      override def number: _root_.scala.Int = 17
+    }
+    @SerialVersionUID(0L)
+    final case class UnionType(value: dotty.tools.dotc.semanticdb.UnionType) extends dotty.tools.dotc.semanticdb.TypeMessage.SealedValue  derives CanEqual {
+      type ValueType = dotty.tools.dotc.semanticdb.UnionType
+      override def isUnionType: _root_.scala.Boolean = true
+      override def unionType: _root_.scala.Option[dotty.tools.dotc.semanticdb.UnionType] = Some(value)
+      override def number: _root_.scala.Int = 18
+    }
+    @SerialVersionUID(0L)
+    final case class WithType(value: dotty.tools.dotc.semanticdb.WithType) extends dotty.tools.dotc.semanticdb.TypeMessage.SealedValue  derives CanEqual {
+      type ValueType = dotty.tools.dotc.semanticdb.WithType
+      override def isWithType: _root_.scala.Boolean = true
+      override def withType: _root_.scala.Option[dotty.tools.dotc.semanticdb.WithType] = Some(value)
+      override def number: _root_.scala.Int = 19
+    }
+    @SerialVersionUID(0L)
+    final case class StructuralType(value: dotty.tools.dotc.semanticdb.StructuralType) extends dotty.tools.dotc.semanticdb.TypeMessage.SealedValue  derives CanEqual {
+      type ValueType = dotty.tools.dotc.semanticdb.StructuralType
+      override def isStructuralType: _root_.scala.Boolean = true
+      override def structuralType: _root_.scala.Option[dotty.tools.dotc.semanticdb.StructuralType] = Some(value)
+      override def number: _root_.scala.Int = 7
+    }
+    @SerialVersionUID(0L)
+    final case class AnnotatedType(value: dotty.tools.dotc.semanticdb.AnnotatedType) extends dotty.tools.dotc.semanticdb.TypeMessage.SealedValue  derives CanEqual {
+      type ValueType = dotty.tools.dotc.semanticdb.AnnotatedType
+      override def isAnnotatedType: _root_.scala.Boolean = true
+      override def annotatedType: _root_.scala.Option[dotty.tools.dotc.semanticdb.AnnotatedType] = Some(value)
+      override def number: _root_.scala.Int = 8
+    }
+    @SerialVersionUID(0L)
+    final case class ExistentialType(value: dotty.tools.dotc.semanticdb.ExistentialType) extends dotty.tools.dotc.semanticdb.TypeMessage.SealedValue  derives CanEqual {
+      type ValueType = dotty.tools.dotc.semanticdb.ExistentialType
+      override def isExistentialType: _root_.scala.Boolean = true
+      override def existentialType: _root_.scala.Option[dotty.tools.dotc.semanticdb.ExistentialType] = Some(value)
+      override def number: _root_.scala.Int = 9
+    }
+    @SerialVersionUID(0L)
+    final case class UniversalType(value: dotty.tools.dotc.semanticdb.UniversalType) extends dotty.tools.dotc.semanticdb.TypeMessage.SealedValue  derives CanEqual {
+      type ValueType = dotty.tools.dotc.semanticdb.UniversalType
+      override def isUniversalType: _root_.scala.Boolean = true
+      override def universalType: _root_.scala.Option[dotty.tools.dotc.semanticdb.UniversalType] = Some(value)
+      override def number: _root_.scala.Int = 10
+    }
+    @SerialVersionUID(0L)
+    final case class ByNameType(value: dotty.tools.dotc.semanticdb.ByNameType) extends dotty.tools.dotc.semanticdb.TypeMessage.SealedValue  derives CanEqual {
+      type ValueType = dotty.tools.dotc.semanticdb.ByNameType
+      override def isByNameType: _root_.scala.Boolean = true
+      override def byNameType: _root_.scala.Option[dotty.tools.dotc.semanticdb.ByNameType] = Some(value)
+      override def number: _root_.scala.Int = 13
+    }
+    @SerialVersionUID(0L)
+    final case class RepeatedType(value: dotty.tools.dotc.semanticdb.RepeatedType) extends dotty.tools.dotc.semanticdb.TypeMessage.SealedValue  derives CanEqual {
+      type ValueType = dotty.tools.dotc.semanticdb.RepeatedType
+      override def isRepeatedType: _root_.scala.Boolean = true
+      override def repeatedType: _root_.scala.Option[dotty.tools.dotc.semanticdb.RepeatedType] = Some(value)
+      override def number: _root_.scala.Int = 14
+    }
+    @SerialVersionUID(0L)
+    final case class MatchType(value: dotty.tools.dotc.semanticdb.MatchType) extends dotty.tools.dotc.semanticdb.TypeMessage.SealedValue  derives CanEqual {
+      type ValueType = dotty.tools.dotc.semanticdb.MatchType
+      override def isMatchType: _root_.scala.Boolean = true
+      override def matchType: _root_.scala.Option[dotty.tools.dotc.semanticdb.MatchType] = Some(value)
+      override def number: _root_.scala.Int = 25
+    }
+  }
+  final val TYPE_REF_FIELD_NUMBER = 2
+  final val SINGLE_TYPE_FIELD_NUMBER = 20
+  final val THIS_TYPE_FIELD_NUMBER = 21
+  final val SUPER_TYPE_FIELD_NUMBER = 22
+  final val CONSTANT_TYPE_FIELD_NUMBER = 23
+  final val INTERSECTION_TYPE_FIELD_NUMBER = 17
+  final val UNION_TYPE_FIELD_NUMBER = 18
+  final val WITH_TYPE_FIELD_NUMBER = 19
+  final val STRUCTURAL_TYPE_FIELD_NUMBER = 7
+  final val ANNOTATED_TYPE_FIELD_NUMBER = 8
+  final val EXISTENTIAL_TYPE_FIELD_NUMBER = 9
+  final val UNIVERSAL_TYPE_FIELD_NUMBER = 10
+  final val BY_NAME_TYPE_FIELD_NUMBER = 13
+  final val REPEATED_TYPE_FIELD_NUMBER = 14
+  final val MATCH_TYPE_FIELD_NUMBER = 25
+  def of(
+    sealedValue: dotty.tools.dotc.semanticdb.TypeMessage.SealedValue
+  ): _root_.dotty.tools.dotc.semanticdb.TypeMessage = _root_.dotty.tools.dotc.semanticdb.TypeMessage(
+    sealedValue
+  )
+  // @@protoc_insertion_point(GeneratedMessageCompanion[dotty.tools.dotc.semanticdb.Type])
+}
+
+@SerialVersionUID(0L)
+final case class TypeRef(
+    prefix: dotty.tools.dotc.semanticdb.Type = dotty.tools.dotc.semanticdb.TypeRef._typemapper_prefix.toCustom(dotty.tools.dotc.semanticdb.TypeMessage.defaultInstance),
+    symbol: _root_.scala.Predef.String = "",
+    typeArguments: _root_.scala.Seq[dotty.tools.dotc.semanticdb.Type] = _root_.scala.Seq.empty
+    )  extends dotty.tools.dotc.semanticdb.Type.NonEmpty with SemanticdbGeneratedMessage  derives CanEqual {
+    @transient @sharable
+    private[this] var __serializedSizeMemoized: _root_.scala.Int = 0
+    private[this] def __computeSerializedSize(): _root_.scala.Int = {
+      var __size = 0
+      
+      {
+        val __value = dotty.tools.dotc.semanticdb.TypeRef._typemapper_prefix.toBase(prefix)
+        if (__value.serializedSize != 0) {
+          __size += 1 + SemanticdbOutputStream.computeUInt32SizeNoTag(__value.serializedSize) + __value.serializedSize
+        }
+      };
+      
+      {
+        val __value = symbol
+        if (!__value.isEmpty) {
+          __size += SemanticdbOutputStream.computeStringSize(2, __value)
+        }
+      };
+      typeArguments.foreach { __item =>
+        val __value = dotty.tools.dotc.semanticdb.TypeRef._typemapper_typeArguments.toBase(__item)
+        __size += 1 + SemanticdbOutputStream.computeUInt32SizeNoTag(__value.serializedSize) + __value.serializedSize
+      }
+      __size
+    }
+    override def serializedSize: _root_.scala.Int = {
+      var __size = __serializedSizeMemoized
+      if (__size == 0) {
+        __size = __computeSerializedSize() + 1
+        __serializedSizeMemoized = __size
+      }
+      __size - 1
+      
+    }
+    def writeTo(`_output__`: SemanticdbOutputStream): _root_.scala.Unit = {
+      {
+        val __v = dotty.tools.dotc.semanticdb.TypeRef._typemapper_prefix.toBase(prefix)
+        if (__v.serializedSize != 0) {
+          _output__.writeTag(1, 2)
+          _output__.writeUInt32NoTag(__v.serializedSize)
+          __v.writeTo(_output__)
+        }
+      };
+      {
+        val __v = symbol
+        if (!__v.isEmpty) {
+          _output__.writeString(2, __v)
+        }
+      };
+      typeArguments.foreach { __v =>
+        val __m = dotty.tools.dotc.semanticdb.TypeRef._typemapper_typeArguments.toBase(__v)
+        _output__.writeTag(3, 2)
+        _output__.writeUInt32NoTag(__m.serializedSize)
+        __m.writeTo(_output__)
+      };
+    }
+    def withPrefix(__v: dotty.tools.dotc.semanticdb.Type): TypeRef = copy(prefix = __v)
+    def withSymbol(__v: _root_.scala.Predef.String): TypeRef = copy(symbol = __v)
+    def clearTypeArguments = copy(typeArguments = _root_.scala.Seq.empty)
+    def addTypeArguments(__vs: dotty.tools.dotc.semanticdb.Type *): TypeRef = addAllTypeArguments(__vs)
+    def addAllTypeArguments(__vs: Iterable[dotty.tools.dotc.semanticdb.Type]): TypeRef = copy(typeArguments = typeArguments ++ __vs)
+    def withTypeArguments(__v: _root_.scala.Seq[dotty.tools.dotc.semanticdb.Type]): TypeRef = copy(typeArguments = __v)
+    
+    
+    
+    
+    // @@protoc_insertion_point(GeneratedMessage[dotty.tools.dotc.semanticdb.TypeRef])
+}
+
+object TypeRef  extends SemanticdbGeneratedMessageCompanion[dotty.tools.dotc.semanticdb.TypeRef] {
+  implicit def messageCompanion: SemanticdbGeneratedMessageCompanion[dotty.tools.dotc.semanticdb.TypeRef] = this
+  def parseFrom(`_input__`: SemanticdbInputStream): dotty.tools.dotc.semanticdb.TypeRef = {
+    var __prefix: _root_.scala.Option[dotty.tools.dotc.semanticdb.TypeMessage] = _root_.scala.None
+    var __symbol: _root_.scala.Predef.String = ""
+    val __typeArguments: _root_.scala.collection.immutable.VectorBuilder[dotty.tools.dotc.semanticdb.Type] = new _root_.scala.collection.immutable.VectorBuilder[dotty.tools.dotc.semanticdb.Type]
+    var _done__ = false
+    while (!_done__) {
+      val _tag__ = _input__.readTag()
+      _tag__ match {
+        case 0 => _done__ = true
+        case 10 =>
+          __prefix = _root_.scala.Some(__prefix.fold(LiteParser.readMessage[dotty.tools.dotc.semanticdb.TypeMessage](_input__))(LiteParser.readMessage(_input__, _)))
+        case 18 =>
+          __symbol = _input__.readStringRequireUtf8()
+        case 26 =>
+          __typeArguments += dotty.tools.dotc.semanticdb.TypeRef._typemapper_typeArguments.toCustom(LiteParser.readMessage[dotty.tools.dotc.semanticdb.TypeMessage](_input__))
+        case tag => _input__.skipField(tag)
+      }
+    }
+    dotty.tools.dotc.semanticdb.TypeRef(
+        prefix = dotty.tools.dotc.semanticdb.TypeRef._typemapper_prefix.toCustom(__prefix.getOrElse(dotty.tools.dotc.semanticdb.TypeMessage.defaultInstance)),
+        symbol = __symbol,
+        typeArguments = __typeArguments.result()
+    )
+  }
+  
+  
+  
+  
+  
+  
+  lazy val defaultInstance = dotty.tools.dotc.semanticdb.TypeRef(
+    prefix = dotty.tools.dotc.semanticdb.TypeRef._typemapper_prefix.toCustom(dotty.tools.dotc.semanticdb.TypeMessage.defaultInstance),
+    symbol = "",
+    typeArguments = _root_.scala.Seq.empty
+  )
+  final val PREFIX_FIELD_NUMBER = 1
+  final val SYMBOL_FIELD_NUMBER = 2
+  final val TYPE_ARGUMENTS_FIELD_NUMBER = 3
+  @transient @sharable
+  private[semanticdb] val _typemapper_prefix: SemanticdbTypeMapper[dotty.tools.dotc.semanticdb.TypeMessage, dotty.tools.dotc.semanticdb.Type] = implicitly[SemanticdbTypeMapper[dotty.tools.dotc.semanticdb.TypeMessage, dotty.tools.dotc.semanticdb.Type]]
+  @transient @sharable
+  private[semanticdb] val _typemapper_typeArguments: SemanticdbTypeMapper[dotty.tools.dotc.semanticdb.TypeMessage, dotty.tools.dotc.semanticdb.Type] = implicitly[SemanticdbTypeMapper[dotty.tools.dotc.semanticdb.TypeMessage, dotty.tools.dotc.semanticdb.Type]]
+  def of(
+    prefix: dotty.tools.dotc.semanticdb.Type,
+    symbol: _root_.scala.Predef.String,
+    typeArguments: _root_.scala.Seq[dotty.tools.dotc.semanticdb.Type]
+  ): _root_.dotty.tools.dotc.semanticdb.TypeRef = _root_.dotty.tools.dotc.semanticdb.TypeRef(
+    prefix,
+    symbol,
+    typeArguments
+  )
+  // @@protoc_insertion_point(GeneratedMessageCompanion[dotty.tools.dotc.semanticdb.TypeRef])
+}
+
+@SerialVersionUID(0L)
+final case class SingleType(
+    prefix: dotty.tools.dotc.semanticdb.Type = dotty.tools.dotc.semanticdb.SingleType._typemapper_prefix.toCustom(dotty.tools.dotc.semanticdb.TypeMessage.defaultInstance),
+    symbol: _root_.scala.Predef.String = ""
+    )  extends dotty.tools.dotc.semanticdb.Type.NonEmpty with SemanticdbGeneratedMessage  derives CanEqual {
+    @transient @sharable
+    private[this] var __serializedSizeMemoized: _root_.scala.Int = 0
+    private[this] def __computeSerializedSize(): _root_.scala.Int = {
+      var __size = 0
+      
+      {
+        val __value = dotty.tools.dotc.semanticdb.SingleType._typemapper_prefix.toBase(prefix)
+        if (__value.serializedSize != 0) {
+          __size += 1 + SemanticdbOutputStream.computeUInt32SizeNoTag(__value.serializedSize) + __value.serializedSize
+        }
+      };
+      
+      {
+        val __value = symbol
+        if (!__value.isEmpty) {
+          __size += SemanticdbOutputStream.computeStringSize(2, __value)
+        }
+      };
+      __size
+    }
+    override def serializedSize: _root_.scala.Int = {
+      var __size = __serializedSizeMemoized
+      if (__size == 0) {
+        __size = __computeSerializedSize() + 1
+        __serializedSizeMemoized = __size
+      }
+      __size - 1
+      
+    }
+    def writeTo(`_output__`: SemanticdbOutputStream): _root_.scala.Unit = {
+      {
+        val __v = dotty.tools.dotc.semanticdb.SingleType._typemapper_prefix.toBase(prefix)
+        if (__v.serializedSize != 0) {
+          _output__.writeTag(1, 2)
+          _output__.writeUInt32NoTag(__v.serializedSize)
+          __v.writeTo(_output__)
+        }
+      };
+      {
+        val __v = symbol
+        if (!__v.isEmpty) {
+          _output__.writeString(2, __v)
+        }
+      };
+    }
+    def withPrefix(__v: dotty.tools.dotc.semanticdb.Type): SingleType = copy(prefix = __v)
+    def withSymbol(__v: _root_.scala.Predef.String): SingleType = copy(symbol = __v)
+    
+    
+    
+    
+    // @@protoc_insertion_point(GeneratedMessage[dotty.tools.dotc.semanticdb.SingleType])
+}
+
+object SingleType  extends SemanticdbGeneratedMessageCompanion[dotty.tools.dotc.semanticdb.SingleType] {
+  implicit def messageCompanion: SemanticdbGeneratedMessageCompanion[dotty.tools.dotc.semanticdb.SingleType] = this
+  def parseFrom(`_input__`: SemanticdbInputStream): dotty.tools.dotc.semanticdb.SingleType = {
+    var __prefix: _root_.scala.Option[dotty.tools.dotc.semanticdb.TypeMessage] = _root_.scala.None
+    var __symbol: _root_.scala.Predef.String = ""
+    var _done__ = false
+    while (!_done__) {
+      val _tag__ = _input__.readTag()
+      _tag__ match {
+        case 0 => _done__ = true
+        case 10 =>
+          __prefix = _root_.scala.Some(__prefix.fold(LiteParser.readMessage[dotty.tools.dotc.semanticdb.TypeMessage](_input__))(LiteParser.readMessage(_input__, _)))
+        case 18 =>
+          __symbol = _input__.readStringRequireUtf8()
+        case tag => _input__.skipField(tag)
+      }
+    }
+    dotty.tools.dotc.semanticdb.SingleType(
+        prefix = dotty.tools.dotc.semanticdb.SingleType._typemapper_prefix.toCustom(__prefix.getOrElse(dotty.tools.dotc.semanticdb.TypeMessage.defaultInstance)),
+        symbol = __symbol
+    )
+  }
+  
+  
+  
+  
+  
+  
+  lazy val defaultInstance = dotty.tools.dotc.semanticdb.SingleType(
+    prefix = dotty.tools.dotc.semanticdb.SingleType._typemapper_prefix.toCustom(dotty.tools.dotc.semanticdb.TypeMessage.defaultInstance),
+    symbol = ""
+  )
+  final val PREFIX_FIELD_NUMBER = 1
+  final val SYMBOL_FIELD_NUMBER = 2
+  @transient @sharable
+  private[semanticdb] val _typemapper_prefix: SemanticdbTypeMapper[dotty.tools.dotc.semanticdb.TypeMessage, dotty.tools.dotc.semanticdb.Type] = implicitly[SemanticdbTypeMapper[dotty.tools.dotc.semanticdb.TypeMessage, dotty.tools.dotc.semanticdb.Type]]
+  def of(
+    prefix: dotty.tools.dotc.semanticdb.Type,
+    symbol: _root_.scala.Predef.String
+  ): _root_.dotty.tools.dotc.semanticdb.SingleType = _root_.dotty.tools.dotc.semanticdb.SingleType(
+    prefix,
+    symbol
+  )
+  // @@protoc_insertion_point(GeneratedMessageCompanion[dotty.tools.dotc.semanticdb.SingleType])
+}
+
+@SerialVersionUID(0L)
+final case class ThisType(
+    symbol: _root_.scala.Predef.String = ""
+    )  extends dotty.tools.dotc.semanticdb.Type.NonEmpty with SemanticdbGeneratedMessage  derives CanEqual {
+    @transient @sharable
+    private[this] var __serializedSizeMemoized: _root_.scala.Int = 0
+    private[this] def __computeSerializedSize(): _root_.scala.Int = {
+      var __size = 0
+      
+      {
+        val __value = symbol
+        if (!__value.isEmpty) {
+          __size += SemanticdbOutputStream.computeStringSize(1, __value)
+        }
+      };
+      __size
+    }
+    override def serializedSize: _root_.scala.Int = {
+      var __size = __serializedSizeMemoized
+      if (__size == 0) {
+        __size = __computeSerializedSize() + 1
+        __serializedSizeMemoized = __size
+      }
+      __size - 1
+      
+    }
+    def writeTo(`_output__`: SemanticdbOutputStream): _root_.scala.Unit = {
+      {
+        val __v = symbol
+        if (!__v.isEmpty) {
+          _output__.writeString(1, __v)
+        }
+      };
+    }
+    def withSymbol(__v: _root_.scala.Predef.String): ThisType = copy(symbol = __v)
+    
+    
+    
+    
+    // @@protoc_insertion_point(GeneratedMessage[dotty.tools.dotc.semanticdb.ThisType])
+}
+
+object ThisType  extends SemanticdbGeneratedMessageCompanion[dotty.tools.dotc.semanticdb.ThisType] {
+  implicit def messageCompanion: SemanticdbGeneratedMessageCompanion[dotty.tools.dotc.semanticdb.ThisType] = this
+  def parseFrom(`_input__`: SemanticdbInputStream): dotty.tools.dotc.semanticdb.ThisType = {
+    var __symbol: _root_.scala.Predef.String = ""
+    var _done__ = false
+    while (!_done__) {
+      val _tag__ = _input__.readTag()
+      _tag__ match {
+        case 0 => _done__ = true
+        case 10 =>
+          __symbol = _input__.readStringRequireUtf8()
+        case tag => _input__.skipField(tag)
+      }
+    }
+    dotty.tools.dotc.semanticdb.ThisType(
+        symbol = __symbol
+    )
+  }
+  
+  
+  
+  
+  
+  
+  lazy val defaultInstance = dotty.tools.dotc.semanticdb.ThisType(
+    symbol = ""
+  )
+  final val SYMBOL_FIELD_NUMBER = 1
+  def of(
+    symbol: _root_.scala.Predef.String
+  ): _root_.dotty.tools.dotc.semanticdb.ThisType = _root_.dotty.tools.dotc.semanticdb.ThisType(
+    symbol
+  )
+  // @@protoc_insertion_point(GeneratedMessageCompanion[dotty.tools.dotc.semanticdb.ThisType])
+}
+
+@SerialVersionUID(0L)
+final case class SuperType(
+    prefix: dotty.tools.dotc.semanticdb.Type = dotty.tools.dotc.semanticdb.SuperType._typemapper_prefix.toCustom(dotty.tools.dotc.semanticdb.TypeMessage.defaultInstance),
+    symbol: _root_.scala.Predef.String = ""
+    )  extends dotty.tools.dotc.semanticdb.Type.NonEmpty with SemanticdbGeneratedMessage  derives CanEqual {
+    @transient @sharable
+    private[this] var __serializedSizeMemoized: _root_.scala.Int = 0
+    private[this] def __computeSerializedSize(): _root_.scala.Int = {
+      var __size = 0
+      
+      {
+        val __value = dotty.tools.dotc.semanticdb.SuperType._typemapper_prefix.toBase(prefix)
+        if (__value.serializedSize != 0) {
+          __size += 1 + SemanticdbOutputStream.computeUInt32SizeNoTag(__value.serializedSize) + __value.serializedSize
+        }
+      };
+      
+      {
+        val __value = symbol
+        if (!__value.isEmpty) {
+          __size += SemanticdbOutputStream.computeStringSize(2, __value)
+        }
+      };
+      __size
+    }
+    override def serializedSize: _root_.scala.Int = {
+      var __size = __serializedSizeMemoized
+      if (__size == 0) {
+        __size = __computeSerializedSize() + 1
+        __serializedSizeMemoized = __size
+      }
+      __size - 1
+      
+    }
+    def writeTo(`_output__`: SemanticdbOutputStream): _root_.scala.Unit = {
+      {
+        val __v = dotty.tools.dotc.semanticdb.SuperType._typemapper_prefix.toBase(prefix)
+        if (__v.serializedSize != 0) {
+          _output__.writeTag(1, 2)
+          _output__.writeUInt32NoTag(__v.serializedSize)
+          __v.writeTo(_output__)
+        }
+      };
+      {
+        val __v = symbol
+        if (!__v.isEmpty) {
+          _output__.writeString(2, __v)
+        }
+      };
+    }
+    def withPrefix(__v: dotty.tools.dotc.semanticdb.Type): SuperType = copy(prefix = __v)
+    def withSymbol(__v: _root_.scala.Predef.String): SuperType = copy(symbol = __v)
+    
+    
+    
+    
+    // @@protoc_insertion_point(GeneratedMessage[dotty.tools.dotc.semanticdb.SuperType])
+}
+
+object SuperType  extends SemanticdbGeneratedMessageCompanion[dotty.tools.dotc.semanticdb.SuperType] {
+  implicit def messageCompanion: SemanticdbGeneratedMessageCompanion[dotty.tools.dotc.semanticdb.SuperType] = this
+  def parseFrom(`_input__`: SemanticdbInputStream): dotty.tools.dotc.semanticdb.SuperType = {
+    var __prefix: _root_.scala.Option[dotty.tools.dotc.semanticdb.TypeMessage] = _root_.scala.None
+    var __symbol: _root_.scala.Predef.String = ""
+    var _done__ = false
+    while (!_done__) {
+      val _tag__ = _input__.readTag()
+      _tag__ match {
+        case 0 => _done__ = true
+        case 10 =>
+          __prefix = _root_.scala.Some(__prefix.fold(LiteParser.readMessage[dotty.tools.dotc.semanticdb.TypeMessage](_input__))(LiteParser.readMessage(_input__, _)))
+        case 18 =>
+          __symbol = _input__.readStringRequireUtf8()
+        case tag => _input__.skipField(tag)
+      }
+    }
+    dotty.tools.dotc.semanticdb.SuperType(
+        prefix = dotty.tools.dotc.semanticdb.SuperType._typemapper_prefix.toCustom(__prefix.getOrElse(dotty.tools.dotc.semanticdb.TypeMessage.defaultInstance)),
+        symbol = __symbol
+    )
+  }
+  
+  
+  
+  
+  
+  
+  lazy val defaultInstance = dotty.tools.dotc.semanticdb.SuperType(
+    prefix = dotty.tools.dotc.semanticdb.SuperType._typemapper_prefix.toCustom(dotty.tools.dotc.semanticdb.TypeMessage.defaultInstance),
+    symbol = ""
+  )
+  final val PREFIX_FIELD_NUMBER = 1
+  final val SYMBOL_FIELD_NUMBER = 2
+  @transient @sharable
+  private[semanticdb] val _typemapper_prefix: SemanticdbTypeMapper[dotty.tools.dotc.semanticdb.TypeMessage, dotty.tools.dotc.semanticdb.Type] = implicitly[SemanticdbTypeMapper[dotty.tools.dotc.semanticdb.TypeMessage, dotty.tools.dotc.semanticdb.Type]]
+  def of(
+    prefix: dotty.tools.dotc.semanticdb.Type,
+    symbol: _root_.scala.Predef.String
+  ): _root_.dotty.tools.dotc.semanticdb.SuperType = _root_.dotty.tools.dotc.semanticdb.SuperType(
+    prefix,
+    symbol
+  )
+  // @@protoc_insertion_point(GeneratedMessageCompanion[dotty.tools.dotc.semanticdb.SuperType])
+}
+
+@SerialVersionUID(0L)
+final case class ConstantType(
+    constant: dotty.tools.dotc.semanticdb.Constant = dotty.tools.dotc.semanticdb.ConstantType._typemapper_constant.toCustom(dotty.tools.dotc.semanticdb.ConstantMessage.defaultInstance)
+    )  extends dotty.tools.dotc.semanticdb.Type.NonEmpty with SemanticdbGeneratedMessage  derives CanEqual {
+    @transient @sharable
+    private[this] var __serializedSizeMemoized: _root_.scala.Int = 0
+    private[this] def __computeSerializedSize(): _root_.scala.Int = {
+      var __size = 0
+      
+      {
+        val __value = dotty.tools.dotc.semanticdb.ConstantType._typemapper_constant.toBase(constant)
+        if (__value.serializedSize != 0) {
+          __size += 1 + SemanticdbOutputStream.computeUInt32SizeNoTag(__value.serializedSize) + __value.serializedSize
+        }
+      };
+      __size
+    }
+    override def serializedSize: _root_.scala.Int = {
+      var __size = __serializedSizeMemoized
+      if (__size == 0) {
+        __size = __computeSerializedSize() + 1
+        __serializedSizeMemoized = __size
+      }
+      __size - 1
+      
+    }
+    def writeTo(`_output__`: SemanticdbOutputStream): _root_.scala.Unit = {
+      {
+        val __v = dotty.tools.dotc.semanticdb.ConstantType._typemapper_constant.toBase(constant)
+        if (__v.serializedSize != 0) {
+          _output__.writeTag(1, 2)
+          _output__.writeUInt32NoTag(__v.serializedSize)
+          __v.writeTo(_output__)
+        }
+      };
+    }
+    def withConstant(__v: dotty.tools.dotc.semanticdb.Constant): ConstantType = copy(constant = __v)
+    
+    
+    
+    
+    // @@protoc_insertion_point(GeneratedMessage[dotty.tools.dotc.semanticdb.ConstantType])
+}
+
+object ConstantType  extends SemanticdbGeneratedMessageCompanion[dotty.tools.dotc.semanticdb.ConstantType] {
+  implicit def messageCompanion: SemanticdbGeneratedMessageCompanion[dotty.tools.dotc.semanticdb.ConstantType] = this
+  def parseFrom(`_input__`: SemanticdbInputStream): dotty.tools.dotc.semanticdb.ConstantType = {
+    var __constant: _root_.scala.Option[dotty.tools.dotc.semanticdb.ConstantMessage] = _root_.scala.None
+    var _done__ = false
+    while (!_done__) {
+      val _tag__ = _input__.readTag()
+      _tag__ match {
+        case 0 => _done__ = true
+        case 10 =>
+          __constant = _root_.scala.Some(__constant.fold(LiteParser.readMessage[dotty.tools.dotc.semanticdb.ConstantMessage](_input__))(LiteParser.readMessage(_input__, _)))
+        case tag => _input__.skipField(tag)
+      }
+    }
+    dotty.tools.dotc.semanticdb.ConstantType(
+        constant = dotty.tools.dotc.semanticdb.ConstantType._typemapper_constant.toCustom(__constant.getOrElse(dotty.tools.dotc.semanticdb.ConstantMessage.defaultInstance))
+    )
+  }
+  
+  
+  
+  
+  
+  
+  lazy val defaultInstance = dotty.tools.dotc.semanticdb.ConstantType(
+    constant = dotty.tools.dotc.semanticdb.ConstantType._typemapper_constant.toCustom(dotty.tools.dotc.semanticdb.ConstantMessage.defaultInstance)
+  )
+  final val CONSTANT_FIELD_NUMBER = 1
+  @transient @sharable
+  private[semanticdb] val _typemapper_constant: SemanticdbTypeMapper[dotty.tools.dotc.semanticdb.ConstantMessage, dotty.tools.dotc.semanticdb.Constant] = implicitly[SemanticdbTypeMapper[dotty.tools.dotc.semanticdb.ConstantMessage, dotty.tools.dotc.semanticdb.Constant]]
+  def of(
+    constant: dotty.tools.dotc.semanticdb.Constant
+  ): _root_.dotty.tools.dotc.semanticdb.ConstantType = _root_.dotty.tools.dotc.semanticdb.ConstantType(
+    constant
+  )
+  // @@protoc_insertion_point(GeneratedMessageCompanion[dotty.tools.dotc.semanticdb.ConstantType])
+}
+
+@SerialVersionUID(0L)
+final case class IntersectionType(
+    types: _root_.scala.Seq[dotty.tools.dotc.semanticdb.Type] = _root_.scala.Seq.empty
+    )  extends dotty.tools.dotc.semanticdb.Type.NonEmpty with SemanticdbGeneratedMessage  derives CanEqual {
+    @transient @sharable
+    private[this] var __serializedSizeMemoized: _root_.scala.Int = 0
+    private[this] def __computeSerializedSize(): _root_.scala.Int = {
+      var __size = 0
+      types.foreach { __item =>
+        val __value = dotty.tools.dotc.semanticdb.IntersectionType._typemapper_types.toBase(__item)
+        __size += 1 + SemanticdbOutputStream.computeUInt32SizeNoTag(__value.serializedSize) + __value.serializedSize
+      }
+      __size
+    }
+    override def serializedSize: _root_.scala.Int = {
+      var __size = __serializedSizeMemoized
+      if (__size == 0) {
+        __size = __computeSerializedSize() + 1
+        __serializedSizeMemoized = __size
+      }
+      __size - 1
+      
+    }
+    def writeTo(`_output__`: SemanticdbOutputStream): _root_.scala.Unit = {
+      types.foreach { __v =>
+        val __m = dotty.tools.dotc.semanticdb.IntersectionType._typemapper_types.toBase(__v)
+        _output__.writeTag(1, 2)
+        _output__.writeUInt32NoTag(__m.serializedSize)
+        __m.writeTo(_output__)
+      };
+    }
+    def clearTypes = copy(types = _root_.scala.Seq.empty)
+    def addTypes(__vs: dotty.tools.dotc.semanticdb.Type *): IntersectionType = addAllTypes(__vs)
+    def addAllTypes(__vs: Iterable[dotty.tools.dotc.semanticdb.Type]): IntersectionType = copy(types = types ++ __vs)
+    def withTypes(__v: _root_.scala.Seq[dotty.tools.dotc.semanticdb.Type]): IntersectionType = copy(types = __v)
+    
+    
+    
+    
+    // @@protoc_insertion_point(GeneratedMessage[dotty.tools.dotc.semanticdb.IntersectionType])
+}
+
+object IntersectionType  extends SemanticdbGeneratedMessageCompanion[dotty.tools.dotc.semanticdb.IntersectionType] {
+  implicit def messageCompanion: SemanticdbGeneratedMessageCompanion[dotty.tools.dotc.semanticdb.IntersectionType] = this
+  def parseFrom(`_input__`: SemanticdbInputStream): dotty.tools.dotc.semanticdb.IntersectionType = {
+    val __types: _root_.scala.collection.immutable.VectorBuilder[dotty.tools.dotc.semanticdb.Type] = new _root_.scala.collection.immutable.VectorBuilder[dotty.tools.dotc.semanticdb.Type]
+    var _done__ = false
+    while (!_done__) {
+      val _tag__ = _input__.readTag()
+      _tag__ match {
+        case 0 => _done__ = true
+        case 10 =>
+          __types += dotty.tools.dotc.semanticdb.IntersectionType._typemapper_types.toCustom(LiteParser.readMessage[dotty.tools.dotc.semanticdb.TypeMessage](_input__))
+        case tag => _input__.skipField(tag)
+      }
+    }
+    dotty.tools.dotc.semanticdb.IntersectionType(
+        types = __types.result()
+    )
+  }
+  
+  
+  
+  
+  
+  
+  lazy val defaultInstance = dotty.tools.dotc.semanticdb.IntersectionType(
+    types = _root_.scala.Seq.empty
+  )
+  final val TYPES_FIELD_NUMBER = 1
+  @transient @sharable
+  private[semanticdb] val _typemapper_types: SemanticdbTypeMapper[dotty.tools.dotc.semanticdb.TypeMessage, dotty.tools.dotc.semanticdb.Type] = implicitly[SemanticdbTypeMapper[dotty.tools.dotc.semanticdb.TypeMessage, dotty.tools.dotc.semanticdb.Type]]
+  def of(
+    types: _root_.scala.Seq[dotty.tools.dotc.semanticdb.Type]
+  ): _root_.dotty.tools.dotc.semanticdb.IntersectionType = _root_.dotty.tools.dotc.semanticdb.IntersectionType(
+    types
+  )
+  // @@protoc_insertion_point(GeneratedMessageCompanion[dotty.tools.dotc.semanticdb.IntersectionType])
+}
+
+@SerialVersionUID(0L)
+final case class UnionType(
+    types: _root_.scala.Seq[dotty.tools.dotc.semanticdb.Type] = _root_.scala.Seq.empty
+    )  extends dotty.tools.dotc.semanticdb.Type.NonEmpty with SemanticdbGeneratedMessage  derives CanEqual {
+    @transient @sharable
+    private[this] var __serializedSizeMemoized: _root_.scala.Int = 0
+    private[this] def __computeSerializedSize(): _root_.scala.Int = {
+      var __size = 0
+      types.foreach { __item =>
+        val __value = dotty.tools.dotc.semanticdb.UnionType._typemapper_types.toBase(__item)
+        __size += 1 + SemanticdbOutputStream.computeUInt32SizeNoTag(__value.serializedSize) + __value.serializedSize
+      }
+      __size
+    }
+    override def serializedSize: _root_.scala.Int = {
+      var __size = __serializedSizeMemoized
+      if (__size == 0) {
+        __size = __computeSerializedSize() + 1
+        __serializedSizeMemoized = __size
+      }
+      __size - 1
+      
+    }
+    def writeTo(`_output__`: SemanticdbOutputStream): _root_.scala.Unit = {
+      types.foreach { __v =>
+        val __m = dotty.tools.dotc.semanticdb.UnionType._typemapper_types.toBase(__v)
+        _output__.writeTag(1, 2)
+        _output__.writeUInt32NoTag(__m.serializedSize)
+        __m.writeTo(_output__)
+      };
+    }
+    def clearTypes = copy(types = _root_.scala.Seq.empty)
+    def addTypes(__vs: dotty.tools.dotc.semanticdb.Type *): UnionType = addAllTypes(__vs)
+    def addAllTypes(__vs: Iterable[dotty.tools.dotc.semanticdb.Type]): UnionType = copy(types = types ++ __vs)
+    def withTypes(__v: _root_.scala.Seq[dotty.tools.dotc.semanticdb.Type]): UnionType = copy(types = __v)
+    
+    
+    
+    
+    // @@protoc_insertion_point(GeneratedMessage[dotty.tools.dotc.semanticdb.UnionType])
+}
+
+object UnionType  extends SemanticdbGeneratedMessageCompanion[dotty.tools.dotc.semanticdb.UnionType] {
+  implicit def messageCompanion: SemanticdbGeneratedMessageCompanion[dotty.tools.dotc.semanticdb.UnionType] = this
+  def parseFrom(`_input__`: SemanticdbInputStream): dotty.tools.dotc.semanticdb.UnionType = {
+    val __types: _root_.scala.collection.immutable.VectorBuilder[dotty.tools.dotc.semanticdb.Type] = new _root_.scala.collection.immutable.VectorBuilder[dotty.tools.dotc.semanticdb.Type]
+    var _done__ = false
+    while (!_done__) {
+      val _tag__ = _input__.readTag()
+      _tag__ match {
+        case 0 => _done__ = true
+        case 10 =>
+          __types += dotty.tools.dotc.semanticdb.UnionType._typemapper_types.toCustom(LiteParser.readMessage[dotty.tools.dotc.semanticdb.TypeMessage](_input__))
+        case tag => _input__.skipField(tag)
+      }
+    }
+    dotty.tools.dotc.semanticdb.UnionType(
+        types = __types.result()
+    )
+  }
+  
+  
+  
+  
+  
+  
+  lazy val defaultInstance = dotty.tools.dotc.semanticdb.UnionType(
+    types = _root_.scala.Seq.empty
+  )
+  final val TYPES_FIELD_NUMBER = 1
+  @transient @sharable
+  private[semanticdb] val _typemapper_types: SemanticdbTypeMapper[dotty.tools.dotc.semanticdb.TypeMessage, dotty.tools.dotc.semanticdb.Type] = implicitly[SemanticdbTypeMapper[dotty.tools.dotc.semanticdb.TypeMessage, dotty.tools.dotc.semanticdb.Type]]
+  def of(
+    types: _root_.scala.Seq[dotty.tools.dotc.semanticdb.Type]
+  ): _root_.dotty.tools.dotc.semanticdb.UnionType = _root_.dotty.tools.dotc.semanticdb.UnionType(
+    types
+  )
+  // @@protoc_insertion_point(GeneratedMessageCompanion[dotty.tools.dotc.semanticdb.UnionType])
+}
+
+@SerialVersionUID(0L)
+final case class WithType(
+    types: _root_.scala.Seq[dotty.tools.dotc.semanticdb.Type] = _root_.scala.Seq.empty
+    )  extends dotty.tools.dotc.semanticdb.Type.NonEmpty with SemanticdbGeneratedMessage  derives CanEqual {
+    @transient @sharable
+    private[this] var __serializedSizeMemoized: _root_.scala.Int = 0
+    private[this] def __computeSerializedSize(): _root_.scala.Int = {
+      var __size = 0
+      types.foreach { __item =>
+        val __value = dotty.tools.dotc.semanticdb.WithType._typemapper_types.toBase(__item)
+        __size += 1 + SemanticdbOutputStream.computeUInt32SizeNoTag(__value.serializedSize) + __value.serializedSize
+      }
+      __size
+    }
+    override def serializedSize: _root_.scala.Int = {
+      var __size = __serializedSizeMemoized
+      if (__size == 0) {
+        __size = __computeSerializedSize() + 1
+        __serializedSizeMemoized = __size
+      }
+      __size - 1
+      
+    }
+    def writeTo(`_output__`: SemanticdbOutputStream): _root_.scala.Unit = {
+      types.foreach { __v =>
+        val __m = dotty.tools.dotc.semanticdb.WithType._typemapper_types.toBase(__v)
+        _output__.writeTag(1, 2)
+        _output__.writeUInt32NoTag(__m.serializedSize)
+        __m.writeTo(_output__)
+      };
+    }
+    def clearTypes = copy(types = _root_.scala.Seq.empty)
+    def addTypes(__vs: dotty.tools.dotc.semanticdb.Type *): WithType = addAllTypes(__vs)
+    def addAllTypes(__vs: Iterable[dotty.tools.dotc.semanticdb.Type]): WithType = copy(types = types ++ __vs)
+    def withTypes(__v: _root_.scala.Seq[dotty.tools.dotc.semanticdb.Type]): WithType = copy(types = __v)
+    
+    
+    
+    
+    // @@protoc_insertion_point(GeneratedMessage[dotty.tools.dotc.semanticdb.WithType])
+}
+
+object WithType  extends SemanticdbGeneratedMessageCompanion[dotty.tools.dotc.semanticdb.WithType] {
+  implicit def messageCompanion: SemanticdbGeneratedMessageCompanion[dotty.tools.dotc.semanticdb.WithType] = this
+  def parseFrom(`_input__`: SemanticdbInputStream): dotty.tools.dotc.semanticdb.WithType = {
+    val __types: _root_.scala.collection.immutable.VectorBuilder[dotty.tools.dotc.semanticdb.Type] = new _root_.scala.collection.immutable.VectorBuilder[dotty.tools.dotc.semanticdb.Type]
+    var _done__ = false
+    while (!_done__) {
+      val _tag__ = _input__.readTag()
+      _tag__ match {
+        case 0 => _done__ = true
+        case 10 =>
+          __types += dotty.tools.dotc.semanticdb.WithType._typemapper_types.toCustom(LiteParser.readMessage[dotty.tools.dotc.semanticdb.TypeMessage](_input__))
+        case tag => _input__.skipField(tag)
+      }
+    }
+    dotty.tools.dotc.semanticdb.WithType(
+        types = __types.result()
+    )
+  }
+  
+  
+  
+  
+  
+  
+  lazy val defaultInstance = dotty.tools.dotc.semanticdb.WithType(
+    types = _root_.scala.Seq.empty
+  )
+  final val TYPES_FIELD_NUMBER = 1
+  @transient @sharable
+  private[semanticdb] val _typemapper_types: SemanticdbTypeMapper[dotty.tools.dotc.semanticdb.TypeMessage, dotty.tools.dotc.semanticdb.Type] = implicitly[SemanticdbTypeMapper[dotty.tools.dotc.semanticdb.TypeMessage, dotty.tools.dotc.semanticdb.Type]]
+  def of(
+    types: _root_.scala.Seq[dotty.tools.dotc.semanticdb.Type]
+  ): _root_.dotty.tools.dotc.semanticdb.WithType = _root_.dotty.tools.dotc.semanticdb.WithType(
+    types
+  )
+  // @@protoc_insertion_point(GeneratedMessageCompanion[dotty.tools.dotc.semanticdb.WithType])
+}
+
+@SerialVersionUID(0L)
+final case class StructuralType(
+    tpe: dotty.tools.dotc.semanticdb.Type = dotty.tools.dotc.semanticdb.StructuralType._typemapper_tpe.toCustom(dotty.tools.dotc.semanticdb.TypeMessage.defaultInstance),
+    declarations: _root_.scala.Option[dotty.tools.dotc.semanticdb.Scope] = _root_.scala.None
+    )  extends dotty.tools.dotc.semanticdb.Type.NonEmpty with SemanticdbGeneratedMessage  derives CanEqual {
+    @transient @sharable
+    private[this] var __serializedSizeMemoized: _root_.scala.Int = 0
+    private[this] def __computeSerializedSize(): _root_.scala.Int = {
+      var __size = 0
+      
+      {
+        val __value = dotty.tools.dotc.semanticdb.StructuralType._typemapper_tpe.toBase(tpe)
+        if (__value.serializedSize != 0) {
+          __size += 1 + SemanticdbOutputStream.computeUInt32SizeNoTag(__value.serializedSize) + __value.serializedSize
+        }
+      };
+      if (declarations.isDefined) {
+        val __value = declarations.get
+        __size += 1 + SemanticdbOutputStream.computeUInt32SizeNoTag(__value.serializedSize) + __value.serializedSize
+      };
+      __size
+    }
+    override def serializedSize: _root_.scala.Int = {
+      var __size = __serializedSizeMemoized
+      if (__size == 0) {
+        __size = __computeSerializedSize() + 1
+        __serializedSizeMemoized = __size
+      }
+      __size - 1
+      
+    }
+    def writeTo(`_output__`: SemanticdbOutputStream): _root_.scala.Unit = {
+      {
+        val __v = dotty.tools.dotc.semanticdb.StructuralType._typemapper_tpe.toBase(tpe)
+        if (__v.serializedSize != 0) {
+          _output__.writeTag(4, 2)
+          _output__.writeUInt32NoTag(__v.serializedSize)
+          __v.writeTo(_output__)
+        }
+      };
+      declarations.foreach { __v =>
+        val __m = __v
+        _output__.writeTag(5, 2)
+        _output__.writeUInt32NoTag(__m.serializedSize)
+        __m.writeTo(_output__)
+      };
+    }
+    def withTpe(__v: dotty.tools.dotc.semanticdb.Type): StructuralType = copy(tpe = __v)
+    def getDeclarations: dotty.tools.dotc.semanticdb.Scope = declarations.getOrElse(dotty.tools.dotc.semanticdb.Scope.defaultInstance)
+    def clearDeclarations: StructuralType = copy(declarations = _root_.scala.None)
+    def withDeclarations(__v: dotty.tools.dotc.semanticdb.Scope): StructuralType = copy(declarations = Option(__v))
+    
+    
+    
+    
+    // @@protoc_insertion_point(GeneratedMessage[dotty.tools.dotc.semanticdb.StructuralType])
+}
+
+object StructuralType  extends SemanticdbGeneratedMessageCompanion[dotty.tools.dotc.semanticdb.StructuralType] {
+  implicit def messageCompanion: SemanticdbGeneratedMessageCompanion[dotty.tools.dotc.semanticdb.StructuralType] = this
+  def parseFrom(`_input__`: SemanticdbInputStream): dotty.tools.dotc.semanticdb.StructuralType = {
+    var __tpe: _root_.scala.Option[dotty.tools.dotc.semanticdb.TypeMessage] = _root_.scala.None
+    var __declarations: _root_.scala.Option[dotty.tools.dotc.semanticdb.Scope] = _root_.scala.None
+    var _done__ = false
+    while (!_done__) {
+      val _tag__ = _input__.readTag()
+      _tag__ match {
+        case 0 => _done__ = true
+        case 34 =>
+          __tpe = _root_.scala.Some(__tpe.fold(LiteParser.readMessage[dotty.tools.dotc.semanticdb.TypeMessage](_input__))(LiteParser.readMessage(_input__, _)))
+        case 42 =>
+          __declarations = Option(__declarations.fold(LiteParser.readMessage[dotty.tools.dotc.semanticdb.Scope](_input__))(LiteParser.readMessage(_input__, _)))
+        case tag => _input__.skipField(tag)
+      }
+    }
+    dotty.tools.dotc.semanticdb.StructuralType(
+        tpe = dotty.tools.dotc.semanticdb.StructuralType._typemapper_tpe.toCustom(__tpe.getOrElse(dotty.tools.dotc.semanticdb.TypeMessage.defaultInstance)),
+        declarations = __declarations
+    )
+  }
+  
+  
+  
+  
+  
+  
+  lazy val defaultInstance = dotty.tools.dotc.semanticdb.StructuralType(
+    tpe = dotty.tools.dotc.semanticdb.StructuralType._typemapper_tpe.toCustom(dotty.tools.dotc.semanticdb.TypeMessage.defaultInstance),
+    declarations = _root_.scala.None
+  )
+  final val TPE_FIELD_NUMBER = 4
+  final val DECLARATIONS_FIELD_NUMBER = 5
+  @transient @sharable
+  private[semanticdb] val _typemapper_tpe: SemanticdbTypeMapper[dotty.tools.dotc.semanticdb.TypeMessage, dotty.tools.dotc.semanticdb.Type] = implicitly[SemanticdbTypeMapper[dotty.tools.dotc.semanticdb.TypeMessage, dotty.tools.dotc.semanticdb.Type]]
+  def of(
+    tpe: dotty.tools.dotc.semanticdb.Type,
+    declarations: _root_.scala.Option[dotty.tools.dotc.semanticdb.Scope]
+  ): _root_.dotty.tools.dotc.semanticdb.StructuralType = _root_.dotty.tools.dotc.semanticdb.StructuralType(
+    tpe,
+    declarations
+  )
+  // @@protoc_insertion_point(GeneratedMessageCompanion[dotty.tools.dotc.semanticdb.StructuralType])
+}
+
+@SerialVersionUID(0L)
+final case class AnnotatedType(
+    annotations: _root_.scala.Seq[dotty.tools.dotc.semanticdb.Annotation] = _root_.scala.Seq.empty,
+    tpe: dotty.tools.dotc.semanticdb.Type = dotty.tools.dotc.semanticdb.AnnotatedType._typemapper_tpe.toCustom(dotty.tools.dotc.semanticdb.TypeMessage.defaultInstance)
+    )  extends dotty.tools.dotc.semanticdb.Type.NonEmpty with SemanticdbGeneratedMessage  derives CanEqual {
+    @transient @sharable
+    private[this] var __serializedSizeMemoized: _root_.scala.Int = 0
+    private[this] def __computeSerializedSize(): _root_.scala.Int = {
+      var __size = 0
+      annotations.foreach { __item =>
+        val __value = __item
+        __size += 1 + SemanticdbOutputStream.computeUInt32SizeNoTag(__value.serializedSize) + __value.serializedSize
+      }
+      
+      {
+        val __value = dotty.tools.dotc.semanticdb.AnnotatedType._typemapper_tpe.toBase(tpe)
+        if (__value.serializedSize != 0) {
+          __size += 1 + SemanticdbOutputStream.computeUInt32SizeNoTag(__value.serializedSize) + __value.serializedSize
+        }
+      };
+      __size
+    }
+    override def serializedSize: _root_.scala.Int = {
+      var __size = __serializedSizeMemoized
+      if (__size == 0) {
+        __size = __computeSerializedSize() + 1
+        __serializedSizeMemoized = __size
+      }
+      __size - 1
+      
+    }
+    def writeTo(`_output__`: SemanticdbOutputStream): _root_.scala.Unit = {
+      {
+        val __v = dotty.tools.dotc.semanticdb.AnnotatedType._typemapper_tpe.toBase(tpe)
+        if (__v.serializedSize != 0) {
+          _output__.writeTag(1, 2)
+          _output__.writeUInt32NoTag(__v.serializedSize)
+          __v.writeTo(_output__)
+        }
+      };
+      annotations.foreach { __v =>
+        val __m = __v
+        _output__.writeTag(3, 2)
+        _output__.writeUInt32NoTag(__m.serializedSize)
+        __m.writeTo(_output__)
+      };
+    }
+    def clearAnnotations = copy(annotations = _root_.scala.Seq.empty)
+    def addAnnotations(__vs: dotty.tools.dotc.semanticdb.Annotation *): AnnotatedType = addAllAnnotations(__vs)
+    def addAllAnnotations(__vs: Iterable[dotty.tools.dotc.semanticdb.Annotation]): AnnotatedType = copy(annotations = annotations ++ __vs)
+    def withAnnotations(__v: _root_.scala.Seq[dotty.tools.dotc.semanticdb.Annotation]): AnnotatedType = copy(annotations = __v)
+    def withTpe(__v: dotty.tools.dotc.semanticdb.Type): AnnotatedType = copy(tpe = __v)
+    
+    
+    
+    
+    // @@protoc_insertion_point(GeneratedMessage[dotty.tools.dotc.semanticdb.AnnotatedType])
+}
+
+object AnnotatedType  extends SemanticdbGeneratedMessageCompanion[dotty.tools.dotc.semanticdb.AnnotatedType] {
+  implicit def messageCompanion: SemanticdbGeneratedMessageCompanion[dotty.tools.dotc.semanticdb.AnnotatedType] = this
+  def parseFrom(`_input__`: SemanticdbInputStream): dotty.tools.dotc.semanticdb.AnnotatedType = {
+    val __annotations: _root_.scala.collection.immutable.VectorBuilder[dotty.tools.dotc.semanticdb.Annotation] = new _root_.scala.collection.immutable.VectorBuilder[dotty.tools.dotc.semanticdb.Annotation]
+    var __tpe: _root_.scala.Option[dotty.tools.dotc.semanticdb.TypeMessage] = _root_.scala.None
+    var _done__ = false
+    while (!_done__) {
+      val _tag__ = _input__.readTag()
+      _tag__ match {
+        case 0 => _done__ = true
+        case 26 =>
+          __annotations += LiteParser.readMessage[dotty.tools.dotc.semanticdb.Annotation](_input__)
+        case 10 =>
+          __tpe = _root_.scala.Some(__tpe.fold(LiteParser.readMessage[dotty.tools.dotc.semanticdb.TypeMessage](_input__))(LiteParser.readMessage(_input__, _)))
+        case tag => _input__.skipField(tag)
+      }
+    }
+    dotty.tools.dotc.semanticdb.AnnotatedType(
+        annotations = __annotations.result(),
+        tpe = dotty.tools.dotc.semanticdb.AnnotatedType._typemapper_tpe.toCustom(__tpe.getOrElse(dotty.tools.dotc.semanticdb.TypeMessage.defaultInstance))
+    )
+  }
+  
+  
+  
+  
+  
+  
+  lazy val defaultInstance = dotty.tools.dotc.semanticdb.AnnotatedType(
+    annotations = _root_.scala.Seq.empty,
+    tpe = dotty.tools.dotc.semanticdb.AnnotatedType._typemapper_tpe.toCustom(dotty.tools.dotc.semanticdb.TypeMessage.defaultInstance)
+  )
+  final val ANNOTATIONS_FIELD_NUMBER = 3
+  final val TPE_FIELD_NUMBER = 1
+  @transient @sharable
+  private[semanticdb] val _typemapper_tpe: SemanticdbTypeMapper[dotty.tools.dotc.semanticdb.TypeMessage, dotty.tools.dotc.semanticdb.Type] = implicitly[SemanticdbTypeMapper[dotty.tools.dotc.semanticdb.TypeMessage, dotty.tools.dotc.semanticdb.Type]]
+  def of(
+    annotations: _root_.scala.Seq[dotty.tools.dotc.semanticdb.Annotation],
+    tpe: dotty.tools.dotc.semanticdb.Type
+  ): _root_.dotty.tools.dotc.semanticdb.AnnotatedType = _root_.dotty.tools.dotc.semanticdb.AnnotatedType(
+    annotations,
+    tpe
+  )
+  // @@protoc_insertion_point(GeneratedMessageCompanion[dotty.tools.dotc.semanticdb.AnnotatedType])
+}
+
+@SerialVersionUID(0L)
+final case class ExistentialType(
+    tpe: dotty.tools.dotc.semanticdb.Type = dotty.tools.dotc.semanticdb.ExistentialType._typemapper_tpe.toCustom(dotty.tools.dotc.semanticdb.TypeMessage.defaultInstance),
+    declarations: _root_.scala.Option[dotty.tools.dotc.semanticdb.Scope] = _root_.scala.None
+    )  extends dotty.tools.dotc.semanticdb.Type.NonEmpty with SemanticdbGeneratedMessage  derives CanEqual {
+    @transient @sharable
+    private[this] var __serializedSizeMemoized: _root_.scala.Int = 0
+    private[this] def __computeSerializedSize(): _root_.scala.Int = {
+      var __size = 0
+      
+      {
+        val __value = dotty.tools.dotc.semanticdb.ExistentialType._typemapper_tpe.toBase(tpe)
+        if (__value.serializedSize != 0) {
+          __size += 1 + SemanticdbOutputStream.computeUInt32SizeNoTag(__value.serializedSize) + __value.serializedSize
+        }
+      };
+      if (declarations.isDefined) {
+        val __value = declarations.get
+        __size += 1 + SemanticdbOutputStream.computeUInt32SizeNoTag(__value.serializedSize) + __value.serializedSize
+      };
+      __size
+    }
+    override def serializedSize: _root_.scala.Int = {
+      var __size = __serializedSizeMemoized
+      if (__size == 0) {
+        __size = __computeSerializedSize() + 1
+        __serializedSizeMemoized = __size
+      }
+      __size - 1
+      
+    }
+    def writeTo(`_output__`: SemanticdbOutputStream): _root_.scala.Unit = {
+      {
+        val __v = dotty.tools.dotc.semanticdb.ExistentialType._typemapper_tpe.toBase(tpe)
+        if (__v.serializedSize != 0) {
+          _output__.writeTag(1, 2)
+          _output__.writeUInt32NoTag(__v.serializedSize)
+          __v.writeTo(_output__)
+        }
+      };
+      declarations.foreach { __v =>
+        val __m = __v
+        _output__.writeTag(3, 2)
+        _output__.writeUInt32NoTag(__m.serializedSize)
+        __m.writeTo(_output__)
+      };
+    }
+    def withTpe(__v: dotty.tools.dotc.semanticdb.Type): ExistentialType = copy(tpe = __v)
+    def getDeclarations: dotty.tools.dotc.semanticdb.Scope = declarations.getOrElse(dotty.tools.dotc.semanticdb.Scope.defaultInstance)
+    def clearDeclarations: ExistentialType = copy(declarations = _root_.scala.None)
+    def withDeclarations(__v: dotty.tools.dotc.semanticdb.Scope): ExistentialType = copy(declarations = Option(__v))
+    
+    
+    
+    
+    // @@protoc_insertion_point(GeneratedMessage[dotty.tools.dotc.semanticdb.ExistentialType])
+}
+
+object ExistentialType  extends SemanticdbGeneratedMessageCompanion[dotty.tools.dotc.semanticdb.ExistentialType] {
+  implicit def messageCompanion: SemanticdbGeneratedMessageCompanion[dotty.tools.dotc.semanticdb.ExistentialType] = this
+  def parseFrom(`_input__`: SemanticdbInputStream): dotty.tools.dotc.semanticdb.ExistentialType = {
+    var __tpe: _root_.scala.Option[dotty.tools.dotc.semanticdb.TypeMessage] = _root_.scala.None
+    var __declarations: _root_.scala.Option[dotty.tools.dotc.semanticdb.Scope] = _root_.scala.None
+    var _done__ = false
+    while (!_done__) {
+      val _tag__ = _input__.readTag()
+      _tag__ match {
+        case 0 => _done__ = true
+        case 10 =>
+          __tpe = _root_.scala.Some(__tpe.fold(LiteParser.readMessage[dotty.tools.dotc.semanticdb.TypeMessage](_input__))(LiteParser.readMessage(_input__, _)))
+        case 26 =>
+          __declarations = Option(__declarations.fold(LiteParser.readMessage[dotty.tools.dotc.semanticdb.Scope](_input__))(LiteParser.readMessage(_input__, _)))
+        case tag => _input__.skipField(tag)
+      }
+    }
+    dotty.tools.dotc.semanticdb.ExistentialType(
+        tpe = dotty.tools.dotc.semanticdb.ExistentialType._typemapper_tpe.toCustom(__tpe.getOrElse(dotty.tools.dotc.semanticdb.TypeMessage.defaultInstance)),
+        declarations = __declarations
+    )
+  }
+  
+  
+  
+  
+  
+  
+  lazy val defaultInstance = dotty.tools.dotc.semanticdb.ExistentialType(
+    tpe = dotty.tools.dotc.semanticdb.ExistentialType._typemapper_tpe.toCustom(dotty.tools.dotc.semanticdb.TypeMessage.defaultInstance),
+    declarations = _root_.scala.None
+  )
+  final val TPE_FIELD_NUMBER = 1
+  final val DECLARATIONS_FIELD_NUMBER = 3
+  @transient @sharable
+  private[semanticdb] val _typemapper_tpe: SemanticdbTypeMapper[dotty.tools.dotc.semanticdb.TypeMessage, dotty.tools.dotc.semanticdb.Type] = implicitly[SemanticdbTypeMapper[dotty.tools.dotc.semanticdb.TypeMessage, dotty.tools.dotc.semanticdb.Type]]
+  def of(
+    tpe: dotty.tools.dotc.semanticdb.Type,
+    declarations: _root_.scala.Option[dotty.tools.dotc.semanticdb.Scope]
+  ): _root_.dotty.tools.dotc.semanticdb.ExistentialType = _root_.dotty.tools.dotc.semanticdb.ExistentialType(
+    tpe,
+    declarations
+  )
+  // @@protoc_insertion_point(GeneratedMessageCompanion[dotty.tools.dotc.semanticdb.ExistentialType])
+}
+
+@SerialVersionUID(0L)
+final case class UniversalType(
+    typeParameters: _root_.scala.Option[dotty.tools.dotc.semanticdb.Scope] = _root_.scala.None,
+    tpe: dotty.tools.dotc.semanticdb.Type = dotty.tools.dotc.semanticdb.UniversalType._typemapper_tpe.toCustom(dotty.tools.dotc.semanticdb.TypeMessage.defaultInstance)
+    )  extends dotty.tools.dotc.semanticdb.Type.NonEmpty with SemanticdbGeneratedMessage  derives CanEqual {
+    @transient @sharable
+    private[this] var __serializedSizeMemoized: _root_.scala.Int = 0
+    private[this] def __computeSerializedSize(): _root_.scala.Int = {
+      var __size = 0
+      if (typeParameters.isDefined) {
+        val __value = typeParameters.get
+        __size += 1 + SemanticdbOutputStream.computeUInt32SizeNoTag(__value.serializedSize) + __value.serializedSize
+      };
+      
+      {
+        val __value = dotty.tools.dotc.semanticdb.UniversalType._typemapper_tpe.toBase(tpe)
+        if (__value.serializedSize != 0) {
+          __size += 1 + SemanticdbOutputStream.computeUInt32SizeNoTag(__value.serializedSize) + __value.serializedSize
+        }
+      };
+      __size
+    }
+    override def serializedSize: _root_.scala.Int = {
+      var __size = __serializedSizeMemoized
+      if (__size == 0) {
+        __size = __computeSerializedSize() + 1
+        __serializedSizeMemoized = __size
+      }
+      __size - 1
+      
+    }
+    def writeTo(`_output__`: SemanticdbOutputStream): _root_.scala.Unit = {
+      {
+        val __v = dotty.tools.dotc.semanticdb.UniversalType._typemapper_tpe.toBase(tpe)
+        if (__v.serializedSize != 0) {
+          _output__.writeTag(2, 2)
+          _output__.writeUInt32NoTag(__v.serializedSize)
+          __v.writeTo(_output__)
+        }
+      };
+      typeParameters.foreach { __v =>
+        val __m = __v
+        _output__.writeTag(3, 2)
+        _output__.writeUInt32NoTag(__m.serializedSize)
+        __m.writeTo(_output__)
+      };
+    }
+    def getTypeParameters: dotty.tools.dotc.semanticdb.Scope = typeParameters.getOrElse(dotty.tools.dotc.semanticdb.Scope.defaultInstance)
+    def clearTypeParameters: UniversalType = copy(typeParameters = _root_.scala.None)
+    def withTypeParameters(__v: dotty.tools.dotc.semanticdb.Scope): UniversalType = copy(typeParameters = Option(__v))
+    def withTpe(__v: dotty.tools.dotc.semanticdb.Type): UniversalType = copy(tpe = __v)
+    
+    
+    
+    
+    // @@protoc_insertion_point(GeneratedMessage[dotty.tools.dotc.semanticdb.UniversalType])
+}
+
+object UniversalType  extends SemanticdbGeneratedMessageCompanion[dotty.tools.dotc.semanticdb.UniversalType] {
+  implicit def messageCompanion: SemanticdbGeneratedMessageCompanion[dotty.tools.dotc.semanticdb.UniversalType] = this
+  def parseFrom(`_input__`: SemanticdbInputStream): dotty.tools.dotc.semanticdb.UniversalType = {
+    var __typeParameters: _root_.scala.Option[dotty.tools.dotc.semanticdb.Scope] = _root_.scala.None
+    var __tpe: _root_.scala.Option[dotty.tools.dotc.semanticdb.TypeMessage] = _root_.scala.None
+    var _done__ = false
+    while (!_done__) {
+      val _tag__ = _input__.readTag()
+      _tag__ match {
+        case 0 => _done__ = true
+        case 26 =>
+          __typeParameters = Option(__typeParameters.fold(LiteParser.readMessage[dotty.tools.dotc.semanticdb.Scope](_input__))(LiteParser.readMessage(_input__, _)))
+        case 18 =>
+          __tpe = _root_.scala.Some(__tpe.fold(LiteParser.readMessage[dotty.tools.dotc.semanticdb.TypeMessage](_input__))(LiteParser.readMessage(_input__, _)))
+        case tag => _input__.skipField(tag)
+      }
+    }
+    dotty.tools.dotc.semanticdb.UniversalType(
+        typeParameters = __typeParameters,
+        tpe = dotty.tools.dotc.semanticdb.UniversalType._typemapper_tpe.toCustom(__tpe.getOrElse(dotty.tools.dotc.semanticdb.TypeMessage.defaultInstance))
+    )
+  }
+  
+  
+  
+  
+  
+  
+  lazy val defaultInstance = dotty.tools.dotc.semanticdb.UniversalType(
+    typeParameters = _root_.scala.None,
+    tpe = dotty.tools.dotc.semanticdb.UniversalType._typemapper_tpe.toCustom(dotty.tools.dotc.semanticdb.TypeMessage.defaultInstance)
+  )
+  final val TYPE_PARAMETERS_FIELD_NUMBER = 3
+  final val TPE_FIELD_NUMBER = 2
+  @transient @sharable
+  private[semanticdb] val _typemapper_tpe: SemanticdbTypeMapper[dotty.tools.dotc.semanticdb.TypeMessage, dotty.tools.dotc.semanticdb.Type] = implicitly[SemanticdbTypeMapper[dotty.tools.dotc.semanticdb.TypeMessage, dotty.tools.dotc.semanticdb.Type]]
+  def of(
+    typeParameters: _root_.scala.Option[dotty.tools.dotc.semanticdb.Scope],
+    tpe: dotty.tools.dotc.semanticdb.Type
+  ): _root_.dotty.tools.dotc.semanticdb.UniversalType = _root_.dotty.tools.dotc.semanticdb.UniversalType(
+    typeParameters,
+    tpe
+  )
+  // @@protoc_insertion_point(GeneratedMessageCompanion[dotty.tools.dotc.semanticdb.UniversalType])
+}
+
+@SerialVersionUID(0L)
+final case class ByNameType(
+    tpe: dotty.tools.dotc.semanticdb.Type = dotty.tools.dotc.semanticdb.ByNameType._typemapper_tpe.toCustom(dotty.tools.dotc.semanticdb.TypeMessage.defaultInstance)
+    )  extends dotty.tools.dotc.semanticdb.Type.NonEmpty with SemanticdbGeneratedMessage  derives CanEqual {
+    @transient @sharable
+    private[this] var __serializedSizeMemoized: _root_.scala.Int = 0
+    private[this] def __computeSerializedSize(): _root_.scala.Int = {
+      var __size = 0
+      
+      {
+        val __value = dotty.tools.dotc.semanticdb.ByNameType._typemapper_tpe.toBase(tpe)
+        if (__value.serializedSize != 0) {
+          __size += 1 + SemanticdbOutputStream.computeUInt32SizeNoTag(__value.serializedSize) + __value.serializedSize
+        }
+      };
+      __size
+    }
+    override def serializedSize: _root_.scala.Int = {
+      var __size = __serializedSizeMemoized
+      if (__size == 0) {
+        __size = __computeSerializedSize() + 1
+        __serializedSizeMemoized = __size
+      }
+      __size - 1
+      
+    }
+    def writeTo(`_output__`: SemanticdbOutputStream): _root_.scala.Unit = {
+      {
+        val __v = dotty.tools.dotc.semanticdb.ByNameType._typemapper_tpe.toBase(tpe)
+        if (__v.serializedSize != 0) {
+          _output__.writeTag(1, 2)
+          _output__.writeUInt32NoTag(__v.serializedSize)
+          __v.writeTo(_output__)
+        }
+      };
+    }
+    def withTpe(__v: dotty.tools.dotc.semanticdb.Type): ByNameType = copy(tpe = __v)
+    
+    
+    
+    
+    // @@protoc_insertion_point(GeneratedMessage[dotty.tools.dotc.semanticdb.ByNameType])
+}
+
+object ByNameType  extends SemanticdbGeneratedMessageCompanion[dotty.tools.dotc.semanticdb.ByNameType] {
+  implicit def messageCompanion: SemanticdbGeneratedMessageCompanion[dotty.tools.dotc.semanticdb.ByNameType] = this
+  def parseFrom(`_input__`: SemanticdbInputStream): dotty.tools.dotc.semanticdb.ByNameType = {
+    var __tpe: _root_.scala.Option[dotty.tools.dotc.semanticdb.TypeMessage] = _root_.scala.None
+    var _done__ = false
+    while (!_done__) {
+      val _tag__ = _input__.readTag()
+      _tag__ match {
+        case 0 => _done__ = true
+        case 10 =>
+          __tpe = _root_.scala.Some(__tpe.fold(LiteParser.readMessage[dotty.tools.dotc.semanticdb.TypeMessage](_input__))(LiteParser.readMessage(_input__, _)))
+        case tag => _input__.skipField(tag)
+      }
+    }
+    dotty.tools.dotc.semanticdb.ByNameType(
+        tpe = dotty.tools.dotc.semanticdb.ByNameType._typemapper_tpe.toCustom(__tpe.getOrElse(dotty.tools.dotc.semanticdb.TypeMessage.defaultInstance))
+    )
+  }
+  
+  
+  
+  
+  
+  
+  lazy val defaultInstance = dotty.tools.dotc.semanticdb.ByNameType(
+    tpe = dotty.tools.dotc.semanticdb.ByNameType._typemapper_tpe.toCustom(dotty.tools.dotc.semanticdb.TypeMessage.defaultInstance)
+  )
+  final val TPE_FIELD_NUMBER = 1
+  @transient @sharable
+  private[semanticdb] val _typemapper_tpe: SemanticdbTypeMapper[dotty.tools.dotc.semanticdb.TypeMessage, dotty.tools.dotc.semanticdb.Type] = implicitly[SemanticdbTypeMapper[dotty.tools.dotc.semanticdb.TypeMessage, dotty.tools.dotc.semanticdb.Type]]
+  def of(
+    tpe: dotty.tools.dotc.semanticdb.Type
+  ): _root_.dotty.tools.dotc.semanticdb.ByNameType = _root_.dotty.tools.dotc.semanticdb.ByNameType(
+    tpe
+  )
+  // @@protoc_insertion_point(GeneratedMessageCompanion[dotty.tools.dotc.semanticdb.ByNameType])
+}
+
+@SerialVersionUID(0L)
+final case class RepeatedType(
+    tpe: dotty.tools.dotc.semanticdb.Type = dotty.tools.dotc.semanticdb.RepeatedType._typemapper_tpe.toCustom(dotty.tools.dotc.semanticdb.TypeMessage.defaultInstance)
+    )  extends dotty.tools.dotc.semanticdb.Type.NonEmpty with SemanticdbGeneratedMessage  derives CanEqual {
+    @transient @sharable
+    private[this] var __serializedSizeMemoized: _root_.scala.Int = 0
+    private[this] def __computeSerializedSize(): _root_.scala.Int = {
+      var __size = 0
+      
+      {
+        val __value = dotty.tools.dotc.semanticdb.RepeatedType._typemapper_tpe.toBase(tpe)
+        if (__value.serializedSize != 0) {
+          __size += 1 + SemanticdbOutputStream.computeUInt32SizeNoTag(__value.serializedSize) + __value.serializedSize
+        }
+      };
+      __size
+    }
+    override def serializedSize: _root_.scala.Int = {
+      var __size = __serializedSizeMemoized
+      if (__size == 0) {
+        __size = __computeSerializedSize() + 1
+        __serializedSizeMemoized = __size
+      }
+      __size - 1
+      
+    }
+    def writeTo(`_output__`: SemanticdbOutputStream): _root_.scala.Unit = {
+      {
+        val __v = dotty.tools.dotc.semanticdb.RepeatedType._typemapper_tpe.toBase(tpe)
+        if (__v.serializedSize != 0) {
+          _output__.writeTag(1, 2)
+          _output__.writeUInt32NoTag(__v.serializedSize)
+          __v.writeTo(_output__)
+        }
+      };
+    }
+    def withTpe(__v: dotty.tools.dotc.semanticdb.Type): RepeatedType = copy(tpe = __v)
+    
+    
+    
+    
+    // @@protoc_insertion_point(GeneratedMessage[dotty.tools.dotc.semanticdb.RepeatedType])
+}
+
+object RepeatedType  extends SemanticdbGeneratedMessageCompanion[dotty.tools.dotc.semanticdb.RepeatedType] {
+  implicit def messageCompanion: SemanticdbGeneratedMessageCompanion[dotty.tools.dotc.semanticdb.RepeatedType] = this
+  def parseFrom(`_input__`: SemanticdbInputStream): dotty.tools.dotc.semanticdb.RepeatedType = {
+    var __tpe: _root_.scala.Option[dotty.tools.dotc.semanticdb.TypeMessage] = _root_.scala.None
+    var _done__ = false
+    while (!_done__) {
+      val _tag__ = _input__.readTag()
+      _tag__ match {
+        case 0 => _done__ = true
+        case 10 =>
+          __tpe = _root_.scala.Some(__tpe.fold(LiteParser.readMessage[dotty.tools.dotc.semanticdb.TypeMessage](_input__))(LiteParser.readMessage(_input__, _)))
+        case tag => _input__.skipField(tag)
+      }
+    }
+    dotty.tools.dotc.semanticdb.RepeatedType(
+        tpe = dotty.tools.dotc.semanticdb.RepeatedType._typemapper_tpe.toCustom(__tpe.getOrElse(dotty.tools.dotc.semanticdb.TypeMessage.defaultInstance))
+    )
+  }
+  
+  
+  
+  
+  
+  
+  lazy val defaultInstance = dotty.tools.dotc.semanticdb.RepeatedType(
+    tpe = dotty.tools.dotc.semanticdb.RepeatedType._typemapper_tpe.toCustom(dotty.tools.dotc.semanticdb.TypeMessage.defaultInstance)
+  )
+  final val TPE_FIELD_NUMBER = 1
+  @transient @sharable
+  private[semanticdb] val _typemapper_tpe: SemanticdbTypeMapper[dotty.tools.dotc.semanticdb.TypeMessage, dotty.tools.dotc.semanticdb.Type] = implicitly[SemanticdbTypeMapper[dotty.tools.dotc.semanticdb.TypeMessage, dotty.tools.dotc.semanticdb.Type]]
+  def of(
+    tpe: dotty.tools.dotc.semanticdb.Type
+  ): _root_.dotty.tools.dotc.semanticdb.RepeatedType = _root_.dotty.tools.dotc.semanticdb.RepeatedType(
+    tpe
+  )
+  // @@protoc_insertion_point(GeneratedMessageCompanion[dotty.tools.dotc.semanticdb.RepeatedType])
+}
+
+@SerialVersionUID(0L)
+final case class MatchType(
+    scrutinee: dotty.tools.dotc.semanticdb.Type = dotty.tools.dotc.semanticdb.MatchType._typemapper_scrutinee.toCustom(dotty.tools.dotc.semanticdb.TypeMessage.defaultInstance),
+    cases: _root_.scala.Seq[dotty.tools.dotc.semanticdb.MatchType.CaseType] = _root_.scala.Seq.empty
+    )  extends dotty.tools.dotc.semanticdb.Type.NonEmpty with SemanticdbGeneratedMessage  derives CanEqual {
+    @transient @sharable
+    private[this] var __serializedSizeMemoized: _root_.scala.Int = 0
+    private[this] def __computeSerializedSize(): _root_.scala.Int = {
+      var __size = 0
+      
+      {
+        val __value = dotty.tools.dotc.semanticdb.MatchType._typemapper_scrutinee.toBase(scrutinee)
+        if (__value.serializedSize != 0) {
+          __size += 1 + SemanticdbOutputStream.computeUInt32SizeNoTag(__value.serializedSize) + __value.serializedSize
+        }
+      };
+      cases.foreach { __item =>
+        val __value = __item
+        __size += 1 + SemanticdbOutputStream.computeUInt32SizeNoTag(__value.serializedSize) + __value.serializedSize
+      }
+      __size
+    }
+    override def serializedSize: _root_.scala.Int = {
+      var __size = __serializedSizeMemoized
+      if (__size == 0) {
+        __size = __computeSerializedSize() + 1
+        __serializedSizeMemoized = __size
+      }
+      __size - 1
+      
+    }
+    def writeTo(`_output__`: SemanticdbOutputStream): _root_.scala.Unit = {
+      {
+        val __v = dotty.tools.dotc.semanticdb.MatchType._typemapper_scrutinee.toBase(scrutinee)
+        if (__v.serializedSize != 0) {
+          _output__.writeTag(1, 2)
+          _output__.writeUInt32NoTag(__v.serializedSize)
+          __v.writeTo(_output__)
+        }
+      };
+      cases.foreach { __v =>
+        val __m = __v
+        _output__.writeTag(2, 2)
+        _output__.writeUInt32NoTag(__m.serializedSize)
+        __m.writeTo(_output__)
+      };
+    }
+    def withScrutinee(__v: dotty.tools.dotc.semanticdb.Type): MatchType = copy(scrutinee = __v)
+    def clearCases = copy(cases = _root_.scala.Seq.empty)
+    def addCases(__vs: dotty.tools.dotc.semanticdb.MatchType.CaseType *): MatchType = addAllCases(__vs)
+    def addAllCases(__vs: Iterable[dotty.tools.dotc.semanticdb.MatchType.CaseType]): MatchType = copy(cases = cases ++ __vs)
+    def withCases(__v: _root_.scala.Seq[dotty.tools.dotc.semanticdb.MatchType.CaseType]): MatchType = copy(cases = __v)
+    
+    
+    
+    
+    // @@protoc_insertion_point(GeneratedMessage[dotty.tools.dotc.semanticdb.MatchType])
+}
+
+object MatchType  extends SemanticdbGeneratedMessageCompanion[dotty.tools.dotc.semanticdb.MatchType] {
+  implicit def messageCompanion: SemanticdbGeneratedMessageCompanion[dotty.tools.dotc.semanticdb.MatchType] = this
+  def parseFrom(`_input__`: SemanticdbInputStream): dotty.tools.dotc.semanticdb.MatchType = {
+    var __scrutinee: _root_.scala.Option[dotty.tools.dotc.semanticdb.TypeMessage] = _root_.scala.None
+    val __cases: _root_.scala.collection.immutable.VectorBuilder[dotty.tools.dotc.semanticdb.MatchType.CaseType] = new _root_.scala.collection.immutable.VectorBuilder[dotty.tools.dotc.semanticdb.MatchType.CaseType]
+    var _done__ = false
+    while (!_done__) {
+      val _tag__ = _input__.readTag()
+      _tag__ match {
+        case 0 => _done__ = true
+        case 10 =>
+          __scrutinee = _root_.scala.Some(__scrutinee.fold(LiteParser.readMessage[dotty.tools.dotc.semanticdb.TypeMessage](_input__))(LiteParser.readMessage(_input__, _)))
+        case 18 =>
+          __cases += LiteParser.readMessage[dotty.tools.dotc.semanticdb.MatchType.CaseType](_input__)
+        case tag => _input__.skipField(tag)
+      }
+    }
+    dotty.tools.dotc.semanticdb.MatchType(
+        scrutinee = dotty.tools.dotc.semanticdb.MatchType._typemapper_scrutinee.toCustom(__scrutinee.getOrElse(dotty.tools.dotc.semanticdb.TypeMessage.defaultInstance)),
+        cases = __cases.result()
+    )
+  }
+  
+  
+  
+  
+  
+  
+  lazy val defaultInstance = dotty.tools.dotc.semanticdb.MatchType(
+    scrutinee = dotty.tools.dotc.semanticdb.MatchType._typemapper_scrutinee.toCustom(dotty.tools.dotc.semanticdb.TypeMessage.defaultInstance),
+    cases = _root_.scala.Seq.empty
+  )
+  @SerialVersionUID(0L)
+  final case class CaseType(
+      key: dotty.tools.dotc.semanticdb.Type = dotty.tools.dotc.semanticdb.MatchType.CaseType._typemapper_key.toCustom(dotty.tools.dotc.semanticdb.TypeMessage.defaultInstance),
+      body: dotty.tools.dotc.semanticdb.Type = dotty.tools.dotc.semanticdb.MatchType.CaseType._typemapper_body.toCustom(dotty.tools.dotc.semanticdb.TypeMessage.defaultInstance)
+      )  extends SemanticdbGeneratedMessage  derives CanEqual {
+      @transient @sharable
+      private[this] var __serializedSizeMemoized: _root_.scala.Int = 0
+      private[this] def __computeSerializedSize(): _root_.scala.Int = {
+        var __size = 0
+        
+        {
+          val __value = dotty.tools.dotc.semanticdb.MatchType.CaseType._typemapper_key.toBase(key)
+          if (__value.serializedSize != 0) {
+            __size += 1 + SemanticdbOutputStream.computeUInt32SizeNoTag(__value.serializedSize) + __value.serializedSize
+          }
+        };
+        
+        {
+          val __value = dotty.tools.dotc.semanticdb.MatchType.CaseType._typemapper_body.toBase(body)
+          if (__value.serializedSize != 0) {
+            __size += 1 + SemanticdbOutputStream.computeUInt32SizeNoTag(__value.serializedSize) + __value.serializedSize
+          }
+        };
+        __size
+      }
+      override def serializedSize: _root_.scala.Int = {
+        var __size = __serializedSizeMemoized
+        if (__size == 0) {
+          __size = __computeSerializedSize() + 1
+          __serializedSizeMemoized = __size
+        }
+        __size - 1
+        
+      }
+      def writeTo(`_output__`: SemanticdbOutputStream): _root_.scala.Unit = {
+        {
+          val __v = dotty.tools.dotc.semanticdb.MatchType.CaseType._typemapper_key.toBase(key)
+          if (__v.serializedSize != 0) {
+            _output__.writeTag(1, 2)
+            _output__.writeUInt32NoTag(__v.serializedSize)
+            __v.writeTo(_output__)
+          }
+        };
+        {
+          val __v = dotty.tools.dotc.semanticdb.MatchType.CaseType._typemapper_body.toBase(body)
+          if (__v.serializedSize != 0) {
+            _output__.writeTag(2, 2)
+            _output__.writeUInt32NoTag(__v.serializedSize)
+            __v.writeTo(_output__)
+          }
+        };
+      }
+      def withKey(__v: dotty.tools.dotc.semanticdb.Type): CaseType = copy(key = __v)
+      def withBody(__v: dotty.tools.dotc.semanticdb.Type): CaseType = copy(body = __v)
+      
+      
+      
+      
+      // @@protoc_insertion_point(GeneratedMessage[dotty.tools.dotc.semanticdb.MatchType.CaseType])
+  }
+  
+  object CaseType  extends SemanticdbGeneratedMessageCompanion[dotty.tools.dotc.semanticdb.MatchType.CaseType] {
+    implicit def messageCompanion: SemanticdbGeneratedMessageCompanion[dotty.tools.dotc.semanticdb.MatchType.CaseType] = this
+    def parseFrom(`_input__`: SemanticdbInputStream): dotty.tools.dotc.semanticdb.MatchType.CaseType = {
+      var __key: _root_.scala.Option[dotty.tools.dotc.semanticdb.TypeMessage] = _root_.scala.None
+      var __body: _root_.scala.Option[dotty.tools.dotc.semanticdb.TypeMessage] = _root_.scala.None
+      var _done__ = false
+      while (!_done__) {
+        val _tag__ = _input__.readTag()
+        _tag__ match {
+          case 0 => _done__ = true
+          case 10 =>
+            __key = _root_.scala.Some(__key.fold(LiteParser.readMessage[dotty.tools.dotc.semanticdb.TypeMessage](_input__))(LiteParser.readMessage(_input__, _)))
+          case 18 =>
+            __body = _root_.scala.Some(__body.fold(LiteParser.readMessage[dotty.tools.dotc.semanticdb.TypeMessage](_input__))(LiteParser.readMessage(_input__, _)))
+          case tag => _input__.skipField(tag)
+        }
+      }
+      dotty.tools.dotc.semanticdb.MatchType.CaseType(
+          key = dotty.tools.dotc.semanticdb.MatchType.CaseType._typemapper_key.toCustom(__key.getOrElse(dotty.tools.dotc.semanticdb.TypeMessage.defaultInstance)),
+          body = dotty.tools.dotc.semanticdb.MatchType.CaseType._typemapper_body.toCustom(__body.getOrElse(dotty.tools.dotc.semanticdb.TypeMessage.defaultInstance))
+      )
+    }
+    
+    
+    
+    
+    
+    
+    lazy val defaultInstance = dotty.tools.dotc.semanticdb.MatchType.CaseType(
+      key = dotty.tools.dotc.semanticdb.MatchType.CaseType._typemapper_key.toCustom(dotty.tools.dotc.semanticdb.TypeMessage.defaultInstance),
+      body = dotty.tools.dotc.semanticdb.MatchType.CaseType._typemapper_body.toCustom(dotty.tools.dotc.semanticdb.TypeMessage.defaultInstance)
+    )
+    final val KEY_FIELD_NUMBER = 1
+    final val BODY_FIELD_NUMBER = 2
+    @transient @sharable
+    private[semanticdb] val _typemapper_key: SemanticdbTypeMapper[dotty.tools.dotc.semanticdb.TypeMessage, dotty.tools.dotc.semanticdb.Type] = implicitly[SemanticdbTypeMapper[dotty.tools.dotc.semanticdb.TypeMessage, dotty.tools.dotc.semanticdb.Type]]
+    @transient @sharable
+    private[semanticdb] val _typemapper_body: SemanticdbTypeMapper[dotty.tools.dotc.semanticdb.TypeMessage, dotty.tools.dotc.semanticdb.Type] = implicitly[SemanticdbTypeMapper[dotty.tools.dotc.semanticdb.TypeMessage, dotty.tools.dotc.semanticdb.Type]]
+    def of(
+      key: dotty.tools.dotc.semanticdb.Type,
+      body: dotty.tools.dotc.semanticdb.Type
+    ): _root_.dotty.tools.dotc.semanticdb.MatchType.CaseType = _root_.dotty.tools.dotc.semanticdb.MatchType.CaseType(
+      key,
+      body
+    )
+    // @@protoc_insertion_point(GeneratedMessageCompanion[dotty.tools.dotc.semanticdb.MatchType.CaseType])
+  }
+  
+  final val SCRUTINEE_FIELD_NUMBER = 1
+  final val CASES_FIELD_NUMBER = 2
+  @transient @sharable
+  private[semanticdb] val _typemapper_scrutinee: SemanticdbTypeMapper[dotty.tools.dotc.semanticdb.TypeMessage, dotty.tools.dotc.semanticdb.Type] = implicitly[SemanticdbTypeMapper[dotty.tools.dotc.semanticdb.TypeMessage, dotty.tools.dotc.semanticdb.Type]]
+  def of(
+    scrutinee: dotty.tools.dotc.semanticdb.Type,
+    cases: _root_.scala.Seq[dotty.tools.dotc.semanticdb.MatchType.CaseType]
+  ): _root_.dotty.tools.dotc.semanticdb.MatchType = _root_.dotty.tools.dotc.semanticdb.MatchType(
+    scrutinee,
+    cases
+  )
+  // @@protoc_insertion_point(GeneratedMessageCompanion[dotty.tools.dotc.semanticdb.MatchType])
+}
diff --git a/tests/pos-with-compiler-cc/dotc/semanticdb/internal/InvalidProtocolBufferException.scala b/tests/pos-with-compiler-cc/dotc/semanticdb/internal/InvalidProtocolBufferException.scala
new file mode 100644
index 000000000000..886067ed7a43
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/semanticdb/internal/InvalidProtocolBufferException.scala
@@ -0,0 +1,55 @@
+package dotty.tools.dotc.semanticdb.internal
+
+import java.io.IOException
+
+@SerialVersionUID(-1616151763072450476L)
+class InvalidProtocolBufferException(description: String) extends IOException(description)
+
+object InvalidProtocolBufferException {
+
+  def truncatedMessage(): InvalidProtocolBufferException = {
+    new InvalidProtocolBufferException("While parsing a protocol message, the input ended unexpectedly " +
+      "in the middle of a field.  This could mean either that the " +
+      "input has been truncated or that an embedded message " +
+      "misreported its own length.")
+  }
+
+  def negativeSize(): InvalidProtocolBufferException = {
+    new InvalidProtocolBufferException("SemanticdbInputStream encountered an embedded string or message " +
+      "which claimed to have negative size.")
+  }
+
+  def malformedVarint(): InvalidProtocolBufferException = {
+    new InvalidProtocolBufferException("SemanticdbInputStream encountered a malformed varint.")
+  }
+
+  def invalidTag(): InvalidProtocolBufferException = {
+    new InvalidProtocolBufferException("Protocol message contained an invalid tag (zero).")
+  }
+
+  def invalidEndTag(): InvalidProtocolBufferException = {
+    new InvalidProtocolBufferException("Protocol message end-group tag did not match expected tag.")
+  }
+
+  def invalidWireType(): InvalidProtocolBufferException = {
+    new InvalidProtocolBufferException("Protocol message tag had invalid wire type.")
+  }
+
+  def recursionLimitExceeded(): InvalidProtocolBufferException = {
+    new InvalidProtocolBufferException("Protocol message had too many levels of nesting.  May be malicious.  " +
+      "Use SemanticdbInputStream.setRecursionLimit() to increase the depth limit.")
+  }
+
+  def sizeLimitExceeded(): InvalidProtocolBufferException = {
+    new InvalidProtocolBufferException("Protocol message was too large.  May be malicious.  " +
+      "Use SemanticdbInputStream.setSizeLimit() to increase the size limit.")
+  }
+
+  def parseFailure(): InvalidProtocolBufferException = {
+    new InvalidProtocolBufferException("Failed to parse the message.")
+  }
+
+  def invalidUtf8(): InvalidProtocolBufferException = {
+    new InvalidProtocolBufferException("Protocol message had invalid UTF-8.")
+  }
+}
diff --git a/tests/pos-with-compiler-cc/dotc/semanticdb/internal/LiteParser.scala b/tests/pos-with-compiler-cc/dotc/semanticdb/internal/LiteParser.scala
new file mode 100644
index 000000000000..1000fc6601da
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/semanticdb/internal/LiteParser.scala
@@ -0,0 +1,36 @@
+package dotty.tools.dotc.semanticdb.internal
+
+
+object LiteParser {
+
+  def readMessage[A <: SemanticdbGeneratedMessage](
+      input: SemanticdbInputStream,
+      message: A
+  )(implicit
+      cmp: SemanticdbGeneratedMessageCompanion[A]
+  ): A = {
+    val length = input.readRawVarint32()
+    val oldLimit = input.pushLimit(length)
+    val result: A = cmp.merge(message, input)
+    input.checkLastTagWas(0)
+    input.popLimit(oldLimit)
+    result
+  }
+
+  def readMessage[A <: SemanticdbGeneratedMessage](
+      input: SemanticdbInputStream
+  )(implicit
+      cmp: SemanticdbGeneratedMessageCompanion[A]
+  ): A = {
+    val length = input.readRawVarint32()
+    val oldLimit = input.pushLimit(length)
+    val result: A = cmp.parseFrom(input)
+    input.checkLastTagWas(0)
+    input.popLimit(oldLimit)
+    result
+  }
+
+  @inline
+  def preferredSemanticdbOutputStreamBufferSize(dataLength: Int) =
+    dataLength min SemanticdbOutputStream.DEFAULT_BUFFER_SIZE
+}
diff --git a/tests/pos-with-compiler-cc/dotc/semanticdb/internal/MD5.scala b/tests/pos-with-compiler-cc/dotc/semanticdb/internal/MD5.scala
new file mode 100644
index 000000000000..dc10df6a5bba
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/semanticdb/internal/MD5.scala
@@ -0,0 +1,30 @@
+package dotty.tools.dotc.semanticdb.internal
+
+import scala.language.unsafeNulls
+
+import java.nio.ByteBuffer
+import java.nio.charset.StandardCharsets
+import java.security.MessageDigest
+
+object MD5 {
+  def compute(string: String): String = {
+    compute(ByteBuffer.wrap(string.getBytes(StandardCharsets.UTF_8)))
+  }
+  def compute(buffer: ByteBuffer): String = {
+    val md = MessageDigest.getInstance("MD5")
+    md.update(buffer)
+    bytesToHex(md.digest())
+  }
+  private val hexArray = "0123456789ABCDEF".toCharArray
+  def bytesToHex(bytes: Array[Byte]): String = {
+    val hexChars = new Array[Char](bytes.length * 2)
+    var j = 0
+    while (j < bytes.length) {
+      val v: Int = bytes(j) & 0xFF
+      hexChars(j * 2) = hexArray(v >>> 4)
+      hexChars(j * 2 + 1) = hexArray(v & 0x0F)
+      j += 1
+    }
+    new String(hexChars)
+  }
+}
diff --git a/tests/pos-with-compiler-cc/dotc/semanticdb/internal/SemanticdbEnum.scala b/tests/pos-with-compiler-cc/dotc/semanticdb/internal/SemanticdbEnum.scala
new file mode 100644
index 000000000000..18b8edf8dab0
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/semanticdb/internal/SemanticdbEnum.scala
@@ -0,0 +1,5 @@
+package dotty.tools.dotc.semanticdb.internal
+
+trait SemanticdbEnum {
+  def value: Int
+}
diff --git a/tests/pos-with-compiler-cc/dotc/semanticdb/internal/SemanticdbGeneratedMessageCompanion.scala b/tests/pos-with-compiler-cc/dotc/semanticdb/internal/SemanticdbGeneratedMessageCompanion.scala
new file mode 100644
index 000000000000..bad0ff9b8fc8
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/semanticdb/internal/SemanticdbGeneratedMessageCompanion.scala
@@ -0,0 +1,79 @@
+package dotty.tools.dotc.semanticdb.internal
+
+
+// https://github.com/scalapb/ScalaPB/blob/194463272125b872b99d4902b7712355a53e96c4/scalapb-runtime/src/main/scala/scalapb/GeneratedMessageCompanion.scala#L61-L68
+trait SemanticdbGeneratedOneof extends Any with Product with Serializable {
+  type ValueType
+  def number: Int
+  def isDefined: Boolean
+  def isEmpty: Boolean
+  def value: ValueType
+  def valueOption: Option[ValueType] = if (isDefined) Some(value) else None
+}
+
+// https://github.com/scalapb/ScalaPB/blob/194463272125b872b99d4902b7712355a53e96c4/scalapb-runtime/src/main/scala/scalapb/GeneratedMessageCompanion.scala#L72-L138
+trait SemanticdbGeneratedMessage extends Any with Product with Serializable {
+  def serializedSize: Int
+
+  def writeTo(output: SemanticdbOutputStream): Unit
+
+  /** Serializes the messgae and returns a byte array containing its raw bytes */
+  final def toByteArray: Array[Byte] = {
+    val a = new Array[Byte](serializedSize)
+    val outputStream = SemanticdbOutputStream.newInstance(a)
+    writeTo(outputStream)
+    outputStream.checkNoSpaceLeft()
+    a
+  }
+}
+
+trait SemanticdbGeneratedSealedOneof
+    extends Any
+    with Product
+    with Serializable {
+  type MessageType <: SemanticdbGeneratedMessage
+  def isEmpty: Boolean
+  def isDefined: Boolean
+  def asMessage: MessageType
+}
+
+trait SemanticdbGeneratedEnum extends Any with Product with Serializable {
+  type EnumType <: SemanticdbGeneratedEnum
+
+  def value: Int
+
+  def index: Int
+
+  def name: String
+
+  override def toString = name
+
+  def isUnrecognized: Boolean = false
+
+}
+
+trait SemanticdbUnrecognizedEnum extends SemanticdbGeneratedEnum {
+  def name = "UNRECOGNIZED"
+
+  def index = -1
+
+  override def isUnrecognized: Boolean = true
+}
+
+trait SemanticdbGeneratedMessageCompanion[A <: SemanticdbGeneratedMessage]
+    extends Serializable {
+  self =>
+  type ValueType = A
+
+  /** Parses a message from a CodedInputStream. */
+  def parseFrom(input: SemanticdbInputStream): A
+
+  def parseFrom(input: Array[Byte]): A = parseFrom(
+    SemanticdbInputStream.newInstance(input)
+  )
+
+  /** Merges the given message with the additional fields in the steam. */
+  def merge(a: A, input: SemanticdbInputStream): A = {
+    parseFrom(a.toByteArray ++ parseFrom(input).toByteArray)
+  }
+}
diff --git a/tests/pos-with-compiler-cc/dotc/semanticdb/internal/SemanticdbInputStream.scala b/tests/pos-with-compiler-cc/dotc/semanticdb/internal/SemanticdbInputStream.scala
new file mode 100644
index 000000000000..8aed9e5b9771
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/semanticdb/internal/SemanticdbInputStream.scala
@@ -0,0 +1,802 @@
+package dotty.tools.dotc.semanticdb.internal
+
+import scala.language.unsafeNulls
+
+import java.io.IOException
+import java.io.InputStream
+import java.util.Arrays
+import java.nio.charset.StandardCharsets
+
+import SemanticdbInputStream._
+
+import scala.collection.mutable
+
+object SemanticdbInputStream {
+
+  def newInstance(input: InputStream): SemanticdbInputStream = new SemanticdbInputStream(input)
+
+  def newInstance(buf: Array[Byte]): SemanticdbInputStream = newInstance(buf, 0, buf.length)
+
+  def newInstance(buf: Array[Byte], off: Int, len: Int): SemanticdbInputStream = {
+    val result = new SemanticdbInputStream(buf, off, len)
+    result.pushLimit(len)
+    result
+  }
+
+  @throws[InvalidProtocolBufferException]
+  def readRawVarint32(input: InputStream): Int = {
+    val firstByte = input.read()
+    if (firstByte == -1) {
+      throw InvalidProtocolBufferException.truncatedMessage()
+    }
+    readRawVarint32(firstByte, input)
+  }
+
+  def readRawVarint32(firstByte: Int, input: InputStream): Int = {
+    if ((firstByte & 0x80) == 0) {
+      return firstByte
+    }
+    var result = firstByte & 0x7f
+    var offset = 7
+    while (offset < 32) {
+      val b = input.read()
+      if (b == -1) {
+        throw InvalidProtocolBufferException.truncatedMessage()
+      }
+      result |= (b & 0x7f) << offset
+      if ((b & 0x80) == 0) {
+        return result
+      }
+      offset += 7
+    }
+    while (offset < 64) {
+      val b = input.read()
+      if (b == -1) {
+        throw InvalidProtocolBufferException.truncatedMessage()
+      }
+      if ((b & 0x80) == 0) {
+        return result
+      }
+      offset += 7
+    }
+    throw InvalidProtocolBufferException.malformedVarint()
+  }
+
+  def decodeZigZag32(n: Int): Int = (n >>> 1) ^ -(n & 1)
+
+  def decodeZigZag64(n: Long): Long = (n >>> 1) ^ -(n & 1)
+
+  private val DEFAULT_RECURSION_LIMIT = 100
+
+  private val DEFAULT_SIZE_LIMIT = 64 << 20
+
+  private val BUFFER_SIZE = 4096
+}
+
+class SemanticdbInputStream private (buffer: Array[Byte], input: InputStream) {
+  /**
+    * The total number of bytes read before the current buffer.  The total
+    * bytes read up to the current position can be computed as
+    * {@code totalBytesRetired + bufferPos}.  This value may be negative if
+    * reading started in the middle of the current buffer (e.g. if the
+    * constructor that takes a byte array and an offset was used).
+    */
+  private var totalBytesRetired: Int = 0
+
+  // Current position in the buffer.
+  private var bufferPos: Int = 0
+
+  // How many bytes in the buffer contain actual content (bufferSize <= buffer.length)
+  private var bufferSize: Int = 0
+
+  private var currentLimit: Int = Int.MaxValue
+
+  private var sizeLimit = SemanticdbInputStream.DEFAULT_SIZE_LIMIT
+
+  private var bufferSizeAfterLimit = 0
+
+  private var lastTag = 0
+
+  def this(buffer: Array[Byte], offset: Int, len: Int) = {
+    this(buffer, null)
+    bufferPos = offset
+    bufferSize = offset + len
+    totalBytesRetired = -offset
+  }
+
+  def this(is: InputStream) = {
+    this(new Array[Byte](SemanticdbInputStream.BUFFER_SIZE), is)
+    totalBytesRetired = 0
+  }
+
+  /**
+    * Ensures that at least {@code n} bytes are available in the buffer, reading
+    * more bytes from the input if necessary to make it so.  Caller must ensure
+    * that the requested space is less than BUFFER_SIZE.
+    */
+  private def ensureAvailable(n: Int): Unit = {
+    if (bufferSize - bufferPos < n) {
+      refillBuffer(n)
+    }
+  }
+
+  /**
+    * Reads more bytes from the input, making at least {@code n} bytes available
+    * in the buffer.  Caller must ensure that the requested space is not yet
+    * available, and that the requested space is less than BUFFER_SIZE.
+    */
+  private def refillBuffer(n: Int): Unit = {
+    if (!tryRefillBuffer(n)) {
+      throw InvalidProtocolBufferException.truncatedMessage()
+    }
+  }
+  /**
+    * Tries to read more bytes from the input, making at least {@code n} bytes
+    * available in the buffer.  Caller must ensure that the requested space is
+    * not yet available, and that the requested space is less than BUFFER_SIZE.
+    *
+    * @return { @code true} if the bytes could be made available; { @code false}
+    *                                                                     if the end of the stream or the current limit was reached.
+    */
+  private def tryRefillBuffer(n: Int): Boolean = {
+    if (bufferPos + n <= bufferSize) {
+      throw new IllegalStateException(
+        s"refillBuffer() called when $n bytes were already available in buffer")
+    }
+    if totalBytesRetired + bufferPos + n <= currentLimit && input != null then
+      val pos: Int = bufferPos
+      if (pos > 0) {
+        if (bufferSize > pos) {
+          System.arraycopy(buffer, pos, buffer, 0, bufferSize - pos)
+        }
+        totalBytesRetired += pos
+        bufferSize -= pos
+        bufferPos = 0
+      }
+      val bytesRead: Int = input.read(buffer, bufferSize, buffer.length - bufferSize)
+      if (bytesRead == 0 || bytesRead < -1 || bytesRead > buffer.length) {
+        throw new IllegalStateException("InputStream#read(byte[]) returned invalid result: " + bytesRead + "\nThe InputStream implementation is buggy.")
+      }
+      if (bytesRead > 0) {
+        bufferSize += bytesRead
+        if (totalBytesRetired + n - sizeLimit > 0) {
+          throw InvalidProtocolBufferException.sizeLimitExceeded()
+        }
+        recomputeBufferSizeAfterLimit()
+        return ((bufferSize >= n) || tryRefillBuffer(n))
+      }
+    false
+  }
+
+  private def recomputeBufferSizeAfterLimit(): Unit = {
+    bufferSize += bufferSizeAfterLimit
+    val bufferEnd: Int = totalBytesRetired + bufferSize
+    if (bufferEnd > currentLimit) {
+      bufferSizeAfterLimit = bufferEnd - currentLimit
+      bufferSize -= bufferSizeAfterLimit
+    }
+    else {
+      bufferSizeAfterLimit = 0
+    }
+  }
+
+  /**
+    * Returns true if the stream has reached the end of the input.  This is the
+    * case if either the end of the underlying input source has been reached or
+    * if the stream has reached a limit created using {@link #pushLimit(int)}.
+    */
+  def isAtEnd: Boolean = {
+    bufferPos == bufferSize && !tryRefillBuffer(1)
+  }
+
+  def getTotalBytesRead() = {
+    totalBytesRetired + bufferPos
+  }
+
+  /**
+    * Sets {@code currentLimit} to (current position) + {@code byteLimit}.  This
+    * is called when descending into a length-delimited embedded message.
+    *
+    * <p>Note that {@code pushLimit()} does NOT affect how many bytes the
+    * {@code SemanticdbInputStream} reads from an underlying {@code InputStream} when
+    * refreshing its buffer.  If you need to prevent reading past a certain
+    * point in the underlying {@code InputStream} (e.g. because you expect it to
+    * contain more data after the end of the message which you need to handle
+    * differently) then you must place a wrapper around your {@code InputStream}
+    * which limits the amount of data that can be read from it.
+    *
+    * @return the old limit.
+    */
+  def pushLimit(byteLimit0: Int): Int = {
+    if (byteLimit0 < 0) {
+      throw InvalidProtocolBufferException.negativeSize()
+    }
+    val byteLimit = byteLimit0 + totalBytesRetired + bufferPos
+    val oldLimit: Int = currentLimit
+    if (byteLimit > oldLimit) {
+      throw InvalidProtocolBufferException.truncatedMessage()
+    }
+    currentLimit = byteLimit
+    recomputeBufferSizeAfterLimit()
+    oldLimit
+  }
+
+  /**
+    * Discards the current limit, returning to the previous limit.
+    *
+    * @param oldLimit The old limit, as returned by { @code pushLimit}.
+    */
+  def popLimit(oldLimit: Int): Unit = {
+    currentLimit = oldLimit
+    recomputeBufferSizeAfterLimit()
+  }
+
+  /**
+    * Reads and discards a single field, given its tag value.
+    *
+    * @return { @code false} if the tag is an endgroup tag, in which case
+    *                 nothing is skipped.  Otherwise, returns { @code true}.
+    */
+  @throws(classOf[IOException])
+  def skipField(tag: Int): Boolean = {
+    WireFormat.getTagWireType(tag) match {
+      case WireFormat.WIRETYPE_VARINT =>
+        skipRawVarint()
+        true
+      case WireFormat.WIRETYPE_FIXED64 =>
+        skipRawBytes(8)
+        true
+      case WireFormat.WIRETYPE_LENGTH_DELIMITED =>
+        skipRawBytes(readRawVarint32())
+        true
+      case WireFormat.WIRETYPE_START_GROUP =>
+        skipMessage()
+        checkLastTagWas(WireFormat.makeTag(WireFormat.getTagFieldNumber(tag), WireFormat.WIRETYPE_END_GROUP))
+        true
+      case WireFormat.WIRETYPE_END_GROUP =>
+        false
+      case WireFormat.WIRETYPE_FIXED32 =>
+        skipRawBytes(4)
+        true
+      case _ =>
+        throw InvalidProtocolBufferException.invalidWireType()
+    }
+  }
+
+  /**
+    * Reads and discards an entire message.  This will read either until EOF
+    * or until an endgroup tag, whichever comes first.
+    */
+  def skipMessage(): Unit = {
+    while (true) {
+      val tag: Int = readTag()
+      if (tag == 0 || !skipField(tag)) {
+        return
+      }
+    }
+  }
+
+  /**
+    * Reads and discards {@code size} bytes.
+    */
+  def skipRawBytes(size: Int): Unit = {
+    if (size <= (bufferSize - bufferPos) && size >= 0) {
+      bufferPos += size
+    }
+    else {
+      skipRawBytesSlowPath(size)
+    }
+  }
+
+  /**
+    * Read a raw Varint from the stream.  If larger than 32 bits, discard the
+    * upper bits.
+    */
+  @throws[InvalidProtocolBufferException]
+  def readRawVarint32(): Int = {
+    {
+      var pos: Int = bufferPos
+      if (bufferSize == pos) {
+        return readRawVarint64SlowPath().toInt
+      }
+      val buffer: Array[Byte] = this.buffer
+      var x: Int = 0
+      if ((({
+        x = buffer(({
+          pos += 1; pos - 1
+        })); x
+      })) >= 0) {
+        bufferPos = pos
+        return x
+      }
+      else if (bufferSize - pos < 9) {
+        return readRawVarint64SlowPath().toInt
+      }
+      else if ((({
+        x ^= (buffer(({
+          pos += 1; pos - 1
+        })) << 7); x
+      })) < 0) {
+        x ^= (~0 << 7)
+      }
+      else if ((({
+        x ^= (buffer(({
+          pos += 1; pos - 1
+        })) << 14); x
+      })) >= 0) {
+        x ^= (~0 << 7) ^ (~0 << 14)
+      }
+      else if ((({
+        x ^= (buffer(({
+          pos += 1; pos - 1
+        })) << 21); x
+      })) < 0) {
+        x ^= (~0 << 7) ^ (~0 << 14) ^ (~0 << 21)
+      }
+      else {
+        val y: Int = buffer(({
+          pos += 1; pos - 1
+        }))
+        x ^= y << 28
+        x ^= (~0 << 7) ^ (~0 << 14) ^ (~0 << 21) ^ (~0 << 28)
+        if (y < 0 && buffer(({
+          pos += 1; pos - 1
+        })) < 0 && buffer(({
+          pos += 1; pos - 1
+        })) < 0 && buffer(({
+          pos += 1; pos - 1
+        })) < 0 && buffer(({
+          pos += 1; pos - 1
+        })) < 0 && buffer(({
+          pos += 1; pos - 1
+        })) < 0) {
+          return readRawVarint64SlowPath().toInt
+        }
+      }
+      bufferPos = pos
+      return x
+    } //todo: labels is not supported
+  }
+
+  private def skipRawVarint(): Unit = {
+    if (bufferSize - bufferPos >= 10) {
+      val buffer: Array[Byte] = this.buffer
+      var pos: Int = bufferPos
+      var i: Int = 0
+      while (i < 10) {
+        {
+          if (buffer(({
+            pos += 1; pos - 1
+          })) >= 0) {
+            bufferPos = pos
+            return
+          }
+        }
+        ({
+          i += 1; i - 1
+        })
+      }
+    }
+    skipRawVarintSlowPath
+  }
+
+  @throws(classOf[IOException])
+  private def skipRawVarintSlowPath: Unit = {
+    var i: Int = 0
+    while (i < 10) {
+      if (readRawByte() >= 0) {
+        return
+      }
+      i += 1; i - 1
+    }
+    throw InvalidProtocolBufferException.malformedVarint()
+  }
+
+  /**
+    * Exactly like skipRawBytes, but caller must have already checked the fast
+    * path: (size <= (bufferSize - pos) && size >= 0)
+    */
+  private def skipRawBytesSlowPath(size: Int): Unit = {
+    if (size < 0) {
+      throw InvalidProtocolBufferException.negativeSize()
+    }
+    if (totalBytesRetired + bufferPos + size > currentLimit) {
+      skipRawBytes(currentLimit - totalBytesRetired - bufferPos)
+      throw InvalidProtocolBufferException.truncatedMessage()
+    }
+    var pos: Int = bufferSize - bufferPos
+    bufferPos = bufferSize
+    refillBuffer(1)
+    while (size - pos > bufferSize) {
+      pos += bufferSize
+      bufferPos = bufferSize
+      refillBuffer(1)
+    }
+    bufferPos = size - pos
+  }
+
+  /**
+    * Attempt to read a field tag, returning zero if we have reached EOF.
+    * Protocol message parsers use this to read tags, since a protocol message
+    * may legally end wherever a tag occurs, and zero is not a valid tag number.
+    */
+  @throws[InvalidProtocolBufferException]
+  def readTag(): Int = {
+    if (isAtEnd) {
+      lastTag = 0
+      return 0
+    }
+    lastTag = readRawVarint32()
+    if (WireFormat.getTagFieldNumber(lastTag) == 0) {
+      throw InvalidProtocolBufferException.invalidTag()
+    }
+    lastTag
+  }
+
+  def readString(): String = {
+    val size: Int = readRawVarint32()
+    if (size <= (bufferSize - bufferPos) && size > 0) {
+      val result: String = new String(buffer, bufferPos, size, StandardCharsets.UTF_8)
+      bufferPos += size
+      return result
+    }
+    else if (size == 0) {
+      return ""
+    }
+    else {
+      return new String(readRawBytesSlowPath(size), StandardCharsets.UTF_8)
+    }
+  }
+
+  def readStringRequireUtf8(): String = {
+    val size: Int = readRawVarint32()
+    var bytes: Array[Byte] = Array()
+    var pos = bufferPos;
+    if (size <= (bufferSize - pos) && size > 0) {
+      // Fast path:  We already have the bytes in a contiguous buffer, so
+      //   just copy directly from it.
+      bytes = buffer;
+      bufferPos = pos + size;
+    } else if (size == 0) {
+      return "";
+    } else {
+      // Slow path:  Build a byte array first then copy it.
+      bytes = readRawBytesSlowPath(size);
+      pos = 0;
+    }
+    // TODO(martinrb): We could save a pass by validating while decoding.
+    // if (!Utf8.isValidUtf8(bytes, pos, pos + size)) {
+    //   throw InvalidProtocolBufferException.invalidUtf8();
+    // }
+    return new String(bytes, pos, size, "UTF-8");
+  }
+
+  def checkLastTagWas(value: Int): Unit = {
+    if (lastTag != value) {
+      throw InvalidProtocolBufferException.invalidEndTag();
+    }
+  }
+
+  def getBytesUntilLimit: Int = {
+    if (currentLimit == Integer.MAX_VALUE) {
+      return -1
+    }
+
+    val currentAbsolutePosition: Int = totalBytesRetired + bufferPos
+    return currentLimit - currentAbsolutePosition
+  }
+
+  /** Read a {@code double} field value from the stream. */
+  def readDouble(): Double = {
+    return java.lang.Double.longBitsToDouble(readRawLittleEndian64())
+  }
+
+  /** Read a {@code float} field value from the stream. */
+  def readFloat(): Float = {
+    java.lang.Float.intBitsToFloat(readRawLittleEndian32())
+  }
+
+  /** Read a {@code uint64} field value from the stream. */
+  def readUInt64(): Long = {
+    readRawVarint64()
+  }
+
+  /** Read an {@code int64} field value from the stream. */
+  def readInt64(): Long = {
+    readRawVarint64()
+  }
+
+  /** Read an {@code int32} field value from the stream. */
+  def readInt32(): Int = {
+    readRawVarint32()
+  }
+
+  /** Read a {@code fixed64} field value from the stream. */
+  def readFixed64(): Long = {
+    readRawLittleEndian64()
+  }
+
+  /** Read a {@code fixed32} field value from the stream. */
+  def readFixed32(): Int = {
+    readRawLittleEndian32()
+  }
+
+  /** Read a {@code uint32} field value from the stream. */
+  def readUInt32(): Int = {
+    readRawVarint32()
+  }
+
+  /**
+    * Read an enum field value from the stream.  Caller is responsible
+    * for converting the numeric value to an actual enum.
+    */
+  def readEnum(): Int = {
+    readRawVarint32()
+  }
+
+  /** Read an {@code sfixed32} field value from the stream. */
+  def readSFixed32(): Int = {
+    readRawLittleEndian32()
+  }
+
+  /** Read an {@code sfixed64} field value from the stream. */
+  def readSFixed64(): Long = {
+    readRawLittleEndian64()
+  }
+
+  /** Read an {@code sint32} field value from the stream. */
+  def readSInt32(): Int = {
+    decodeZigZag32(readRawVarint32())
+  }
+
+  /** Read an {@code sint64} field value from the stream. */
+  def readSInt64(): Long = {
+    decodeZigZag64(readRawVarint64())
+  }
+
+  /** Read a {@code bool} field value from the stream. */
+  def readBool(): Boolean = {
+    readRawVarint64() != 0
+  }
+
+  /** Read a raw Varint from the stream. */
+  @throws[InvalidProtocolBufferException]
+  def readRawVarint64(): Long = {
+    var pos: Int = bufferPos
+    if (bufferSize == pos) {
+      return readRawVarint64SlowPath()
+    }
+    val buffer: Array[Byte] = this.buffer
+    var x: Long = 0L
+    var y: Int = 0
+    if ((({
+      y = buffer(({
+        pos += 1; pos - 1
+      })); y
+    })) >= 0) {
+      bufferPos = pos
+      return y
+    }
+    else if (bufferSize - pos < 9) {
+      return readRawVarint64SlowPath()
+    }
+    else if ((({
+      y ^= (buffer(({
+        pos += 1; pos - 1
+      })) << 7); y
+    })) < 0) {
+      x = y ^ (~0 << 7)
+    }
+    else if ((({
+      y ^= (buffer(({
+        pos += 1; pos - 1
+      })) << 14); y
+    })) >= 0) {
+      x = y ^ ((~0 << 7) ^ (~0 << 14))
+    }
+    else if ((({
+      y ^= (buffer(({
+        pos += 1; pos - 1
+      })) << 21); y
+    })) < 0) {
+      x = y ^ ((~0 << 7) ^ (~0 << 14) ^ (~0 << 21))
+    }
+    else if ((({
+      x = (y.toLong) ^ (buffer(({
+        pos += 1; pos - 1
+      })).toLong << 28); x
+    })) >= 0L) {
+      x ^= (~0L << 7) ^ (~0L << 14) ^ (~0L << 21) ^ (~0L << 28)
+    }
+    else if ((({
+      x ^= (buffer(({
+        pos += 1; pos - 1
+      })).toLong << 35); x
+    })) < 0L) {
+      x ^= (~0L << 7) ^ (~0L << 14) ^ (~0L << 21) ^ (~0L << 28) ^ (~0L << 35)
+    }
+    else if ((({
+      x ^= (buffer(({
+        pos += 1; pos - 1
+      })).toLong << 42); x
+    })) >= 0L) {
+      x ^= (~0L << 7) ^ (~0L << 14) ^ (~0L << 21) ^ (~0L << 28) ^ (~0L << 35) ^ (~0L << 42)
+    }
+    else if ((({
+      x ^= (buffer(({
+        pos += 1; pos - 1
+      })).toLong << 49); x
+    })) < 0L) {
+      x ^= (~0L << 7) ^ (~0L << 14) ^ (~0L << 21) ^ (~0L << 28) ^ (~0L << 35) ^ (~0L << 42) ^ (~0L << 49)
+    }
+    else {
+      x ^= (buffer(({
+        pos += 1; pos - 1
+      })).toLong << 56)
+      x ^= (~0L << 7) ^ (~0L << 14) ^ (~0L << 21) ^ (~0L << 28) ^ (~0L << 35) ^ (~0L << 42) ^ (~0L << 49) ^ (~0L << 56)
+      if (x < 0L) {
+        if (buffer(({
+          pos += 1; pos - 1
+        })) < 0L) {
+          return readRawVarint64SlowPath()
+        }
+      }
+    }
+    bufferPos = pos
+    x
+  }
+
+  /** Variant of readRawVarint64 for when uncomfortably close to the limit. */
+  @throws[InvalidProtocolBufferException]
+  private[semanticdb] def readRawVarint64SlowPath(): Long = {
+    var result: Long = 0
+    var shift: Int = 0
+    while (shift < 64) {
+      val b: Byte = readRawByte()
+      result |= (b & 0x7F).toLong << shift
+      if ((b & 0x80) == 0) {
+        return result
+      }
+      shift += 7
+    }
+    throw InvalidProtocolBufferException.malformedVarint()
+  }
+
+  /** Read a 32-bit little-endian integer from the stream. */
+  def readRawLittleEndian32(): Int = {
+    var pos: Int = bufferPos
+    if (bufferSize - pos < 4) {
+      refillBuffer(4)
+      pos = bufferPos
+    }
+    val buffer: Array[Byte] = this.buffer
+    bufferPos = pos + 4
+    (((buffer(pos) & 0xff)) |
+      ((buffer(pos + 1) & 0xff) << 8) |
+      ((buffer(pos + 2) & 0xff) << 16) |
+      ((buffer(pos + 3) & 0xff) << 24))
+  }
+
+  /** Read a 64-bit little-endian integer from the stream. */
+  def readRawLittleEndian64(): Long = {
+    var pos: Int = bufferPos
+    if (bufferSize - pos < 8) {
+      refillBuffer(8)
+      pos = bufferPos
+    }
+    val buffer: Array[Byte] = this.buffer
+    bufferPos = pos + 8
+    (((buffer(pos).toLong & 0xffL)) |
+      ((buffer(pos + 1).toLong & 0xffL) << 8) |
+      ((buffer(pos + 2).toLong & 0xffL) << 16) |
+      ((buffer(pos + 3).toLong & 0xffL) << 24) |
+      ((buffer(pos + 4).toLong & 0xffL) << 32) |
+      ((buffer(pos + 5).toLong & 0xffL) << 40) |
+      ((buffer(pos + 6).toLong & 0xffL) << 48) |
+      ((buffer(pos + 7).toLong & 0xffL) << 56))
+  }
+
+  /**
+    * Read one byte from the input.
+    */
+  @throws[InvalidProtocolBufferException]
+  def readRawByte(): Byte = {
+    if (bufferPos == bufferSize) {
+      refillBuffer(1)
+    }
+    buffer({
+      bufferPos += 1; bufferPos - 1
+    })
+  }
+
+  /**
+    * Read a fixed size of bytes from the input.
+    */
+  @throws[InvalidProtocolBufferException]
+  def readRawBytes(size: Int): Array[Byte] = {
+    val pos: Int = bufferPos
+    if (size <= (bufferSize - pos) && size > 0) {
+      bufferPos = pos + size
+      Arrays.copyOfRange(buffer, pos, pos + size)
+    }
+    else {
+      readRawBytesSlowPath(size)
+    }
+  }
+
+  /**
+    * Exactly like readRawBytes, but caller must have already checked the fast
+    * path: (size <= (bufferSize - pos) && size > 0)
+    */
+  private def readRawBytesSlowPath(size: Int): Array[Byte] = {
+    if (size <= 0) {
+      if (size == 0) {
+        return Internal.EMPTY_BYTE_ARRAY
+      }
+      else {
+        throw InvalidProtocolBufferException.negativeSize()
+      }
+    }
+    if (totalBytesRetired + bufferPos + size > currentLimit) {
+      skipRawBytes(currentLimit - totalBytesRetired - bufferPos)
+      throw InvalidProtocolBufferException.truncatedMessage()
+    }
+    if (size < BUFFER_SIZE) {
+      val bytes: Array[Byte] = new Array[Byte](size)
+      val pos: Int = bufferSize - bufferPos
+      System.arraycopy(buffer, bufferPos, bytes, 0, pos)
+      bufferPos = bufferSize
+      ensureAvailable(size - pos)
+      System.arraycopy(buffer, 0, bytes, pos, size - pos)
+      bufferPos = size - pos
+      bytes
+    }
+    else {
+      val originalBufferPos: Int = bufferPos
+      val originalBufferSize: Int = bufferSize
+      totalBytesRetired += bufferSize
+      bufferPos = 0
+      bufferSize = 0
+      var sizeLeft: Int = size - (originalBufferSize - originalBufferPos)
+      val chunks: mutable.ArrayBuffer[Array[Byte]] = new mutable.ArrayBuffer[Array[Byte]]
+      while (sizeLeft > 0) {
+        val chunk: Array[Byte] = new Array[Byte](Math.min(sizeLeft, BUFFER_SIZE))
+        var pos: Int = 0
+        while (pos < chunk.length) {
+          val n: Int = if ((input == null)) -1 else input.read(chunk, pos, chunk.length - pos)
+          if (n == -1) {
+            throw InvalidProtocolBufferException.truncatedMessage()
+          }
+          totalBytesRetired += n
+          pos += n
+        }
+        sizeLeft -= chunk.length
+        chunks+=(chunk)
+      }
+      val bytes: Array[Byte] = new Array[Byte](size)
+      var pos: Int = originalBufferSize - originalBufferPos
+      System.arraycopy(buffer, originalBufferPos, bytes, 0, pos)
+      for (chunk <- chunks) {
+        System.arraycopy(chunk, 0, bytes, pos, chunk.length)
+        pos += chunk.length
+      }
+      bytes
+    }
+  }
+
+  def enableAliasing(aliasing: Boolean): Unit = {}
+
+  def setSizeLimit(limit: Int): Int = {
+    if (limit < 0) {
+      throw new IllegalArgumentException(
+        "Size limit cannot be negative: " + limit)
+    }
+    val oldLimit: Int = sizeLimit
+    sizeLimit = limit
+    oldLimit
+  }
+
+  def resetSizeCounter(): Unit = {
+    totalBytesRetired = -bufferPos;
+  }
+}
diff --git a/tests/pos-with-compiler-cc/dotc/semanticdb/internal/SemanticdbMessage.scala b/tests/pos-with-compiler-cc/dotc/semanticdb/internal/SemanticdbMessage.scala
new file mode 100644
index 000000000000..e20d1691a05d
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/semanticdb/internal/SemanticdbMessage.scala
@@ -0,0 +1,7 @@
+package dotty.tools.dotc.semanticdb.internal
+
+trait SemanticdbMessage[A] {
+  def serializedSize: Int
+  def writeTo(out: SemanticdbOutputStream): Unit
+  def mergeFrom(in: SemanticdbInputStream): A
+}
diff --git a/tests/pos-with-compiler-cc/dotc/semanticdb/internal/SemanticdbOutputStream.scala b/tests/pos-with-compiler-cc/dotc/semanticdb/internal/SemanticdbOutputStream.scala
new file mode 100644
index 000000000000..37da7f868e25
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/semanticdb/internal/SemanticdbOutputStream.scala
@@ -0,0 +1,610 @@
+package dotty.tools.dotc.semanticdb.internal
+
+import scala.language.unsafeNulls
+
+import java.io.IOException
+import java.io.OutputStream
+import java.nio.ByteBuffer
+import java.nio.charset.StandardCharsets
+
+import SemanticdbOutputStream._
+
+object SemanticdbOutputStream {
+
+  val DEFAULT_BUFFER_SIZE = 4096
+
+  def computePreferredBufferSize(dataLength: Int): Int = {
+    if (dataLength > DEFAULT_BUFFER_SIZE) return DEFAULT_BUFFER_SIZE
+    dataLength
+  }
+
+  def newInstance(output: OutputStream): SemanticdbOutputStream = {
+    newInstance(output, DEFAULT_BUFFER_SIZE)
+  }
+
+  def newInstance(output: OutputStream, bufferSize: Int): SemanticdbOutputStream = {
+    new SemanticdbOutputStream(output, Array.ofDim[Byte](bufferSize))
+  }
+
+  def newInstance(byteBuffer: ByteBuffer): SemanticdbOutputStream = {
+    newInstance(byteBuffer, DEFAULT_BUFFER_SIZE)
+  }
+
+  def newInstance(b: Array[Byte]): SemanticdbOutputStream = {
+    new SemanticdbOutputStream(null, b)
+  }
+
+  def newInstance(
+      byteBuffer: ByteBuffer,
+      bufferSize: Int
+  ): SemanticdbOutputStream = {
+    newInstance(new ByteBufferOutputStream(byteBuffer), bufferSize)
+  }
+
+  private class ByteBufferOutputStream(private val byteBuffer: ByteBuffer)
+      extends OutputStream {
+
+    override def write(b: Int): Unit = {
+      byteBuffer.put(b.toByte)
+    }
+
+    override def write(data: Array[Byte], offset: Int, length: Int): Unit = {
+      byteBuffer.put(data, offset, length)
+    }
+  }
+
+  def computeDoubleSize(fieldNumber: Int, value: Double): Int = {
+    computeTagSize(fieldNumber) + computeDoubleSizeNoTag(value)
+  }
+
+  def computeFloatSize(fieldNumber: Int, value: Float): Int = {
+    computeTagSize(fieldNumber) + computeFloatSizeNoTag(value)
+  }
+
+  def computeUInt64Size(fieldNumber: Int, value: Long): Int = {
+    computeTagSize(fieldNumber) + computeUInt64SizeNoTag(value)
+  }
+
+  def computeInt64Size(fieldNumber: Int, value: Long): Int = {
+    computeTagSize(fieldNumber) + computeInt64SizeNoTag(value)
+  }
+
+  def computeInt32Size(fieldNumber: Int, value: Int): Int = {
+    computeTagSize(fieldNumber) + computeInt32SizeNoTag(value)
+  }
+
+  def computeFixed64Size(fieldNumber: Int, value: Long): Int = {
+    computeTagSize(fieldNumber) + computeFixed64SizeNoTag(value)
+  }
+
+  def computeFixed32Size(fieldNumber: Int, value: Int): Int = {
+    computeTagSize(fieldNumber) + computeFixed32SizeNoTag(value)
+  }
+
+  def computeBoolSize(fieldNumber: Int, value: Boolean): Int = {
+    computeTagSize(fieldNumber) + computeBoolSizeNoTag(value)
+  }
+
+  def computeStringSize(fieldNumber: Int, value: String): Int = {
+    computeTagSize(fieldNumber) + computeStringSizeNoTag(value)
+  }
+
+  // def computeBytesSize(fieldNumber: Int, value: ByteString): Int = {
+  //   computeTagSize(fieldNumber) + computeBytesSizeNoTag(value)
+  // }
+
+  def computeByteArraySize(fieldNumber: Int, value: Array[Byte]): Int = {
+    computeTagSize(fieldNumber) + computeByteArraySizeNoTag(value)
+  }
+
+  def computeByteBufferSize(fieldNumber: Int, value: ByteBuffer): Int = {
+    computeTagSize(fieldNumber) + computeByteBufferSizeNoTag(value)
+  }
+
+  def computeUInt32Size(fieldNumber: Int, value: Int): Int = {
+    computeTagSize(fieldNumber) + computeUInt32SizeNoTag(value)
+  }
+
+  def computeEnumSize(fieldNumber: Int, value: Int): Int = {
+    computeTagSize(fieldNumber) + computeEnumSizeNoTag(value)
+  }
+
+  def computeSFixed32Size(fieldNumber: Int, value: Int): Int = {
+    computeTagSize(fieldNumber) + computeSFixed32SizeNoTag(value)
+  }
+
+  def computeSFixed64Size(fieldNumber: Int, value: Long): Int = {
+    computeTagSize(fieldNumber) + computeSFixed64SizeNoTag(value)
+  }
+
+  def computeSInt32Size(fieldNumber: Int, value: Int): Int = {
+    computeTagSize(fieldNumber) + computeSInt32SizeNoTag(value)
+  }
+
+  def computeSInt64Size(fieldNumber: Int, value: Long): Int = {
+    computeTagSize(fieldNumber) + computeSInt64SizeNoTag(value)
+  }
+
+  def computeDoubleSizeNoTag(value: Double): Int = LITTLE_ENDIAN_64_SIZE
+
+  def computeFloatSizeNoTag(value: Float): Int = LITTLE_ENDIAN_32_SIZE
+
+  def computeUInt64SizeNoTag(value: Long): Int = computeRawVarint64Size(value)
+
+  def computeInt64SizeNoTag(value: Long): Int = computeRawVarint64Size(value)
+
+  def computeInt32SizeNoTag(value: Int): Int = {
+    if (value >= 0) {
+      computeRawVarint32Size(value)
+    } else {
+      10
+    }
+  }
+
+  def computeFixed64SizeNoTag(value: Long): Int = LITTLE_ENDIAN_64_SIZE
+
+  def computeFixed32SizeNoTag(value: Int): Int = LITTLE_ENDIAN_32_SIZE
+
+  def computeBoolSizeNoTag(value: Boolean): Int = 1
+
+  def computeStringSizeNoTag(value: String): Int = {
+    val bytes = value.getBytes(StandardCharsets.UTF_8)
+    computeRawVarint32Size(bytes.length) + bytes.length
+  }
+
+  // def computeBytesSizeNoTag(value: ByteString): Int = {
+  //   computeRawVarint32Size(value.size) + value.size
+  // }
+
+  def computeByteArraySizeNoTag(value: Array[Byte]): Int = {
+    computeRawVarint32Size(value.length) + value.length
+  }
+
+  def computeByteBufferSizeNoTag(value: ByteBuffer): Int = {
+    computeRawVarint32Size(value.capacity()) + value.capacity()
+  }
+
+  def computeUInt32SizeNoTag(value: Int): Int = computeRawVarint32Size(value)
+
+  def computeEnumSizeNoTag(value: Int): Int = computeInt32SizeNoTag(value)
+
+  def computeSFixed32SizeNoTag(value: Int): Int = LITTLE_ENDIAN_32_SIZE
+
+  def computeSFixed64SizeNoTag(value: Long): Int = LITTLE_ENDIAN_64_SIZE
+
+  def computeSInt32SizeNoTag(value: Int): Int = {
+    computeRawVarint32Size(encodeZigZag32(value))
+  }
+
+  def computeSInt64SizeNoTag(value: Long): Int = {
+    computeRawVarint64Size(encodeZigZag64(value))
+  }
+
+  @SerialVersionUID(-6947486886997889499L)
+  class OutOfSpaceException()
+      extends IOException(
+        "SemanticdbOutputStream was writing to a flat byte array and ran " +
+          "out of space."
+      )
+
+  def computeTagSize(fieldNumber: Int): Int = {
+    computeRawVarint32Size(WireFormat.makeTag(fieldNumber, 0))
+  }
+
+  def computeRawVarint32Size(value: Int): Int = {
+    if ((value & (0xffffffff << 7)) == 0) return 1
+    if ((value & (0xffffffff << 14)) == 0) return 2
+    if ((value & (0xffffffff << 21)) == 0) return 3
+    if ((value & (0xffffffff << 28)) == 0) return 4
+    5
+  }
+
+  def computeRawVarint64Size(value: Long): Int = {
+    if ((value & (0xFFFFFFFFFFFFFFFFL << 7)) == 0) return 1
+    if ((value & (0xFFFFFFFFFFFFFFFFL << 14)) == 0) return 2
+    if ((value & (0xFFFFFFFFFFFFFFFFL << 21)) == 0) return 3
+    if ((value & (0xFFFFFFFFFFFFFFFFL << 28)) == 0) return 4
+    if ((value & (0xFFFFFFFFFFFFFFFFL << 35)) == 0) return 5
+    if ((value & (0xFFFFFFFFFFFFFFFFL << 42)) == 0) return 6
+    if ((value & (0xFFFFFFFFFFFFFFFFL << 49)) == 0) return 7
+    if ((value & (0xFFFFFFFFFFFFFFFFL << 56)) == 0) return 8
+    if ((value & (0xFFFFFFFFFFFFFFFFL << 63)) == 0) return 9
+    10
+  }
+
+  val LITTLE_ENDIAN_32_SIZE = 4
+
+  val LITTLE_ENDIAN_64_SIZE = 8
+
+  def encodeZigZag32(n: Int): Int = (n << 1) ^ (n >> 31)
+
+  def encodeZigZag64(n: Long): Long = (n << 1) ^ (n >> 63)
+}
+
+class SemanticdbOutputStream(output: OutputStream, buffer: Array[Byte]) {
+  private def refreshBuffer(): Unit = {
+    if (output == null) {
+      throw new OutOfSpaceException()
+    }
+    output.write(buffer, 0, position)
+    position = 0
+  }
+
+  def flush(): Unit = {
+    if (output != null) {
+      refreshBuffer()
+    }
+  }
+
+  def spaceLeft(): Int = {
+    if (output == null) {
+      limit - position
+    } else {
+      throw new UnsupportedOperationException(
+        "spaceLeft() can only be called on SemanticdbOutputStreams that are " +
+          "writing to a flat array."
+      )
+    }
+  }
+
+  def checkNoSpaceLeft(): Unit = {
+    if (spaceLeft() != 0) {
+      throw new IllegalStateException("Did not write as much data as expected.")
+    }
+  }
+
+  private var position = 0
+  private val limit = buffer.length
+
+  private var totalBytesWritten: Int = 0
+
+  def writeDouble(fieldNumber: Int, value: Double): Unit = {
+    writeTag(fieldNumber, WireFormat.WIRETYPE_FIXED64)
+    writeDoubleNoTag(value)
+  }
+
+  def writeFloat(fieldNumber: Int, value: Float): Unit = {
+    writeTag(fieldNumber, WireFormat.WIRETYPE_FIXED32)
+    writeFloatNoTag(value)
+  }
+
+  def writeUInt64(fieldNumber: Int, value: Long): Unit = {
+    writeTag(fieldNumber, WireFormat.WIRETYPE_VARINT)
+    writeUInt64NoTag(value)
+  }
+
+  def writeInt64(fieldNumber: Int, value: Long): Unit = {
+    writeTag(fieldNumber, WireFormat.WIRETYPE_VARINT)
+    writeInt64NoTag(value)
+  }
+
+  def writeInt32(fieldNumber: Int, value: Int): Unit = {
+    writeTag(fieldNumber, WireFormat.WIRETYPE_VARINT)
+    writeInt32NoTag(value)
+  }
+
+  def writeFixed64(fieldNumber: Int, value: Long): Unit = {
+    writeTag(fieldNumber, WireFormat.WIRETYPE_FIXED64)
+    writeFixed64NoTag(value)
+  }
+
+  def writeFixed32(fieldNumber: Int, value: Int): Unit = {
+    writeTag(fieldNumber, WireFormat.WIRETYPE_FIXED32)
+    writeFixed32NoTag(value)
+  }
+
+  def writeBool(fieldNumber: Int, value: Boolean): Unit = {
+    writeTag(fieldNumber, WireFormat.WIRETYPE_VARINT)
+    writeBoolNoTag(value)
+  }
+
+  def writeString(fieldNumber: Int, value: String): Unit = {
+    writeTag(fieldNumber, WireFormat.WIRETYPE_LENGTH_DELIMITED)
+    writeStringNoTag(value)
+  }
+
+  // def writeBytes(fieldNumber: Int, value: ByteString): Unit = {
+  //   writeTag(fieldNumber, WireFormat.WIRETYPE_LENGTH_DELIMITED)
+  //   writeBytesNoTag(value)
+  // }
+
+  def writeByteArray(fieldNumber: Int, value: Array[Byte]): Unit = {
+    writeTag(fieldNumber, WireFormat.WIRETYPE_LENGTH_DELIMITED)
+    writeByteArrayNoTag(value)
+  }
+
+  def writeByteArray(
+      fieldNumber: Int,
+      value: Array[Byte],
+      offset: Int,
+      length: Int
+  ): Unit = {
+    writeTag(fieldNumber, WireFormat.WIRETYPE_LENGTH_DELIMITED)
+    writeByteArrayNoTag(value, offset, length)
+  }
+
+  def writeByteBuffer(fieldNumber: Int, value: ByteBuffer): Unit = {
+    writeTag(fieldNumber, WireFormat.WIRETYPE_LENGTH_DELIMITED)
+    writeByteBufferNoTag(value)
+  }
+
+  def writeUInt32(fieldNumber: Int, value: Int): Unit = {
+    writeTag(fieldNumber, WireFormat.WIRETYPE_VARINT)
+    writeUInt32NoTag(value)
+  }
+
+  def writeEnum(fieldNumber: Int, value: Int): Unit = {
+    writeTag(fieldNumber, WireFormat.WIRETYPE_VARINT)
+    writeEnumNoTag(value)
+  }
+
+  def writeSFixed32(fieldNumber: Int, value: Int): Unit = {
+    writeTag(fieldNumber, WireFormat.WIRETYPE_FIXED32)
+    writeSFixed32NoTag(value)
+  }
+
+  def writeSFixed64(fieldNumber: Int, value: Long): Unit = {
+    writeTag(fieldNumber, WireFormat.WIRETYPE_FIXED64)
+    writeSFixed64NoTag(value)
+  }
+
+  def writeSInt32(fieldNumber: Int, value: Int): Unit = {
+    writeTag(fieldNumber, WireFormat.WIRETYPE_VARINT)
+    writeSInt32NoTag(value)
+  }
+
+  def writeSInt64(fieldNumber: Int, value: Long): Unit = {
+    writeTag(fieldNumber, WireFormat.WIRETYPE_VARINT)
+    writeSInt64NoTag(value)
+  }
+
+  def writeDoubleNoTag(value: Double): Unit = {
+    writeRawLittleEndian64(java.lang.Double.doubleToLongBits(value))
+  }
+
+  def writeFloatNoTag(value: Float): Unit = {
+    writeRawLittleEndian32(java.lang.Float.floatToIntBits(value))
+  }
+
+  def writeUInt64NoTag(value: Long): Unit = {
+    writeRawVarint64(value)
+  }
+
+  def writeInt64NoTag(value: Long): Unit = {
+    writeRawVarint64(value)
+  }
+
+  def writeInt32NoTag(value: Int): Unit = {
+    if (value >= 0) {
+      writeRawVarint32(value)
+    } else {
+      writeRawVarint64(value)
+    }
+  }
+
+  def writeFixed64NoTag(value: Long): Unit = {
+    writeRawLittleEndian64(value)
+  }
+
+  def writeFixed32NoTag(value: Int): Unit = {
+    writeRawLittleEndian32(value)
+  }
+
+  def writeBoolNoTag(value: Boolean): Unit = {
+    writeRawByte(if (value) 1 else 0)
+  }
+
+  def writeStringNoTag(value: String): Unit = {
+    val bytes = value.getBytes(StandardCharsets.UTF_8)
+    writeRawVarint32(bytes.length)
+    writeRawBytes(bytes)
+  }
+
+  def writeTag(fieldNumber: Int, wireType: Int): Unit = {
+    writeRawVarint32(WireFormat.makeTag(fieldNumber, wireType))
+  }
+
+  def writeRawVarint32(value0: Int): Unit = {
+    var value = value0
+    while (true) {
+      if ((value & ~0x7F) == 0) {
+        writeRawByte(value)
+        return
+      } else {
+        writeRawByte((value & 0x7F) | 0x80)
+        value >>>= 7
+      }
+    }
+  }
+
+  def writeRawVarint64(value0: Long): Unit = {
+    var value = value0
+    while (true) {
+      if ((value & ~0x7FL) == 0) {
+        writeRawByte(value.toInt)
+        return
+      } else {
+        writeRawByte((value.toInt & 0x7F) | 0x80)
+        value >>>= 7
+      }
+    }
+  }
+
+  def writeRawLittleEndian32(value: Int): Unit = {
+    writeRawByte((value) & 0xFF)
+    writeRawByte((value >> 8) & 0xFF)
+    writeRawByte((value >> 16) & 0xFF)
+    writeRawByte((value >> 24) & 0xFF)
+  }
+
+  def writeRawLittleEndian64(value: Long): Unit = {
+    writeRawByte((value).toInt & 0xFF)
+    writeRawByte((value >> 8).toInt & 0xFF)
+    writeRawByte((value >> 16).toInt & 0xFF)
+    writeRawByte((value >> 24).toInt & 0xFF)
+    writeRawByte((value >> 32).toInt & 0xFF)
+    writeRawByte((value >> 40).toInt & 0xFF)
+    writeRawByte((value >> 48).toInt & 0xFF)
+    writeRawByte((value >> 56).toInt & 0xFF)
+  }
+
+  // def writeBytesNoTag(value: ByteString): Unit = {
+  //   writeRawVarint32(value.size)
+  //   writeRawBytes(value)
+  // }
+
+  def writeByteArrayNoTag(value: Array[Byte]): Unit = {
+    writeRawVarint32(value.length)
+    writeRawBytes(value)
+  }
+
+  def writeByteArrayNoTag(
+      value: Array[Byte],
+      offset: Int,
+      length: Int
+  ): Unit = {
+    writeRawVarint32(length)
+    writeRawBytes(value, offset, length)
+  }
+
+  def writeByteBufferNoTag(value: ByteBuffer): Unit = {
+    writeRawVarint32(value.capacity())
+    writeRawBytes(value)
+  }
+
+  def writeUInt32NoTag(value: Int): Unit = {
+    writeRawVarint32(value)
+  }
+
+  def writeEnumNoTag(value: Int): Unit = {
+    writeInt32NoTag(value)
+  }
+
+  def writeSFixed32NoTag(value: Int): Unit = {
+    writeRawLittleEndian32(value)
+  }
+
+  def writeSFixed64NoTag(value: Long): Unit = {
+    writeRawLittleEndian64(value)
+  }
+
+  def writeSInt32NoTag(value: Int): Unit = {
+    writeRawVarint32(encodeZigZag32(value))
+  }
+
+  def writeSInt64NoTag(value: Long): Unit = {
+    writeRawVarint64(encodeZigZag64(value))
+  }
+
+  def writeRawByte(value: Byte): Unit = {
+    if (position == limit) {
+      refreshBuffer()
+    }
+    buffer(position) = value
+    position += 1
+  }
+
+  def writeRawByte(value: Int): Unit = {
+    writeRawByte(value.toByte)
+  }
+
+  // def writeRawBytes(value: ByteString): Unit = {
+  //   var offset = 0
+  //   var length = value.size
+  //   if (limit - position >= length) {
+  //     // We have room in the current buffer.
+  //     value.copyTo(buffer, offset, position, length)
+  //     position += length
+  //     totalBytesWritten += length
+  //   } else {
+  //     // Write extends past current buffer.  Fill the rest of this buffer and
+  //     // flush.
+  //     val bytesWritten = limit - position
+  //     value.copyTo(buffer, offset, position, bytesWritten)
+  //     offset += bytesWritten
+  //     length -= bytesWritten
+  //     position = limit
+  //     totalBytesWritten += bytesWritten
+  //     refreshBuffer()
+  //     // Now deal with the rest.
+  //     // Since we have an output stream, this is our buffer
+  //     // and buffer offset == 0
+  //     if (length <= limit) {
+  //       value.copyTo(buffer, offset, 0, length)
+  //       position = length
+  //     } else {
+  //       value.slice(offset, offset + length).writeTo(output)
+  //     }
+  //     totalBytesWritten += length
+  //   }
+  // }
+
+  def writeRawBytes(value: Array[Byte]): Unit = {
+    writeRawBytes(value, 0, value.length)
+  }
+
+  def writeRawBytes(value: ByteBuffer): Unit = {
+    if (value.hasArray()) {
+      writeRawBytes(value.array(), value.arrayOffset(), value.capacity())
+    } else {
+      val duplicated = value.duplicate()
+      duplicated.clear()
+      writeRawBytesInternal(duplicated)
+    }
+  }
+
+  private def writeRawBytesInternal(value: ByteBuffer): Unit = {
+    var length = value.remaining()
+    if (limit - position >= length) {
+      value.get(buffer, position, length)
+      position += length
+      totalBytesWritten += length
+    } else {
+      val bytesWritten = limit - position
+      value.get(buffer, position, bytesWritten)
+      length -= bytesWritten
+      position = limit
+      totalBytesWritten += bytesWritten
+      refreshBuffer()
+      while (length > limit) {
+        value.get(buffer, 0, limit)
+        output.write(buffer, 0, limit)
+        length -= limit
+        totalBytesWritten += limit
+      }
+      value.get(buffer, 0, length)
+      position = length
+      totalBytesWritten += length
+    }
+  }
+
+  def writeRawBytes(value: Array[Byte], offset0: Int, length0: Int): Unit = {
+    var offset = offset0
+    var length = length0
+    if (limit - position >= length) {
+      System.arraycopy(value, offset, buffer, position, length)
+      position += length
+      totalBytesWritten += length
+    } else {
+      val bytesWritten = limit - position
+      System.arraycopy(value, offset, buffer, position, bytesWritten)
+      offset += bytesWritten
+      length -= bytesWritten
+      position = limit
+      totalBytesWritten += bytesWritten
+      refreshBuffer()
+      if (length <= limit) {
+        System.arraycopy(value, offset, buffer, 0, length)
+        position = length
+      } else {
+        output.write(value, offset, length)
+      }
+      totalBytesWritten += length
+    }
+  }
+
+}
+
+object Internal {
+  val EMPTY_BYTE_ARRAY: Array[Byte] = Array()
+}
diff --git a/tests/pos-with-compiler-cc/dotc/semanticdb/internal/SemanticdbTypeMapper.scala b/tests/pos-with-compiler-cc/dotc/semanticdb/internal/SemanticdbTypeMapper.scala
new file mode 100644
index 000000000000..71cb30fbd5fb
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/semanticdb/internal/SemanticdbTypeMapper.scala
@@ -0,0 +1,18 @@
+package dotty.tools.dotc.semanticdb.internal
+import language.experimental.pureFunctions
+
+abstract class SemanticdbTypeMapper[BaseType, CustomType] {
+  def toCustom(base: BaseType): CustomType
+  def toBase(custom: CustomType): BaseType
+}
+
+object SemanticdbTypeMapper {
+  def apply[BaseType, CustomType](baseToCustom: BaseType -> CustomType)(
+      customToBase: CustomType -> BaseType
+  ): SemanticdbTypeMapper[BaseType, CustomType] =
+    new SemanticdbTypeMapper[BaseType, CustomType] {
+      def toCustom(base: BaseType): CustomType = baseToCustom(base)
+      def toBase(custom: CustomType): BaseType = customToBase(custom)
+    }
+}
+
diff --git a/tests/pos-with-compiler-cc/dotc/semanticdb/internal/WireFormat.scala b/tests/pos-with-compiler-cc/dotc/semanticdb/internal/WireFormat.scala
new file mode 100644
index 000000000000..1a193fe99ca6
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/semanticdb/internal/WireFormat.scala
@@ -0,0 +1,20 @@
+package dotty.tools.dotc.semanticdb.internal
+
+object WireFormat {
+  val WIRETYPE_VARINT = 0
+  val WIRETYPE_FIXED64 = 1
+  val WIRETYPE_LENGTH_DELIMITED = 2
+  val WIRETYPE_START_GROUP = 3
+  val WIRETYPE_END_GROUP = 4
+  val WIRETYPE_FIXED32 = 5
+
+  val TAG_TYPE_BITS = 3
+  val TAG_TYPE_MASK = (1 << TAG_TYPE_BITS) - 1
+
+  def getTagWireType(tag: Int) = tag & TAG_TYPE_MASK
+
+  def makeTag(fieldNumber: Int, wireType: Int) =
+    (fieldNumber << TAG_TYPE_BITS) | wireType
+
+  def getTagFieldNumber(tag: Int): Int = tag >>> TAG_TYPE_BITS
+}
diff --git a/tests/pos-with-compiler-cc/dotc/transform/AccessProxies.scala b/tests/pos-with-compiler-cc/dotc/transform/AccessProxies.scala
new file mode 100644
index 000000000000..14362260d032
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/transform/AccessProxies.scala
@@ -0,0 +1,174 @@
+package dotty.tools
+package dotc
+package transform
+
+import core._
+import Contexts._
+import Symbols._
+import Flags._
+import Names._
+import NameOps._
+import Decorators._
+import TypeUtils._
+import Types._
+import util.Spans.Span
+import config.Printers.transforms
+
+/** A utility class for generating access proxies. Currently used for
+ *  inline accessors and protected accessors.
+ */
+abstract class AccessProxies {
+  import ast.tpd._
+  import AccessProxies._
+
+  /** accessor -> accessed */
+  private val accessedBy = MutableSymbolMap[Symbol]()
+
+  /** Given the name of an accessor, is the receiver of the call to accessed obtained
+   *  as a parameterer?
+   */
+  protected def passReceiverAsArg(accessorName: Name)(using Context): Boolean = false
+
+  /** The accessor definitions that need to be added to class `cls` */
+  private def accessorDefs(cls: Symbol)(using Context): Iterator[DefDef] =
+    for accessor <- cls.info.decls.iterator; accessed <- accessedBy.get(accessor) yield
+      DefDef(accessor.asTerm, prefss => {
+        def numTypeParams = accessed.info match {
+          case info: PolyType => info.paramNames.length
+          case _ => 0
+        }
+        val (targs, argss) = splitArgs(prefss)
+        val (accessRef, forwardedTpts, forwardedArgss) =
+          if (passReceiverAsArg(accessor.name))
+            (argss.head.head.select(accessed), targs.takeRight(numTypeParams), argss.tail)
+          else
+            (if (accessed.isStatic) ref(accessed) else ref(TermRef(cls.thisType, accessed)),
+             targs, argss)
+        val rhs =
+          if (accessor.name.isSetterName &&
+              forwardedArgss.nonEmpty && forwardedArgss.head.nonEmpty) // defensive conditions
+            accessRef.becomes(forwardedArgss.head.head)
+          else
+            accessRef
+              .appliedToTypeTrees(forwardedTpts)
+              .appliedToArgss(forwardedArgss)
+              .etaExpandCFT(using ctx.withOwner(accessor))
+        rhs.withSpan(accessed.span)
+      })
+
+  /** Add all needed accessors to the `body` of class `cls` */
+  def addAccessorDefs(cls: Symbol, body: List[Tree])(using Context): List[Tree] = {
+    val accDefs = accessorDefs(cls).toList
+    transforms.println(i"add accessors for $cls: $accDefs%, %")
+    if (accDefs.isEmpty) body else body ++ accDefs
+  }
+
+  trait Insert {
+    import ast.tpd._
+
+    /** The name of the accessor for definition with given `name` in given `site` */
+    def accessorNameOf(name: TermName, site: Symbol)(using Context): TermName
+    def needsAccessor(sym: Symbol)(using Context): Boolean
+
+    def ifNoHost(reference: RefTree)(using Context): Tree = {
+      assert(false, "no host found for $reference with ${reference.symbol.showLocated} from ${ctx.owner}")
+      reference
+    }
+
+    /** A fresh accessor symbol */
+    private def newAccessorSymbol(owner: Symbol, name: TermName, info: Type, accessed: Symbol)(using Context): TermSymbol = {
+      val sym = newSymbol(owner, name, Synthetic | Method, info, coord = accessed.span).entered
+      if accessed.is(Private) then sym.setFlag(Final)
+      else if sym.allOverriddenSymbols.exists(!_.is(Deferred)) then sym.setFlag(Override)
+      if accessed.hasAnnotation(defn.ExperimentalAnnot) then
+        sym.addAnnotation(defn.ExperimentalAnnot)
+      sym
+    }
+
+    /** An accessor symbol, create a fresh one unless one exists already */
+    protected def accessorSymbol(owner: Symbol, accessorName: TermName, accessorInfo: Type, accessed: Symbol)(using Context): Symbol = {
+      def refersToAccessed(sym: Symbol) = accessedBy.get(sym).contains(accessed)
+      owner.info.decl(accessorName).suchThat(refersToAccessed).symbol.orElse {
+        val acc = newAccessorSymbol(owner, accessorName, accessorInfo, accessed)
+        accessedBy(acc) = accessed
+        acc
+      }
+    }
+
+    /** Rewire reference to refer to `accessor` symbol */
+    private def rewire(reference: RefTree, accessor: Symbol)(using Context): Tree = {
+      reference match {
+        case Select(qual, _) if qual.tpe.derivesFrom(accessor.owner) => qual.select(accessor)
+        case _ => ref(accessor)
+      }
+    }.withSpan(reference.span)
+
+    /** Given a reference to a getter accessor, the corresponding setter reference */
+    def useSetter(getterRef: Tree)(using Context): Tree = getterRef match {
+      case getterRef: RefTree =>
+        val getter = getterRef.symbol.asTerm
+        val accessed = accessedBy(getter)
+        val setterName = getter.name.setterName
+        def toSetterInfo(getterInfo: Type): Type = getterInfo match {
+          case getterInfo: LambdaType =>
+            getterInfo.derivedLambdaType(resType = toSetterInfo(getterInfo.resType))
+          case _ =>
+            MethodType(getterInfo :: Nil, defn.UnitType)
+        }
+        val setterInfo = toSetterInfo(getter.info.widenExpr)
+        val setter = accessorSymbol(getter.owner, setterName, setterInfo, accessed)
+        rewire(getterRef, setter)
+      case Apply(fn, args) =>
+        cpy.Apply(getterRef)(useSetter(fn), args)
+      case TypeApply(fn, args) =>
+        cpy.TypeApply(getterRef)(useSetter(fn), args)
+    }
+
+    /** Create an accessor unless one exists already, and replace the original
+      *  access with a reference to the accessor.
+      *
+      *  @param reference    The original reference to the non-public symbol
+      *  @param onLHS        The reference is on the left-hand side of an assignment
+      */
+    def useAccessor(reference: RefTree)(using Context): Tree = {
+      val accessed = reference.symbol.asTerm
+      var accessorClass = hostForAccessorOf(accessed: Symbol)
+      if (accessorClass.exists) {
+        if accessorClass.is(Package) then
+          accessorClass = ctx.owner.topLevelClass
+        val accessorName = accessorNameOf(accessed.name, accessorClass)
+        val accessorInfo =
+          accessed.info.ensureMethodic.asSeenFrom(accessorClass.thisType, accessed.owner)
+        val accessor = accessorSymbol(accessorClass, accessorName, accessorInfo, accessed)
+        rewire(reference, accessor)
+      }
+      else ifNoHost(reference)
+    }
+
+    /** Replace tree with a reference to an accessor if needed */
+    def accessorIfNeeded(tree: Tree)(using Context): Tree = tree match {
+      case tree: RefTree if needsAccessor(tree.symbol) =>
+        if (tree.symbol.isConstructor) {
+          report.error("Implementation restriction: cannot use private constructors in inlineable methods", tree.srcPos)
+          tree // TODO: create a proper accessor for the private constructor
+        }
+        else useAccessor(tree)
+      case _ =>
+        tree
+    }
+  }
+}
+object AccessProxies {
+  /** Where an accessor for the `accessed` symbol should be placed.
+   *  This is the closest enclosing class that has `accessed` as a member.
+   */
+  def hostForAccessorOf(accessed: Symbol)(using Context): Symbol = {
+    def recur(cls: Symbol): Symbol =
+      if (!cls.exists) NoSymbol
+      else if cls.derivesFrom(accessed.owner)
+              || cls.companionModule.moduleClass == accessed.owner
+      then cls
+      else recur(cls.owner)
+    recur(ctx.owner)
+  }
+}
diff --git a/tests/pos-with-compiler-cc/dotc/transform/ArrayApply.scala b/tests/pos-with-compiler-cc/dotc/transform/ArrayApply.scala
new file mode 100644
index 000000000000..872c7cc897de
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/transform/ArrayApply.scala
@@ -0,0 +1,76 @@
+package dotty.tools.dotc
+package transform
+
+import core._
+import MegaPhase._
+import Contexts._
+import Symbols._
+import Flags._
+import StdNames._
+import dotty.tools.dotc.ast.tpd
+
+
+
+/** This phase rewrites calls to `Array.apply` to a direct instantiation of the array in the bytecode.
+ *
+ *  Transforms `scala.Array.apply([....])` and `scala.Array.apply(..., [....])` into `[...]`
+ */
+class ArrayApply extends MiniPhase {
+  import tpd._
+
+  override def phaseName: String = ArrayApply.name
+
+  override def description: String = ArrayApply.description
+
+  override def transformApply(tree: tpd.Apply)(using Context): tpd.Tree =
+    if isArrayModuleApply(tree.symbol) then
+      tree.args match {
+        case StripAscription(Apply(wrapRefArrayMeth, (seqLit: tpd.JavaSeqLiteral) :: Nil)) :: ct :: Nil
+            if defn.WrapArrayMethods().contains(wrapRefArrayMeth.symbol) && elideClassTag(ct) =>
+          seqLit
+
+        case elem0 :: StripAscription(Apply(wrapRefArrayMeth, (seqLit: tpd.JavaSeqLiteral) :: Nil)) :: Nil
+            if defn.WrapArrayMethods().contains(wrapRefArrayMeth.symbol) =>
+          tpd.JavaSeqLiteral(elem0 :: seqLit.elems, seqLit.elemtpt)
+
+        case _ =>
+          tree
+      }
+
+    else tree
+
+  private def isArrayModuleApply(sym: Symbol)(using Context): Boolean =
+    sym.name == nme.apply
+    && (sym.owner == defn.ArrayModuleClass || (sym.owner == defn.IArrayModuleClass && !sym.is(Extension)))
+
+  /** Only optimize when classtag if it is one of
+   *  - `ClassTag.apply(classOf[XYZ])`
+   *  - `ClassTag.apply(java.lang.XYZ.Type)` for boxed primitives `XYZ``
+   *  - `ClassTag.XYZ` for primitive types
+   */
+  private def elideClassTag(ct: Tree)(using Context): Boolean = ct match {
+    case Apply(_, rc :: Nil) if ct.symbol == defn.ClassTagModule_apply =>
+      rc match {
+        case _: Literal => true // ClassTag.apply(classOf[XYZ])
+        case rc: RefTree if rc.name == nme.TYPE_ =>
+          // ClassTag.apply(java.lang.XYZ.Type)
+          defn.ScalaBoxedClasses().contains(rc.symbol.maybeOwner.companionClass)
+        case _ => false
+      }
+    case Apply(ctm: RefTree, _) if ctm.symbol.maybeOwner.companionModule == defn.ClassTagModule =>
+      // ClassTag.XYZ
+      nme.ScalaValueNames.contains(ctm.name)
+    case _ => false
+  }
+
+  object StripAscription {
+    def unapply(tree: Tree)(using Context): Some[Tree] = tree match {
+      case Typed(expr, _) => unapply(expr)
+      case _ => Some(tree)
+    }
+  }
+}
+
+object ArrayApply:
+  val name: String = "arrayApply"
+  val description: String = "optimize `scala.Array.apply`"
diff --git a/tests/pos-with-compiler-cc/dotc/transform/ArrayConstructors.scala b/tests/pos-with-compiler-cc/dotc/transform/ArrayConstructors.scala
new file mode 100644
index 000000000000..e783961649dd
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/transform/ArrayConstructors.scala
@@ -0,0 +1,56 @@
+package dotty.tools.dotc
+package transform
+
+import core._
+import MegaPhase._
+import Contexts._
+import Symbols._
+import Types._
+import StdNames._
+import dotty.tools.dotc.ast.tpd
+
+
+import scala.collection.immutable.::
+
+
+/** This phase rewrites calls to array constructors to newArray method in Dotty.runtime.Arrays module.
+ *
+ * It assummes that generic arrays have already been handled by typer(see Applications.convertNewGenericArray).
+ * Additionally it optimizes calls to scala.Array.ofDim functions by replacing them with calls to newArray with specific dimensions
+ */
+class ArrayConstructors extends MiniPhase {
+  import ast.tpd._
+
+  override def phaseName: String = ArrayConstructors.name
+
+  override def description: String = ArrayConstructors.description
+
+  override def transformApply(tree: tpd.Apply)(using Context): tpd.Tree = {
+    def expand(elemType: Type, dims: List[Tree]) =
+      tpd.newArray(elemType, tree.tpe, tree.span, JavaSeqLiteral(dims, TypeTree(defn.IntClass.typeRef)))
+
+    if (tree.fun.symbol eq defn.ArrayConstructor) {
+      val TypeApply(tycon, targ :: Nil) = tree.fun: @unchecked
+      expand(targ.tpe, tree.args)
+    }
+    else if ((tree.fun.symbol.maybeOwner eq defn.ArrayModuleClass) && (tree.fun.symbol.name eq nme.ofDim) && !tree.tpe.isInstanceOf[MethodicType]) {
+      val Apply(Apply(TypeApply(_, List(tp)), _), _) = tree: @unchecked
+      val cs = tp.tpe.classSymbol
+      tree.fun match {
+        case Apply(TypeApply(t: Ident, targ), dims)
+          if !TypeErasure.isGeneric(targ.head.tpe) && !ValueClasses.isDerivedValueClass(cs) =>
+          expand(targ.head.tpe, dims)
+        case Apply(TypeApply(t: Select, targ), dims)
+          if !TypeErasure.isGeneric(targ.head.tpe) && !ValueClasses.isDerivedValueClass(cs) =>
+          Block(t.qualifier :: Nil, expand(targ.head.tpe, dims))
+        case _ => tree
+      }
+    }
+
+    else tree
+  }
+}
+
+object ArrayConstructors:
+  val name: String = "arrayConstructors"
+  val description: String = "intercept creation of (non-generic) arrays and intrinsify"
diff --git a/tests/pos-with-compiler-cc/dotc/transform/BeanProperties.scala b/tests/pos-with-compiler-cc/dotc/transform/BeanProperties.scala
new file mode 100644
index 000000000000..0d464d319848
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/transform/BeanProperties.scala
@@ -0,0 +1,65 @@
+package dotty.tools.dotc
+package transform
+
+import core._
+import ast.tpd._
+import Annotations._
+import Contexts._
+import Symbols.newSymbol
+import Decorators._
+import Flags._
+import Names._
+import Types._
+import util.Spans._
+
+import DenotTransformers._
+
+class BeanProperties(thisPhase: DenotTransformer):
+  def addBeanMethods(impl: Template)(using Context): Template =
+    val origBody = impl.body
+    cpy.Template(impl)(body = impl.body.flatMap {
+      case v: ValDef => generateAccessors(v)
+      case _ => Nil
+    } ::: origBody)
+
+  def generateAccessors(valDef: ValDef)(using Context): List[Tree] =
+    import Symbols.defn
+
+    def generateGetter(valDef: ValDef, annot: Annotation)(using Context) : Tree =
+      val prefix = if annot matches defn.BooleanBeanPropertyAnnot then "is" else "get"
+      val meth = newSymbol(
+        owner = ctx.owner,
+        name = prefixedName(prefix, valDef.name),
+        flags = Method | Synthetic | Invisible,
+        info = MethodType(Nil, valDef.denot.info),
+        coord = annot.tree.span
+      ).enteredAfter(thisPhase).asTerm
+      meth.addAnnotations(valDef.symbol.annotations)
+      val body: Tree = ref(valDef.symbol)
+      DefDef(meth, body)
+
+    def maybeGenerateSetter(valDef: ValDef, annot: Annotation)(using Context): Option[Tree] =
+      Option.when(valDef.denot.asSymDenotation.flags.is(Mutable)) {
+        val owner = ctx.owner
+        val meth = newSymbol(
+          owner,
+          name = prefixedName("set", valDef.name),
+          flags = Method | Synthetic | Invisible,
+          info = MethodType(valDef.name :: Nil, valDef.denot.info :: Nil, defn.UnitType),
+          coord = annot.tree.span
+        ).enteredAfter(thisPhase).asTerm
+        meth.addAnnotations(valDef.symbol.annotations)
+        def body(params: List[List[Tree]]): Tree = Assign(ref(valDef.symbol), params.head.head)
+        DefDef(meth, body)
+      }
+
+    def prefixedName(prefix: String, valName: Name) =
+      (prefix + valName.lastPart.toString.capitalize).toTermName
+
+    val symbol = valDef.denot.symbol
+    symbol.getAnnotation(defn.BeanPropertyAnnot)
+      .orElse(symbol.getAnnotation(defn.BooleanBeanPropertyAnnot))
+      .toList.flatMap { annot =>
+        generateGetter(valDef, annot) +: maybeGenerateSetter(valDef, annot) ++: Nil
+      }
+  end generateAccessors
diff --git a/tests/pos-with-compiler-cc/dotc/transform/BetaReduce.scala b/tests/pos-with-compiler-cc/dotc/transform/BetaReduce.scala
new file mode 100644
index 000000000000..90c0207ebb6d
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/transform/BetaReduce.scala
@@ -0,0 +1,106 @@
+package dotty.tools
+package dotc
+package transform
+
+import core._
+import Flags._
+import MegaPhase._
+import Symbols._, Contexts._, Types._, Decorators._
+import StdNames.nme
+import ast.TreeTypeMap
+
+/** Rewrite an application
+ *
+ *    (((x1, ..., xn) => b): T)(y1, ..., yn)
+ *
+ *  where
+ *
+ *    - all yi are pure references without a prefix
+ *    - the closure can also be contextual or erased, but cannot be a SAM type
+ *    _ the type ascription ...: T is optional
+ *
+ *  to
+ *
+ *    [xi := yi]b
+ *
+ *  This is more limited than beta reduction in inlining since it only works for simple variables `yi`.
+ *  It is more general since it also works for type-ascripted closures.
+ *
+ *  A typical use case is eliminating redundant closures for blackbox macros that
+ *  return context functions. See i6375.scala.
+ */
+class BetaReduce extends MiniPhase:
+  import ast.tpd._
+
+  override def phaseName: String = BetaReduce.name
+
+  override def description: String = BetaReduce.description
+
+  override def transformApply(app: Apply)(using Context): Tree = app.fun match
+    case Select(fn, nme.apply) if defn.isFunctionType(fn.tpe) =>
+      val app1 = BetaReduce(app, fn, app.args)
+      if app1 ne app then report.log(i"beta reduce $app -> $app1")
+      app1
+    case _ =>
+      app
+
+
+object BetaReduce:
+  import ast.tpd._
+
+  val name: String = "betaReduce"
+  val description: String = "reduce closure applications"
+
+  /** Beta-reduces a call to `fn` with arguments `argSyms` or returns `tree` */
+  def apply(original: Tree, fn: Tree, args: List[Tree])(using Context): Tree =
+    fn match
+      case Typed(expr, _) =>
+        BetaReduce(original, expr, args)
+      case Block((anonFun: DefDef) :: Nil, closure: Closure) =>
+        BetaReduce(anonFun, args)
+      case Block(stats, expr) =>
+        val tree = BetaReduce(original, expr, args)
+        if tree eq original then original
+        else cpy.Block(fn)(stats, tree)
+      case Inlined(call, bindings, expr) =>
+        val tree = BetaReduce(original, expr, args)
+        if tree eq original then original
+        else cpy.Inlined(fn)(call, bindings, tree)
+      case _ =>
+        original
+  end apply
+
+  /** Beta-reduces a call to `ddef` with arguments `argSyms` */
+  def apply(ddef: DefDef, args: List[Tree])(using Context) =
+    val bindings = List.newBuilder[ValDef]
+    val vparams = ddef.termParamss.iterator.flatten.toList
+    assert(args.hasSameLengthAs(vparams))
+    val argSyms =
+      for (arg, param) <- args.zip(vparams) yield
+        arg.tpe.dealias match
+          case ref @ TermRef(NoPrefix, _) if isPurePath(arg) =>
+            ref.symbol
+          case _ =>
+            val flags = Synthetic | (param.symbol.flags & Erased)
+            val tpe = if arg.tpe.dealias.isInstanceOf[ConstantType] then arg.tpe.dealias else arg.tpe.widen
+            val binding = ValDef(newSymbol(ctx.owner, param.name, flags, tpe, coord = arg.span), arg).withSpan(arg.span)
+            bindings += binding
+            binding.symbol
+
+    val expansion = TreeTypeMap(
+      oldOwners = ddef.symbol :: Nil,
+      newOwners = ctx.owner :: Nil,
+      substFrom = vparams.map(_.symbol),
+      substTo = argSyms
+    ).transform(ddef.rhs)
+
+    val expansion1 = new TreeMap {
+      override def transform(tree: Tree)(using Context) = tree.tpe.widenTermRefExpr match
+        case ConstantType(const) if isPureExpr(tree) => cpy.Literal(tree)(const)
+        case _ => super.transform(tree)
+    }.transform(expansion)
+    val bindings1 =
+      bindings.result().filterNot(vdef => vdef.tpt.tpe.isInstanceOf[ConstantType] && isPureExpr(vdef.rhs))
+
+    seq(bindings1, expansion1)
+  end apply
diff --git a/tests/pos-with-compiler-cc/dotc/transform/Bridges.scala b/tests/pos-with-compiler-cc/dotc/transform/Bridges.scala
new file mode 100644
index 000000000000..e302170991f9
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/transform/Bridges.scala
@@ -0,0 +1,180 @@
+package dotty.tools
+package dotc
+package transform
+
+import core._
+import Symbols._, Types._, Contexts._, Decorators._, Flags._, Scopes._, Phases._
+import DenotTransformers._
+import ast.untpd
+import collection.{mutable, immutable}
+import util.SrcPos
+import ContextFunctionResults.{contextResultCount, contextFunctionResultTypeAfter}
+import StdNames.nme
+import Constants.Constant
+import TypeErasure.transformInfo
+import Erasure.Boxing.adaptClosure
+
+/** A helper class for generating bridge methods in class `root`. */
+class Bridges(root: ClassSymbol, thisPhase: DenotTransformer)(using Context) {
+  import ast.tpd._
+
+  assert(ctx.phase == erasurePhase.next)
+  private val preErasureCtx = ctx.withPhase(erasurePhase)
+  private lazy val elimErasedCtx = ctx.withPhase(elimErasedValueTypePhase.next)
+
+  private class BridgesCursor(using Context) extends OverridingPairs.Cursor(root) {
+
+    override def isSubParent(parent: Symbol, bc: Symbol)(using Context) =
+      true
+      	// Never consider a bridge if there is a superclass that would contain it
+      	// See run/t2857.scala for a test that would break with a VerifyError otherwise.
+
+    /** Only use the superclass of `root` as a parent class. This means
+     *  overriding pairs that have a common implementation in a trait parent
+     *  are also counted. This is necessary because we generate bridge methods
+     *  only in classes, never in traits.
+     */
+    override def parents = Array(root.superClass)
+
+    override def exclude(sym: Symbol) =
+      !sym.isOneOf(MethodOrModule) || sym.isAllOf(Module | JavaDefined) || super.exclude(sym)
+
+    override def canBeHandledByParent(sym1: Symbol, sym2: Symbol, parent: Symbol): Boolean =
+      OverridingPairs.isOverridingPair(sym1, sym2, parent.thisType)
+  }
+
+  val site = root.thisType
+
+  private var toBeRemoved = immutable.Set[Symbol]()
+  private val bridges = mutable.ListBuffer[Tree]()
+  private val bridgesScope = newScope
+  private val bridgeTarget = MutableSymbolMap[Symbol]()
+
+  def bridgePosFor(member: Symbol): SrcPos =
+    (if (member.owner == root && member.span.exists) member else root).srcPos
+
+  /** Add a bridge between `member` and `other`, where `member` overrides `other`
+   *  before erasure, if the following conditions are satisfied.
+   *
+   *   - `member` and `other` have different signatures
+   *   - there is not yet a bridge with the same name and signature in `root`.
+   *
+   *  The bridge has the erased info of `other` and forwards to `member`.
+   *  Additionally, if `member` and `other` do have the same signature,
+   *  but not the same type after erasure and before elimErasedValueTypes
+   *  issue an error: A bridge would be needed yet it would clash with the member itself.
+   *  See neg/i1905.scala
+   */
+  private def addBridgeIfNeeded(member: Symbol, other: Symbol) = {
+    def bridgeExists =
+      bridgesScope.lookupAll(member.name).exists(bridge =>
+        bridgeTarget(bridge) == member && bridge.signature == other.signature)
+    def info(sym: Symbol)(using Context) = sym.info
+    def desc(sym: Symbol)= {
+      val infoStr = info(sym)(using preErasureCtx) match {
+        case ExprType(info) => i": $info"
+        case info => info.show
+      }
+      i"$sym$infoStr in ${sym.owner}"
+    }
+    if (member.signature == other.signature) {
+      if (!member.info.matches(other.info))
+        report.error(em"""bridge generated for member ${desc(member)}
+                      |which overrides ${desc(other)}
+                      |clashes with definition of the member itself; both have erased type ${info(member)(using elimErasedCtx)}."""",
+                  bridgePosFor(member))
+    }
+    else if !inContext(preErasureCtx)(site.memberInfo(member).matches(site.memberInfo(other))) then
+      // Neither symbol signatures nor pre-erasure types seen from root match; this means
+      // according to Scala 2 semantics there is no override.
+      // A bridge might introduce a classcast exception.
+      // Example where this was observed: run/i12828a.scala and MapView in stdlib213
+      report.log(i"suppress bridge in $root for ${member} in ${member.owner} and ${other.showLocated} since member infos ${site.memberInfo(member)} and ${site.memberInfo(other)} do not match")
+    else if !bridgeExists then
+      addBridge(member, other)
+  }
+
+  /** Generate bridge between `member` and `other`
+   */
+  private def addBridge(member: Symbol, other: Symbol) = {
+    val bridge = other.copy(
+      owner = root,
+      flags = (member.flags | Method | Bridge | Artifact) &~
+        (Accessor | ParamAccessor | CaseAccessor | Deferred | Lazy | Module),
+      coord = bridgePosFor(member).span).enteredAfter(thisPhase).asTerm
+
+    report.debuglog(
+      i"""generating bridge from ${other.showLocated}: ${other.info}
+             |to ${member.showLocated}: ${member.info} @ ${member.span}
+             |bridge: ${bridge.showLocated} with flags: ${bridge.flagsString}""")
+
+    bridgeTarget(bridge) = member
+    bridgesScope.enter(bridge)
+
+    if (other.owner == root) {
+      root.delete(other)
+      toBeRemoved += other
+    }
+
+    val memberCount = contextResultCount(member)
+
+    /** Eta expand application `ref(args)` as needed.
+     *  To do this correctly, we have to look at the member's original pre-erasure
+     *  type and figure out which context function types in its result are
+     *  not yet instantiated.
+     */
+    def etaExpand(ref: Tree, args: List[Tree])(using Context): Tree =
+      def expand(args: List[Tree], tp: Type, n: Int)(using Context): Tree =
+        if n <= 0 then
+          assert(ctx.typer.isInstanceOf[Erasure.Typer])
+          ctx.typer.typed(untpd.cpy.Apply(ref)(ref, args), member.info.finalResultType)
+        else
+          val defn.ContextFunctionType(argTypes, resType, isErased) = tp: @unchecked
+          val anonFun = newAnonFun(ctx.owner,
+            MethodType(if isErased then Nil else argTypes, resType),
+            coord = ctx.owner.coord)
+          anonFun.info = transformInfo(anonFun, anonFun.info)
+
+          def lambdaBody(refss: List[List[Tree]]) =
+            val refs :: Nil = refss: @unchecked
+            val expandedRefs = refs.map(_.withSpan(ctx.owner.span.endPos)) match
+              case (bunchedParam @ Ident(nme.ALLARGS)) :: Nil =>
+                argTypes.indices.toList.map(n =>
+                  bunchedParam
+                    .select(nme.primitive.arrayApply)
+                    .appliedTo(Literal(Constant(n))))
+              case refs1 => refs1
+            expand(args ::: expandedRefs, resType, n - 1)(using ctx.withOwner(anonFun))
+
+          val unadapted = Closure(anonFun, lambdaBody)
+          cpy.Block(unadapted)(unadapted.stats,
+            adaptClosure(unadapted.expr.asInstanceOf[Closure]))
+      end expand
+
+      val otherCount = contextResultCount(other)
+      val start = contextFunctionResultTypeAfter(member, otherCount)(using preErasureCtx)
+      expand(args, start, memberCount - otherCount)(using ctx.withOwner(bridge))
+    end etaExpand
+
+    def bridgeRhs(argss: List[List[Tree]]) =
+      assert(argss.tail.isEmpty)
+      val ref = This(root).select(member)
+      if member.info.isParameterless then ref // can happen if `member` is a module
+      else if memberCount == 0 then ref.appliedToTermArgs(argss.head)
+      else etaExpand(ref, argss.head)
+
+    bridges += DefDef(bridge, bridgeRhs(_).withSpan(bridge.span))
+  }
+
+  /** Add all necessary bridges to template statements `stats`, and remove at the same
+   *  time deferred methods in `stats` that are replaced by a bridge with the same signature.
+   */
+  def add(stats: List[untpd.Tree]): List[untpd.Tree] =
+    val opc = inContext(preErasureCtx) { new BridgesCursor }
+    while opc.hasNext do
+      if !opc.overriding.is(Deferred) then
+        addBridgeIfNeeded(opc.overriding, opc.overridden)
+      opc.next()
+    if bridges.isEmpty then stats
+    else stats.filterNot(stat => toBeRemoved contains stat.symbol) ::: bridges.toList
+}
diff --git a/tests/pos-with-compiler-cc/dotc/transform/CapturedVars.scala b/tests/pos-with-compiler-cc/dotc/transform/CapturedVars.scala
new file mode 100644
index 000000000000..32bcc53184b1
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/transform/CapturedVars.scala
@@ -0,0 +1,173 @@
+package dotty.tools.dotc
+package transform
+
+import MegaPhase._
+import core.DenotTransformers._
+import core.Symbols._
+import core.Contexts._
+import core.Flags._
+import core.Decorators._
+import core.StdNames.nme
+import core.Names._
+import core.NameKinds.TempResultName
+import core.Constants._
+import util.Store
+import dotty.tools.uncheckedNN
+
+/** This phase translates variables that are captured in closures to
+ *  heap-allocated refs.
+ */
+class CapturedVars extends MiniPhase with IdentityDenotTransformer:
+  thisPhase =>
+  import ast.tpd._
+
+  override def phaseName: String = CapturedVars.name
+
+  override def description: String = CapturedVars.description
+
+  override def runsAfterGroupsOf: Set[String] = Set(LiftTry.name)
+    // lifting tries changes what variables are considered to be captured
+
+  private[this] var Captured: Store.Location[util.ReadOnlySet[Symbol]] = _
+  private def captured(using Context) = ctx.store(Captured)
+
+  override def initContext(ctx: FreshContext): Unit =
+    Captured = ctx.addLocation(util.ReadOnlySet.empty)
+
+  private class RefInfo(using Context) {
+    /** The classes for which a Ref type exists. */
+    val refClassKeys: collection.Set[Symbol] =
+      defn.ScalaNumericValueClasses() `union` Set(defn.BooleanClass, defn.ObjectClass)
+
+    val refClass: Map[Symbol, Symbol] =
+      refClassKeys.map(rc => rc -> requiredClass(s"scala.runtime.${rc.name}Ref")).toMap
+
+    val volatileRefClass: Map[Symbol, Symbol] =
+      refClassKeys.map(rc => rc -> requiredClass(s"scala.runtime.Volatile${rc.name}Ref")).toMap
+
+    val boxedRefClasses: collection.Set[Symbol] =
+      refClassKeys.flatMap(k => Set(refClass(k), volatileRefClass(k)))
+
+    val objectRefClasses: collection.Set[Symbol] =
+      Set(refClass(defn.ObjectClass), volatileRefClass(defn.ObjectClass))
+  }
+
+  private var myRefInfo: RefInfo | Null = null
+  private def refInfo(using Context): RefInfo = {
+    if (myRefInfo == null) myRefInfo = new RefInfo()
+    myRefInfo.uncheckedNN
+  }
+
+  private class CollectCaptured extends TreeTraverser {
+    private val captured = util.HashSet[Symbol]()
+    def traverse(tree: Tree)(using Context) = tree match {
+      case id: Ident =>
+        val sym = id.symbol
+        if (sym.is(Mutable, butNot = Method) && sym.owner.isTerm) {
+          val enclMeth = ctx.owner.enclosingMethod
+          if (sym.enclosingMethod != enclMeth) {
+            report.log(i"capturing $sym in ${sym.enclosingMethod}, referenced from $enclMeth")
+            captured += sym
+          }
+        }
+      case _ =>
+        traverseChildren(tree)
+    }
+    def runOver(tree: Tree)(using Context): util.ReadOnlySet[Symbol] = {
+      traverse(tree)
+      captured
+    }
+  }
+
+  override def prepareForUnit(tree: Tree)(using Context): Context = {
+    val captured = atPhase(thisPhase) {
+      CollectCaptured().runOver(ctx.compilationUnit.tpdTree)
+    }
+    ctx.fresh.updateStore(Captured, captured)
+  }
+
+  /** The {Volatile|}{Int|Double|...|Object}Ref class corresponding to the class `cls`,
+    *  depending on whether the reference should be @volatile
+    */
+  def refClass(cls: Symbol, isVolatile: Boolean)(using Context): Symbol = {
+    val refMap = if (isVolatile) refInfo.volatileRefClass else refInfo.refClass
+    if (cls.isClass)
+      refMap.getOrElse(cls, refMap(defn.ObjectClass))
+    else refMap(defn.ObjectClass)
+  }
+
+  override def prepareForValDef(vdef: ValDef)(using Context): Context = {
+    val sym = atPhase(thisPhase)(vdef.symbol)
+    if (captured contains sym) {
+      val newd = atPhase(thisPhase)(sym.denot).copySymDenotation(
+        info = refClass(sym.info.classSymbol, sym.hasAnnotation(defn.VolatileAnnot)).typeRef,
+        initFlags = sym.flags &~ Mutable)
+      newd.removeAnnotation(defn.VolatileAnnot)
+      newd.installAfter(thisPhase)
+    }
+    ctx
+  }
+
+  override def transformValDef(vdef: ValDef)(using Context): Tree = {
+    val vble = vdef.symbol
+    if (captured.contains(vble)) {
+      def boxMethod(name: TermName): Tree =
+        ref(vble.info.classSymbol.companionModule.info.member(name).symbol)
+      cpy.ValDef(vdef)(
+        rhs = boxMethod(nme.create).appliedTo(vdef.rhs),
+        tpt = TypeTree(vble.info).withSpan(vdef.tpt.span))
+    }
+    else vdef
+  }
+
+  override def transformIdent(id: Ident)(using Context): Tree = {
+    val vble = id.symbol
+    if (captured.contains(vble))
+      id.select(nme.elem).ensureConforms(atPhase(thisPhase)(vble.denot).info)
+    else id
+  }
+
+  /** If assignment is to a boxed ref type, e.g.
+   *
+   *      intRef.elem = expr
+   *
+   *  rewrite using a temporary var to
+   *
+   *      val ev$n = expr
+   *      intRef.elem = ev$n
+   *
+   *  That way, we avoid the problem that `expr` might contain a `try` that would
+   *  run on a non-empty stack (which is illegal under JVM rules). Note that LiftTry
+   *  has already run before, so such `try`s would not be eliminated.
+   *
+   *  If the ref type lhs is followed by a cast (can be an artifact of nested translation),
+   *  drop the cast.
+   *
+   *  If the ref type is `ObjectRef` or `VolatileObjectRef`, immediately assign `null`
+   *  to the temporary to make the underlying target of the reference available for
+   *  garbage collection. Nullification is omitted if the `expr` is already `null`.
+   *
+   *      var ev$n: RHS = expr
+   *      objRef.elem = ev$n
+   *      ev$n = null.asInstanceOf[RHS]
+   */
+  override def transformAssign(tree: Assign)(using Context): Tree =
+    def absolved: Boolean = tree.rhs match
+      case Literal(Constant(null)) | Typed(Literal(Constant(null)), _) => true
+      case _ => false
+    def recur(lhs: Tree): Tree = lhs match
+      case TypeApply(Select(qual@Select(_, nme.elem), nme.asInstanceOf_), _) =>
+        recur(qual)
+      case Select(_, nme.elem) if refInfo.boxedRefClasses.contains(lhs.symbol.maybeOwner) =>
+        val tempDef = transformFollowing(SyntheticValDef(TempResultName.fresh(), tree.rhs, flags = Mutable))
+        val update  = cpy.Assign(tree)(lhs, ref(tempDef.symbol))
+        def reset   = cpy.Assign(tree)(ref(tempDef.symbol), nullLiteral.cast(tempDef.symbol.info))
+        val res     = if refInfo.objectRefClasses(lhs.symbol.maybeOwner) && !absolved then reset else unitLiteral
+        transformFollowing(Block(tempDef :: update :: Nil, res))
+      case _ =>
+        tree
+    recur(tree.lhs)
+
+object CapturedVars:
+  val name: String = "capturedVars"
+  val description: String = "represent vars captured by closures as heap objects"
diff --git a/tests/pos-with-compiler-cc/dotc/transform/CheckLoopingImplicits.scala b/tests/pos-with-compiler-cc/dotc/transform/CheckLoopingImplicits.scala
new file mode 100644
index 000000000000..7c8082265161
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/transform/CheckLoopingImplicits.scala
@@ -0,0 +1,111 @@
+package dotty.tools.dotc
+package transform
+
+import core.*
+import MegaPhase.MiniPhase
+import Contexts.*, Types.*, Symbols.*, SymDenotations.*, Flags.*
+import ast.*
+import Decorators.*
+import StdNames.*
+
+object CheckLoopingImplicits:
+  val name: String = "checkLoopingImplicits"
+  val description: String = "check that implicit defs do not call themselves in an infinite loop"
+
+/** Checks that some definitions do not call themselves in an infinite loop
+ *  This is an incomplete check, designed to catch some likely bugs instead
+ *  of being exhaustive. The situations where infinite loops are diagnosed are
+ *   1. A given method should not directly call itself
+ *   2. An apply method in a given object should not directly call itself
+ *   3. A lazy val should not directly force itself
+ *   4. An extension method should not directly call itself
+ *
+ *  In all these cases, there are some situations which would not lead to
+ *  an infinite loop at runtime. For instance, the call could go at runtime to an
+ *  overriding version of the method or val which breaks the loop. That's why
+ *  this phase only issues warnings, not errors, and also why we restrict
+ *  checks to the 4 cases above, where a recursion is somewhat hidden.
+ *  There are also other more complicated calling patterns that could also
+ *  be diagnosed as loops with more effort. This could be improved in the future.
+ */
+class CheckLoopingImplicits extends MiniPhase:
+  thisPhase =>
+  import tpd._
+
+  override def phaseName: String = CheckLoopingImplicits.name
+
+  override def description: String = CheckLoopingImplicits.description
+
+  override def transformValDef(mdef: ValDef)(using Context): Tree =
+    transform(mdef)
+
+  override def transformDefDef(mdef: DefDef)(using Context): Tree =
+    transform(mdef)
+
+  def transform(mdef: ValOrDefDef)(using Context): Tree =
+    val sym = mdef.symbol
+
+    def checkNotSelfRef(t: RefTree) =
+      if t.symbol eq sym then
+          report.warning(
+              em"""Infinite loop in function body
+                  |${mdef.rhs}""",
+              mdef.rhs.srcPos
+            )
+
+    def checkNotLooping(t: Tree): Unit = t match
+      case t: Ident =>
+        checkNotSelfRef(t)
+      case t @ Select(qual, _) =>
+        checkNotSelfRef(t)
+        checkNotLooping(qual)
+      case Apply(fn, args) =>
+        checkNotLooping(fn)
+        fn.tpe.widen match
+          case mt: MethodType
+               // Boolean && and || aren't defined with by-name parameters
+               // and therefore their type isn't an ExprType, so we exempt them by symbol name
+               if t.symbol != defn.Boolean_&& && t.symbol != defn.Boolean_|| =>
+            args.lazyZip(mt.paramInfos).foreach { (arg, pinfo) =>
+              if !pinfo.isInstanceOf[ExprType] then checkNotLooping(arg)
+            }
+          case _ =>
+      case TypeApply(fn, _) =>
+        checkNotLooping(fn)
+      case Block(stats, expr) =>
+        stats.foreach(checkNotLooping)
+        checkNotLooping(expr)
+      case Inlined(_, bindings, expr) =>
+        bindings.foreach(checkNotLooping)
+        checkNotLooping(expr)
+      case Typed(expr, _) =>
+        checkNotLooping(expr)
+      case Assign(lhs, rhs) =>
+        checkNotLooping(lhs)
+        checkNotLooping(rhs)
+      case If(cond, _, _) =>
+        checkNotLooping(cond)
+      case Match(selector, _) =>
+        checkNotLooping(selector)
+      case Labeled(_, expr) =>
+        checkNotLooping(expr)
+      case Return(expr, _) =>
+        checkNotLooping(expr)
+      case WhileDo(cond, _) =>
+        checkNotLooping(cond)
+      case Try(block, _, finalizer) =>
+        checkNotLooping(block)
+        checkNotLooping(finalizer)
+      case SeqLiteral(elems, _) =>
+        elems.foreach(checkNotLooping)
+      case t: ValDef if !t.symbol.is(Lazy) =>
+        checkNotLooping(t.rhs)
+      case _ =>
+
+    if sym.isOneOf(GivenOrImplicit | Lazy | ExtensionMethod)
+      || sym.name == nme.apply && sym.owner.is(Module) && sym.owner.sourceModule.isOneOf(GivenOrImplicit)
+    then
+      checkNotLooping(mdef.rhs)
+    mdef
+  end transform
+end CheckLoopingImplicits
diff --git a/tests/pos-with-compiler-cc/dotc/transform/CheckNoSuperThis.scala b/tests/pos-with-compiler-cc/dotc/transform/CheckNoSuperThis.scala
new file mode 100644
index 000000000000..f43d000bbf44
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/transform/CheckNoSuperThis.scala
@@ -0,0 +1,51 @@
+package dotty.tools.dotc
+package transform
+
+import core.*
+import MegaPhase.MiniPhase
+import Contexts.*, Types.*, Symbols.*, SymDenotations.*, Flags.*
+import ast.*
+import Decorators.*
+
+
+object CheckNoSuperThis:
+  val name: String = "checkNoSuperThis"
+  val description: String = "check that supercalls don't contain references to This"
+
+/** Checks that super and this calls do not pass `this` as (part of) an argument. */
+class CheckNoSuperThis extends MiniPhase:
+  thisPhase =>
+  import tpd._
+
+  override def phaseName: String = CheckNoSuperThis.name
+
+  override def description: String = CheckNoSuperThis.description
+
+  override def runsAfterGroupsOf: Set[String] = Set(Constructors.name)
+
+  override def transformDefDef(mdef: DefDef)(using Context): DefDef =
+    if mdef.symbol.isClassConstructor then
+      mdef.rhs match
+        case Block(stats, _) => splitAtSuper(stats) match
+          case (Apply(_, superArgs) :: _, _) =>
+            val cls = mdef.symbol.owner
+            def fail(t: Tree) =
+              report.error(em"super constructor cannot be passed a self reference $t unless parameter is declared by-name", t.srcPos)
+            for arg <- superArgs do
+              arg.foreachSubTree {
+                case t: This if t.symbol == cls =>
+                  fail(t)
+                case t: RefTree => t.tpe match
+                  case tpe @ TermRef(prefix, _)
+                  if (prefix == cls.thisType
+                      || cls.is(Module)
+                         && (prefix.termSymbol == cls.sourceModule || tpe.symbol == cls.sourceModule)
+                    ) && !tpe.symbol.is(JavaStatic) => fail(t)
+                  case _ =>
+                case _ =>
+              }
+          case _ =>
+        case _ =>
+    mdef
+
+end CheckNoSuperThis
diff --git a/tests/pos-with-compiler-cc/dotc/transform/CheckReentrant.scala b/tests/pos-with-compiler-cc/dotc/transform/CheckReentrant.scala
new file mode 100644
index 000000000000..6b0a4c3e9737
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/transform/CheckReentrant.scala
@@ -0,0 +1,92 @@
+package dotty.tools.dotc
+package transform
+
+import core._
+import dotty.tools.dotc.transform.MegaPhase._
+import Flags._
+import Contexts._
+import Symbols._
+import Decorators._
+
+/** A no-op transform that checks whether the compiled sources are re-entrant.
+ *  If -Ycheck:reentrant is set, the phase makes sure that there are no variables
+ *  that are accessible from a global object. It excludes from checking paths that
+ *  are labeled with one of the annotations
+ *
+ *      @sharable   Indicating a class or val can be safely shared
+ *      @unshared   Indicating an object will not be accessed from multiple threads
+ *
+ *  Currently the analysis is only intended to check the dotty compiler itself. To make
+ *  it generally useful we'd need to add at least the following:
+ *
+ *   - Handle polymorphic instantiation: We might instantiate a generic class
+ *     with a type that contains vars. If the class contains fields of the generic
+ *     type, this may constitute a path to a shared var, which currently goes undetected.
+ *   - Handle arrays: Array elements are currently ignored because they are often used
+ *     in an immutable way anyway. To do better, it would be helpful to have a type
+ *     for immutable array.
+ */
+class CheckReentrant extends MiniPhase {
+  import ast.tpd._
+
+  override def phaseName: String = CheckReentrant.name
+
+  override def description: String = CheckReentrant.description
+
+  private var shared: Set[Symbol] = Set()
+  private var seen: Set[ClassSymbol] = Set()
+  private var indent: Int = 0
+
+  private val sharableAnnot = new CtxLazy(
+    requiredClass("scala.annotation.internal.sharable"))
+  private val unsharedAnnot = new CtxLazy(
+    requiredClass("scala.annotation.internal.unshared"))
+
+  private val scalaJSIRPackageClass = new CtxLazy(
+    getPackageClassIfDefined("org.scalajs.ir"))
+
+  def isIgnored(sym: Symbol)(using Context): Boolean =
+    sym.hasAnnotation(sharableAnnot()) ||
+    sym.hasAnnotation(unsharedAnnot()) ||
+    sym.topLevelClass.owner == scalaJSIRPackageClass()
+      // We would add @sharable annotations on ScalaJSVersions and
+      // VersionChecks but we do not have control over that code
+
+  def scanning(sym: Symbol)(op: => Unit)(using Context): Unit = {
+    report.log(i"${"  " * indent}scanning $sym")
+    indent += 1
+    try op
+    finally indent -= 1
+  }
+
+  def addVars(cls: ClassSymbol)(using Context): Unit =
+    if (!seen.contains(cls) && !isIgnored(cls)) {
+      seen += cls
+      scanning(cls) {
+        for (sym <- cls.classInfo.decls)
+          if (sym.isTerm && !sym.isSetter && !isIgnored(sym))
+            if (sym.is(Mutable)) {
+              report.error(
+                i"""possible data race involving globally reachable ${sym.showLocated}: ${sym.info}
+                   |  use -Ylog:checkReentrant+ to find out more about why the variable is reachable.""")
+              shared += sym
+            }
+            else if (!sym.is(Method) || sym.isOneOf(Accessor | ParamAccessor))
+              scanning(sym) {
+                sym.info.widenExpr.classSymbols.foreach(addVars)
+              }
+        for (parent <- cls.parentSyms)
+          addVars(parent.asClass)
+      }
+    }
+
+  override def transformTemplate(tree: Template)(using Context): Tree = {
+    if (ctx.settings.YcheckReentrant.value && tree.symbol.owner.isStaticOwner)
+      addVars(tree.symbol.owner.asClass)
+    tree
+  }
+}
+
+object CheckReentrant:
+  val name: String = "checkReentrant"
+  val description: String = "check no data races involving global vars"
diff --git a/tests/pos-with-compiler-cc/dotc/transform/CheckStatic.scala b/tests/pos-with-compiler-cc/dotc/transform/CheckStatic.scala
new file mode 100644
index 000000000000..0d5154e212ee
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/transform/CheckStatic.scala
@@ -0,0 +1,68 @@
+package dotty.tools.dotc
+package transform
+
+import core._
+import dotty.tools.dotc.transform.MegaPhase._
+import Flags._
+import Contexts._
+import Symbols._
+import dotty.tools.dotc.ast.tpd
+import reporting._
+
+import dotty.tools.dotc.transform.SymUtils._
+
+/** A transformer that check that requirements of Static fields\methods are implemented:
+  *  1. Only objects can have members annotated with `@static`
+  *  2. The fields annotated with `@static` should precede any non-`@static` fields.
+  *     This ensures that we do not introduce surprises for users in initialization order.
+  *  3. If a member `foo` of an `object C` is annotated with `@static`,
+  *     the companion class `C` is not allowed to define term members with name `foo`.
+  *  4. If a member `foo` of an `object C` is annotated with `@static`, the companion class `C`
+  *     is not allowed to inherit classes that define a term member with name `foo`.
+  *  5. Only `@static` methods and vals are supported in companions of traits.
+  *     Java8 supports those, but not vars, and JavaScript does not have interfaces at all.
+  *  6. `@static` Lazy vals are currently unsupported.
+  */
+class CheckStatic extends MiniPhase {
+  import ast.tpd._
+
+  override def phaseName: String = CheckStatic.name
+
+  override def description: String = CheckStatic.description
+
+  override def transformTemplate(tree: tpd.Template)(using Context): tpd.Tree = {
+    val defns = tree.body.collect{case t: ValOrDefDef => t}
+    var hadNonStaticField = false
+    for (defn <- defns)
+      if (defn.symbol.isScalaStatic) {
+        if (!ctx.owner.isStaticOwner)
+          report.error(StaticFieldsOnlyAllowedInObjects(defn.symbol), defn.srcPos)
+          defn.symbol.resetFlag(JavaStatic)
+
+        if (defn.isInstanceOf[ValDef] && hadNonStaticField)
+          report.error(StaticFieldsShouldPrecedeNonStatic(defn.symbol, defns), defn.srcPos)
+
+        val companion = ctx.owner.companionClass
+        def clashes = companion.asClass.membersNamed(defn.name)
+
+        if (!companion.exists)
+          report.error(MissingCompanionForStatic(defn.symbol), defn.srcPos)
+        else if (clashes.exists)
+          report.error(MemberWithSameNameAsStatic(), defn.srcPos)
+        else if (defn.symbol.is(Flags.Mutable) && companion.is(Flags.Trait))
+          report.error(TraitCompanionWithMutableStatic(), defn.srcPos)
+        else if (defn.symbol.is(Flags.Lazy))
+          report.error(LazyStaticField(), defn.srcPos)
+        else if (defn.symbol.allOverriddenSymbols.nonEmpty)
+          report.error(StaticOverridingNonStaticMembers(), defn.srcPos)
+      }
+      else hadNonStaticField = hadNonStaticField || defn.isInstanceOf[ValDef]
+
+    tree
+  }
+}
+
+object CheckStatic {
+  val name: String = "checkStatic"
+  val description: String = "check restrictions that apply to @static members"
+}
diff --git a/tests/pos-with-compiler-cc/dotc/transform/CollectEntryPoints.scala b/tests/pos-with-compiler-cc/dotc/transform/CollectEntryPoints.scala
new file mode 100644
index 000000000000..179625759b10
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/transform/CollectEntryPoints.scala
@@ -0,0 +1,53 @@
+package dotty.tools.dotc
+package transform
+
+import core._
+import ast.tpd
+import MegaPhase._
+import Contexts._
+import Symbols._
+import Phases._
+import dotty.tools.io.JarArchive
+import dotty.tools.backend.jvm.GenBCode
+
+/**
+ * Small phase to be run to collect main classes and store them in the context.
+ * The general rule to run this phase is:
+ * - The output of compilation is JarArchive
+ * - There is no `-Xmain-class` defined
+ *
+ * The following flags affect this phase:
+ *   -d path.jar
+ *   -Xmain-class
+ */
+class CollectEntryPoints extends MiniPhase:
+
+  override def phaseName: String = CollectEntryPoints.name
+
+  override def description: String = CollectEntryPoints.description
+
+  override def isRunnable(using Context): Boolean =
+    def forceRun = ctx.settings.XmainClass.isDefault && ctx.settings.outputDir.value.isInstanceOf[JarArchive]
+    super.isRunnable && forceRun
+
+  override def transformTypeDef(tree: tpd.TypeDef)(using Context): tpd.Tree =
+    getEntryPoint(tree).map(registerEntryPoint)
+    tree
+
+  private def getEntryPoint(tree: tpd.TypeDef)(using Context): Option[String] =
+    val sym = tree.symbol
+    import core.NameOps.stripModuleClassSuffix
+    val name = sym.fullName.stripModuleClassSuffix.toString
+    Option.when(sym.isStatic && !sym.is(Flags.Trait) && ctx.platform.hasMainMethod(sym))(name)
+
+  private def registerEntryPoint(s: String)(using Context) = {
+    genBCodePhase match {
+      case genBCodePhase: GenBCode =>
+        genBCodePhase.registerEntryPoint(s)
+      case _ =>
+    }
+  }
+
+object CollectEntryPoints:
+  val name: String = "Collect entry points"
+  val description: String = "collect all entry points and save them in the context"
diff --git a/tests/pos-with-compiler-cc/dotc/transform/CollectNullableFields.scala b/tests/pos-with-compiler-cc/dotc/transform/CollectNullableFields.scala
new file mode 100644
index 000000000000..7b89c8785e05
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/transform/CollectNullableFields.scala
@@ -0,0 +1,110 @@
+package dotty.tools.dotc.transform
+
+import dotty.tools.dotc.ast.tpd
+import dotty.tools.dotc.core.Contexts._
+import dotty.tools.dotc.core.Flags._
+import dotty.tools.dotc.core.Symbols.Symbol
+import dotty.tools.dotc.transform.MegaPhase.MiniPhase
+import dotty.tools.dotc.transform.SymUtils._
+
+import scala.collection.mutable
+
+import java.util.IdentityHashMap
+
+object CollectNullableFields {
+  val name: String = "collectNullableFields"
+  val description: String = "collect fields that can be nulled out after use in lazy initialization"
+}
+
+/** Collect fields that can be nulled out after use in lazy initialization.
+ *
+ *  This information is used during lazy val transformation to assign null to private
+ *  fields that are only used within a lazy val initializer. This is not just an optimization,
+ *  but is needed for correctness to prevent memory leaks. E.g.
+ *
+ *  ```scala
+ *  class TestByNameLazy(byNameMsg: => String) {
+ *    lazy val byLazyValMsg = byNameMsg
+ *  }
+ *  ```
+ *
+ *  Here `byNameMsg` should be null out once `byLazyValMsg` is
+ *  initialised.
+ *
+ *  A field is nullable if all the conditions below hold:
+ *    - belongs to a non trait-class
+ *    - is private[this]
+ *    - is not lazy
+ *    - its type is nullable after erasure
+ *    - is only used in a lazy val initializer
+ *    - defined in the same class as the lazy val
+ */
+class CollectNullableFields extends MiniPhase {
+  import tpd._
+
+  override def phaseName: String = CollectNullableFields.name
+
+  override def description: String = CollectNullableFields.description
+
+  /** Running after `ElimByName` to see by names as nullable types. */
+  override def runsAfter: Set[String] = Set(ElimByName.name)
+
+  private sealed trait FieldInfo
+  private case object NotNullable extends FieldInfo
+  private case class Nullable(by: Symbol) extends FieldInfo
+
+  /** Whether or not a field is nullable */
+  private val nullability = new mutable.LinkedHashMap[Symbol, FieldInfo]
+
+  private def recordUse(tree: Tree)(using Context): Tree = {
+    val sym = tree.symbol
+    val isNullablePrivateField =
+      sym.isField &&
+      !sym.is(Lazy) &&
+      !sym.owner.is(Trait) &&
+      sym.initial.isAllOf(PrivateLocal) &&
+      // We need `isNullableClassAfterErasure` and not `isNullable` because
+      // we care about the values as present in the JVM.
+      sym.info.widenDealias.typeSymbol.isNullableClassAfterErasure
+
+    if (isNullablePrivateField)
+      nullability.get(sym) match {
+        case Some(Nullable(from)) if from != ctx.owner => // used in multiple lazy val initializers
+          nullability.put(sym, NotNullable)
+        case None => // not in the map
+          val from = ctx.owner
+          val isNullable =
+            from.is(Lazy, butNot = Module) && // is lazy val
+            from.owner.isClass &&             // is field
+            from.owner.eq(sym.owner)          // is lazy val and field defined in the same class
+          val info = if (isNullable) Nullable(from) else NotNullable
+          nullability.put(sym, info)
+        case _ =>
+          // Do nothing for:
+          //  - NotNullable
+          //  - Nullable(ctx.owner)
+      }
+
+    tree
+  }
+
+  override def transformIdent(tree: Ident)(using Context): Tree =
+    recordUse(tree)
+
+  override def transformSelect(tree: Select)(using Context): Tree =
+    recordUse(tree)
+
+  /** Map lazy values to the fields they should null after initialization. */
+  def lazyValNullables(using Context): IdentityHashMap[Symbol, mutable.ListBuffer[Symbol]] = {
+    val result = new IdentityHashMap[Symbol, mutable.ListBuffer[Symbol]]
+
+    nullability.foreach {
+      case (sym, Nullable(from)) =>
+        val bldr = result.computeIfAbsent(from, _ => new mutable.ListBuffer).nn
+        bldr += sym
+      case _ =>
+    }
+
+    result
+  }
+}
diff --git a/tests/pos-with-compiler-cc/dotc/transform/CompleteJavaEnums.scala b/tests/pos-with-compiler-cc/dotc/transform/CompleteJavaEnums.scala
new file mode 100644
index 000000000000..be454281bcbb
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/transform/CompleteJavaEnums.scala
@@ -0,0 +1,190 @@
+package dotty.tools
+package dotc
+package transform
+
+import core._
+import Names._
+import StdNames.nme
+import Types._
+import dotty.tools.dotc.transform.MegaPhase._
+import Flags._
+import Contexts._
+import Symbols._
+import Constants._
+import Decorators._
+import DenotTransformers._
+import SymUtils._
+
+
+object CompleteJavaEnums {
+  val name: String = "completeJavaEnums"
+  val description: String = "fill in constructors for Java enums"
+
+  private val nameParamName: TermName = "_$name".toTermName
+  private val ordinalParamName: TermName = "_$ordinal".toTermName
+}
+
+/** For Scala enums that inherit from java.lang.Enum:
+ *  Add constructor parameters for `name` and `ordinal` to pass from each
+ *  case to the java.lang.Enum class.
+ */
+class CompleteJavaEnums extends MiniPhase with InfoTransformer { thisPhase =>
+  import CompleteJavaEnums._
+  import ast.tpd._
+
+  override def phaseName: String = CompleteJavaEnums.name
+
+  override def description: String = CompleteJavaEnums.description
+
+  override def relaxedTypingInGroup: Boolean = true
+    // Because it adds additional parameters to some constructors
+
+  def transformInfo(tp: Type, sym: Symbol)(using Context): Type =
+    if (sym.isConstructor && (
+         sym == defn.JavaEnumClass.primaryConstructor ||
+         sym.owner.derivesFromJavaEnum))
+      addConstrParams(sym.info)
+    else tp
+
+  /** Add constructor parameters `$name: String` and `$ordinal: Int` to the end of
+   *  the last parameter list of (method- or poly-) type `tp`.
+   */
+  private def addConstrParams(tp: Type)(using Context): Type = tp match {
+    case tp: PolyType =>
+      tp.derivedLambdaType(resType = addConstrParams(tp.resType))
+    case tp: MethodType =>
+      tp.resType match {
+        case restpe: MethodType =>
+          tp.derivedLambdaType(resType = addConstrParams(restpe))
+        case _ =>
+          tp.derivedLambdaType(
+            paramNames = tp.paramNames ++ List(nameParamName, ordinalParamName),
+            paramInfos = tp.paramInfos ++ List(defn.StringType, defn.IntType))
+      }
+  }
+
+  /** The list of parameter definitions `$name: String, $ordinal: Int`, in given `owner`
+   *  with given flags (either `Param` or `ParamAccessor`)
+   */
+  private def addedParams(owner: Symbol, isLocal: Boolean, flag: FlagSet)(using Context): List[ValDef] = {
+    val flags = flag | Synthetic | (if isLocal then Private | Deferred else EmptyFlags)
+    val nameParam = newSymbol(owner, nameParamName, flags, defn.StringType, coord = owner.span)
+    val ordinalParam = newSymbol(owner, ordinalParamName, flags, defn.IntType, coord = owner.span)
+    List(ValDef(nameParam), ValDef(ordinalParam))
+  }
+
+  /** Add arguments `args` to the parent constructor application in `parents` that invokes
+   *  a constructor of `targetCls`,
+   */
+  private def addEnumConstrArgs(targetCls: Symbol, parents: List[Tree], args: List[Tree])(using Context): List[Tree] =
+    parents.map {
+      case app @ Apply(fn, args0) if fn.symbol.owner == targetCls =>
+        if args0.nonEmpty && targetCls == defn.JavaEnumClass then
+          report.error("the constructor of java.lang.Enum cannot be called explicitly", app.sourcePos)
+        cpy.Apply(app)(fn, args0 ++ args)
+      case p => p
+    }
+
+  /** If this is a constructor of a enum class that extends, add $name and $ordinal parameters to it. */
+  override def transformDefDef(tree: DefDef)(using Context): DefDef = {
+    val sym = tree.symbol
+    if sym.isConstructor && sym.owner.derivesFromJavaEnum then
+      val tree1 = cpy.DefDef(tree)(
+        paramss = tree.paramss.init
+          :+ (tree.paramss.last.asInstanceOf[List[ValDef]]
+              ++ addedParams(sym, isLocal=false, Param)))
+      sym.setParamssFromDefs(tree1.paramss)
+      tree1
+    else tree
+  }
+
+  /** Return a list of forwarders for enum values defined in the companion object
+   *  for java interop.
+   */
+  private def addedEnumForwarders(clazz: Symbol)(using Context): List[MemberDef] = {
+    val moduleCls = clazz.companionClass
+    val moduleRef = ref(clazz.companionModule)
+
+    val enums = moduleCls.info.decls.filter(member => member.isAllOf(EnumValue))
+    for { enumValue <- enums }
+    yield {
+      def forwarderSym(flags: FlagSet, info: Type): Symbol { type ThisName = TermName } =
+        val sym = newSymbol(clazz, enumValue.name.asTermName, flags, info)
+        sym.addAnnotation(Annotations.Annotation(defn.ScalaStaticAnnot))
+        sym
+      val body = moduleRef.select(enumValue)
+      if ctx.settings.scalajs.value then
+        // Scala.js has no support for <clinit> so we must avoid assigning static fields in the enum class.
+        // However, since the public contract for reading static fields in the IR ABI is to call "static getters",
+        // we achieve the right contract with static forwarders instead.
+        DefDef(forwarderSym(EnumValue | Method | JavaStatic, MethodType(Nil, enumValue.info)), body)
+      else
+        ValDef(forwarderSym(EnumValue | JavaStatic, enumValue.info), body)
+    }
+  }
+
+  private def isJavaEnumValueImpl(cls: Symbol)(using Context): Boolean =
+    cls.isAnonymousClass
+    && (((cls.owner.name eq nme.DOLLAR_NEW) && cls.owner.isAllOf(Private|Synthetic)) || cls.owner.isAllOf(EnumCase))
+    && cls.owner.owner.linkedClass.derivesFromJavaEnum
+
+  private val enumCaseOrdinals = MutableSymbolMap[Int]()
+
+  private def registerEnumClass(cls: Symbol)(using Context): Unit =
+    cls.children.zipWithIndex.foreach(enumCaseOrdinals.update)
+
+  private def ordinalFor(enumCase: Symbol): Int =
+    enumCaseOrdinals.remove(enumCase).nn
+
+  /** 1. If this is an enum class, add $name and $ordinal parameters to its
+   *     parameter accessors and pass them on to the java.lang.Enum constructor.
+   *
+   *  2. If this is an anonymous class that implement a singleton enum case,
+   *     pass $name and $ordinal parameters to the enum superclass. The class
+   *     looks like this:
+   *
+   *       class $anon extends E(...) {
+   *          ...
+   *       }
+   *
+   *     After the transform it is expanded to
+   *
+   *       class $anon extends E(..., $name, _$ordinal) { // if class implements a simple enum case
+   *          "same as before"
+   *       }
+   *
+   *       class $anon extends E(..., "A", 0) { // if class implements a value enum case `A` with ordinal 0
+   *          "same as before"
+   *       }
+   */
+  override def transformTemplate(templ: Template)(using Context): Tree = {
+    val cls = templ.symbol.owner
+    if cls.derivesFromJavaEnum then
+      registerEnumClass(cls) // invariant: class is visited before cases: see tests/pos/enum-companion-first.scala
+      val (params, rest) = decomposeTemplateBody(templ.body)
+      val addedDefs = addedParams(cls, isLocal=true, ParamAccessor)
+      val addedSyms = addedDefs.map(_.symbol.entered)
+      val addedForwarders = addedEnumForwarders(cls)
+      cpy.Template(templ)(
+        parents = addEnumConstrArgs(defn.JavaEnumClass, templ.parents, addedSyms.map(ref)),
+        body = params ++ addedDefs ++ addedForwarders ++ rest)
+    else if isJavaEnumValueImpl(cls) then
+      def creatorParamRef(name: TermName) =
+        ref(cls.owner.paramSymss.head.find(_.name == name).get)
+      val args =
+        if cls.owner.isAllOf(EnumCase) then
+          List(Literal(Constant(cls.owner.name.toString)), Literal(Constant(ordinalFor(cls.owner))))
+        else
+          List(creatorParamRef(nme.nameDollar), creatorParamRef(nme.ordinalDollar_))
+      cpy.Template(templ)(
+        parents = addEnumConstrArgs(cls.owner.owner.linkedClass, templ.parents, args),
+      )
+    else if cls.linkedClass.derivesFromJavaEnum then
+      enumCaseOrdinals.clear() // remove simple cases // invariant: companion is visited after cases
+      templ
+    else templ
+  }
+
+  override def checkPostCondition(tree: Tree)(using Context): Unit =
+    assert(enumCaseOrdinals.isEmpty, "Java based enum ordinal cache was not cleared")
+}
diff --git a/tests/pos-with-compiler-cc/dotc/transform/Constructors.scala b/tests/pos-with-compiler-cc/dotc/transform/Constructors.scala
new file mode 100644
index 000000000000..59b90ff7f084
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/transform/Constructors.scala
@@ -0,0 +1,356 @@
+package dotty.tools.dotc
+package transform
+
+import core._
+import MegaPhase._
+import dotty.tools.dotc.core.Contexts._
+import dotty.tools.dotc.core.StdNames._
+import ast._
+import Flags._
+import Names.Name
+import NameOps._
+import NameKinds.{FieldName, ExplicitFieldName}
+import SymUtils._
+import Symbols._
+import Decorators._
+import DenotTransformers._
+import collection.mutable
+
+object Constructors {
+  val name: String = "constructors"
+  val description: String = "collect initialization code in primary constructors"
+}
+
+/** This transform
+ *   - moves initializers from body to constructor.
+ *   - makes all supercalls explicit
+ *   - also moves private fields that are accessed only from constructor
+ *     into the constructor if possible.
+ */
+class Constructors extends MiniPhase with IdentityDenotTransformer { thisPhase =>
+  import tpd._
+
+  override def phaseName: String = Constructors.name
+
+  override def description: String = Constructors.description
+
+  override def runsAfter: Set[String] = Set(HoistSuperArgs.name)
+  override def runsAfterGroupsOf: Set[String] = Set(Memoize.name)
+    // Memoized needs to be finished because we depend on the ownerchain after Memoize
+    // when checking whether an ident is an access in a constructor or outside it.
+    // This test is done in the right-hand side of a value definition. If Memoize
+    // was in the same group as Constructors, the test on the rhs ident would be
+    // performed before the rhs undergoes the owner change. This would lead
+    // to more symbols being retained as parameters. Test case in run/capturing.scala.
+
+  /** The private vals that are known to be retained as class fields */
+  private val retainedPrivateVals = mutable.Set[Symbol]()
+
+  /** The private vals whose definition comes before the current focus */
+  private val seenPrivateVals = mutable.Set[Symbol]()
+
+  // Collect all private parameter accessors and value definitions that need
+  // to be retained. There are several reasons why a parameter accessor or
+  // definition might need to be retained:
+  // 1. It is accessed after the constructor has finished
+  // 2. It is accessed before it is defined
+  // 3. It is accessed on an object other than `this`
+  // 4. It is a mutable parameter accessor
+  // 5. It is has a wildcard initializer `_`
+  private def markUsedPrivateSymbols(tree: RefTree)(using Context): Unit = {
+
+    val sym = tree.symbol
+    def retain() = retainedPrivateVals.add(sym)
+
+    if (sym.exists && sym.owner.isClass && mightBeDropped(sym)) {
+      val owner = sym.owner.asClass
+
+        tree match {
+          case Ident(_) | Select(This(_), _) =>
+            def inConstructor = {
+              val method = ctx.owner.enclosingMethod
+              method.isPrimaryConstructor && ctx.owner.enclosingClass == owner
+            }
+            if (inConstructor &&
+                (sym.is(ParamAccessor) || seenPrivateVals.contains(sym))) {
+              // used inside constructor, accessed on this,
+              // could use constructor argument instead, no need to retain field
+            }
+            else retain()
+          case _ => retain()
+      }
+    }
+  }
+
+  override def transformIdent(tree: tpd.Ident)(using Context): tpd.Tree = {
+    markUsedPrivateSymbols(tree)
+    tree
+  }
+
+  override def transformSelect(tree: tpd.Select)(using Context): tpd.Tree = {
+    markUsedPrivateSymbols(tree)
+    tree
+  }
+
+  override def transformValDef(tree: tpd.ValDef)(using Context): tpd.Tree = {
+    if (mightBeDropped(tree.symbol)) seenPrivateVals += tree.symbol
+    tree
+  }
+
+  /** All initializers for non-lazy fields should be moved into constructor.
+   *  All non-abstract methods should be implemented (this is assured for constructors
+   *  in this phase and for other methods in memoize).
+   */
+  override def checkPostCondition(tree: tpd.Tree)(using Context): Unit = {
+    def emptyRhsOK(sym: Symbol) =
+      sym.isOneOf(DeferredOrLazy) || sym.isConstructor && sym.owner.isAllOf(NoInitsTrait)
+    tree match {
+      case tree: ValDef if tree.symbol.exists && tree.symbol.owner.isClass && !tree.symbol.is(Lazy) && !tree.symbol.hasAnnotation(defn.ScalaStaticAnnot) =>
+        assert(tree.rhs.isEmpty, i"$tree: initializer should be moved to constructors")
+      case tree: DefDef if !emptyRhsOK(tree.symbol) =>
+        assert(!tree.rhs.isEmpty, i"unimplemented: $tree")
+      case _ =>
+    }
+  }
+
+  /** @return true  if after ExplicitOuter, all references from this tree go via an
+   *                outer link, so no parameter accessors need to be rewired to parameters
+   */
+  private def noDirectRefsFrom(tree: Tree)(using Context) =
+    tree.isDef && tree.symbol.isClass
+
+  /** Class members that can be eliminated if referenced only from their own
+   *  constructor.
+   */
+  private def mightBeDropped(sym: Symbol)(using Context) =
+    sym.is(Private, butNot = MethodOrLazy) && !sym.isAllOf(MutableParamAccessor)
+
+  private final val MutableParamAccessor = Mutable | ParamAccessor
+
+  override def transformTemplate(tree: Template)(using Context): Tree = {
+    val cls = ctx.owner.asClass
+
+    val constr @ DefDef(nme.CONSTRUCTOR, (vparams: List[ValDef] @unchecked) :: Nil, _, EmptyTree) = tree.constr: @unchecked
+
+    // Produce aligned accessors and constructor parameters. We have to adjust
+    // for any outer parameters, which are last in the sequence of original
+    // parameter accessors but come first in the constructor parameter list.
+    val accessors = cls.paramGetters
+    val vparamsWithOuterLast = vparams match {
+      case vparam :: rest if vparam.name == nme.OUTER => rest ::: vparam :: Nil
+      case _ => vparams
+    }
+    val paramSyms = vparamsWithOuterLast map (_.symbol)
+
+    // Adjustments performed when moving code into the constructor:
+    //  (1) Replace references to param accessors by constructor parameters
+    //      except possibly references to mutable variables, if `excluded = Mutable`.
+    //      (Mutable parameters should be replaced only during the super call)
+    //  (2) If the parameter accessor reference was to an alias getter,
+    //      drop the () when replacing by the parameter.
+    object intoConstr extends TreeMap {
+      private var inSuperCall = false
+      override def transform(tree: Tree)(using Context): Tree = tree match {
+        case Ident(_) | Select(This(_), _) =>
+          var sym = tree.symbol
+          def isOverridableSelect = tree.isInstanceOf[Select] && !sym.isEffectivelyFinal
+          def switchOutsideSupercall = !sym.is(Mutable) && !isOverridableSelect
+            // If true, switch to constructor parameters also in the constructor body
+            // that follows the super call.
+            // Variables need to go through the getter since they might have been updated.
+            // References via this need to use the getter as well as long as that getter
+            // can be overridden. This is needed to handle overrides correctly. See run/i15723.scala.
+            // Note that in a supercall we need to switch to parameters in any case since then
+            // calling the virtual getter call would be illegal.
+            //
+            // Note: We intentionally treat references via this and identifiers differently
+            // here. Identifiers in a constructor always bind to the parameter. This is
+            // done for backwards compatbility.
+          if sym.is(ParamAccessor) && (switchOutsideSupercall || inSuperCall) then
+            sym = sym.subst(accessors, paramSyms)
+          if sym.maybeOwner.isConstructor then ref(sym).withSpan(tree.span) else tree
+        case Apply(fn, Nil) =>
+          val fn1 = transform(fn)
+          if ((fn1 ne fn) && fn1.symbol.is(Param) && fn1.symbol.owner.isPrimaryConstructor)
+            fn1 // in this case, fn1.symbol was an alias for a parameter in a superclass
+          else cpy.Apply(tree)(fn1, Nil)
+        case _ =>
+          if (noDirectRefsFrom(tree)) tree else super.transform(tree)
+      }
+
+      def apply(tree: Tree, prevOwner: Symbol)(using Context): Tree =
+        inSuperCall = isSuperConstrCall(tree)
+        transform(tree).changeOwnerAfter(prevOwner, constr.symbol, thisPhase)
+    }
+
+    def isRetained(acc: Symbol) =
+      !mightBeDropped(acc) || retainedPrivateVals(acc)
+
+    val constrStats, clsStats = new mutable.ListBuffer[Tree]
+
+    /** Map outer getters $outer and outer accessors $A$B$$$outer to the given outer parameter. */
+    def mapOuter(outerParam: Symbol) = new TreeMap {
+      override def transform(tree: Tree)(using Context) = tree match {
+        case Apply(fn, Nil)
+          if (fn.symbol.is(OuterAccessor)
+             || fn.symbol.isGetter && fn.symbol.name == nme.OUTER
+             ) &&
+             fn.symbol.info.resultType.classSymbol == outerParam.info.classSymbol =>
+          ref(outerParam)
+        case tree: RefTree if tree.symbol.is(ParamAccessor) && tree.symbol.name == nme.OUTER =>
+          ref(outerParam)
+        case _ =>
+          super.transform(tree)
+      }
+    }
+
+    val dropped = mutable.Set[Symbol]()
+
+    // Split class body into statements that go into constructor and
+    // definitions that are kept as members of the class.
+    def splitStats(stats: List[Tree]): Unit = stats match {
+      case stat :: stats1 =>
+        stat match {
+          case stat @ ValDef(name, tpt, _) if !stat.symbol.is(Lazy) && !stat.symbol.hasAnnotation(defn.ScalaStaticAnnot) =>
+            val sym = stat.symbol
+            if (isRetained(sym)) {
+              if (!stat.rhs.isEmpty && !isWildcardArg(stat.rhs))
+                constrStats += Assign(ref(sym), intoConstr(stat.rhs, sym)).withSpan(stat.span)
+              clsStats += cpy.ValDef(stat)(rhs = EmptyTree)
+            }
+            else if (!stat.rhs.isEmpty) {
+              dropped += sym
+              sym.copySymDenotation(
+                initFlags = sym.flags &~ Private,
+                owner = constr.symbol).installAfter(thisPhase)
+              constrStats += intoConstr(stat, sym)
+            } else
+              dropped += sym
+          case stat @ DefDef(name, _, tpt, _)
+              if stat.symbol.isGetter && stat.symbol.owner.is(Trait) && !stat.symbol.is(Lazy) && !stat.symbol.isConstExprFinalVal =>
+            val sym = stat.symbol
+            assert(isRetained(sym), sym)
+            if !stat.rhs.isEmpty && !isWildcardArg(stat.rhs) then
+              /* !!! Work around #9390
+               * This should really just be `sym.setter`. However, if we do that, we'll miss
+               * setters for mixed in `private var`s. Even though the scope clearly contains the
+               * setter symbol with the correct Name structure (since the `find` finds it),
+               * `.decl(setterName)` used by `.setter` through `.accessorNamed` will *not* find it.
+               * Could it be that the hash table of the `Scope` is corrupted?
+               * We still try `sym.setter` first as an optimization, since it will work for all
+               * public vars in traits and all (public or private) vars in classes.
+               */
+              val symSetter =
+                if sym.setter.exists then
+                  sym.setter
+                else
+                  val setterName = sym.asTerm.name.setterName
+                  sym.owner.info.decls.find(d => d.is(Accessor) && d.name == setterName)
+              val setter =
+                if (symSetter.exists) symSetter
+                else sym.accessorNamed(Mixin.traitSetterName(sym.asTerm))
+              constrStats += Apply(ref(setter), intoConstr(stat.rhs, sym).withSpan(stat.span) :: Nil)
+            clsStats += cpy.DefDef(stat)(rhs = EmptyTree)
+          case DefDef(nme.CONSTRUCTOR, ((outerParam @ ValDef(nme.OUTER, _, _)) :: _) :: Nil, _, _) =>
+            clsStats += mapOuter(outerParam.symbol).transform(stat)
+          case _: DefTree =>
+            clsStats += stat
+          case _ =>
+            constrStats += intoConstr(stat, tree.symbol)
+        }
+        splitStats(stats1)
+      case Nil =>
+    }
+
+    /** Check that we do not have both a private field with name `x` and a private field
+     *  with name `FieldName(x)`. These will map to the same JVM name and therefore cause
+     *  a duplicate field error. If that case arises (as in i13862.scala), use an explicit
+     *  name `x$field` instead of `FieldName(x).
+     */
+    def checkNoFieldClashes() =
+      val fieldNames = mutable.HashSet[Name]()
+      for case field: ValDef <- clsStats do
+        field.symbol.name match
+          case FieldName(_) =>
+          case name => fieldNames += name
+      for case field: ValDef <- clsStats do
+        field.symbol.name match
+          case fldName @ FieldName(name) if fieldNames.contains(name) =>
+            val newName = ExplicitFieldName(name)
+            report.log(i"avoid field/field conflict by renaming $fldName to $newName")
+            field.symbol.copySymDenotation(name = newName).installAfter(thisPhase)
+          case _ =>
+
+    splitStats(tree.body)
+    checkNoFieldClashes()
+
+    // The initializers for the retained accessors */
+    val copyParams = accessors flatMap { acc =>
+      if (!isRetained(acc)) {
+        dropped += acc
+        Nil
+      }
+      else if (!isRetained(acc.field)) { // It may happen for unit fields, tests/run/i6987.scala
+        dropped += acc.field
+        Nil
+      }
+      else {
+        val param = acc.subst(accessors, paramSyms)
+        if (param.hasAnnotation(defn.ConstructorOnlyAnnot))
+          report.error(em"${acc.name} is marked `@constructorOnly` but it is retained as a field in ${acc.owner}", acc.srcPos)
+        val target = if (acc.is(Method)) acc.field else acc
+        if (!target.exists) Nil // this case arises when the parameter accessor is an alias
+        else {
+          val assigns = Assign(ref(target), ref(param)).withSpan(tree.span) :: Nil
+          if (acc.name != nme.OUTER) assigns
+          else {
+            // insert test: if ($outer eq null) throw new NullPointerException
+            val nullTest =
+              If(ref(param).select(defn.Object_eq).appliedTo(nullLiteral),
+                 Throw(New(defn.NullPointerExceptionClass.typeRef, Nil)),
+                 unitLiteral)
+            nullTest :: assigns
+          }
+        }
+      }
+    }
+
+    // Drop accessors that are not retained from class scope
+    if (dropped.nonEmpty) {
+      val clsInfo = cls.classInfo
+      val decls = clsInfo.decls.filteredScope(!dropped.contains(_))
+      val clsInfo2 = clsInfo.derivedClassInfo(decls = decls)
+      cls.copySymDenotation(info = clsInfo2).installAfter(thisPhase)
+      // TODO: this happens to work only because Constructors is the last phase in group
+    }
+
+    val (superCalls, followConstrStats) = splitAtSuper(constrStats.toList)
+
+    val mappedSuperCalls = vparams match {
+      case (outerParam @ ValDef(nme.OUTER, _, _)) :: _ =>
+        superCalls.map(mapOuter(outerParam.symbol).transform)
+      case _ => superCalls
+    }
+
+    // Lazy Vals may decide to create an eager val instead of a lazy val
+    // this val should be assigned before constructor body code starts running
+
+    val (lazyAssignments, stats) = followConstrStats.partition {
+      case Assign(l, r) if l.symbol.name.is(NameKinds.LazyLocalName) => true
+      case _ => false
+    }
+
+    val finalConstrStats = copyParams ::: mappedSuperCalls ::: lazyAssignments ::: stats
+    val expandedConstr =
+      if (cls.isAllOf(NoInitsTrait)) {
+        assert(finalConstrStats.isEmpty || {
+          import dotty.tools.dotc.transform.sjs.JSSymUtils._
+          ctx.settings.scalajs.value && cls.isJSType
+        })
+        constr
+      }
+      else cpy.DefDef(constr)(rhs = Block(finalConstrStats, unitLiteral))
+
+    cpy.Template(tree)(constr = expandedConstr, body = clsStats.toList)
+  }
+}
diff --git a/tests/pos-with-compiler-cc/dotc/transform/ContextFunctionResults.scala b/tests/pos-with-compiler-cc/dotc/transform/ContextFunctionResults.scala
new file mode 100644
index 000000000000..be58fb41f1da
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/transform/ContextFunctionResults.scala
@@ -0,0 +1,136 @@
+package dotty.tools
+package dotc
+package transform
+
+import core._
+import Contexts._, Symbols._, Types._, Annotations._, Constants._, Phases._
+import StdNames.nme
+import ast.untpd
+import ast.tpd._
+import config.Config
+
+object ContextFunctionResults:
+
+  /** Annotate methods that have context function result types directly matched by context
+   *  closures on their right-hand side. Parameters to such closures will be integrated
+   *  as additional method parameters in erasure.
+   *
+   *  A @ContextResultCount(n) annotation means that the method's result type
+   *  consists of a string of `n` nested context closures.
+   */
+  def annotateContextResults(mdef: DefDef)(using Context): Unit =
+    def contextResultCount(rhs: Tree, tp: Type): Int = tp match
+      case defn.ContextFunctionType(_, resTpe, _) =>
+        rhs match
+          case closureDef(meth) => 1 + contextResultCount(meth.rhs, resTpe)
+          case _ => 0
+      case _ => 0
+
+    val meth = mdef.symbol
+
+    // Disable context result annotations for anonymous functions
+    // and for implementations of PolyFunction
+    def disabled =
+      meth.isAnonymousFunction
+      || meth.name == nme.apply
+          && meth.owner.isAnonymousClass
+          && meth.owner.info.parents.exists(_.isRef(defn.PolyFunctionClass))
+
+    val count = contextResultCount(mdef.rhs, mdef.tpt.tpe)
+
+    if Config.flattenContextFunctionResults && count != 0 && !disabled then
+      val countAnnot = Annotation(defn.ContextResultCountAnnot, Literal(Constant(count)))
+      mdef.symbol.addAnnotation(countAnnot)
+  end annotateContextResults
+
+  /** The argument of a ContextResultCount annotation, or 0 if none exists.
+   *  See PostTyper#annotateContextResults.
+   */
+  def contextResultCount(sym: Symbol)(using Context): Int =
+    sym.getAnnotation(defn.ContextResultCountAnnot) match
+      case Some(annot) =>
+        val ast.Trees.Literal(Constant(crCount: Int)) :: Nil = annot.arguments: @unchecked
+        crCount
+      case none => 0
+
+  /** True iff `ContextResultCount` is not zero and all context functions in the result
+   *  type are erased.
+   */
+  def contextResultsAreErased(sym: Symbol)(using Context): Boolean =
+    def allErased(tp: Type): Boolean = tp.dealias match
+      case defn.ContextFunctionType(_, resTpe, isErased) => isErased && allErased(resTpe)
+      case _ => true
+    contextResultCount(sym) > 0 && allErased(sym.info.finalResultType)
+
+  /** Turn the first `crCount` context function types in the result type of `tp`
+   *  into the curried method types.
+   */
+  def integrateContextResults(tp: Type, crCount: Int)(using Context): Type =
+    if crCount == 0 then tp
+    else tp match
+      case ExprType(rt) =>
+        integrateContextResults(rt, crCount)
+      case tp: MethodOrPoly =>
+        tp.derivedLambdaType(resType = integrateContextResults(tp.resType, crCount))
+      case defn.ContextFunctionType(argTypes, resType, isErased) =>
+        val methodType: MethodTypeCompanion =
+          if isErased then ErasedMethodType else MethodType
+        methodType(argTypes, integrateContextResults(resType, crCount - 1))
+
+  /** The total number of parameters of method `sym`, not counting
+   *  erased parameters, but including context result parameters.
+   */
+  def totalParamCount(sym: Symbol)(using Context): Int =
+
+    def contextParamCount(tp: Type, crCount: Int): Int =
+      if crCount == 0 then 0
+      else
+        val defn.ContextFunctionType(params, resTpe, isErased) = tp: @unchecked
+        val rest = contextParamCount(resTpe, crCount - 1)
+        if isErased then rest else params.length + rest
+
+    def normalParamCount(tp: Type): Int = tp.widenExpr.stripPoly match
+      case mt @ MethodType(pnames) =>
+        val rest = normalParamCount(mt.resType)
+        if mt.isErasedMethod then rest else pnames.length + rest
+      case _ => contextParamCount(tp, contextResultCount(sym))
+
+    normalParamCount(sym.info)
+  end totalParamCount
+
+  /** The `depth` levels nested context function type in the result type of `meth` */
+  def contextFunctionResultTypeAfter(meth: Symbol, depth: Int)(using Context) =
+    def recur(tp: Type, n: Int): Type =
+      if n == 0 then tp
+      else tp match
+        case defn.ContextFunctionType(_, resTpe, _) => recur(resTpe, n - 1)
+    recur(meth.info.finalResultType, depth)
+
+  /** Should selection `tree` be eliminated since it refers to an `apply`
+   *  node of a context function type whose parameters will end up being
+   *  integrated in the  preceding method?
+   *  @param `n` the select nodes seen in previous recursive iterations of this method
+   */
+  def integrateSelect(tree: untpd.Tree, n: Int = 0)(using Context): Boolean =
+    if ctx.erasedTypes then
+      atPhase(erasurePhase)(integrateSelect(tree, n))
+    else tree match
+      case Select(qual, name) =>
+        if name == nme.apply && defn.isContextFunctionClass(tree.symbol.maybeOwner) then
+          integrateSelect(qual, n + 1)
+        else
+          n > 0 && contextResultCount(tree.symbol) >= n
+      case Ident(name) =>
+        n > 0 && contextResultCount(tree.symbol) >= n
+      case Apply(fn, args) =>
+        integrateSelect(fn, n)
+      case TypeApply(fn, _) =>
+        integrateSelect(fn, n)
+      case Block(_, expr) =>
+        integrateSelect(expr, n)
+      case Inlined(_, _, expr) =>
+        integrateSelect(expr, n)
+      case _ =>
+        false
+
+end ContextFunctionResults
\ No newline at end of file
diff --git a/tests/pos-with-compiler-cc/dotc/transform/CookComments.scala b/tests/pos-with-compiler-cc/dotc/transform/CookComments.scala
new file mode 100644
index 000000000000..27f34891fc2c
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/transform/CookComments.scala
@@ -0,0 +1,34 @@
+package dotty.tools.dotc.transform
+
+import dotty.tools.dotc.ast.tpd
+import dotty.tools.dotc.core.Contexts._
+import dotty.tools.dotc.core.ContextOps._
+import dotty.tools.dotc.typer.Docstrings
+
+class CookComments extends MegaPhase.MiniPhase {
+
+  override def phaseName: String = CookComments.name
+
+  override def description: String = CookComments.description
+
+  override def transformTypeDef(tree: tpd.TypeDef)(using Context): tpd.Tree = {
+    if (ctx.settings.YcookComments.value && tree.isClassDef) {
+      val cls = tree.symbol
+      val cookingCtx = ctx.localContext(tree, cls).setNewScope
+      val template = tree.rhs.asInstanceOf[tpd.Template]
+      val owner = template.self.symbol.orElse(cls)
+
+      template.body.foreach { stat =>
+        Docstrings.cookComment(stat.symbol, owner)(using cookingCtx)
+      }
+
+      Docstrings.cookComment(cls, cls)(using cookingCtx)
+    }
+
+    tree
+  }
+}
+
+object CookComments:
+  val name = "cookComments"
+  val description: String = "cook the comments: expand variables, doc, etc."
diff --git a/tests/pos-with-compiler-cc/dotc/transform/CountOuterAccesses.scala b/tests/pos-with-compiler-cc/dotc/transform/CountOuterAccesses.scala
new file mode 100644
index 000000000000..2342170d79b8
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/transform/CountOuterAccesses.scala
@@ -0,0 +1,59 @@
+package dotty.tools.dotc
+package transform
+
+import core._
+import MegaPhase.MiniPhase
+import dotty.tools.dotc.core.Contexts._
+import ast._
+import Flags._
+import Symbols._
+import ExplicitOuter.isOuterParamAccessor
+
+import collection.mutable
+
+object CountOuterAccesses:
+  val name: String = "countOuterAccesses"
+  val description: String = "identify outer accessors that can be dropped"
+
+  /** Characterizes outer accessors and outer fields that can be dropped
+   *  if there are no references to them from within the toplevel class
+   *  where they are defined.
+   */
+  def mightBeDropped(sym: Symbol)(using Context) =
+    def isLocal(cls: Symbol) =
+      cls.isAnonymousClass
+      || cls.owner.isTerm
+      || cls.accessBoundary(defn.RootClass).isContainedIn(cls.topLevelClass)
+    (sym.is(OuterAccessor) || sym.isOuterParamAccessor) && isLocal(sym.owner)
+
+/** Counts number of accesses to outer accessors and outer fields of
+ *  classes that are visible only within one source file. The info
+ *  is collected in `outerAccessCount` and used in the subsequent
+ *  DropOuterAccessors phase
+ */
+class CountOuterAccesses extends MiniPhase:
+  thisPhase =>
+  import tpd._
+
+  override def phaseName: String = CountOuterAccesses.name
+
+  override def description: String = CountOuterAccesses.description
+
+  override def runsAfter: Set[String] = Set(LambdaLift.name)
+    // LambdaLift can create outer paths. These need to be known in this phase.
+
+  /** The number of times an outer accessor that might be dropped is accessed */
+  val outerAccessCount: mutable.HashMap[Symbol, Int] = new {
+    override def default(s: Symbol): Int = 0
+  }
+
+  private def markAccessed(tree: RefTree)(using Context): Tree =
+    val sym = tree.symbol
+    if CountOuterAccesses.mightBeDropped(sym) then outerAccessCount(sym) += 1
+    tree
+
+  override def transformIdent(tree: Ident)(using Context): Tree =
+    markAccessed(tree)
+
+  override def transformSelect(tree: Select)(using Context): Tree =
+    markAccessed(tree)
diff --git a/tests/pos-with-compiler-cc/dotc/transform/CtxLazy.scala b/tests/pos-with-compiler-cc/dotc/transform/CtxLazy.scala
new file mode 100644
index 000000000000..808cf928ecc2
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/transform/CtxLazy.scala
@@ -0,0 +1,24 @@
+package dotty.tools.dotc
+package transform
+
+import core.Contexts._
+
+/** Utility class for lazy values whose evaluation depends on a context.
+ *  This should be used whenever the evaluation of a lazy expression
+ *  depends on some context, but the value can be re-used afterwards
+ *  with a different context.
+ *
+ *  A typical use case is a lazy val in a phase object which exists once per root context where
+ *  the expression intiializing the lazy val depends only on the root context, but not any changes afterwards.
+ */
+class CtxLazy[T](expr: Context ?=> T) {
+  private var myValue: T = _
+  private var forced = false
+  def apply()(using Context): T = {
+    if (!forced) {
+      myValue = expr
+      forced = true
+    }
+    myValue
+  }
+}
diff --git a/tests/pos-with-compiler-cc/dotc/transform/Dependencies.scala b/tests/pos-with-compiler-cc/dotc/transform/Dependencies.scala
new file mode 100644
index 000000000000..0043c43073ed
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/transform/Dependencies.scala
@@ -0,0 +1,289 @@
+package dotty.tools.dotc
+package transform
+
+import core.*
+import Symbols.*, Contexts.*, Types.*, Flags.*, Decorators.*
+import SymUtils.*
+import collection.mutable.{LinkedHashMap, TreeSet}
+import annotation.constructorOnly
+
+import dotty.tools.backend.sjs.JSDefinitions.jsdefn
+
+/** Exposes the dependencies of the `root` tree in three functions or maps:
+ *  `freeVars`, `tracked`, and `logicalOwner`.
+ */
+abstract class Dependencies(root: ast.tpd.Tree, @constructorOnly rootContext: Context):
+  import ast.tpd._
+
+  /** The symbol is a method or a lazy val that will be mapped to a method */
+  protected def isExpr(sym: Symbol)(using Context): Boolean
+
+  /** The closest enclosing symbol in the current context for which `isExpr` is true */
+  protected def enclosure(using Context): Symbol
+
+  /** The set of free variables of a function, including free variables of its callees */
+  def freeVars(sym: Symbol): collection.Set[Symbol] = free.getOrElse(sym, Set.empty)
+
+  /** The set of functions that have free variables, i.e for which `freeVars` is non-empty */
+  def tracked: Iterable[Symbol] = free.keys
+
+  /** The outermost class that captures all free variables of a function
+   *  that are captured by enclosinh classes (this means that the function could
+   *  be placed in that class without having to add more environment parameters)
+   */
+  def logicalOwner: collection.Map[Symbol, Symbol] = logicOwner
+
+  private type SymSet = TreeSet[Symbol]
+
+  /** A map storing free variables of functions and classes */
+  private val free: LinkedHashMap[Symbol, SymSet] = new LinkedHashMap
+
+  /** A hashtable storing calls between functions */
+  private val called = new LinkedHashMap[Symbol, SymSet]
+
+  /** A map from local methods and classes to the owners to which they will be lifted as members.
+   *  For methods and classes that do not have any dependencies this will be the enclosing package.
+   *  symbols with packages as lifted owners will subsequently represented as static
+   *  members of their toplevel class, unless their enclosing class was already static.
+   *  Note: During tree transform (which runs at phase LambdaLift + 1), liftedOwner
+   *  is also used to decide whether a method had a term owner before.
+   */
+  private val logicOwner = new LinkedHashMap[Symbol, Symbol]
+
+  /** A flag to indicate whether new free variables have been found */
+  private var changedFreeVars: Boolean = _
+
+  /** A flag to indicate whether lifted owners have changed */
+  private var changedLogicOwner: Boolean = _
+
+  private val ord: Ordering[Symbol] = Ordering.by(_.id)
+  private def newSymSet = TreeSet.empty[Symbol](ord)
+
+  private def symSet(f: LinkedHashMap[Symbol, SymSet], sym: Symbol): SymSet =
+    f.getOrElseUpdate(sym, newSymSet)
+
+  /** A symbol is local if it is owned by a term or a local trait,
+   *  or if it is a constructor of a local symbol.
+   *  Note: we count members of local traits as local since their free variables
+   *  have to be passed on from their callers. By contrast, class members get their
+   *  free variable proxies from their enclosing class.
+   */
+  private def isLocal(sym: Symbol)(using Context): Boolean =
+    val owner = sym.maybeOwner
+    owner.isTerm
+    || owner.is(Trait) && isLocal(owner)
+    || sym.isConstructor && isLocal(owner)
+
+  /** Set `liftedOwner(sym)` to `owner` if `owner` is more deeply nested
+   *  than the previous value of `liftedowner(sym)`.
+   */
+  private def narrowLogicOwner(sym: Symbol, owner: Symbol)(using Context): Unit =
+    if sym.maybeOwner.isTerm
+        && owner.isProperlyContainedIn(logicOwner(sym))
+        && owner != sym
+    then
+      report.log(i"narrow lifted $sym to $owner")
+      changedLogicOwner = true
+      logicOwner(sym) = owner
+
+  /** Mark symbol `sym` as being free in `enclosure`, unless `sym` is defined
+   *  in `enclosure` or there is an intermediate class properly containing `enclosure`
+   *  in which `sym` is also free. Also, update `liftedOwner` of `enclosure` so
+   *  that `enclosure` can access `sym`, or its proxy in an intermediate class.
+   *  This means:
+   *
+   *    1. If there is an intermediate class in which `sym` is free, `enclosure`
+   *       must be contained in that class (in order to access the `sym proxy stored
+   *       in the class).
+   *
+   *    2. If there is no intermediate class, `enclosure` must be contained
+   *       in the class enclosing `sym`.
+   *
+   *  @return  If there is a non-trait class between `enclosure` and
+   *           the owner of `sym`, the largest such class.
+   *           Otherwise, if there is a trait between `enclosure` and
+   *           the owner of `sym`, the largest such trait.
+   *           Otherwise, NoSymbol.
+   *
+   *  @pre sym.owner.isTerm, (enclosure.isMethod || enclosure.isClass)
+   *
+   *  The idea of `markFree` is illustrated with an example:
+   *
+   *  def f(x: int) = {
+   *    class C {
+   *      class D {
+   *        val y = x
+   *      }
+   *    }
+   *  }
+   *
+   *  In this case `x` is free in the primary constructor of class `C`.
+   *  but it is not free in `D`, because after lambda lift the code would be transformed
+   *  as follows:
+   *
+   *  def f(x$0: int) {
+   *    class C(x$0: int) {
+   *      val x$1 = x$0
+   *      class D {
+   *        val y = outer.x$1
+   *      }
+   *    }
+   *  }
+   */
+  private def markFree(sym: Symbol, enclosure: Symbol)(using Context): Symbol =
+    import Dependencies.NoPath
+    try
+      if !enclosure.exists then throw NoPath()
+      if enclosure == sym.enclosure then NoSymbol
+      else
+        def nestedInConstructor(sym: Symbol): Boolean =
+          sym.isConstructor
+          || sym.isTerm && nestedInConstructor(sym.enclosure)
+        report.debuglog(i"mark free: ${sym.showLocated} with owner ${sym.maybeOwner} marked free in $enclosure")
+        val intermediate =
+          if enclosure.is(PackageClass) then enclosure
+          else if enclosure.isConstructor then markFree(sym, enclosure.owner.enclosure)
+          else markFree(sym, enclosure.enclosure)
+        if intermediate.exists then
+          narrowLogicOwner(enclosure, intermediate)
+        if !intermediate.isRealClass || nestedInConstructor(enclosure) then
+          // Constructors and methods nested inside traits get the free variables
+          // of the enclosing trait or class.
+          // Conversely, local traits do not get free variables.
+          // Methods inside constructors also don't have intermediates,
+          // need to get all their free variables passed directly.
+          if !enclosure.is(Trait) then
+            if symSet(free, enclosure).add(sym) then
+              changedFreeVars = true
+              report.log(i"$sym is free in $enclosure")
+        if intermediate.isRealClass then intermediate
+        else if enclosure.isRealClass then enclosure
+        else if intermediate.isClass then intermediate
+        else if enclosure.isClass then enclosure
+        else NoSymbol
+    catch case ex: NoPath =>
+      println(i"error lambda lifting ${ctx.compilationUnit}: $sym is not visible from $enclosure")
+      throw ex
+
+  private def markCalled(callee: Symbol, caller: Symbol)(using Context): Unit = {
+    report.debuglog(i"mark called: $callee of ${callee.owner} is called by $caller in ${caller.owner}")
+    assert(isLocal(callee))
+    symSet(called, caller) += callee
+  }
+
+  protected def process(tree: Tree)(using Context) =
+    val sym = tree.symbol
+
+    def narrowTo(thisClass: ClassSymbol) =
+      val enclMethod = enclosure
+      val enclClass = enclMethod.enclosingClass
+      narrowLogicOwner(enclMethod,
+        if enclClass.isContainedIn(thisClass) then thisClass
+        else enclClass) // unknown this reference, play it safe and assume the narrowest possible owner
+
+    def setLogicOwner(local: Symbol) =
+      val encClass = local.owner.enclosingClass
+      val preferEncClass =
+        (
+          encClass.isStatic
+            // non-static classes can capture owners, so should be avoided
+          && (encClass.isProperlyContainedIn(local.topLevelClass)
+              // can be false for symbols which are defined in some weird combination of supercalls.
+              || encClass.is(ModuleClass, butNot = Package)
+                  // needed to not cause deadlocks in classloader. see t5375.scala
+              )
+        )
+        || (
+          /* Scala.js: Never move any member beyond the boundary of a DynamicImportThunk.
+           * DynamicImportThunk subclasses are boundaries between the eventual ES modules
+           * that can be dynamically loaded. Moving members across that boundary changes
+           * the dynamic and static dependencies between ES modules, which is forbidden.
+           */
+          ctx.settings.scalajs.value && encClass.isSubClass(jsdefn.DynamicImportThunkClass)
+        )
+      logicOwner(sym) = if preferEncClass then encClass else local.enclosingPackageClass
+
+    tree match
+      case tree: Ident =>
+        if isLocal(sym) then
+          if isExpr(sym) then markCalled(sym, enclosure)
+          else if sym.isTerm then markFree(sym, enclosure)
+        def captureImplicitThis(x: Type): Unit = x match
+          case tr@TermRef(x, _) if !tr.termSymbol.isStatic => captureImplicitThis(x)
+          case x: ThisType if !x.tref.typeSymbol.isStaticOwner => narrowTo(x.tref.typeSymbol.asClass)
+          case _ =>
+        captureImplicitThis(tree.tpe)
+      case tree: Select =>
+        if isExpr(sym) && isLocal(sym) then markCalled(sym, enclosure)
+      case tree: This =>
+        narrowTo(tree.symbol.asClass)
+      case tree: MemberDef if isExpr(sym) && sym.owner.isTerm =>
+        setLogicOwner(sym)
+          // this will make methods in supercall constructors of top-level classes owned
+          // by the enclosing package, which means they will be static.
+          // On the other hand, all other methods will be indirectly owned by their
+          // top-level class. This avoids possible deadlocks when a static method
+          // has to access its enclosing object from the outside.
+      case tree: DefDef if sym.isPrimaryConstructor && isLocal(sym.owner) && !sym.owner.is(Trait) =>
+        // add a call edge from the constructor of a local non-trait class to
+        // the class itself. This is done so that the constructor inherits
+        // the free variables of the class.
+        symSet(called, sym) += sym.owner
+      case tree: TypeDef if sym.owner.isTerm =>
+        setLogicOwner(sym)
+      case _ =>
+  end process
+
+  private class CollectDependencies extends TreeTraverser:
+    def traverse(tree: Tree)(using Context) =
+      try
+        process(tree)
+        traverseChildren(tree)
+      catch case ex: Exception =>
+        println(i"$ex while traversing $tree")
+        throw ex
+
+  /** Compute final free variables map `fvs by closing over caller dependencies. */
+  private def computeFreeVars()(using Context): Unit =
+    while
+      changedFreeVars = false
+      for
+        caller <- called.keys
+        callee <- called(caller)
+        fvs <- free get callee
+        fv <- fvs
+      do
+        markFree(fv, caller)
+      changedFreeVars
+    do ()
+
+  /** Compute final liftedOwner map by closing over caller dependencies */
+  private def computeLogicOwners()(using Context): Unit =
+    while
+      changedLogicOwner = false
+      for
+        caller <- called.keys
+        callee <- called(caller)
+      do
+        val normalizedCallee = callee.skipConstructor
+        val calleeOwner = normalizedCallee.owner
+        if calleeOwner.isTerm then narrowLogicOwner(caller, logicOwner(normalizedCallee))
+        else
+          assert(calleeOwner.is(Trait))
+          // methods nested inside local trait methods cannot be lifted out
+          // beyond the trait. Note that we can also call a trait method through
+          // a qualifier; in that case no restriction to lifted owner arises.
+          if caller.isContainedIn(calleeOwner) then
+            narrowLogicOwner(caller, calleeOwner)
+      changedLogicOwner
+    do ()
+
+  // initialization
+  inContext(rootContext) {
+    CollectDependencies().traverse(root)
+    computeFreeVars()
+    computeLogicOwners()
+  }
+object Dependencies:
+  private class NoPath extends Exception
+end Dependencies
diff --git a/tests/pos-with-compiler-cc/dotc/transform/DropEmptyCompanions.scala.disabled b/tests/pos-with-compiler-cc/dotc/transform/DropEmptyCompanions.scala.disabled
new file mode 100644
index 000000000000..13adcf5c3f76
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/transform/DropEmptyCompanions.scala.disabled
@@ -0,0 +1,98 @@
+package dotty.tools.dotc
+package transform
+
+import core._
+import DenotTransformers.SymTransformer
+import Phases.Phase
+import Contexts._
+import Flags._
+import Symbols._
+import SymDenotations.SymDenotation
+import ast.Trees._
+import collection.mutable
+import Decorators._
+import NameOps._
+import MegaPhase.MiniPhase
+import dotty.tools.dotc.transform.MegaPhase.TransformerInfo
+
+/** Remove companion objects that are empty
+ *  Lots of constraints here:
+ *  1. It's impractical to place DropEmptyCompanions before lambda lift because dropped
+ *     modules can be anywhere and have hard to trace references.
+ *  2. DropEmptyCompanions cannot be interleaved with LambdaLift or Flatten because
+ *     they put things in liftedDefs sets which cause them to surface later. So
+ *     removed modules resurface.
+ *  3. DropEmptyCompanions has to be before RestoreScopes.
+ *  The solution to the constraints is to put DropEmptyCompanions between Flatten
+ *  and RestoreScopes and to only start working once we are back on PackageDef
+ *  level, so we know that all objects moved by LambdaLift and Flatten have arrived
+ *  at their destination.
+ */
+class DropEmptyCompanions extends MiniPhase { thisTransform =>
+  import ast.tpd._
+  override def phaseName = "dropEmptyCompanions"
+  override def runsAfter = Set(Flatten.name)
+
+  override def transformPackageDef(pdef: PackageDef)(using Context) = {
+
+    /** Is `tree` an empty companion object? */
+    def isEmptyCompanion(tree: Tree) = tree match {
+      case TypeDef(_, impl: Template) if tree.symbol.is(SyntheticModule) &&
+        tree.symbol.companionClass.exists &&
+        impl.body.forall(_.symbol.isPrimaryConstructor) =>
+        report.log(i"removing ${tree.symbol}")
+        true
+      case _ =>
+        false
+    }
+
+    val dropped = pdef.stats.filter(isEmptyCompanion).map(_.symbol).toSet
+
+    /** Symbol is a $lzy field representing a module */
+    def isLazyModuleVar(sym: Symbol) =
+      sym.name.isLazyLocal &&
+        sym.owner.info.decl(sym.name.asTermName.nonLazyName).symbol.is(Module)
+
+    /** Symbol should be dropped together with a dropped companion object.
+     *  Such symbols are:
+     *   - lzy fields pointing to modules,
+     *   - vals and getters representing modules.
+     */
+    def symIsDropped(sym: Symbol): Boolean =
+      (sym.is(Module) || isLazyModuleVar(sym)) &&
+        dropped.contains(sym.info.resultType.typeSymbol)
+
+    /** Tree should be dropped because it (is associated with) an empty
+     *  companion object. Such trees are
+     *   - module classes of empty companion objects
+     *   - definitions of lazy module variables or assignments to them.
+     *   - vals and getters for empty companion objects
+     */
+    def toDrop(stat: Tree): Boolean = stat match {
+      case stat: TypeDef => dropped.contains(stat.symbol)
+      case stat: ValOrDefDef => symIsDropped(stat.symbol)
+      case stat: Assign => symIsDropped(stat.lhs.symbol)
+      case _ => false
+    }
+
+    def prune(tree: Tree): Tree = tree match {
+      case tree @ TypeDef(name, impl @ Template(constr, _, _, _)) =>
+        cpy.TypeDef(tree)(
+          rhs = cpy.Template(impl)(
+            constr = cpy.DefDef(constr)(rhs = pruneLocals(constr.rhs)),
+            body = pruneStats(impl.body)))
+      case _ =>
+        tree
+    }
+
+    def pruneStats(stats: List[Tree]) =
+      stats.filterConserve(!toDrop(_)).mapConserve(prune)
+
+    def pruneLocals(expr: Tree) = expr match {
+      case Block(stats, expr) => cpy.Block(expr)(pruneStats(stats), expr)
+      case _ => expr
+    }
+
+    cpy.PackageDef(pdef)(pdef.pid, pruneStats(pdef.stats))
+  }
+}
diff --git a/tests/pos-with-compiler-cc/dotc/transform/DropOuterAccessors.scala b/tests/pos-with-compiler-cc/dotc/transform/DropOuterAccessors.scala
new file mode 100644
index 000000000000..a363ccaeb0d0
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/transform/DropOuterAccessors.scala
@@ -0,0 +1,87 @@
+package dotty.tools.dotc
+package transform
+
+import core._
+import MegaPhase.MiniPhase
+import dotty.tools.dotc.core.Contexts._
+import ast._
+import Flags._
+import Symbols._
+import Contexts._
+import Decorators._
+import DenotTransformers._
+import ExplicitOuter.isOuterParamAccessor
+import CountOuterAccesses.mightBeDropped
+import collection.mutable
+
+object DropOuterAccessors:
+  val name: String = "dropOuterAccessors"
+  val description: String = "drop unused outer accessors"
+
+/** Drops unused outer accessors of inner classes that are visible only in one
+ *  toplevel class. For other classes, we can't tell whether an outer accessor
+ *  is used or not. It could for instance be used in a type test in some other source.
+ */
+class DropOuterAccessors extends MiniPhase with IdentityDenotTransformer:
+  thisPhase =>
+  import tpd._
+
+  override def phaseName: String = DropOuterAccessors.name
+
+  override def description: String = DropOuterAccessors.description
+
+  override def runsAfterGroupsOf: Set[String] = Set(CountOuterAccesses.name)
+
+  override def changesMembers: Boolean = true // the phase drops outer accessors
+
+  override def transformTemplate(impl: Template)(using Context): Tree =
+    val outerAccessCount = ctx.base.countOuterAccessesPhase
+      .asInstanceOf[CountOuterAccesses]
+      .outerAccessCount
+
+    def dropOuterAccessor(stat: Tree): Boolean = stat match
+      case stat: DefDef
+      if stat.symbol.is(OuterAccessor)
+          && mightBeDropped(stat.symbol)
+          && outerAccessCount(stat.symbol) == 0 =>
+        assert(stat.rhs.isInstanceOf[RefTree], stat)
+        assert(outerAccessCount(stat.rhs.symbol) > 0)
+        outerAccessCount(stat.rhs.symbol) -= 1
+        stat.symbol.dropAfter(thisPhase)
+        true
+      case _ =>
+        false
+
+    val droppedParamAccessors = mutable.Set[Symbol]()
+
+    def dropOuterParamAccessor(stat: Tree): Boolean = stat match
+      case stat: ValDef
+      if stat.symbol.isOuterParamAccessor
+          && mightBeDropped(stat.symbol)
+          && outerAccessCount(stat.symbol) == 1 =>
+        droppedParamAccessors += stat.symbol
+        stat.symbol.dropAfter(thisPhase)
+        true
+      case _ =>
+        false
+
+    def dropOuterInit(stat: Tree): Boolean = stat match
+      case Assign(lhs, rhs) => droppedParamAccessors.remove(lhs.symbol)
+      case _ => false
+
+    val body1 = impl.body
+      .filterNot(dropOuterAccessor)
+      .filterNot(dropOuterParamAccessor)
+    val constr1 =
+      if droppedParamAccessors.isEmpty then impl.constr
+      else cpy.DefDef(impl.constr)(
+        rhs = impl.constr.rhs match {
+          case rhs @ Block(inits, expr) =>
+            cpy.Block(rhs)(inits.filterNot(dropOuterInit), expr)
+        })
+    assert(droppedParamAccessors.isEmpty,
+      i"""Failed to eliminate: ${droppedParamAccessors.toList}
+          when dropping outer accessors for ${ctx.owner} with
+          $impl""")
+    cpy.Template(impl)(constr = constr1, body = body1)
+  end transformTemplate
diff --git a/tests/pos-with-compiler-cc/dotc/transform/ElimByName.scala b/tests/pos-with-compiler-cc/dotc/transform/ElimByName.scala
new file mode 100644
index 000000000000..479a455b4aea
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/transform/ElimByName.scala
@@ -0,0 +1,160 @@
+package dotty.tools
+package dotc
+package transform
+
+import core._
+import Contexts._
+import Symbols._
+import Types._
+import Flags._
+import SymDenotations.*
+import DenotTransformers.InfoTransformer
+import NameKinds.SuperArgName
+import core.StdNames.nme
+import MegaPhase.*
+import Decorators.*
+import typer.RefChecks
+import reporting.trace
+
+/** This phase implements the following transformations:
+ *
+ *  1. For types of method and class parameters:
+ *
+ *     => T     becomes    () ?=> T
+ *
+ *  2. For references to cbn-parameters:
+ *
+ *     x        becomes    x.apply()
+ *
+ *  3. For arguments to cbn parameters
+ *
+ *     e        becomes    () ?=> e
+ *
+ *  An optimization is applied: If the argument `e` to a cbn parameter is already
+ *  of type `() ?=> T` and is a pure expression, we avoid (2) and (3), i.e. we
+ *  pass `e` directly instead of `() ?=> e.apply()`.
+ *
+ *  Note that `() ?=> T`  cannot be written in source since user-defined context functions
+ *  must have at least one parameter. We use the type here as a convenient marker
+ *  of something that will erase to Function0, and where we know that it came from
+ *  a by-name parameter.
+ *
+ *  Note also that the transformation applies only to types of parameters, not to other
+ *  occurrences of ExprTypes. In particular, embedded occurrences in function types
+ *  such as `(=> T) => U` are left as-is here (they are eliminated in erasure).
+ *  Trying to convert these as well would mean traversing all the types, and that
+ *  leads to cyclic reference errors in many cases.  This can cause problems in that
+ *  we might have sometimes a `() ?=> T` where a `=> T` is expected. To compensate,
+ *  there is a new clause in TypeComparer#subArg that declares `() ?=> T` to be a
+ *  subtype of `=> T` for arguments of type applications at any point after this phase
+ *  and up to erasure.
+ */
+class ElimByName extends MiniPhase, InfoTransformer:
+  thisPhase =>
+
+  import ast.tpd._
+
+  override def phaseName: String = ElimByName.name
+
+  override def description: String = ElimByName.description
+
+  override def runsAfterGroupsOf: Set[String] = Set(ExpandSAMs.name, ElimRepeated.name, RefChecks.name)
+    // - ExpanSAMs applied to partial functions creates methods that need
+    //   to be fully defined before converting. Test case is pos/i9391.scala.
+    // - ElimByName needs to run in a group after ElimRepeated since ElimRepeated
+    //   works on simple arguments but not converted closures, and it sees the arguments
+    //   after transformations by subsequent miniphases in the same group.
+    // - ElimByName should run in a group after RefChecks, since RefChecks does heavy
+    //   comparisons of signatures, and ElimByName distorts these signatures by not
+    //   replacing `=>` with `() ?=> T` everywhere.
+
+  override def changesParents: Boolean = true
+    // Expr types in parent type arguments are changed to function types.
+
+  /** If denotation had an ExprType before, it now gets a function type */
+  private def exprBecomesFunction(symd: SymDenotation)(using Context): Boolean =
+    symd.is(Param) || symd.is(ParamAccessor, butNot = Method)
+
+  def transformInfo(tp: Type, sym: Symbol)(using Context): Type = tp match {
+    case ExprType(rt) if exprBecomesFunction(sym) =>
+      defn.ByNameFunction(rt)
+    case tp: MethodType =>
+      def exprToFun(tp: Type) = tp match
+        case ExprType(rt) => defn.ByNameFunction(rt)
+        case tp => tp
+      tp.derivedLambdaType(
+        paramInfos = tp.paramInfos.mapConserve(exprToFun),
+        resType = transformInfo(tp.resType, sym))
+    case tp: PolyType =>
+      tp.derivedLambdaType(resType = transformInfo(tp.resType, sym))
+    case _ => tp
+  }
+
+  override def infoMayChange(sym: Symbol)(using Context): Boolean =
+    sym.is(Method) || exprBecomesFunction(sym)
+
+  def byNameClosure(arg: Tree, argType: Type)(using Context): Tree =
+    report.log(i"creating by name closure for $argType")
+    val meth = newAnonFun(ctx.owner, MethodType(Nil, argType), coord = arg.span)
+    Closure(meth,
+        _ => arg.changeOwnerAfter(ctx.owner, meth, thisPhase),
+        targetType = defn.ByNameFunction(argType)
+      ).withSpan(arg.span)
+
+  private def isByNameRef(tree: Tree)(using Context): Boolean =
+    defn.isByNameFunction(tree.tpe.widen)
+
+  /** Map `tree` to `tree.apply()` is `tree` is of type `() ?=> T` */
+  private def applyIfFunction(tree: Tree)(using Context) =
+    if isByNameRef(tree) then
+      val tree0 = transformFollowing(tree)
+      atPhase(next) { tree0.select(defn.ContextFunction0_apply).appliedToNone }
+    else tree
+
+  override def transformIdent(tree: Ident)(using Context): Tree =
+    applyIfFunction(tree)
+
+  override def transformSelect(tree: Select)(using Context): Tree =
+    applyIfFunction(tree)
+
+  override def transformTypeApply(tree: TypeApply)(using Context): Tree = tree match {
+    case TypeApply(Select(_, nme.asInstanceOf_), arg :: Nil) =>
+      // tree might be of form e.asInstanceOf[x.type] where x becomes a function.
+      // See pos/t296.scala
+      applyIfFunction(tree)
+    case _ => tree
+  }
+
+  override def transformApply(tree: Apply)(using Context): Tree =
+    trace(s"transforming ${tree.show} at phase ${ctx.phase}", show = true) {
+
+      def transformArg(arg: Tree, formal: Type): Tree = formal match
+        case defn.ByNameFunction(formalResult) =>
+          def stripTyped(t: Tree): Tree = t match
+            case Typed(expr, _) => stripTyped(expr)
+            case _ => t
+          stripTyped(arg) match
+            case Apply(Select(qual, nme.apply), Nil)
+            if isByNameRef(qual) && (isPureExpr(qual) || qual.symbol.isAllOf(InlineParam)) =>
+              qual
+            case _ =>
+              if isByNameRef(arg) || arg.symbol.name.is(SuperArgName) then arg
+              else byNameClosure(arg, formalResult)
+        case _ =>
+          arg
+
+      val mt @ MethodType(_) = tree.fun.tpe.widen: @unchecked
+      val args1 = tree.args.zipWithConserve(mt.paramInfos)(transformArg)
+      cpy.Apply(tree)(tree.fun, args1)
+    }
+
+  override def transformValDef(tree: ValDef)(using Context): Tree =
+    atPhase(next) {
+      if exprBecomesFunction(tree.symbol) then
+        cpy.ValDef(tree)(tpt = tree.tpt.withType(tree.symbol.info))
+      else tree
+    }
+
+object ElimByName:
+  val name: String = "elimByName"
+  val description: String = "map by-name parameters to functions"
diff --git a/tests/pos-with-compiler-cc/dotc/transform/ElimErasedValueType.scala b/tests/pos-with-compiler-cc/dotc/transform/ElimErasedValueType.scala
new file mode 100644
index 000000000000..503561915040
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/transform/ElimErasedValueType.scala
@@ -0,0 +1,142 @@
+package dotty.tools
+package dotc
+package transform
+
+import ast.{Trees, tpd}
+import core._, core.Decorators._
+import MegaPhase._
+import Types._, Contexts._, Flags._, DenotTransformers._, Phases._
+import Symbols._, StdNames._, Trees._
+import TypeErasure.ErasedValueType, ValueClasses._
+import reporting._
+import NameKinds.SuperAccessorName
+
+object ElimErasedValueType {
+  val name: String = "elimErasedValueType"
+  val description: String = "expand erased value types to their underlying implmementation types"
+
+  def elimEVT(tp: Type)(using Context): Type = tp match {
+    case ErasedValueType(_, underlying) =>
+      elimEVT(underlying)
+    case tp: MethodType =>
+      val paramTypes = tp.paramInfos.mapConserve(elimEVT)
+      val retType = elimEVT(tp.resultType)
+      tp.derivedLambdaType(tp.paramNames, paramTypes, retType)
+    case _ =>
+      tp
+  }
+}
+
+/** This phase erases ErasedValueType to their underlying type.
+ *  It also removes the synthetic cast methods u2evt$ and evt2u$ which are
+ *  no longer needed afterwards.
+ *  Finally, it checks that we don't introduce "double definitions" of pairs
+ *  of methods that now have the same signature but were not considered matching
+ *  before erasure.
+ */
+class ElimErasedValueType extends MiniPhase with InfoTransformer { thisPhase =>
+
+  import tpd._
+  import ElimErasedValueType.elimEVT
+
+  override def phaseName: String = ElimErasedValueType.name
+
+  override def description: String = ElimErasedValueType.description
+
+  override def runsAfter: Set[String] = Set(Erasure.name)
+
+  def transformInfo(tp: Type, sym: Symbol)(using Context): Type = sym match {
+    case sym: ClassSymbol if sym.is(ModuleClass) =>
+      sym.companionClass match {
+        case origClass: ClassSymbol if isDerivedValueClass(origClass) =>
+          val cinfo = tp.asInstanceOf[ClassInfo]
+          val decls1 = cinfo.decls.cloneScope
+          // Remove synthetic cast methods introduced by ExtensionMethods,
+          // they are no longer needed after this phase.
+          decls1.unlink(cinfo.decl(nme.U2EVT).symbol)
+          decls1.unlink(cinfo.decl(nme.EVT2U).symbol)
+          cinfo.derivedClassInfo(decls = decls1)
+        case _ =>
+          tp
+      }
+    case _ =>
+      elimEVT(tp)
+  }
+
+  def transformTypeOfTree(tree: Tree)(using Context): Tree =
+    tree.withType(elimEVT(tree.tpe))
+
+  override def transformApply(tree: Apply)(using Context): Tree = {
+    val Apply(fun, args) = tree
+
+    // The casts to and from ErasedValueType are no longer needed once ErasedValueType
+    // has been eliminated.
+    val t =
+      if (fun.symbol.isValueClassConvertMethod)
+        args.head
+      else
+        tree
+    transformTypeOfTree(t)
+  }
+
+  /** Check that we don't have pairs of methods that override each other after
+   *  this phase, yet do not have matching types before erasure.
+   */
+  private def checkNoClashes(root: Symbol)(using Context) = {
+    val opc = atPhase(thisPhase) {
+      new OverridingPairs.Cursor(root) {
+        override def isSubParent(parent: Symbol, bc: Symbol)(using Context) =
+          // Need to compute suparents before erasure to not filter out parents
+          // that are bypassed with different types. See neg/11719a.scala.
+          atPhase(elimRepeatedPhase.next) { super.isSubParent(parent, bc) }
+        override def exclude(sym: Symbol) =
+          !sym.is(Method) || sym.is(Bridge) || super.exclude(sym)
+        override def matches(sym1: Symbol, sym2: Symbol) =
+          sym1.signature == sym2.signature
+      }
+    }
+
+    def checkNoConflict(sym1: Symbol, sym2: Symbol, info: Type)(using Context): Unit = {
+      val site = root.thisType
+      val info1 = site.memberInfo(sym1)
+      val info2 = site.memberInfo(sym2)
+      // PolyFunction apply methods will be eliminated later during
+      // ElimPolyFunction, so we let them pass here.
+      def bothPolyApply =
+        sym1.name == nme.apply &&
+        (sym1.owner.derivesFrom(defn.PolyFunctionClass) ||
+         sym2.owner.derivesFrom(defn.PolyFunctionClass))
+
+      // super-accessors start as private, and their expanded name can clash after
+      // erasure. TODO: Verify that this is OK.
+      def bothSuperAccessors = sym1.name.is(SuperAccessorName) && sym2.name.is(SuperAccessorName)
+      if (sym1.name != sym2.name && !bothSuperAccessors ||
+          !info1.matchesLoosely(info2) && !bothPolyApply)
+        report.error(DoubleDefinition(sym1, sym2, root), root.srcPos)
+    }
+    while (opc.hasNext) {
+      val sym1 = opc.overriding
+      val sym2 = opc.overridden
+      // Do the test at the earliest phase where both symbols existed.
+      val phaseId =
+        sym1.originDenotation.validFor.firstPhaseId max sym2.originDenotation.validFor.firstPhaseId
+      atPhase(elimByNamePhase.next)(checkNoConflict(sym1, sym2, sym1.info))
+      opc.next()
+    }
+  }
+
+  override def prepareForTypeDef(tree: TypeDef)(using Context): Context = {
+    checkNoClashes(tree.symbol)
+    ctx
+  }
+
+  override def transformInlined(tree: Inlined)(using Context): Tree =
+    transformTypeOfTree(tree)
+
+  override def transformIdent(tree: Ident)(using Context): Tree =
+    transformTypeOfTree(tree)
+  override def transformSelect(tree: Select)(using Context): Tree =
+    transformTypeOfTree(tree)
+  override def transformTypeTree(tree: TypeTree)(using Context): Tree =
+    transformTypeOfTree(tree)
+}
diff --git a/tests/pos-with-compiler-cc/dotc/transform/ElimOpaque.scala b/tests/pos-with-compiler-cc/dotc/transform/ElimOpaque.scala
new file mode 100644
index 000000000000..2f55826ec2a3
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/transform/ElimOpaque.scala
@@ -0,0 +1,75 @@
+package dotty.tools
+package dotc
+package transform
+
+import core._
+import dotty.tools.dotc.transform.MegaPhase._
+import Flags._
+import Types._
+import Contexts._
+import Symbols._
+import Denotations.{SingleDenotation, NonSymSingleDenotation}
+import SymDenotations.SymDenotation
+import DenotTransformers._
+import Names._
+
+object ElimOpaque {
+  val name: String = "elimOpaque"
+  val description: String = "turn opaque into normal aliases"
+}
+
+/** Rewrites opaque type aliases to normal alias types */
+class ElimOpaque extends MiniPhase with DenotTransformer {
+  thisPhase =>
+  import ast.tpd._
+
+  override def phaseName: String = ElimOpaque.name
+
+  override def description: String = ElimOpaque.description
+
+  // Override checks need to take place before treating opaque types as aliases
+  override def runsAfterGroupsOf: Set[String] = Set(typer.RefChecks.name)
+
+  // base types of opaque aliases change
+  override def changesBaseTypes = true
+
+  def transform(ref: SingleDenotation)(using Context): SingleDenotation = {
+    val sym = ref.symbol
+    ref match {
+      case ref: SymDenotation if sym.isOpaqueAlias =>
+        ref.copySymDenotation(
+          info = TypeAlias(ref.opaqueAlias),
+          initFlags = ref.flags &~ (Opaque | Deferred))
+      case ref: SymDenotation if sym.containsOpaques =>
+        def stripOpaqueRefinements(tp: Type): Type = tp match {
+          case RefinedType(parent, rname, TypeAlias(_))
+          if ref.info.decl(rname).symbol.isOpaqueAlias => stripOpaqueRefinements(parent)
+          case _ => tp
+        }
+        val cinfo = sym.asClass.classInfo
+        val strippedSelfType = stripOpaqueRefinements(cinfo.selfType)
+        ref.copySymDenotation(
+          info = cinfo.derivedClassInfo(selfInfo = strippedSelfType),
+          initFlags = ref.flags &~ Opaque)
+      case ref: NonSymSingleDenotation if sym.isOpaqueAlias =>
+        ref.derivedSingleDenotation(sym, TypeAlias(sym.opaqueAlias.asSeenFrom(ref.prefix, sym.owner)))
+      case _ =>
+        ref
+    }
+  }
+
+  /** Resolve overloading of `==` and `!=` methods with the representation
+   *  types in order to avoid boxing.
+   */
+  override def transformApply(tree: Apply)(using Context): Tree =
+    val sym = tree.symbol
+    if sym == defn.Any_== || sym == defn.Any_!= then
+      tree match
+        case Apply(Select(receiver, name: TermName), args)
+        if atPhase(thisPhase)(receiver.tpe.widenDealias.typeSymbol.isOpaqueAlias) =>
+          applyOverloaded(receiver, name, args, Nil, defn.BooleanType)
+        case _ =>
+          tree
+    else
+      tree
+}
diff --git a/tests/pos-with-compiler-cc/dotc/transform/ElimOuterSelect.scala b/tests/pos-with-compiler-cc/dotc/transform/ElimOuterSelect.scala
new file mode 100644
index 000000000000..3ddc8b614bae
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/transform/ElimOuterSelect.scala
@@ -0,0 +1,38 @@
+package dotty.tools.dotc
+package transform
+
+import core._
+import MegaPhase.MiniPhase
+import Contexts._
+import Types._
+import NameKinds.OuterSelectName
+
+/** This phase rewrites outer selects `E.n_<outer>` which were introduced by
+ *  inlining to outer paths.
+ */
+class ElimOuterSelect extends MiniPhase {
+  import ast.tpd._
+
+  override def phaseName: String = ElimOuterSelect.name
+
+  override def description: String = ElimOuterSelect.description
+
+  override def runsAfterGroupsOf: Set[String] = Set(ExplicitOuter.name)
+    // ExplicitOuter needs to have run to completion before so that all classes
+    // that need an outer accessor have one.
+
+  /** Convert a selection of the form `qual.n_<outer>` to an outer path from `qual` of
+   *  length `n`.
+   */
+  override def transformSelect(tree: Select)(using Context): Tree =
+    tree.name match {
+      case OuterSelectName(_, nhops) =>
+        val SkolemType(tp) = tree.tpe: @unchecked
+        ExplicitOuter.outer.path(start = tree.qualifier, count = nhops).ensureConforms(tp)
+      case _ => tree
+    }
+}
+
+object ElimOuterSelect:
+  val name: String = "elimOuterSelect"
+  val description: String = "expand outer selections"
diff --git a/tests/pos-with-compiler-cc/dotc/transform/ElimPackagePrefixes.scala b/tests/pos-with-compiler-cc/dotc/transform/ElimPackagePrefixes.scala
new file mode 100644
index 000000000000..83349f1f6199
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/transform/ElimPackagePrefixes.scala
@@ -0,0 +1,37 @@
+package dotty.tools.dotc
+package transform
+
+import core._
+import Decorators._, Flags._, Types._, Contexts._, Symbols._
+import ast.tpd._
+import Flags._
+import MegaPhase.MiniPhase
+
+/** Eliminates syntactic references to package terms as prefixes of classes, so that there's no chance
+ *  they accidentally end up in the backend.
+ */
+class ElimPackagePrefixes extends MiniPhase {
+
+  override def phaseName: String = ElimPackagePrefixes.name
+
+  override def description: String = ElimPackagePrefixes.description
+
+  override def transformSelect(tree: Select)(using Context): Tree =
+    if (isPackageClassRef(tree)) Ident(tree.tpe.asInstanceOf[TypeRef]) else tree
+
+  override def checkPostCondition(tree: Tree)(using Context): Unit = tree match {
+    case tree: Select =>
+      assert(!isPackageClassRef(tree), i"Unexpected reference to package in $tree")
+    case _ =>
+  }
+
+  /** Is the given tree a reference to a type in a package? */
+  private def isPackageClassRef(tree: Select)(using Context): Boolean = tree.tpe match {
+    case TypeRef(prefix, _) => prefix.termSymbol.is(Package)
+    case _ => false
+  }
+}
+
+object ElimPackagePrefixes:
+  val name: String = "elimPackagePrefixes"
+  val description: String = "eliminate references to package prefixes in Select nodes"
diff --git a/tests/pos-with-compiler-cc/dotc/transform/ElimPolyFunction.scala b/tests/pos-with-compiler-cc/dotc/transform/ElimPolyFunction.scala
new file mode 100644
index 000000000000..756ddd9bf0eb
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/transform/ElimPolyFunction.scala
@@ -0,0 +1,71 @@
+package dotty.tools.dotc
+package transform
+
+import ast.{Trees, tpd}
+import core._, core.Decorators._
+import MegaPhase._, Phases.Phase
+import Types._, Contexts._, Constants._, Names._, NameOps._, Flags._, DenotTransformers._
+import SymDenotations._, Symbols._, StdNames._, Annotations._, Trees._, Scopes._, Denotations._
+import TypeErasure.ErasedValueType, ValueClasses._
+
+/** This phase rewrite PolyFunction subclasses to FunctionN subclasses
+ *
+ *      class Foo extends PolyFunction {
+ *          def apply(x_1: P_1, ..., x_N: P_N): R = rhs
+ *      }
+ *   becomes:
+ *      class Foo extends FunctionN {
+ *          def apply(x_1: P_1, ..., x_N: P_N): R = rhs
+ *      }
+ */
+class ElimPolyFunction extends MiniPhase with DenotTransformer {
+
+  import tpd._
+
+  override def phaseName: String = ElimPolyFunction.name
+
+  override def description: String = ElimPolyFunction.description
+
+  override def runsAfter = Set(Erasure.name)
+
+  override def changesParents: Boolean = true // Replaces PolyFunction by FunctionN
+
+  override def transform(ref: SingleDenotation)(using Context) = ref match {
+    case ref: ClassDenotation if ref.symbol != defn.PolyFunctionClass && ref.derivesFrom(defn.PolyFunctionClass) =>
+      val cinfo = ref.classInfo
+      val newParent = functionTypeOfPoly(cinfo)
+      val newParents = cinfo.declaredParents.map(parent =>
+        if (parent.typeSymbol == defn.PolyFunctionClass)
+          newParent
+        else
+          parent
+      )
+      ref.copySymDenotation(info = cinfo.derivedClassInfo(declaredParents = newParents))
+    case _ =>
+      ref
+  }
+
+  def functionTypeOfPoly(cinfo: ClassInfo)(using Context): Type = {
+    val applyMeth = cinfo.decls.lookup(nme.apply).info
+    val arity = applyMeth.paramNamess.head.length
+    defn.FunctionType(arity)
+  }
+
+  override def transformTemplate(tree: Template)(using Context): Tree = {
+    val newParents = tree.parents.mapconserve(parent =>
+      if (parent.tpe.typeSymbol == defn.PolyFunctionClass) {
+        val cinfo = tree.symbol.owner.asClass.classInfo
+        tpd.TypeTree(functionTypeOfPoly(cinfo))
+      }
+      else
+        parent
+    )
+    cpy.Template(tree)(parents = newParents)
+  }
+}
+
+object ElimPolyFunction {
+  val name: String = "elimPolyFunction"
+  val description: String = "rewrite PolyFunction subclasses to FunctionN subclasses"
+}
+
diff --git a/tests/pos-with-compiler-cc/dotc/transform/ElimRepeated.scala b/tests/pos-with-compiler-cc/dotc/transform/ElimRepeated.scala
new file mode 100644
index 000000000000..bdc2a268c1f8
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/transform/ElimRepeated.scala
@@ -0,0 +1,299 @@
+package dotty.tools
+package dotc
+package transform
+
+import core._
+import StdNames.nme
+import Types._
+import transform.MegaPhase._
+import Flags._
+import Contexts._
+import Symbols._
+import Decorators._
+import Denotations._, SymDenotations._
+import DenotTransformers._
+import NullOpsDecorator._
+
+object ElimRepeated {
+  val name: String = "elimRepeated"
+  val description: String = "rewrite vararg parameters and arguments"
+}
+
+/** A transformer that eliminates repeated parameters (T*) from all types, replacing
+ *  them with Seq or Array types and adapting repeated arguments to conform to
+ *  the transformed type if needed.
+ */
+class ElimRepeated extends MiniPhase with InfoTransformer { thisPhase =>
+  import ast.tpd._
+
+  override def phaseName: String = ElimRepeated.name
+
+  override def description: String = ElimRepeated.description
+
+  override def changesMembers: Boolean = true // the phase adds vararg forwarders
+
+  def transformInfo(tp: Type, sym: Symbol)(using Context): Type =
+    elimRepeated(tp, sym.is(JavaDefined))
+
+  /** Create forwarder symbols for the methods that are annotated
+   *  with `@varargs` or that override java varargs.
+   *
+   *  The definitions (DefDef) for these symbols are created by transformDefDef.
+   */
+  override def transform(ref: SingleDenotation)(using Context): SingleDenotation =
+    def transformVarArgs(sym: Symbol, isJavaVarargsOverride: Boolean): Unit =
+      val hasAnnotation = hasVarargsAnnotation(sym)
+      val hasRepeatedParam = hasRepeatedParams(sym)
+      if hasRepeatedParam then
+        val parentHasAnnotation = parentHasVarargsAnnotation(sym)
+        if isJavaVarargsOverride || hasAnnotation || parentHasAnnotation then
+          // java varargs are more restrictive than scala's
+          // see https://github.com/scala/bug/issues/11714
+          val validJava = isValidJavaVarArgs(sym.info)
+          if !validJava then
+            report.error("""To generate java-compatible varargs:
+                      |  - there must be a single repeated parameter
+                      |  - it must be the last argument in the last parameter list
+                      |""".stripMargin,
+              sym.sourcePos)
+          else
+            addVarArgsForwarder(sym, isJavaVarargsOverride, hasAnnotation, parentHasAnnotation)
+      else if hasAnnotation then
+        report.error("A method without repeated parameters cannot be annotated with @varargs", sym.sourcePos)
+    end
+
+    super.transform(ref) match
+      case ref1: SymDenotation if ref1.is(Method, butNot = JavaDefined) =>
+        val sym = ref1.symbol
+        val isJavaVarargsOverride = (ref1 ne ref) && overridesJava(sym)
+        transformVarArgs(sym, isJavaVarargsOverride)
+        if isJavaVarargsOverride then
+          // This method won't override the corresponding Java method at the end of this phase,
+          // only the forwarder added by `addVarArgsForwarder` will.
+          ref1.copySymDenotation(initFlags = ref1.flags &~ Override)
+        else
+          ref1
+      case ref1 =>
+        ref1
+
+  override def infoMayChange(sym: Symbol)(using Context): Boolean = sym.is(Method)
+
+  /** Does `sym` override a symbol defined in a Java class? One might think that
+   *  this can be expressed as
+   *
+   *      sym.allOverriddenSymbols.exists(_.is(JavaDefined))
+   *
+   *  but that does not work, since `allOverriddenSymbols` gets confused because the
+   *  signatures of a Java varargs method and a Scala varargs override are not the same.
+   */
+  private def overridesJava(sym: Symbol)(using Context) =
+    sym.owner.info.baseClasses.drop(1).exists { bc =>
+      bc.is(JavaDefined) && {
+        val other = bc.info.nonPrivateDecl(sym.name)
+        other.hasAltWith { alt =>
+          sym.owner.thisType.memberInfo(alt.symbol).matchesLoosely(sym.info)
+        }
+      }
+    }
+
+  private def hasVarargsAnnotation(sym: Symbol)(using Context) = sym.hasAnnotation(defn.VarargsAnnot)
+
+  private def parentHasVarargsAnnotation(sym: Symbol)(using Context) = sym.allOverriddenSymbols.exists(hasVarargsAnnotation)
+
+  private def isVarargsMethod(sym: Symbol)(using Context) =
+    hasVarargsAnnotation(sym)
+    || hasRepeatedParams(sym)
+        && (overridesJava(sym) || sym.allOverriddenSymbols.exists(hasVarargsAnnotation))
+
+  /** Eliminate repeated parameters from method types. */
+  private def elimRepeated(tp: Type, isJava: Boolean)(using Context): Type = tp.stripTypeVar match
+    case tp @ MethodTpe(paramNames, paramTypes, resultType) =>
+      val resultType1 = elimRepeated(resultType, isJava)
+      val paramTypes1 =
+        val lastIdx = paramTypes.length - 1
+        if lastIdx >= 0 then
+          val last = paramTypes(lastIdx)
+          if last.isRepeatedParam then
+            paramTypes.updated(lastIdx, last.translateFromRepeated(toArray = isJava))
+          else paramTypes
+        else paramTypes
+      tp.derivedLambdaType(paramNames, paramTypes1, resultType1)
+    case tp: PolyType =>
+      tp.derivedLambdaType(tp.paramNames, tp.paramInfos, elimRepeated(tp.resultType, isJava))
+    case tp =>
+      tp
+
+  override def transformApply(tree: Apply)(using Context): Tree =
+    val args = tree.args.mapConserve { arg =>
+      if isWildcardStarArg(arg) then
+        val expr = arg match
+          case t: Typed => t.expr
+          case _ => arg // if the argument has been lifted it's not a Typed (often it's an Ident)
+
+        val isJavaDefined = tree.fun.symbol.is(JavaDefined)
+        if isJavaDefined then
+          adaptToArray(expr)
+        else if expr.tpe.derivesFrom(defn.ArrayClass) then
+          arrayToSeq(expr)
+        else
+          expr
+      else
+        arg
+    }
+    cpy.Apply(tree)(tree.fun, args)
+
+  private def adaptToArray(tree: Tree)(implicit ctx: Context): Tree = tree match
+    case SeqLiteral(elems, elemtpt) =>
+      JavaSeqLiteral(elems, elemtpt).withSpan(tree.span)
+    case _ =>
+      val elemTp = tree.tpe.elemType
+      val adapted =
+        if tree.tpe.derivesFrom(defn.ArrayClass) then
+          tree
+        else
+          ref(defn.DottyArraysModule)
+          .select(nme.seqToArray)
+          .appliedToType(elemTp)
+          .appliedTo(tree, clsOf(elemTp))
+      // This seemingly redundant type ascription is needed because the result
+      // type of `adapted` might be erased to `Object`, but we need to keep
+      // the precise result type at erasure for `Erasure.Boxing.cast` to adapt
+      // a primitive array into a reference array if needed.
+      // Test case in tests/run/t1360.scala.
+      Typed(adapted, TypeTree(defn.ArrayOf(elemTp)))
+
+  /** Convert an Array into a scala.Seq */
+  private def arrayToSeq(tree: Tree)(using Context): Tree =
+    wrapArray(tree, tree.tpe.elemType)
+
+  /** Generate the method definitions for the varargs forwarders created in transform */
+  override def transformDefDef(tree: DefDef)(using Context): Tree =
+    // If transform reported an error, don't go further
+    if ctx.reporter.hasErrors then
+      return tree
+
+    val sym = tree.symbol
+    val isVarArgs = atPhase(thisPhase)(isVarargsMethod(sym))
+    if isVarArgs then
+      // Get the symbol generated in transform
+      val forwarderType = atPhase(thisPhase)(toJavaVarArgs(sym.info))
+      val forwarderSym = currentClass.info.decl(sym.name).alternatives
+        .find(_.info.matches(forwarderType))
+        .get
+        .symbol.asTerm
+      // Generate the method
+      val forwarderDef = DefDef(forwarderSym, prefss => {
+        val init :+ (last :+ vararg) = prefss: @unchecked
+        // Can't call `.argTypes` here because the underlying array type is of the
+        // form `Array[? <: SomeType]`, so we need `.argInfos` to get the `TypeBounds`.
+        val elemtp = vararg.tpe.widen.argInfos.head
+        ref(sym.termRef)
+          .appliedToArgss(init)
+          .appliedToTermArgs(last :+ wrapArray(vararg, elemtp))
+        })
+      Thicket(tree, forwarderDef)
+    else
+      tree
+
+  /** Is there a repeated parameter in some parameter list? */
+  private def hasRepeatedParams(sym: Symbol)(using Context): Boolean =
+    sym.info.paramInfoss.nestedExists(_.isRepeatedParam)
+
+  /** Is this the type of a method that has a repeated parameter type as
+   *  its last parameter in the last parameter list?
+   */
+  private def isValidJavaVarArgs(tp: Type)(using Context): Boolean = tp match
+    case mt: MethodType =>
+      val initp :+ lastp = mt.paramInfoss: @unchecked
+      initp.forall(_.forall(!_.isRepeatedParam)) &&
+      lastp.nonEmpty &&
+      lastp.init.forall(!_.isRepeatedParam) &&
+      lastp.last.isRepeatedParam
+    case pt: PolyType =>
+      isValidJavaVarArgs(pt.resultType)
+    case _ =>
+      throw new Exception("Match error in @varargs checks. This should not happen, please open an issue " + tp)
+
+  /** Add the symbol of a Java varargs forwarder to the scope.
+   *  It retains all the flags of the original method.
+   *
+   *  @param original the original method symbol
+   *  @param isBridge true if we are generating a "bridge" (synthetic override forwarder)
+   *  @param hasAnnotation true if the method is annotated with `@varargs`
+   *  @param parentHasAnnotation true if the method overrides a method that is annotated with `@varargs`
+   *
+   *  A forwarder is necessary because the following holds:
+   *    - the varargs in `original` will change from `RepeatedParam[T]` to `Seq[T]` after this phase
+   *    - _but_ the callers of the method expect its varargs to be changed to `Array[? <: T]`
+   *  The solution is to add a method that converts its argument from `Array[? <: T]` to `Seq[T]` and
+   *  forwards it to the original method.
+   */
+  private def addVarArgsForwarder(original: Symbol, isBridge: Boolean, hasAnnotation: Boolean, parentHasAnnotation: Boolean)(using Context): Unit =
+    val owner = original.owner
+    if !owner.isClass then
+      report.error("inner methods cannot be annotated with @varargs", original.sourcePos)
+      return
+
+    val classInfo = owner.info
+
+    // For simplicity we always set the varargs flag,
+    // although it's not strictly necessary for overrides.
+    val flags = original.flags | JavaVarargs
+
+    // The java-compatible forwarder symbol
+    val forwarder =
+      original.copy(
+        flags =
+          if isBridge then flags | Artifact
+          else if hasAnnotation && !parentHasAnnotation then flags &~ Override
+          else flags,
+        info = toJavaVarArgs(original.info)
+      ).asTerm
+
+    // Find methods that would conflict with the forwarder if the latter existed.
+    // This needs to be done at thisPhase so that parent @varargs don't conflict.
+    val conflicts =
+      classInfo.member(original.name).altsWith { s =>
+        s.matches(forwarder) && !(isBridge && s.is(JavaDefined))
+      }
+    conflicts match
+      case conflict :: _ =>
+        val src =
+          if hasAnnotation then "@varargs"
+          else if isBridge then "overriding a java varargs method"
+          else "@varargs (on overridden method)"
+        report.error(s"$src produces a forwarder method that conflicts with ${conflict.showDcl}", original.srcPos)
+      case Nil =>
+        forwarder.enteredAfter(thisPhase)
+  end addVarArgsForwarder
+
+  /** Convert type from Scala to Java varargs method */
+  private def toJavaVarArgs(tp: Type)(using Context): Type = tp match
+    case tp: PolyType =>
+      tp.derivedLambdaType(tp.paramNames, tp.paramInfos, toJavaVarArgs(tp.resultType))
+    case tp: MethodType =>
+      tp.resultType match
+        case m: MethodType => // multiple param lists
+          tp.derivedLambdaType(tp.paramNames, tp.paramInfos, toJavaVarArgs(m))
+        case _ =>
+          val init :+ last = tp.paramInfos: @unchecked
+          val vararg = varargArrayType(last)
+          tp.derivedLambdaType(tp.paramNames, init :+ vararg, tp.resultType)
+
+  /** Translate a repeated type T* to an `Array[? <: Upper]`
+   *  such that it is compatible with java varargs.
+   *
+   *  When necessary we set `Upper = T & AnyRef`
+   *  to prevent the erasure of `Array[? <: Upper]` to Object,
+   *  which would break the varargs from Java.
+   */
+  private def varargArrayType(tp: Type)(using Context): Type =
+    val array = tp.translateFromRepeated(toArray = true) // Array[? <: T]
+    val element = array.elemType.hiBound // T
+
+    if element <:< defn.AnyRefType
+      || ctx.mode.is(Mode.SafeNulls) && element.stripNull <:< defn.AnyRefType
+      || element.typeSymbol.isPrimitiveValueClass
+    then array
+    else defn.ArrayOf(TypeBounds.upper(AndType(element, defn.AnyRefType))) // Array[? <: T & AnyRef]
+}
diff --git a/tests/pos-with-compiler-cc/dotc/transform/ElimStaticThis.scala b/tests/pos-with-compiler-cc/dotc/transform/ElimStaticThis.scala
new file mode 100644
index 000000000000..02612253c735
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/transform/ElimStaticThis.scala
@@ -0,0 +1,43 @@
+package dotty.tools.dotc
+package transform
+
+import core._
+import Contexts._
+import Flags._
+import dotty.tools.dotc.ast.tpd
+import MegaPhase.MiniPhase
+import dotty.tools.dotc.core.Types.{ThisType, TermRef}
+
+/** Replace This references to module classes in static methods by global identifiers to the
+ *  corresponding modules.
+ */
+class ElimStaticThis extends MiniPhase {
+  import ast.tpd._
+
+  override def phaseName: String = ElimStaticThis.name
+
+  override def description: String = ElimStaticThis.description
+
+  override def transformThis(tree: This)(using Context): Tree =
+    if (!tree.symbol.is(Package) && ctx.owner.enclosingMethod.is(JavaStatic)) {
+      assert(tree.symbol.is(ModuleClass))
+      ref(tree.symbol.sourceModule)
+    }
+    else tree
+
+  override def transformIdent(tree: tpd.Ident)(using Context): tpd.Tree =
+    if (ctx.owner.enclosingMethod.is(JavaStatic))
+      tree.tpe match {
+        case TermRef(thiz: ThisType, _) if thiz.cls.is(ModuleClass, JavaDefined) =>
+          ref(thiz.cls.sourceModule).select(tree.symbol)
+        case TermRef(thiz: ThisType, _) =>
+          assert(tree.symbol.is(Flags.JavaStatic) || thiz.cls.is(JavaDefined))
+          tree
+        case _ => tree
+      }
+    else tree
+}
+
+object ElimStaticThis:
+  val name: String = "elimStaticThis"
+  val description: String = "replace This references to static objects by global identifiers"
diff --git a/tests/pos-with-compiler-cc/dotc/transform/EmptyPhase.scala b/tests/pos-with-compiler-cc/dotc/transform/EmptyPhase.scala
new file mode 100644
index 000000000000..9a287b2dd1d9
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/transform/EmptyPhase.scala
@@ -0,0 +1,19 @@
+package dotty.tools.dotc
+package transform
+
+import core.*
+import Contexts.Context
+import Phases.Phase
+
+/** A phase that can be inserted directly after a phase that cannot
+ *  be checked, to enable a -Ycheck as soon as possible afterwards
+ */
+class EmptyPhase extends Phase:
+
+  def phaseName: String = "dummy"
+
+  override def isEnabled(using Context) = prev.isEnabled
+
+  override def run(using Context) = ()
+
+end EmptyPhase
\ No newline at end of file
diff --git a/tests/pos-with-compiler-cc/dotc/transform/Erasure.scala b/tests/pos-with-compiler-cc/dotc/transform/Erasure.scala
new file mode 100644
index 000000000000..84005424e3ec
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/transform/Erasure.scala
@@ -0,0 +1,1069 @@
+package dotty.tools
+package dotc
+package transform
+
+import core.Phases._
+import core.DenotTransformers._
+import core.Denotations._
+import core.SymDenotations._
+import core.Symbols._
+import core.Contexts._
+import core.Types._
+import core.Names._
+import core.StdNames._
+import core.NameOps._
+import core.NameKinds.{AdaptedClosureName, BodyRetainerName, DirectMethName}
+import core.Scopes.newScopeWith
+import core.Decorators._
+import core.Constants._
+import core.Definitions._
+import core.Annotations.BodyAnnotation
+import typer.NoChecking
+import inlines.Inlines
+import typer.ProtoTypes._
+import typer.ErrorReporting.errorTree
+import typer.Checking.checkValue
+import core.TypeErasure._
+import core.Decorators._
+import dotty.tools.dotc.ast.{tpd, untpd}
+import ast.TreeTypeMap
+import dotty.tools.dotc.core.{Constants, Flags}
+import ValueClasses._
+import TypeUtils._
+import ContextFunctionResults._
+import ExplicitOuter._
+import core.Mode
+import util.Property
+import reporting._
+
+class Erasure extends Phase with DenotTransformer {
+
+  override def phaseName: String = Erasure.name
+
+  override def description: String = Erasure.description
+
+  /** List of names of phases that should precede this phase */
+  override def runsAfter: Set[String] = Set(InterceptedMethods.name, ElimRepeated.name)
+
+  override def changesMembers: Boolean = true // the phase adds bridges
+  override def changesParents: Boolean = true // the phase drops Any
+
+  def transform(ref: SingleDenotation)(using Context): SingleDenotation = ref match {
+    case ref: SymDenotation =>
+      def isCompacted(symd: SymDenotation) =
+        symd.isAnonymousFunction && {
+          atPhase(ctx.phase.next)(symd.info) match {
+            case MethodType(nme.ALLARGS :: Nil) => true
+            case _                              => false
+          }
+        }
+
+      def erasedName =
+        if ref.is(Flags.Method)
+            && contextResultsAreErased(ref.symbol)
+            && (ref.owner.is(Flags.Trait) || ref.symbol.allOverriddenSymbols.hasNext)
+        then
+          // Add a `$direct` to prevent this method from having the same signature
+          // as a method it overrides. We need a bridge between the
+          // two methods, so they are not allowed to already override after erasure.
+          DirectMethName(ref.targetName.asTermName)
+        else
+          ref.targetName
+
+      assert(ctx.phase == this, s"transforming $ref at ${ctx.phase}")
+      if (ref.symbol eq defn.ObjectClass) {
+        // After erasure, all former Any members are now Object members
+        val ClassInfo(pre, _, ps, decls, selfInfo) = ref.info: @unchecked
+        val extendedScope = decls.cloneScope
+        for decl <- defn.AnyClass.classInfo.decls do
+          if !decl.isConstructor then extendedScope.enter(decl)
+        ref.copySymDenotation(
+          info = transformInfo(ref.symbol,
+              ClassInfo(pre, defn.ObjectClass, ps, extendedScope, selfInfo))
+        )
+      }
+      else {
+        val oldSymbol = ref.symbol
+        val newSymbol =
+          if ((oldSymbol.owner eq defn.AnyClass) && oldSymbol.isConstructor) then
+            //assert(false)
+            defn.ObjectClass.primaryConstructor
+          else oldSymbol
+        val oldOwner = ref.owner
+        val newOwner = if oldOwner == defn.AnyClass then defn.ObjectClass else oldOwner
+        val oldName = ref.name
+        val newName = erasedName
+        val oldInfo = ref.info
+        var newInfo = transformInfo(oldSymbol, oldInfo)
+        val oldFlags = ref.flags
+        var newFlags =
+          if oldSymbol.is(Flags.TermParam) && isCompacted(oldSymbol.owner.denot) then oldFlags &~ Flags.Param
+          else oldFlags
+        val oldAnnotations = ref.annotations
+        var newAnnotations = oldAnnotations
+        if oldSymbol.isRetainedInlineMethod then
+          newFlags = newFlags &~ Flags.Inline
+          newAnnotations = newAnnotations.filterConserve(!_.isInstanceOf[BodyAnnotation])
+        oldSymbol match
+          case cls: ClassSymbol if cls.is(Flags.Erased) =>
+            newFlags = newFlags | Flags.Trait | Flags.JavaInterface
+            newAnnotations = Nil
+            newInfo = erasedClassInfo(cls)
+          case _ =>
+        // TODO: define derivedSymDenotation?
+        if ref.is(Flags.PackageClass)
+           || !ref.isClass  // non-package classes are always copied since their base types change
+              && (oldSymbol eq newSymbol)
+              && (oldOwner eq newOwner)
+              && (oldName eq newName)
+              && (oldInfo eq newInfo)
+              && (oldFlags == newFlags)
+              && (oldAnnotations eq newAnnotations)
+        then
+          ref
+        else
+          ref.copySymDenotation(
+            symbol = newSymbol,
+            owner = newOwner,
+            name = newName,
+            initFlags = newFlags,
+            info = newInfo,
+            annotations = newAnnotations)
+      }
+    case ref: JointRefDenotation =>
+      new UniqueRefDenotation(
+        ref.symbol, transformInfo(ref.symbol, ref.symbol.info), ref.validFor, ref.prefix)
+    case _ =>
+      ref.derivedSingleDenotation(ref.symbol, transformInfo(ref.symbol, ref.symbol.info))
+  }
+
+  private val eraser = new Erasure.Typer(this)
+
+  def run(using Context): Unit = {
+    val unit = ctx.compilationUnit
+    unit.tpdTree = eraser.typedExpr(unit.tpdTree)(using ctx.fresh.setTyper(eraser).setPhase(this.next))
+  }
+
+  /** erased classes get erased to empty traits with Object as parent and an empty constructor */
+  private def erasedClassInfo(cls: ClassSymbol)(using Context) =
+    cls.classInfo.derivedClassInfo(
+      declaredParents = defn.ObjectClass.typeRef :: Nil,
+      decls = newScopeWith(newConstructor(cls, Flags.EmptyFlags, Nil, Nil)))
+
+  override def checkPostCondition(tree: tpd.Tree)(using Context): Unit = {
+    assertErased(tree)
+    tree match {
+      case _: tpd.Import => assert(false, i"illegal tree: $tree")
+      case res: tpd.This =>
+        assert(!ExplicitOuter.referencesOuter(ctx.owner.lexicallyEnclosingClass, res),
+          i"Reference to $res from ${ctx.owner.showLocated}")
+      case ret: tpd.Return =>
+        // checked only after erasure, as checking before erasure is complicated
+        // due presence of type params in returned types
+        val from = if (ret.from.isEmpty) ctx.owner.enclosingMethod else ret.from.symbol
+        val rType = from.info.finalResultType
+        assert(ret.expr.tpe <:< rType,
+          i"Returned value:${ret.expr}  does not conform to result type(${ret.expr.tpe.widen} of method $from")
+      case _ =>
+    }
+  }
+
+  /** Assert that tree type and its widened underlying type are erased.
+   *  Also assert that term refs have fixed symbols (so we are sure
+   *  they need not be reloaded using member; this would likely fail as signatures
+   *  may change after erasure).
+   */
+  def assertErased(tree: tpd.Tree)(using Context): Unit = {
+    assertErased(tree.typeOpt, tree)
+    if (!defn.isPolymorphicAfterErasure(tree.symbol))
+      assertErased(tree.typeOpt.widen, tree)
+    if (ctx.mode.isExpr)
+      tree.tpe match {
+        case ref: TermRef =>
+          assert(ref.denot.isInstanceOf[SymDenotation] ||
+              ref.denot.isInstanceOf[UniqueRefDenotation],
+            i"non-sym type $ref of class ${ref.getClass} with denot of class ${ref.denot.getClass} of $tree")
+        case _ =>
+      }
+  }
+
+  def assertErased(tp: Type, tree: tpd.Tree = tpd.EmptyTree)(using Context): Unit = {
+    def isAllowed(cls: Symbol, sourceName: String) =
+      tp.typeSymbol == cls && ctx.compilationUnit.source.file.name == sourceName
+    assert(isErasedType(tp) ||
+           isAllowed(defn.ArrayClass, "Array.scala") ||
+           isAllowed(defn.TupleClass, "Tuple.scala") ||
+           isAllowed(defn.NonEmptyTupleClass, "Tuple.scala") ||
+           isAllowed(defn.PairClass, "Tuple.scala"),
+        i"The type $tp - ${tp.toString} of class ${tp.getClass} of tree $tree : ${tree.tpe} / ${tree.getClass} is illegal after erasure, phase = ${ctx.phase.prev}")
+  }
+}
+
+object Erasure {
+  import tpd._
+  import TypeTestsCasts._
+
+  val name: String = "erasure"
+  val description: String = "rewrite types to JVM model"
+
+  /** An attachment on Apply nodes indicating that multiple arguments
+   *  are passed in a single array. This occurs only if the function
+   *  implements a FunctionXXL apply.
+   */
+  private val BunchedArgs = new Property.Key[Unit]
+
+  /** An Apply node which might still be missing some arguments */
+  def partialApply(fn: Tree, args: List[Tree])(using Context): Tree =
+    untpd.Apply(fn, args.toList)
+      .withType(applyResultType(fn.tpe.widen.asInstanceOf[MethodType], args))
+
+  /** The type of an Apply node which might still be missing some arguments */
+  private def applyResultType(mt: MethodType, args: List[Tree])(using Context): Type =
+    if mt.paramInfos.length <= args.length then mt.resultType
+    else MethodType(mt.paramInfos.drop(args.length), mt.resultType)
+
+  /** The method type corresponding to `mt`, except that bunched parameters
+   *  are expanded. The expansion is determined using the original function
+   *  tree `origFun` which has a type that is not yet converted to a type
+   *  with bunched arguments.
+   */
+  def expandedMethodType(mt: MethodType, origFun: Tree)(using Context): MethodType =
+    mt.paramInfos match
+      case JavaArrayType(elemType) :: Nil if elemType.isRef(defn.ObjectClass) =>
+        val origArity = totalParamCount(origFun.symbol)(using preErasureCtx)
+        if origArity > MaxImplementedFunctionArity then
+          MethodType(List.fill(origArity)(defn.ObjectType), mt.resultType)
+        else mt
+      case _ => mt
+
+  object Boxing:
+
+    def isUnbox(sym: Symbol)(using Context): Boolean =
+      sym.name == nme.unbox && sym.owner.linkedClass.isPrimitiveValueClass
+
+    def isBox(sym: Symbol)(using Context): Boolean =
+      sym.name == nme.box && sym.owner.linkedClass.isPrimitiveValueClass
+
+    def boxMethod(cls: ClassSymbol)(using Context): Symbol =
+      cls.linkedClass.info.member(nme.box).symbol
+    def unboxMethod(cls: ClassSymbol)(using Context): Symbol =
+      cls.linkedClass.info.member(nme.unbox).symbol
+
+    /** Isf this tree is an unbox operation which can be safely removed
+     *  when enclosed in a box, the unboxed argument, otherwise EmptyTree.
+     *  Note that one can't always remove a Box(Unbox(x)) combination because the
+     *  process of unboxing x may lead to throwing an exception.
+     *  This is important for specialization: calls to the super constructor should not box/unbox specialized
+     *  fields (see TupleX). (ID)
+     */
+    private def safelyRemovableUnboxArg(tree: Tree)(using Context): Tree = tree match {
+      case Apply(fn, arg :: Nil)
+      if isUnbox(fn.symbol) && defn.ScalaBoxedClasses().contains(arg.tpe.typeSymbol) =>
+        arg
+      case _ =>
+        EmptyTree
+    }
+
+    def constant(tree: Tree, const: Tree)(using Context): Tree =
+      (if (isPureExpr(tree)) const else Block(tree :: Nil, const)).withSpan(tree.span)
+
+    final def box(tree: Tree, target: => String = "")(using Context): Tree = trace(i"boxing ${tree.showSummary()}: ${tree.tpe} into $target") {
+      tree.tpe.widen match {
+        case ErasedValueType(tycon, _) =>
+          New(tycon, cast(tree, underlyingOfValueClass(tycon.symbol.asClass)) :: Nil) // todo: use adaptToType?
+        case tp =>
+          val cls = tp.classSymbol
+          if (cls eq defn.UnitClass) constant(tree, ref(defn.BoxedUnit_UNIT))
+          else if (cls eq defn.NothingClass) tree // a non-terminating expression doesn't need boxing
+          else {
+            assert(cls ne defn.ArrayClass)
+            val arg = safelyRemovableUnboxArg(tree)
+            if (arg.isEmpty) ref(boxMethod(cls.asClass)).appliedTo(tree)
+            else {
+              report.log(s"boxing an unbox: ${tree.symbol} -> ${arg.tpe}")
+              arg
+            }
+          }
+      }
+    }
+
+    def unbox(tree: Tree, pt: Type)(using Context): Tree = trace(i"unboxing ${tree.showSummary()}: ${tree.tpe} as a $pt") {
+      pt match {
+        case ErasedValueType(tycon, underlying) =>
+          def unboxedTree(t: Tree) =
+            adaptToType(t, tycon)
+            .select(valueClassUnbox(tycon.symbol.asClass))
+            .appliedToNone
+
+          // Null unboxing needs to be treated separately since we cannot call a method on null.
+          // "Unboxing" null to underlying is equivalent to doing null.asInstanceOf[underlying]
+          // See tests/pos/valueclasses/nullAsInstanceOfVC.scala for cases where this might happen.
+          val tree1 =
+            if (tree.tpe isRef defn.NullClass)
+              adaptToType(tree, underlying)
+            else if (!(tree.tpe <:< tycon)) {
+              assert(!(tree.tpe.typeSymbol.isPrimitiveValueClass))
+              val nullTree = nullLiteral
+              val unboxedNull = adaptToType(nullTree, underlying)
+
+              evalOnce(tree) { t =>
+                If(t.select(defn.Object_eq).appliedTo(nullTree),
+                  unboxedNull,
+                  unboxedTree(t))
+              }
+            }
+            else unboxedTree(tree)
+
+          cast(tree1, pt)
+        case _ =>
+          val cls = pt.classSymbol
+          if (cls eq defn.UnitClass) constant(tree, Literal(Constant(())))
+          else {
+            assert(cls ne defn.ArrayClass)
+            ref(unboxMethod(cls.asClass)).appliedTo(tree)
+          }
+      }
+    }
+
+    /** Generate a synthetic cast operation from tree.tpe to pt.
+     *  Does not do any boxing/unboxing (this is handled upstream).
+     *  Casts from and to ErasedValueType are special, see the explanation
+     *  in ExtensionMethods#transform.
+     */
+    def cast(tree: Tree, pt: Type)(using Context): Tree = trace(i"cast ${tree.tpe.widen} --> $pt", show = true) {
+      def wrap(tycon: TypeRef) =
+        ref(u2evt(tycon.typeSymbol.asClass)).appliedTo(tree)
+      def unwrap(tycon: TypeRef) =
+        ref(evt2u(tycon.typeSymbol.asClass)).appliedTo(tree)
+
+      assert(!pt.isInstanceOf[SingletonType], pt)
+      if (pt isRef defn.UnitClass) unbox(tree, pt)
+      else (tree.tpe.widen, pt) match {
+        // Convert primitive arrays into reference arrays, this path is only
+        // needed to handle repeated arguments, see
+        // `Definitions#FromJavaObjectSymbol` and `ElimRepeated#adaptToArray`.
+        case (JavaArrayType(treeElem), JavaArrayType(ptElem))
+        if treeElem.widen.isPrimitiveValueType && !ptElem.isPrimitiveValueType =>
+          cast(ref(defn.ScalaRuntime_toObjectArray).appliedTo(tree), pt)
+
+        // When casting between two EVTs, we need to check which one underlies the other to determine
+        // whether u2evt or evt2u should be used.
+        case (tp1 @ ErasedValueType(tycon1, underlying1), tp2 @ ErasedValueType(tycon2, underlying2)) =>
+          if (tp1 <:< underlying2)
+            // Cast EVT(tycon1, underlying1) to EVT(tycon2, EVT(tycon1, underlying1))
+            wrap(tycon2)
+          else {
+            assert(underlying1 <:< tp2, i"Non-sensical cast between unrelated types $tp1 and $tp2")
+            // Cast EVT(tycon1, EVT(tycon2, underlying2)) to EVT(tycon2, underlying2)
+            unwrap(tycon1)
+          }
+
+        // When only one type is an EVT then we already know that the other one is the underlying
+        case (_, ErasedValueType(tycon2, _)) =>
+          wrap(tycon2)
+        case (ErasedValueType(tycon1, _), _) =>
+          unwrap(tycon1)
+
+        case _ =>
+          if (pt.isPrimitiveValueType)
+            primitiveConversion(tree, pt.classSymbol)
+          else
+            tree.asInstance(pt)
+      }
+    }
+
+    /** Adaptation of an expression `e` to an expected type `PT`, applying the following
+     *  rewritings exhaustively as long as the type of `e` is not a subtype of `PT`.
+     *
+     *    e -> e()           if `e` appears not as the function part of an application
+     *    e -> box(e)        if `e` is of erased value type
+     *    e -> unbox(e, PT)  otherwise, if `PT` is an erased value type
+     *    e -> box(e)        if `e` is of primitive type and `PT` is not a primitive type
+     *    e -> unbox(e, PT)  if `PT` is a primitive type and `e` is not of primitive type
+     *    e -> cast(e, PT)   otherwise
+     */
+    def adaptToType(tree: Tree, pt: Type)(using Context): Tree = pt match
+      case _: FunProto | AnyFunctionProto => tree
+      case _ => tree.tpe.widen match
+        case mt: MethodType if tree.isTerm =>
+          assert(mt.paramInfos.isEmpty, i"bad adapt for $tree: $mt")
+          adaptToType(tree.appliedToNone, pt)
+        case tpw =>
+          if (pt.isInstanceOf[ProtoType] || tree.tpe <:< pt)
+            tree
+          else if (tpw.isErasedValueType)
+            if (pt.isErasedValueType) then
+              tree.asInstance(pt)
+            else
+              adaptToType(box(tree), pt)
+          else if (pt.isErasedValueType)
+            adaptToType(unbox(tree, pt), pt)
+          else if (tpw.isPrimitiveValueType && !pt.isPrimitiveValueType)
+            adaptToType(box(tree), pt)
+          else if (pt.isPrimitiveValueType && !tpw.isPrimitiveValueType)
+            adaptToType(unbox(tree, pt), pt)
+          else
+            cast(tree, pt)
+    end adaptToType
+
+    /** The following code:
+     *
+     *      val f: Function1[Int, Any] = x => ...
+     *
+     *  results in the creation of a closure and an implementation method in the typer:
+     *
+     *      def $anonfun(x: Int): Any = ...
+     *      val f: Function1[Int, Any] = closure($anonfun)
+     *
+     *  Notice that `$anonfun` takes a primitive as argument, but the SAM (Single Abstract Method)
+     *  of `Function1` after erasure is:
+     *
+     *      def apply(x: Object): Object
+     *
+     *  which takes a reference as argument. Hence, some form of adaptation is
+     *  required. The most reliable way to do this adaptation is to replace the
+     *  closure implementation method by a bridge method that forwards to the
+     *  original method with appropriate boxing/unboxing. For our example above,
+     *  this would be:
+     *
+     *      def $anonfun$adapted(x: Object): Object = $anonfun(BoxesRunTime.unboxToInt(x))
+     *      val f: Function1 = closure($anonfun$adapted)
+     *
+     *  But in some situations we can avoid generating this bridge, either
+     *  because the runtime can perform auto-adaptation, or because we can
+     *  replace the closure functional interface by a specialized sub-interface,
+     *  see comments in this method for details.
+     *
+     *  See test cases lambda-*.scala and t8017/ for concrete examples.
+     */
+    def adaptClosure(tree: tpd.Closure)(using Context): Tree =
+      val Closure(env, meth, tpt) = tree
+      assert(env.isEmpty, tree)
+
+      // The type of the lambda expression
+      val lambdaType = tree.tpe
+      // The interface containing the SAM that this closure should implement
+      val functionalInterface = tpt.tpe
+      // A lack of an explicit functional interface means we're implementing a scala.FunctionN
+      val isFunction = !functionalInterface.exists
+      // The actual type of the implementation method
+      val implType = meth.tpe.widen.asInstanceOf[MethodType]
+      val implParamTypes = implType.paramInfos
+      val implResultType = implType.resultType
+      val implReturnsUnit = implResultType.classSymbol eq defn.UnitClass
+      // The SAM that this closure should implement.
+      // At this point it should be already guaranteed that there's only one method to implement
+      val Seq(sam: MethodType) = lambdaType.possibleSamMethods.map(_.info): @unchecked
+      val samParamTypes = sam.paramInfos
+      val samResultType = sam.resultType
+
+      /** Can the implementation parameter type `tp` be auto-adapted to a different
+       *  parameter type in the SAM?
+       *
+       *  For derived value classes, we always need to do the bridging manually.
+       *  For primitives, we cannot rely on auto-adaptation on the JVM because
+       *  the Scala spec requires null to be "unboxed" to the default value of
+       *  the value class, but the adaptation performed by LambdaMetaFactory
+       *  will throw a `NullPointerException` instead. See `lambda-null.scala`
+       *  for test cases.
+       *
+       *  @see [LambdaMetaFactory](https://docs.oracle.com/javase/8/docs/api/java/lang/invoke/LambdaMetafactory.html)
+       */
+      def autoAdaptedParam(tp: Type) =
+        !tp.isErasedValueType && !tp.isPrimitiveValueType
+
+      /** Can the implementation result type be auto-adapted to a different result
+       *  type in the SAM?
+       *
+       *  For derived value classes, it's the same story as for parameters.
+       *  For non-Unit primitives, we can actually rely on the `LambdaMetaFactory`
+       *  adaptation, because it only needs to box, not unbox, so no special
+       *  handling of null is required.
+       */
+      def autoAdaptedResult =
+        !implResultType.isErasedValueType && !implReturnsUnit
+
+      def sameClass(tp1: Type, tp2: Type) = tp1.classSymbol == tp2.classSymbol
+
+      val paramAdaptationNeeded =
+        implParamTypes.lazyZip(samParamTypes).exists((implType, samType) =>
+          !sameClass(implType, samType) && !autoAdaptedParam(implType))
+      val resultAdaptationNeeded =
+        !sameClass(implResultType, samResultType) && !autoAdaptedResult
+
+      if paramAdaptationNeeded || resultAdaptationNeeded then
+        // Instead of instantiating `scala.FunctionN`, see if we can instantiate
+        // a specialized sub-interface where the SAM type matches the
+        // implementation method type, thus avoiding the need for bridging.
+        // This optimization is skipped when using Scala.js because its backend
+        // does not support closures using custom functional interfaces.
+        if isFunction && !ctx.settings.scalajs.value then
+          val arity = implParamTypes.length
+          val specializedFunctionalInterface =
+            if defn.isSpecializableFunctionSAM(implParamTypes, implResultType) then
+              // Using these subclasses is critical to avoid boxing since their
+              // SAM is a specialized method `apply$mc*$sp` whose default
+              // implementation in FunctionN boxes.
+              tpnme.JFunctionPrefix(arity).specializedFunction(implResultType, implParamTypes)
+            else if !paramAdaptationNeeded && implReturnsUnit then
+              // Here, there is no actual boxing to avoid so we could get by
+              // without JProcedureN, but Unit-returning functions are very
+              // common so it seems worth it to not generate bridges for them.
+              tpnme.JProcedure(arity)
+            else
+              EmptyTypeName
+          if !specializedFunctionalInterface.isEmpty then
+            return cpy.Closure(tree)(tpt = TypeTree(requiredClass(specializedFunctionalInterface).typeRef))
+
+        // Otherwise, generate a new closure implemented with a bridge.
+        val bridgeType =
+          if paramAdaptationNeeded then
+            if resultAdaptationNeeded then
+              sam
+            else
+              implType.derivedLambdaType(paramInfos = samParamTypes)
+          else
+            implType.derivedLambdaType(resType = samResultType)
+        val bridge = newSymbol(ctx.owner, AdaptedClosureName(meth.symbol.name.asTermName), Flags.Synthetic | Flags.Method | Flags.Bridge, bridgeType)
+        Closure(bridge, bridgeParamss =>
+          inContext(ctx.withOwner(bridge)) {
+            val List(bridgeParams) = bridgeParamss
+            assert(ctx.typer.isInstanceOf[Erasure.Typer])
+            val rhs = Apply(meth, bridgeParams.lazyZip(implParamTypes).map(ctx.typer.adapt(_, _)))
+            ctx.typer.adapt(rhs, bridgeType.resultType)
+          },
+          targetType = functionalInterface).withSpan(tree.span)
+      else
+        tree
+    end adaptClosure
+  end Boxing
+
+  class Typer(erasurePhase: DenotTransformer) extends typer.ReTyper with NoChecking {
+    import Boxing._
+
+    def isErased(tree: Tree)(using Context): Boolean = tree match {
+      case TypeApply(Select(qual, _), _) if tree.symbol == defn.Any_typeCast =>
+        isErased(qual)
+      case _ => tree.symbol.isEffectivelyErased
+    }
+
+    /** Check that Java statics and packages can only be used in selections.
+      */
+    private def checkNotErased(tree: Tree)(using Context): tree.type = {
+      if (!ctx.mode.is(Mode.Type)) {
+        if isErased(tree) then
+          val msg =
+            if tree.symbol.is(Flags.Inline) then
+              em"""${tree.symbol} is declared as `inline`, but was not inlined
+                  |
+                  |Try increasing `-Xmax-inlines` above ${ctx.settings.XmaxInlines.value}""".stripMargin
+            else em"${tree.symbol} is declared as `erased`, but is in fact used"
+          report.error(msg, tree.srcPos)
+        tree.symbol.getAnnotation(defn.CompileTimeOnlyAnnot) match {
+          case Some(annot) =>
+            def defaultMsg =
+              i"""Reference to ${tree.symbol.showLocated} should not have survived,
+                 |it should have been processed and eliminated during expansion of an enclosing macro or term erasure."""
+            val message = annot.argumentConstant(0).fold(defaultMsg)(_.stringValue)
+            report.error(message, tree.srcPos)
+          case _ => // OK
+        }
+      }
+      checkNotErasedClass(tree)
+    }
+
+    private def checkNotErasedClass(tp: Type, tree: untpd.Tree)(using Context): Unit = tp match
+      case JavaArrayType(et) =>
+        checkNotErasedClass(et, tree)
+      case _ =>
+        if tp.isErasedClass then
+          val (kind, tree1) = tree match
+            case tree: untpd.ValOrDefDef => ("definition", tree.tpt)
+            case tree: untpd.DefTree => ("definition", tree)
+            case _ => ("expression", tree)
+          report.error(em"illegal reference to erased ${tp.typeSymbol} in $kind that is not itself erased", tree1.srcPos)
+
+    private def checkNotErasedClass(tree: Tree)(using Context): tree.type =
+      checkNotErasedClass(tree.tpe.widen.finalResultType, tree)
+      tree
+
+    def erasedDef(sym: Symbol)(using Context): Tree =
+      if sym.isClass then
+      	// We cannot simply drop erased classes, since then they would not generate classfiles
+      	// and would not be visible under separate compilation. So we transform them to
+      	// empty interfaces instead.
+        tpd.ClassDef(sym.asClass, DefDef(sym.primaryConstructor.asTerm), Nil)
+      else
+        if sym.owner.isClass then sym.dropAfter(erasurePhase)
+        tpd.EmptyTree
+
+    def erasedType(tree: untpd.Tree)(using Context): Type = {
+      val tp = tree.typeOpt
+      if (tree.isTerm) erasedRef(tp) else valueErasure(tp)
+    }
+
+    override def promote(tree: untpd.Tree)(using Context): tree.ThisTree[Type] = {
+      assert(tree.hasType)
+      val erasedTp = erasedType(tree)
+      report.log(s"promoting ${tree.show}: ${erasedTp.showWithUnderlying()}")
+      tree.withType(erasedTp)
+    }
+
+    /** When erasing most TypeTrees we should not semi-erase value types.
+     *  This is not the case for [[DefDef#tpt]], [[ValDef#tpt]] and [[Typed#tpt]], they
+     *  are handled separately by [[typedDefDef]], [[typedValDef]] and [[typedTyped]].
+     */
+    override def typedTypeTree(tree: untpd.TypeTree, pt: Type)(using Context): TypeTree =
+      checkNotErasedClass(tree.withType(erasure(tree.tpe)))
+
+    /** This override is only needed to semi-erase type ascriptions */
+    override def typedTyped(tree: untpd.Typed, pt: Type)(using Context): Tree =
+      val Typed(expr, tpt) = tree
+      if tpt.typeOpt.typeSymbol == defn.UnitClass then
+        typed(expr, defn.UnitType)
+      else
+        val tpt1 = tpt match
+          case Block(_, tpt) => tpt // erase type aliases (statements) from type block
+          case tpt => tpt
+        val tpt2 = typedType(tpt1)
+        val expr1 = typed(expr, tpt2.tpe)
+        assignType(untpd.cpy.Typed(tree)(expr1, tpt2), tpt2)
+
+    override def typedLiteral(tree: untpd.Literal)(using Context): Tree =
+      if (tree.typeOpt.isRef(defn.UnitClass))
+        tree.withType(tree.typeOpt)
+      else if (tree.const.tag == Constants.ClazzTag)
+        checkNotErasedClass(clsOf(tree.const.typeValue))
+      else
+        super.typedLiteral(tree)
+
+    override def typedIdent(tree: untpd.Ident, pt: Type)(using Context): Tree =
+      checkNotErased(super.typedIdent(tree, pt))
+
+    /** Type check select nodes, applying the following rewritings exhaustively
+     *  on selections `e.m`, where `OT` is the type of the owner of `m` and `ET`
+     *  is the erased type of the selection's original qualifier expression.
+     *
+     *      e.m1 -> e.m2          if `m1` is a member of a class that erases to Object and `m2` is
+     *                            the same-named member in Object.
+     *      e.m -> box(e).m       if `e` is primitive and `m` is a member or a reference class
+     *                            or `e` has an erased value class type.
+     *      e.m -> unbox(e).m     if `e` is not primitive and `m` is a member of a primtive type.
+     *      e.m -> cast(e, OT).m  if the type of `e` does not conform to OT and `m`
+     *                            is not an array operation.
+     *
+     *  If `m` is an array operation, i.e. one of the members apply, update, length, clone, and
+     *  <init> of class Array, we additionally try the following rewritings:
+     *
+     *      e.m -> runtime.array_m(e)   if ET is Object
+     *      e.m -> cast(e, ET).m        if the type of `e` does not conform to ET
+     *      e.clone -> e.clone'         where clone' is Object's clone method
+     *      e.m -> e.[]m                if `m` is an array operation other than `clone`.
+     */
+    override def typedSelect(tree: untpd.Select, pt: Type)(using Context): Tree = {
+      if tree.name == nme.apply && integrateSelect(tree) then
+      	return typed(tree.qualifier, pt)
+
+      val qual1 = typed(tree.qualifier, AnySelectionProto)
+
+      def mapOwner(sym: Symbol): Symbol =
+        if !sym.exists && tree.name == nme.apply then
+          // PolyFunction apply Selects will not have a symbol, so deduce the owner
+          // from the typed tree of the erasure of the original qualifier's PolyFunction type.
+          // We cannot simply call `erasure` on the qualifier because its erasure might be
+          // `Object` due to how we erase intersections (see pos/i13950.scala).
+          // Instead, we manually lookup the type of `apply` in the qualifier.
+          inContext(preErasureCtx) {
+            val qualTp = tree.qualifier.typeOpt.widen
+            if qualTp.derivesFrom(defn.PolyFunctionClass) then
+              erasePolyFunctionApply(qualTp.select(nme.apply).widen).classSymbol
+            else
+              NoSymbol
+          }
+        else
+          val owner = sym.maybeOwner
+          if defn.specialErasure.contains(owner) then
+            assert(sym.isConstructor, s"${sym.showLocated}")
+            defn.specialErasure(owner).nn
+          else if defn.isSyntheticFunctionClass(owner) then
+            defn.functionTypeErasure(owner).typeSymbol
+          else
+            owner
+
+      val origSym = tree.symbol
+
+      if !origSym.exists && qual1.tpe.widen.isInstanceOf[JavaArrayType] then
+        return tree.asInstanceOf[Tree] // we are re-typing a primitive array op
+
+      val owner = mapOwner(origSym)
+      var sym = if (owner eq origSym.maybeOwner) origSym else owner.info.decl(tree.name).symbol
+      if !sym.exists then
+        // We fail the sym.exists test for pos/i15158.scala, where we pass an infinitely
+        // recurring match type to an overloaded constructor. An equivalent test
+        // with regular apply methods succeeds. It's at present unclear whether
+        //  - the program should be rejected, or
+        //  - there is another fix.
+        // Therefore, we apply the fix to use the pre-erasure symbol, but only
+        // for constructors, in order not to mask other possible bugs that would
+        // trigger the assert(sym.exists, ...) below.
+        val prevSym = tree.symbol(using preErasureCtx)
+        if prevSym.isConstructor then sym = prevSym
+
+      assert(sym.exists, i"no owner from $owner/${origSym.showLocated} in $tree")
+
+      if owner == defn.ObjectClass then checkValue(qual1)
+
+      def select(qual: Tree, sym: Symbol): Tree =
+        untpd.cpy.Select(tree)(qual, sym.name).withType(NamedType(qual.tpe, sym))
+
+      def selectArrayMember(qual: Tree, erasedPre: Type): Tree =
+        if erasedPre.isAnyRef then
+          partialApply(ref(defn.runtimeMethodRef(tree.name.genericArrayOp)), qual :: Nil)
+        else if !(qual.tpe <:< erasedPre) then
+          selectArrayMember(cast(qual, erasedPre), erasedPre)
+        else
+          assignType(untpd.cpy.Select(tree)(qual, tree.name.primitiveArrayOp), qual)
+
+      def adaptIfSuper(qual: Tree): Tree = qual match {
+        case Super(thisQual, untpd.EmptyTypeIdent) =>
+          val SuperType(thisType, supType) = qual.tpe: @unchecked
+          if (sym.owner.is(Flags.Trait))
+            cpy.Super(qual)(thisQual, untpd.Ident(sym.owner.asClass.name))
+              .withType(SuperType(thisType, sym.owner.typeRef))
+          else
+            qual.withType(SuperType(thisType, thisType.firstParent.typeConstructor))
+        case _ =>
+          qual
+      }
+
+      /** Can we safely use `cls` as a qualifier without getting a runtime error on
+       *  the JVM due to its accessibility checks?
+       */
+      def isJvmAccessible(cls: Symbol): Boolean =
+        // Scala classes are always emitted as public, unless the
+        // `private` modifier is used, but a non-private class can never
+        // extend a private class, so such a class will never be a cast target.
+        !cls.is(Flags.JavaDefined) || {
+          // We can't rely on `isContainedWith` here because packages are
+          // not nested from the JVM point of view.
+          val boundary = cls.accessBoundary(cls.owner)(using preErasureCtx)
+          (boundary eq defn.RootClass) ||
+          (ctx.owner.enclosingPackageClass eq boundary)
+        }
+
+      def recur(qual: Tree): Tree = {
+        val qualIsPrimitive = qual.tpe.widen.isPrimitiveValueType
+        val symIsPrimitive = sym.owner.isPrimitiveValueClass
+
+        def originalQual: Type =
+          erasure(tree.qualifier.typeOpt.widen.finalResultType)
+
+        if (qualIsPrimitive && !symIsPrimitive || qual.tpe.widenDealias.isErasedValueType)
+          recur(box(qual))
+        else if (!qualIsPrimitive && symIsPrimitive)
+          recur(unbox(qual, sym.owner.typeRef))
+        else if (sym.owner eq defn.ArrayClass)
+          selectArrayMember(qual, originalQual)
+        else {
+          val qual1 = adaptIfSuper(qual)
+          if (qual1.tpe.derivesFrom(sym.owner) || qual1.isInstanceOf[Super])
+            select(qual1, sym)
+          else
+            val castTarget = // Avoid inaccessible cast targets, see i8661
+              if isJvmAccessible(sym.owner)
+              then
+                sym.owner.typeRef
+              else
+                // If the owner is inaccessible, try going through the qualifier,
+                // but be careful to not go in an infinite loop in case that doesn't
+                // work either.
+                val tp = originalQual
+                if tp =:= qual1.tpe.widen then
+                  return errorTree(qual1,
+                    ex"Unable to emit reference to ${sym.showLocated}, ${sym.owner} is not accessible in ${ctx.owner.enclosingClass}")
+                tp
+            recur(cast(qual1, castTarget))
+        }
+      }
+
+      checkNotErased(recur(qual1))
+    }
+
+    override def typedThis(tree: untpd.This)(using Context): Tree =
+      if (tree.symbol == ctx.owner.lexicallyEnclosingClass || tree.symbol.isStaticOwner) promote(tree)
+      else {
+        report.log(i"computing outer path from ${ctx.owner.ownersIterator.toList}%, % to ${tree.symbol}, encl class = ${ctx.owner.enclosingClass}")
+        outer.path(toCls = tree.symbol)
+      }
+
+    override def typedTypeApply(tree: untpd.TypeApply, pt: Type)(using Context): Tree = {
+      val ntree = atPhase(erasurePhase){
+        // Use erased-type semantic to intercept TypeApply in explicit nulls
+        val interceptCtx = if ctx.explicitNulls then ctx.retractMode(Mode.SafeNulls) else ctx
+        interceptTypeApply(tree.asInstanceOf[TypeApply])(using interceptCtx)
+      }.withSpan(tree.span)
+
+      ntree match {
+        case TypeApply(fun, args) =>
+          val fun1 = typedExpr(fun, AnyFunctionProto)
+          fun1.tpe.widen match {
+            case funTpe: PolyType =>
+              val args1 = args.mapconserve(typedType(_))
+              untpd.cpy.TypeApply(tree)(fun1, args1).withType(funTpe.instantiate(args1.tpes))
+            case _ => fun1
+          }
+        case _ => typedExpr(ntree, pt)
+      }
+    }
+
+    /** Besides normal typing, this method does uncurrying and collects parameters
+     *  to anonymous functions of arity > 22.
+     */
+    override def typedApply(tree: untpd.Apply, pt: Type)(using Context): Tree =
+      val Apply(fun, args) = tree
+      val origFun = fun.asInstanceOf[tpd.Tree]
+      val origFunType = origFun.tpe.widen(using preErasureCtx)
+      val ownArgs = if origFunType.isErasedMethod then Nil else args
+      val fun1 = typedExpr(fun, AnyFunctionProto)
+      fun1.tpe.widen match
+        case mt: MethodType =>
+          val (xmt,        // A method type like `mt` but with bunched arguments expanded to individual ones
+                bunchArgs,  // whether arguments are bunched
+                outers) =   // the outer reference parameter(s)
+            if fun1.isInstanceOf[Apply] then
+              (mt, fun1.removeAttachment(BunchedArgs).isDefined, Nil)
+            else
+              val xmt = expandedMethodType(mt, origFun)
+              (xmt, xmt ne mt, outer.args(origFun))
+
+          val args0 = outers ::: ownArgs
+          val args1 = args0.zipWithConserve(xmt.paramInfos)(typedExpr)
+
+          def mkApply(finalFun: Tree, finalArgs: List[Tree]) =
+            val app = untpd.cpy.Apply(tree)(finalFun, finalArgs)
+              .withType(applyResultType(xmt, args1))
+            if bunchArgs then app.withAttachment(BunchedArgs, ()) else app
+
+          def app(fun1: Tree): Tree = fun1 match
+            case Block(stats, expr) =>
+              cpy.Block(fun1)(stats, app(expr))
+            case Apply(fun2, SeqLiteral(prevArgs, argTpt) :: _) if bunchArgs =>
+              mkApply(fun2, JavaSeqLiteral(prevArgs ++ args1, argTpt) :: Nil)
+            case Apply(fun2, prevArgs) =>
+              mkApply(fun2, prevArgs ++ args1)
+            case _ if bunchArgs =>
+              mkApply(fun1, JavaSeqLiteral(args1, TypeTree(defn.ObjectType)) :: Nil)
+            case _ =>
+              mkApply(fun1, args1)
+
+          app(fun1)
+        case t =>
+          if ownArgs.isEmpty then fun1
+          else throw new MatchError(i"tree $tree has unexpected type of function $fun/$fun1: $t, was $origFunType, args = $ownArgs")
+    end typedApply
+
+    // The following four methods take as the proto-type the erasure of the pre-existing type,
+    // if the original proto-type is not a value type.
+    // This makes all branches be adapted to the correct type.
+    override def typedSeqLiteral(tree: untpd.SeqLiteral, pt: Type)(using Context): SeqLiteral =
+      super.typedSeqLiteral(tree, erasure(tree.typeOpt))
+        // proto type of typed seq literal is original type;
+
+    override def typedIf(tree: untpd.If, pt: Type)(using Context): Tree =
+      super.typedIf(tree, adaptProto(tree, pt))
+
+    override def typedMatch(tree: untpd.Match, pt: Type)(using Context): Tree =
+      super.typedMatch(tree, adaptProto(tree, pt))
+
+    override def typedTry(tree: untpd.Try, pt: Type)(using Context): Try =
+      super.typedTry(tree, adaptProto(tree, pt))
+
+    private def adaptProto(tree: untpd.Tree, pt: Type)(using Context) =
+      if (pt.isValueType) pt else
+        if (tree.typeOpt.derivesFrom(ctx.definitions.UnitClass))
+          tree.typeOpt
+        else valueErasure(tree.typeOpt)
+
+    override def typedInlined(tree: untpd.Inlined, pt: Type)(using Context): Tree =
+      super.typedInlined(tree, pt) match {
+        case tree: Inlined => Inlines.dropInlined(tree)
+      }
+
+    override def typedValDef(vdef: untpd.ValDef, sym: Symbol)(using Context): Tree =
+      if (sym.isEffectivelyErased) erasedDef(sym)
+      else
+        checkNotErasedClass(sym.info, vdef)
+        super.typedValDef(untpd.cpy.ValDef(vdef)(
+          tpt = untpd.TypedSplice(TypeTree(sym.info).withSpan(vdef.tpt.span))), sym)
+
+    /** Besides normal typing, this function also compacts anonymous functions
+     *  with more than `MaxImplementedFunctionArity` parameters to use a single
+     *  parameter of type `[]Object`.
+     */
+    override def typedDefDef(ddef: untpd.DefDef, sym: Symbol)(using Context): Tree =
+      if sym.isEffectivelyErased || sym.name.is(BodyRetainerName) then
+        erasedDef(sym)
+      else
+        checkNotErasedClass(sym.info.finalResultType, ddef)
+        val restpe = if sym.isConstructor then defn.UnitType else sym.info.resultType
+        var vparams = outerParamDefs(sym)
+            ::: ddef.paramss.collect {
+              case untpd.ValDefs(vparams) => vparams
+            }.flatten.filterConserve(!_.symbol.is(Flags.Erased))
+
+        def skipContextClosures(rhs: Tree, crCount: Int)(using Context): Tree =
+          if crCount == 0 then rhs
+          else rhs match
+            case closureDef(meth) =>
+              val contextParams = meth.termParamss.head
+              for param <- contextParams do
+                if !param.symbol.is(Flags.Erased) then
+                  param.symbol.copySymDenotation(owner = sym).installAfter(erasurePhase)
+                  vparams = vparams :+ param
+              if crCount == 1 then meth.rhs.changeOwnerAfter(meth.symbol, sym, erasurePhase)
+              else skipContextClosures(meth.rhs, crCount - 1)
+
+        var rhs1 = skipContextClosures(ddef.rhs.asInstanceOf[Tree], contextResultCount(sym))
+
+        if sym.isAnonymousFunction && vparams.length > MaxImplementedFunctionArity then
+          val bunchedParam = newSymbol(sym, nme.ALLARGS, Flags.TermParam, JavaArrayType(defn.ObjectType))
+          def selector(n: Int) = ref(bunchedParam)
+            .select(defn.Array_apply)
+            .appliedTo(Literal(Constant(n)))
+          val paramDefs = vparams.zipWithIndex.map {
+            case (paramDef, idx) =>
+              assignType(untpd.cpy.ValDef(paramDef)(rhs = selector(idx)), paramDef.symbol)
+          }
+          vparams = ValDef(bunchedParam) :: Nil
+          rhs1 = Block(paramDefs, rhs1)
+
+        val ddef1 = untpd.cpy.DefDef(ddef)(
+          paramss = vparams :: Nil,
+          tpt = untpd.TypedSplice(TypeTree(restpe).withSpan(ddef.tpt.span)),
+          rhs = rhs1)
+        super.typedDefDef(ddef1, sym)
+    end typedDefDef
+
+    /** The outer parameter definition of a constructor if it needs one */
+    private def outerParamDefs(constr: Symbol)(using Context): List[ValDef] =
+      if constr.isConstructor && needsOuterParam(constr.owner.asClass) then
+        constr.info match
+          case MethodTpe(outerName :: _, outerType :: _, _) =>
+            val outerSym = newSymbol(constr, outerName, Flags.Param | Flags.SyntheticArtifact, outerType)
+            ValDef(outerSym) :: Nil
+          case _ =>
+            // There's a possible race condition that a constructor was looked at
+            // after erasure before we had a chance to run ExplicitOuter on its class
+            // If furthermore the enclosing class does not always have constructors,
+            // but needs constructors in this particular case, we miss the constructor
+            // accessor that's produced with an `enteredAfter` in ExplicitOuter, so
+            // `tranformInfo` of the constructor in erasure yields a method type without
+            // an outer parameter. We fix this problem by adding the missing outer
+            // parameter here.
+            constr.copySymDenotation(
+              info = outer.addParam(constr.owner.asClass, constr.info)
+            ).installAfter(erasurePhase)
+            outerParamDefs(constr)
+      else Nil
+
+    /** For all statements in stats: given a retained inline method and
+     *  its retainedBody method such as
+     *
+     *     inline override def f(x: T) = body1
+     *     private def f$retainedBody(x: T) = body2
+     *
+     *  return the runtime version of `f` as
+     *
+     *     override def f(x: T) = body2
+     *
+     *  Here, the owner of body2 is changed to f and all references
+     *  to parameters of f$retainedBody are changed to references of
+     *  corresponding parameters in f.
+     *
+     *  `f$retainedBody` is subseqently mapped to the empty tree in `typedDefDef`
+     *  which is then dropped in `typedStats`.
+     */
+    private def addRetainedInlineBodies(stats: List[untpd.Tree])(using Context): List[untpd.Tree] =
+      lazy val retainerDef: Map[Symbol, DefDef] = stats.collect {
+        case stat: DefDef @unchecked if stat.symbol.name.is(BodyRetainerName) =>
+          val retainer = stat.symbol
+          val origName = retainer.name.asTermName.exclude(BodyRetainerName)
+          val targetName =
+            if retainer.hasAnnotation(defn.TargetNameAnnot) then
+              retainer.targetName.unmangle(BodyRetainerName).exclude(BodyRetainerName)
+            else origName
+          val inlineMeth = atPhase(typerPhase) {
+            retainer.owner.info.decl(origName)
+              .matchingDenotation(retainer.owner.thisType, stat.symbol.info, targetName)
+              .symbol
+          }
+          (inlineMeth, stat)
+      }.toMap
+      stats.mapConserve {
+        case stat: DefDef @unchecked if stat.symbol.isRetainedInlineMethod =>
+          val rdef = retainerDef(stat.symbol)
+          val fromParams = untpd.allParamSyms(rdef)
+          val toParams = untpd.allParamSyms(stat)
+          assert(fromParams.hasSameLengthAs(toParams))
+          val mapBody = TreeTypeMap(
+            oldOwners = rdef.symbol :: Nil,
+            newOwners = stat.symbol :: Nil,
+            substFrom = fromParams,
+            substTo   = toParams)
+          cpy.DefDef(stat)(rhs = mapBody.transform(rdef.rhs))
+        case stat => stat
+      }
+
+    override def typedClosure(tree: untpd.Closure, pt: Type)(using Context): Tree = {
+      val xxl = defn.isXXLFunctionClass(tree.typeOpt.typeSymbol)
+      var implClosure = super.typedClosure(tree, pt).asInstanceOf[Closure]
+      if (xxl) implClosure = cpy.Closure(implClosure)(tpt = TypeTree(defn.FunctionXXLClass.typeRef))
+      adaptClosure(implClosure)
+    }
+
+    override def typedNew(tree: untpd.New, pt: Type)(using Context): Tree =
+      checkNotErasedClass(super.typedNew(tree, pt))
+
+    override def typedTypeDef(tdef: untpd.TypeDef, sym: Symbol)(using Context): Tree =
+      EmptyTree
+
+    override def typedClassDef(cdef: untpd.TypeDef, cls: ClassSymbol)(using Context): Tree =
+      if cls.is(Flags.Erased) then erasedDef(cls)
+      else super.typedClassDef(cdef, cls)
+
+    override def typedAnnotated(tree: untpd.Annotated, pt: Type)(using Context): Tree =
+      typed(tree.arg, pt)
+
+    override def typedStats(stats: List[untpd.Tree], exprOwner: Symbol)(using Context): (List[Tree], Context) = {
+      // discard Imports first, since Bridges will use tree's symbol
+      val stats0 = addRetainedInlineBodies(stats.filter(!_.isInstanceOf[untpd.Import]))(using preErasureCtx)
+      val stats1 =
+        if (takesBridges(ctx.owner)) new Bridges(ctx.owner.asClass, erasurePhase).add(stats0)
+        else stats0
+      val (stats2, finalCtx) = super.typedStats(stats1, exprOwner)
+      (stats2.filterConserve(!_.isEmpty), finalCtx)
+    }
+
+    /** Finally drops all (language-) imports in erasure.
+     *  Since some of the language imports change the subtyping,
+     *  we cannot check the trees before erasure.
+     */
+    override def typedImport(tree: untpd.Import)(using Context) = EmptyTree
+
+    override def adapt(tree: Tree, pt: Type, locked: TypeVars)(using Context): Tree =
+      trace(i"adapting ${tree.showSummary()}: ${tree.tpe} to $pt", show = true) {
+        if ctx.phase != erasurePhase && ctx.phase != erasurePhase.next then
+          // this can happen when reading annotations loaded during erasure,
+          // since these are loaded at phase typer.
+          atPhase(erasurePhase.next)(adapt(tree, pt, locked))
+        else if (tree.isEmpty) tree
+        else if (ctx.mode is Mode.Pattern) tree // TODO: replace with assertion once pattern matcher is active
+        else adaptToType(tree, pt)
+      }
+
+    override def simplify(tree: Tree, pt: Type, locked: TypeVars)(using Context): tree.type = tree
+  }
+
+  private def takesBridges(sym: Symbol)(using Context): Boolean =
+    sym.isClass && !sym.isOneOf(Flags.Trait | Flags.Package)
+}
diff --git a/tests/pos-with-compiler-cc/dotc/transform/EtaReduce.scala b/tests/pos-with-compiler-cc/dotc/transform/EtaReduce.scala
new file mode 100644
index 000000000000..cf62cffd4cdb
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/transform/EtaReduce.scala
@@ -0,0 +1,76 @@
+package dotty.tools
+package dotc
+package transform
+
+import MegaPhase.MiniPhase
+import core.*
+import Symbols.*, Contexts.*, Types.*, Decorators.*
+import StdNames.nme
+import SymUtils.*
+import NameKinds.AdaptedClosureName
+
+/** Rewrite `(x1, ... xN) => f(x1, ... xN)` for N >= 0 to `f`,
+ *  provided `f` is a pure path of function type.
+ *
+ *  This optimization is crucial for context functions. The compiler
+ *  produces a contextual closure around values passed as arguments
+ *  where a context function is expected, unless that value has the
+ *  syntactic form of a context function literal.
+ *
+ *  Also handle variants of eta-expansions where
+ *   - result f.apply(X_1,...,X_n) is subject to a synthetic cast, or
+ *   - the application uses a specialized apply method, or
+ *   - the closure is adapted (see Erasure#adaptClosure)
+ *
+ *  Without this phase, when a contextual function is passed as an argument to a
+ *  recursive function, that would have the unfortunate effect of a linear growth
+ *  in transient thunks of identical type wrapped around each other, leading
+ *  to performance degradation, and in some cases, stack overflows.
+ */
+class EtaReduce extends MiniPhase:
+  import ast.tpd._
+
+  override def phaseName: String = EtaReduce.name
+
+  override def description: String = EtaReduce.description
+
+  override def transformBlock(tree: Block)(using Context): Tree =
+
+    def tryReduce(mdef: DefDef, rhs: Tree): Tree = rhs match
+      case Apply(Select(fn, name), args)
+      if (name == nme.apply || defn.FunctionSpecializedApplyNames.contains(name))
+          && mdef.paramss.head.corresponds(args)((param, arg) =>
+              arg.isInstanceOf[Ident] && arg.symbol == param.symbol)
+          && isPurePath(fn)
+          && fn.tpe <:< tree.tpe
+          && defn.isFunctionClass(fn.tpe.widen.typeSymbol) =>
+        report.log(i"eta reducing $tree --> $fn")
+        fn
+      case TypeApply(Select(qual, _), _) if rhs.symbol.isTypeCast && rhs.span.isSynthetic =>
+        tryReduce(mdef, qual)
+      case Apply(_, arg :: Nil) if Erasure.Boxing.isUnbox(rhs.symbol) && rhs.span.isSynthetic =>
+        tryReduce(mdef, arg)
+      case Block(call :: Nil, unit @ Literal(Constants.Constant(()))) if unit.span.isSynthetic =>
+        tryReduce(mdef, call)
+      case _ =>
+        tree
+
+    tree match
+      case Block((meth: DefDef) :: Nil, expr) if meth.symbol.isAnonymousFunction =>
+        expr match
+          case closure: Closure if meth.symbol == closure.meth.symbol =>
+            tryReduce(meth, meth.rhs)
+          case Block((adapted: DefDef) :: Nil, closure: Closure)
+          if adapted.name.is(AdaptedClosureName) && adapted.symbol == closure.meth.symbol =>
+            tryReduce(meth, meth.rhs)
+          case _ =>
+            tree
+      case _ =>
+        tree
+  end transformBlock
+
+end EtaReduce
+
+object EtaReduce:
+  val name: String = "etaReduce"
+  val description: String = "reduce eta expansions of pure paths"
diff --git a/tests/pos-with-compiler-cc/dotc/transform/ExpandPrivate.scala b/tests/pos-with-compiler-cc/dotc/transform/ExpandPrivate.scala
new file mode 100644
index 000000000000..41e5b76ca874
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/transform/ExpandPrivate.scala
@@ -0,0 +1,118 @@
+package dotty.tools.dotc
+package transform
+
+import core._
+import dotty.tools.dotc.core.DenotTransformers.IdentityDenotTransformer
+import Contexts._
+import Symbols._
+import Flags._
+import SymDenotations._
+
+import Decorators._
+import MegaPhase._
+import java.io.File.separatorChar
+
+import ValueClasses._
+
+/** Make private term members that are accessed from another class
+ *  non-private by resetting the Private flag and expanding their name.
+ *
+ *  Make private accessor in value class not-private. This is necessary to unbox
+ *  the value class when accessing it from separate compilation units
+ *
+ *  Also, make non-private any private parameter forwarders that forward to an inherited
+ *  public or protected parameter accessor with the same name as the forwarder.
+ *  This is necessary since private methods are not allowed to have the same name
+ *  as inherited public ones.
+ *
+ *  See discussion in https://github.com/lampepfl/dotty/pull/784
+ *  and https://github.com/lampepfl/dotty/issues/783
+ */
+class ExpandPrivate extends MiniPhase with IdentityDenotTransformer { thisPhase =>
+  import ast.tpd._
+
+  override def phaseName: String = ExpandPrivate.name
+
+  override def description: String = ExpandPrivate.description
+
+  // This phase moves methods around (in infotransform) so it may need to make other methods public
+  override def runsAfter: Set[String] = Set(MoveStatics.name)
+
+  override def changesMembers: Boolean = true // the phase introduces new members with mangled names
+
+  override def checkPostCondition(tree: Tree)(using Context): Unit =
+    tree match {
+      case t: DefDef =>
+        val sym = t.symbol
+        def hasWeakerAccess(other: Symbol) =
+          // public > protected > /* default */ > private
+          if (sym.is(Private)) other.is(Private)
+          else if (sym.is(Protected)) other.isOneOf(Protected | Private)
+          else true // sym is public
+        val fail = sym.allOverriddenSymbols.findSymbol(x => !hasWeakerAccess(x))
+        if (fail.exists)
+          assert(false, i"${sym.showFullName}: ${sym.info} has weaker access than superclass method ${fail.showFullName}: ${fail.info}")
+      case _ =>
+    }
+
+  private def isVCPrivateParamAccessor(d: SymDenotation)(using Context) =
+    d.isTerm && d.isAllOf(PrivateParamAccessor) && isDerivedValueClass(d.owner)
+
+  /** Make private terms accessed from different classes non-private.
+   *  Note: this happens also for accesses between class and linked module class.
+   *  If we change the scheme at one point to make static module class computations
+   *  static members of the companion class, we should tighten the condition below.
+   */
+  private def ensurePrivateAccessible(d: SymDenotation)(using Context) =
+    if (isVCPrivateParamAccessor(d))
+      d.ensureNotPrivate.installAfter(thisPhase)
+    else if (d.is(PrivateTerm) && !d.owner.is(Package) && d.owner != ctx.owner.lexicallyEnclosingClass) {
+      // Paths `p1` and `p2` are similar if they have a common suffix that follows
+      // possibly different directory paths. That is, their common suffix extends
+      // in both cases either to the start of the path or to a file separator character.
+      // TODO: should we test absolute paths instead?
+      def isSimilar(p1: String, p2: String): Boolean = {
+        var i = p1.length - 1
+        var j = p2.length - 1
+        while (i >= 0 && j >= 0 && p1(i) == p2(j) && p1(i) != separatorChar) {
+          i -= 1
+          j -= 1
+        }
+        (i < 0 || p1(i) == separatorChar) &&
+        (j < 0 || p2(j) == separatorChar)
+      }
+
+      assert(d.symbol.source.exists &&
+             ctx.owner.source.exists &&
+             isSimilar(d.symbol.source.path, ctx.owner.source.path),
+          s"private ${d.symbol.showLocated} in ${d.symbol.source} accessed from ${ctx.owner.showLocated} in ${ctx.owner.source}")
+      d.ensureNotPrivate.installAfter(thisPhase)
+    }
+
+  override def transformIdent(tree: Ident)(using Context): Ident = {
+    ensurePrivateAccessible(tree.symbol)
+    tree
+  }
+
+  override def transformSelect(tree: Select)(using Context): Select = {
+    ensurePrivateAccessible(tree.symbol)
+    tree
+  }
+
+  override def transformDefDef(tree: DefDef)(using Context): DefDef = {
+    val sym = tree.symbol
+    tree.rhs match {
+      case Apply(sel @ Select(_: Super, _), _)
+      if sym.isAllOf(PrivateParamAccessor) && sel.symbol.is(ParamAccessor) && sym.name == sel.symbol.name =>
+        sym.ensureNotPrivate.installAfter(thisPhase)
+      case _ =>
+        if (isVCPrivateParamAccessor(sym))
+          sym.ensureNotPrivate.installAfter(thisPhase)
+    }
+    tree
+  }
+}
+
+object ExpandPrivate:
+  val name: String = "expandPrivate"
+  val description: String = "widen private definitions accessed from nested classes"
diff --git a/tests/pos-with-compiler-cc/dotc/transform/ExpandSAMs.scala b/tests/pos-with-compiler-cc/dotc/transform/ExpandSAMs.scala
new file mode 100644
index 000000000000..cd6753eaed69
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/transform/ExpandSAMs.scala
@@ -0,0 +1,194 @@
+package dotty.tools
+package dotc
+package transform
+
+import core._
+import Scopes.newScope
+import Contexts._, Symbols._, Types._, Flags._, Decorators._, StdNames._, Constants._
+import MegaPhase._
+import SymUtils._
+import NullOpsDecorator._
+import ast.untpd
+
+/** Expand SAM closures that cannot be represented by the JVM as lambdas to anonymous classes.
+ *  These fall into five categories
+ *
+ *   1. Partial function closures, we need to generate isDefinedAt and applyOrElse methods for these.
+ *   2. Closures implementing non-trait classes
+ *   3. Closures implementing classes that inherit from a class other than Object
+ *      (a lambda cannot not be a run-time subtype of such a class)
+ *   4. Closures that implement traits which run initialization code.
+ *   5. Closures that get synthesized abstract methods in the transformation pipeline. These methods can be
+ *      (1) superaccessors, (2) outer references, (3) accessors for fields.
+ *
+ *  However, implicit function types do not count as SAM types.
+ */
+object ExpandSAMs:
+  val name: String = "expandSAMs"
+  val description: String = "expand SAM closures to anonymous classes"
+
+  /** Is the SAMType `cls` also a SAM under the rules of the platform? */
+  def isPlatformSam(cls: ClassSymbol)(using Context): Boolean =
+    ctx.platform.isSam(cls)
+
+  def needsWrapperClass(tpe: Type)(using Context): Boolean =
+    tpe.classSymbol match
+      case cls: ClassSymbol => !isPlatformSam(cls) || cls == defn.PartialFunctionClass
+      case _ => false
+
+class ExpandSAMs extends MiniPhase:
+  import ast.tpd._
+
+  override def phaseName: String = ExpandSAMs.name
+
+  override def description: String = ExpandSAMs.description
+
+  override def transformBlock(tree: Block)(using Context): Tree = tree match {
+    case Block(stats @ (fn: DefDef) :: Nil, Closure(_, fnRef, tpt)) if fnRef.symbol == fn.symbol =>
+      tpt.tpe match {
+        case NoType =>
+          tree // it's a plain function
+        case tpe if defn.isContextFunctionType(tpe) =>
+          tree
+        case tpe @ SAMType(_) if tpe.isRef(defn.PartialFunctionClass) =>
+          val tpe1 = checkRefinements(tpe, fn)
+          toPartialFunction(tree, tpe1)
+        case tpe @ SAMType(_) if ExpandSAMs.isPlatformSam(tpe.classSymbol.asClass) =>
+          checkRefinements(tpe, fn)
+          tree
+        case tpe =>
+          val tpe1 = checkRefinements(tpe.stripNull, fn)
+          val Seq(samDenot) = tpe1.possibleSamMethods
+          cpy.Block(tree)(stats,
+              AnonClass(tpe1 :: Nil, fn.symbol.asTerm :: Nil, samDenot.symbol.asTerm.name :: Nil))
+      }
+    case _ =>
+      tree
+  }
+
+  private def checkNoContextFunction(tpt: Tree)(using Context): Unit =
+    if defn.isContextFunctionType(tpt.tpe) then
+      report.error(
+        em"""Implementation restriction: cannot convert this expression to
+            |partial function with context function result type $tpt""",
+        tpt.srcPos)
+
+  /** A partial function literal:
+   *
+   *  ```
+   *  val x: PartialFunction[A, B] = { case C1 => E1; ...; case Cn => En }
+   *  ```
+   *
+   *  which desugars to:
+   *
+   *  ```
+   *  val x: PartialFunction[A, B] = {
+   *    def $anonfun(x: A): B = x match { case C1 => E1; ...; case Cn => En }
+   *    closure($anonfun: PartialFunction[A, B])
+   *  }
+   *  ```
+   *
+   *  is expanded to an anomymous class:
+   *
+   *  ```
+   *  val x: PartialFunction[A, B] = {
+   *    class $anon extends AbstractPartialFunction[A, B] {
+   *      final def isDefinedAt(x: A): Boolean = x match {
+   *        case C1 => true
+   *        ...
+   *        case Cn => true
+   *        case _  => false
+   *      }
+   *
+   *      final def applyOrElse[A1 <: A, B1 >: B](x: A1, default: A1 => B1): B1 = x match {
+   *        case C1 => E1
+   *        ...
+   *        case Cn => En
+   *        case _  => default(x)
+   *      }
+   *    }
+   *
+   *    new $anon
+   *  }
+   *  ```
+   */
+  private def toPartialFunction(tree: Block, tpe: Type)(using Context): Tree = {
+    val closureDef(anon @ DefDef(_, List(List(param)), _, _)) = tree: @unchecked
+
+    checkNoContextFunction(anon.tpt)
+
+    // The right hand side from which to construct the partial function. This is always a Match.
+    // If the original rhs is already a Match (possibly in braces), return that.
+    // Otherwise construct a match `x match case _ => rhs` where `x` is the parameter of the closure.
+    def partialFunRHS(tree: Tree): Match = tree match
+      case m: Match => m
+      case Block(Nil, expr) => partialFunRHS(expr)
+      case _ =>
+        Match(ref(param.symbol),
+          CaseDef(untpd.Ident(nme.WILDCARD).withType(param.symbol.info), EmptyTree, tree) :: Nil)
+
+    val pfRHS = partialFunRHS(anon.rhs)
+    val anonSym = anon.symbol
+    val anonTpe = anon.tpe.widen
+    val parents = List(
+      defn.AbstractPartialFunctionClass.typeRef.appliedTo(anonTpe.firstParamTypes.head, anonTpe.resultType),
+      defn.SerializableType)
+
+    AnonClass(anonSym.owner, parents, tree.span) { pfSym =>
+      def overrideSym(sym: Symbol) = sym.copy(
+        owner = pfSym,
+        flags = Synthetic | Method | Final | Override,
+        info = tpe.memberInfo(sym),
+        coord = tree.span).asTerm.entered
+      val isDefinedAtFn = overrideSym(defn.PartialFunction_isDefinedAt)
+      val applyOrElseFn = overrideSym(defn.PartialFunction_applyOrElse)
+
+      def translateMatch(tree: Match, pfParam: Symbol, cases: List[CaseDef], defaultValue: Tree)(using Context) = {
+        val selector = tree.selector
+        val selectorTpe = selector.tpe.widen
+        val defaultSym = newSymbol(pfParam.owner, nme.WILDCARD, SyntheticCase, selectorTpe)
+        val defaultCase =
+          CaseDef(
+            Bind(defaultSym, Underscore(selectorTpe)),
+            EmptyTree,
+            defaultValue)
+        val unchecked = selector.annotated(New(ref(defn.UncheckedAnnot.typeRef)))
+        cpy.Match(tree)(unchecked, cases :+ defaultCase)
+          .subst(param.symbol :: Nil, pfParam :: Nil)
+            // Needed because  a partial function can be written as:
+            // param => param match { case "foo" if foo(param) => param }
+            // And we need to update all references to 'param'
+      }
+
+      def isDefinedAtRhs(paramRefss: List[List[Tree]])(using Context) = {
+        val tru = Literal(Constant(true))
+        def translateCase(cdef: CaseDef) =
+          cpy.CaseDef(cdef)(body = tru).changeOwner(anonSym, isDefinedAtFn)
+        val paramRef = paramRefss.head.head
+        val defaultValue = Literal(Constant(false))
+        translateMatch(pfRHS, paramRef.symbol, pfRHS.cases.map(translateCase), defaultValue)
+      }
+
+      def applyOrElseRhs(paramRefss: List[List[Tree]])(using Context) = {
+        val List(paramRef, defaultRef) = paramRefss(1)
+        def translateCase(cdef: CaseDef) =
+          cdef.changeOwner(anonSym, applyOrElseFn)
+        val defaultValue = defaultRef.select(nme.apply).appliedTo(paramRef)
+        translateMatch(pfRHS, paramRef.symbol, pfRHS.cases.map(translateCase), defaultValue)
+      }
+
+      val isDefinedAtDef = transformFollowingDeep(DefDef(isDefinedAtFn, isDefinedAtRhs(_)(using ctx.withOwner(isDefinedAtFn))))
+      val applyOrElseDef = transformFollowingDeep(DefDef(applyOrElseFn, applyOrElseRhs(_)(using ctx.withOwner(applyOrElseFn))))
+      List(isDefinedAtDef, applyOrElseDef)
+    }
+  }
+
+  private def checkRefinements(tpe: Type, tree: Tree)(using Context): Type = tpe.dealias match {
+    case RefinedType(parent, name, _) =>
+      if (name.isTermName && tpe.member(name).symbol.ownersIterator.isEmpty) // if member defined in the refinement
+        report.error("Lambda does not define " + name, tree.srcPos)
+      checkRefinements(parent, tree)
+    case tpe =>
+      tpe
+  }
+end ExpandSAMs
diff --git a/tests/pos-with-compiler-cc/dotc/transform/ExplicitOuter.scala b/tests/pos-with-compiler-cc/dotc/transform/ExplicitOuter.scala
new file mode 100644
index 000000000000..00074a6ea81a
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/transform/ExplicitOuter.scala
@@ -0,0 +1,477 @@
+package dotty.tools
+package dotc
+package transform
+
+import MegaPhase._
+import core.DenotTransformers._
+import core.Symbols._
+import core.Contexts._
+import core.Phases._
+import core.Types._
+import core.Flags._
+import core.Decorators._
+import core.StdNames.nme
+import core.Names._
+import core.NameOps._
+import SymUtils._
+import dotty.tools.dotc.ast.tpd
+
+import collection.mutable
+import scala.annotation.tailrec
+
+/** This phase adds outer accessors to classes and traits that need them.
+ *  Compared to Scala 2.x, it tries to minimize the set of classes
+ *  that take outer accessors by scanning class implementations for
+ *  outer references.
+ *
+ *  The following things are delayed until erasure and are performed
+ *  by class OuterOps:
+ *
+ *   - add outer parameters to constructors
+ *   - pass outer arguments in constructor calls
+ *
+ *   replacement of outer this by outer paths is done in Erasure.
+ *   needs to run after pattern matcher as it can add outer checks and force creation of $outer
+ */
+class ExplicitOuter extends MiniPhase with InfoTransformer { thisPhase =>
+  import ExplicitOuter._
+  import ast.tpd._
+
+  override def phaseName: String = ExplicitOuter.name
+
+  override def description: String = ExplicitOuter.description
+
+  override def runsAfter:         Set[String] = Set(HoistSuperArgs.name)
+  override def runsAfterGroupsOf: Set[String] = Set(PatternMatcher.name)
+
+  override def changesMembers: Boolean = true // the phase adds outer accessors
+
+  /** Add outer accessors if a class always needs an outer pointer */
+  override def transformInfo(tp: Type, sym: Symbol)(using Context): Type = tp match {
+    case tp @ ClassInfo(_, cls, _, decls, _) if needsOuterAlways(cls) =>
+      val newDecls = decls.cloneScope
+      newOuterAccessors(cls).foreach(newDecls.enter)
+      tp.derivedClassInfo(decls = newDecls)
+    case _ =>
+      tp
+  }
+
+  override def infoMayChange(sym: Symbol)(using Context): Boolean = sym.isClass && !sym.is(JavaDefined)
+
+  /** First, add outer accessors if a class does not have them yet and it references an outer this.
+   *  If the class has outer accessors, implement them.
+   *  Furthermore, if a parent trait might have an outer accessor,
+   *  provide an implementation for the outer accessor by computing the parent's
+   *  outer from the parent type prefix. If the trait ends up not having an outer accessor
+   *  after all, the implementation is redundant, but does not harm.
+   *  The same logic is not done for non-trait parent classes because for them the outer
+   *  pointer is passed in the super constructor, which will be implemented later in
+   *  a separate phase which needs to run after erasure. However, we make sure here
+   *  that the super class constructor is indeed a New, and not just a type.
+   */
+  override def transformTemplate(impl: Template)(using Context): Tree = {
+    val cls = ctx.owner.asClass
+    val isTrait = cls.is(Trait)
+    if needsOuterIfReferenced(cls) && !needsOuterAlways(cls) && referencesOuter(cls, impl) then
+      ensureOuterAccessors(cls)
+
+    val clsHasOuter = hasOuter(cls)
+    if (clsHasOuter || cls.mixins.exists(needsOuterIfReferenced)) {
+      val newDefs = new mutable.ListBuffer[Tree]
+
+      if (clsHasOuter)
+        if (isTrait)
+          newDefs += DefDef(outerAccessor(cls).asTerm, EmptyTree)
+        else {
+          val outerParamAcc = outerParamAccessor(cls)
+          newDefs += ValDef(outerParamAcc, EmptyTree)
+          newDefs += DefDef(outerAccessor(cls).asTerm, ref(outerParamAcc))
+        }
+
+      for (parentTrait <- cls.mixins)
+        if (needsOuterIfReferenced(parentTrait)) {
+          val parentTp = cls.denot.thisType.baseType(parentTrait)
+          val outerAccImpl = newOuterAccessor(cls, parentTrait).enteredAfter(thisPhase)
+          newDefs += DefDef(outerAccImpl, singleton(fixThis(outerPrefix(parentTp))))
+        }
+
+      val parents1 =
+        for (parent <- impl.parents) yield
+          val parentCls = parent.tpe.classSymbol.asClass
+          parent match
+            // if we are in a regular class and first parent is also a regular class,
+            // make sure we have a contructor
+            case parent: TypeTree
+            if !cls.is(Trait) && !parentCls.is(Trait) && !defn.NotRuntimeClasses.contains(parentCls) =>
+              New(parent.tpe, Nil).withSpan(impl.span)
+            case _ => parent
+      cpy.Template(impl)(parents = parents1, body = impl.body ++ newDefs)
+    }
+    else impl
+  }
+
+  override def transformClosure(tree: Closure)(using Context): tpd.Tree = {
+    if (tree.tpt ne EmptyTree) {
+      val cls = tree.tpt.asInstanceOf[TypeTree].tpe.classSymbol
+      if (cls.exists && hasOuter(cls.asClass))
+        report.error("Not a single abstract method type, requires an outer pointer", tree.srcPos)
+    }
+    tree
+  }
+}
+
+object ExplicitOuter {
+  import ast.tpd._
+
+  val name: String = "explicitOuter"
+  val description: String = "add accessors to outer classes from nested ones"
+
+  /** Ensure that class `cls` has outer accessors */
+  def ensureOuterAccessors(cls: ClassSymbol)(using Context): Unit =
+    atPhase(explicitOuterPhase.next) {
+      if (!hasOuter(cls))
+        newOuterAccessors(cls).foreach(_.enteredAfter(explicitOuterPhase.asInstanceOf[DenotTransformer]))
+    }
+
+  /** The outer accessor and potentially outer param accessor needed for class `cls` */
+  private def newOuterAccessors(cls: ClassSymbol)(using Context) =
+    newOuterAccessor(cls, cls) :: (if (cls.is(Trait)) Nil else newOuterParamAccessor(cls) :: Nil)
+
+  /** Scala 2.x and Dotty don't always agree on what should be the type of the outer parameter,
+   *  so we replicate the old behavior when passing arguments to methods coming from Scala 2.x.
+   */
+  private def outerClass(cls: ClassSymbol)(using Context): Symbol = {
+    val encl = cls.owner.enclosingClass
+    if (cls.is(Scala2x))
+      encl.asClass.classInfo.selfInfo match {
+        case tp: TypeRef => tp.classSymbol
+        case self: Symbol => self
+        case _ => encl
+      }
+    else encl
+  }
+
+  /** A new outer accessor or param accessor.
+   *  @param  owner  The class where the outer accessor is located
+   *  @param  cls    The class relative to which the outer is computed (can be a base class of owner)
+   *  @param  name   The name of the outer access
+   *  @param  flags  The flags of the outer accessor
+   *
+   * The type of the outer accessor is computed as follows:
+   * Let O[X1, .., Xn] be the class enclosing `cls`.
+   *  - if owner == cls, O[X1, ..., Xn]
+   *  - otherwise, if the class P enclosing `owner` derives from O, the
+   *    base type of P.this wrt class O
+   *  - otherwise O[?, ..., ?]
+   */
+  private def newOuterSym(owner: ClassSymbol, cls: ClassSymbol, name: TermName, flags: FlagSet)(using Context) = {
+    val outerThis = owner.owner.enclosingClass.thisType
+    val outerCls = outerClass(cls)
+    val prefix = owner.thisType.baseType(cls).normalizedPrefix
+    val target =
+      if (owner == cls)
+        outerCls.appliedRef
+      else
+        outerThis.baseType(outerCls).orElse(
+          if prefix == NoPrefix then outerCls.typeRef.appliedTo(outerCls.typeParams.map(_ => TypeBounds.empty))
+          else prefix.widen)
+    val info = if (flags.is(Method)) ExprType(target) else target
+    atPhaseNoEarlier(explicitOuterPhase.next) { // outer accessors are entered at explicitOuter + 1, should not be defined before.
+      newSymbol(owner, name, SyntheticArtifact | flags, info, coord = cls.coord)
+    }
+  }
+
+  /** A new param accessor for the outer field in class `cls` */
+  private def newOuterParamAccessor(cls: ClassSymbol)(using Context) =
+    newOuterSym(cls, cls, nme.OUTER, LocalParamAccessor)
+
+  /** A new outer accessor for class `cls` which is a member of `owner` */
+  private def newOuterAccessor(owner: ClassSymbol, cls: ClassSymbol)(using Context) = {
+    val deferredIfTrait = if (owner.is(Trait)) Deferred else EmptyFlags
+    val outerAccIfOwn = if (owner == cls) OuterAccessor else EmptyFlags
+    newOuterSym(owner, cls, outerAccName(cls),
+      Final | StableMethod | outerAccIfOwn | deferredIfTrait)
+  }
+
+  private def outerAccName(cls: ClassSymbol)(using Context): TermName =
+    nme.OUTER.expandedName(cls)
+
+  /** Class needs an outer pointer, provided there is a reference to an outer this in it. */
+  def needsOuterIfReferenced(cls: ClassSymbol)(using Context): Boolean =
+    !(cls.isStatic ||
+      cls.owner.enclosingClass.isStaticOwner ||
+      cls.is(PureInterface)
+     )
+
+  /** Class unconditionally needs an outer pointer. This is the case if
+   *  the class needs an outer pointer if referenced and one of the following holds:
+   *  - we might not know at all instantiation sites whether outer is referenced or not
+   *  - we need to potentially pass along outer to a parent class or trait
+   */
+  private def needsOuterAlways(cls: ClassSymbol)(using Context): Boolean =
+    needsOuterIfReferenced(cls) &&
+    (!hasLocalInstantiation(cls) || // needs outer because we might not know whether outer is referenced or not
+     cls.mixins.exists(needsOuterIfReferenced) || // needs outer for parent traits
+     cls.info.parents.exists(parent => // needs outer to potentially pass along to parent
+       needsOuterIfReferenced(parent.classSymbol.asClass)))
+
+  /** Class is only instantiated in the compilation unit where it is defined */
+  private def hasLocalInstantiation(cls: ClassSymbol)(using Context): Boolean =
+    // Modules are normally locally instantiated, except if they are declared in a trait,
+    // in which case they will be instantiated in the classes that mix in the trait.
+    cls.owner.ownersIterator.takeWhile(!_.isStatic).exists(_.isTerm)
+    || cls.is(Private, butNot = Module)
+    || cls.is(Module) && !cls.owner.is(Trait)
+
+  /** The outer parameter accessor of cass `cls` */
+  private def outerParamAccessor(cls: ClassSymbol)(using Context): TermSymbol =
+    cls.info.decl(nme.OUTER).symbol.asTerm
+
+  /** The outer accessor of class `cls`. To find it is a bit tricky. The
+   *  class might have been moved with new owners between ExplicitOuter and Erasure,
+   *  where the method is also called. For instance, it might have been part
+   *  of a by-name argument, and therefore be moved under a closure method
+   *  by ElimByName. In that case looking up the method again at Erasure with the
+   *  fully qualified name `outerAccName` will fail, because the `outerAccName`'s
+   *  result is phase dependent. In that case we use a backup strategy where we search all
+   *  definitions in the class to find the one with the OuterAccessor flag.
+   */
+  def outerAccessor(cls: ClassSymbol)(using Context): Symbol =
+    if (cls.isStatic) NoSymbol // fast return to avoid scanning package decls
+    else cls.info.member(outerAccName(cls)).suchThat(_.is(OuterAccessor)).symbol orElse
+      cls.info.decls.find(_.is(OuterAccessor))
+
+  /** Class has an outer accessor. Can be called only after phase ExplicitOuter. */
+  private def hasOuter(cls: ClassSymbol)(using Context): Boolean =
+    needsOuterIfReferenced(cls) && outerAccessor(cls).exists
+
+  /** Class constructor needs an outer argument. Can be called only after phase ExplicitOuter. */
+  def needsOuterParam(cls: ClassSymbol)(using Context): Boolean =
+    !cls.is(Trait) && needsOuterIfReferenced(cls) && (
+      cls.is(JavaDefined) || // java inner class doesn't has outer accessor
+      outerAccessor(cls).exists)
+
+  /** Tree references an outer class of `cls` which is not a static owner.
+   */
+  def referencesOuter(cls: Symbol, tree: Tree)(using Context): Boolean =
+
+
+    val test = new TreeAccumulator[Boolean]:
+      private var inInline = false
+
+      def isOuterSym(sym: Symbol) =
+        !sym.isStaticOwner && cls.isProperlyContainedIn(sym)
+
+      def isOuterRef(ref: Type): Boolean = ref match
+        case ref: ThisType =>
+          isOuterSym(ref.cls)
+        case ref: TermRef =>
+          if (ref.prefix ne NoPrefix)
+            !ref.symbol.isStatic && isOuterRef(ref.prefix)
+          else (
+            ref.symbol.isOneOf(HoistableFlags) &&
+              // ref.symbol will be placed in enclosing class scope by LambdaLift, so it might need
+              // an outer path then.
+              isOuterSym(ref.symbol.owner.enclosingClass)
+            ||
+              // If not hoistable, ref.symbol will get a proxy in immediately enclosing class. If this properly
+              // contains the current class, it needs an outer path.
+              // If the symbol is hoistable, it might have free variables for which the same
+              // reasoning applies. See pos/i1664.scala
+              ctx.owner.enclosingClass.owner.enclosingClass.isContainedIn(ref.symbol.owner)
+            )
+        case _ => false
+
+      def hasOuterPrefix(tp: Type): Boolean = tp.stripped match
+        case AppliedType(tycon, _) => hasOuterPrefix(tycon)
+        case TypeRef(prefix, _) => isOuterRef(prefix)
+        case _ => false
+
+      def containsOuterRefsAtTopLevel(tp: Type): Boolean = tp match
+        case tp: SingletonType => isOuterRef(tp)
+        case tp: AndOrType => containsOuterRefsAtTopLevel(tp.tp1) || containsOuterRefsAtTopLevel(tp.tp2)
+        case _ => false
+
+      def containsOuterRefsAnywhere(tp: Type): Boolean =
+        tp.existsPart({
+            case t: SingletonType => isOuterRef(t)
+            case _ => false
+          }, StopAt.Static)
+
+      def containsOuterRefs(t: Tree): Boolean = t match
+        case _: This | _: Ident => isOuterRef(t.tpe)
+        case nw: New =>
+          val newCls = nw.tpe.classSymbol
+          isOuterSym(newCls.owner.enclosingClass) ||
+          hasOuterPrefix(nw.tpe) ||
+          newCls.owner.isTerm && cls.isProperlyContainedIn(newCls)
+            // newCls might get proxies for free variables. If current class is
+            // properly contained in newCls, it needs an outer path to newCls access the
+            // proxies and forward them to the new instance.
+        case app: TypeApply if app.symbol.isTypeTest =>
+          // Type tests of singletons translate to `eq` tests with references, which might require outer pointers
+          containsOuterRefsAtTopLevel(app.args.head.tpe)
+        case t: TypeTree if inInline =>
+          // Expansions of inline methods must be able to address outer types
+          containsOuterRefsAnywhere(t.tpe)
+        case _ =>
+          false
+
+      def apply(x: Boolean, t: Tree)(using Context) =
+        if x || containsOuterRefs(t) then true
+        else t match
+          case t: DefDef if t.symbol.isInlineMethod =>
+            val saved = inInline
+            inInline = true
+            try foldOver(x, t)
+            finally inInline = saved
+          case _ =>
+            foldOver(x, t)
+
+    test(false, tree)
+  end referencesOuter
+
+  private final val HoistableFlags = Method | Lazy | Module
+
+  /** The outer prefix implied by type `tpe` */
+  private def outerPrefix(tpe: Type)(using Context): Type = tpe match {
+    case tpe: TypeRef =>
+      tpe.symbol match {
+        case cls: ClassSymbol =>
+          if (tpe.prefix eq NoPrefix) cls.owner.enclosingClass.thisType
+          else tpe.prefix
+        case _ =>
+          // Need to be careful to dealias before erasure, otherwise we lose prefixes.
+          atPhaseNoLater(erasurePhase)(outerPrefix(tpe.underlying))
+          	// underlying is fine here and below since we are calling this after erasure.
+          	// However, there is some weird stuff going on with parboiled2 where an
+          	// AppliedType with a type alias as constructor is fed to outerPrefix.
+          	// For some other unknown reason this works with underlying but not with superType.
+          	// I was not able to minimize the problem and parboiled2 spits out way too much
+          	// macro generated code to be able to pinpoint the root problem.
+      }
+    case tpe: TypeProxy =>
+      outerPrefix(tpe.underlying)
+  }
+
+  /** It's possible (i1755.scala gives an example) that the type
+   *  given by outerPrefix contains a This-reference to a module outside
+   *  the context where that module is defined. This needs to be translated
+   *  to an access to the module object from the enclosing class or object.
+   *
+   *  This solution is a bit of a hack; it would be better to avoid
+   *  such references to the This of a module from outside the module
+   *  in the first place. I was not yet able to find out how such references
+   *  arise and how to avoid them.
+   */
+  private def fixThis(tpe: Type)(using Context): Type = tpe match {
+    case tpe: ThisType if tpe.cls.is(Module) && !ctx.owner.isContainedIn(tpe.cls) =>
+      fixThis(tpe.cls.owner.thisType.select(tpe.cls.sourceModule.asTerm))
+    case tpe: TermRef =>
+      tpe.derivedSelect(fixThis(tpe.prefix))
+    case _ =>
+      tpe
+  }
+
+  extension (sym: Symbol) def isOuterParamAccessor(using Context): Boolean =
+    sym.is(ParamAccessor) && sym.name == nme.OUTER
+
+  def outer(using Context): OuterOps = new OuterOps(ctx)
+
+  /** The operations in this class
+   *   - add outer parameters
+   *   - pass outer arguments to these parameters
+   *   - replace outer this references by outer paths.
+   *  They are called from erasure. There are two constraints which
+   *  suggest these operations should be done in erasure.
+   *   - Replacing this references with outer paths loses aliasing information,
+   *     so programs will not typecheck with unerased types unless a lot of type
+   *     refinements are added. Therefore, outer paths should be computed no
+   *     earlier than erasure.
+   *   - outer parameters should not show up in signatures, so again
+   *     they cannot be added before erasure.
+   *   - outer arguments need access to outer parameters as well as to the
+   *     original type prefixes of types in New expressions. These prefixes
+   *     get erased during erasure. Therefore, outer arguments have to be passed
+   *     no later than erasure.
+   */
+  class OuterOps(val ictx: Context) extends AnyVal {
+    /** The context of all operations of this class */
+    given [Dummy]: Context = ictx
+
+    /** If `cls` has an outer parameter add one to the method type `tp`. */
+    def addParam(cls: ClassSymbol, tp: Type): Type =
+      if (needsOuterParam(cls)) {
+        val mt @ MethodTpe(pnames, ptypes, restpe) = tp: @unchecked
+        mt.derivedLambdaType(
+          nme.OUTER :: pnames, outerClass(cls).typeRef :: ptypes, restpe)
+      }
+      else tp
+
+    /** If function in an apply node is a constructor that needs to be passed an
+     *  outer argument, the singleton list with the argument, otherwise Nil.
+     */
+    def args(fun: Tree): List[Tree] =
+      if (fun.symbol.isConstructor) {
+        val cls = fun.symbol.owner.asClass
+        def outerArg(receiver: Tree): Tree = receiver match {
+          case New(_) | Super(_, _) =>
+            singleton(fixThis(outerPrefix(receiver.tpe)))
+          case This(_) =>
+            ref(outerParamAccessor(cls)) // will be rewired to outer argument of secondary constructor in phase Constructors
+          case TypeApply(Select(r, nme.asInstanceOf_), args) =>
+            outerArg(r) // cast was inserted, skip
+        }
+        if (needsOuterParam(cls))
+          methPart(fun) match {
+            case Select(receiver, _) => outerArg(receiver).withSpan(fun.span) :: Nil
+          }
+        else Nil
+      }
+      else Nil
+
+    /** If the constructors of the given `cls` need to be passed an outer
+     *  argument, the singleton list with the argument, otherwise Nil.
+     */
+    def argsForNew(cls: ClassSymbol, tpe: Type): List[Tree] =
+      if (needsOuterParam(cls)) singleton(fixThis(outerPrefix(tpe))) :: Nil
+      else Nil
+
+    /** A path of outer accessors starting from node `start`. `start` defaults to the
+     *  context owner's this node. There are two alternative conditions that determine
+     *  where the path ends:
+     *
+     *   - if the initial `count` parameter is non-negative: where the number of
+     *     outer accessors reaches count.
+     *   - if the initial `count` parameter is negative: where the class symbol of
+     *     the type of the reached tree matches `toCls`.
+     */
+    def path(start: Tree = This(ctx.owner.lexicallyEnclosingClass.asClass),
+             toCls: Symbol = NoSymbol,
+             count: Int = -1): Tree =
+      try
+        @tailrec def loop(tree: Tree, count: Int): Tree =
+          val treeCls = tree.tpe.classSymbol
+          report.log(i"outer to $toCls of $tree: ${tree.tpe}, looking for ${atPhaseNoLater(lambdaLiftPhase)(outerAccName(treeCls.asClass))} in $treeCls")
+          if (count == 0 || count < 0 && treeCls == toCls) tree
+          else
+            val enclClass = ctx.owner.lexicallyEnclosingClass.asClass
+            val outerAcc = atPhaseNoLater(lambdaLiftPhase) {
+              // lambdalift mangles local class names, which means we cannot
+              // reliably find outer acessors anymore
+              tree match
+                case tree: This if tree.symbol == enclClass && !enclClass.is(Trait) =>
+                  outerParamAccessor(enclClass)
+                case _ =>
+                  outerAccessor(treeCls.asClass)
+            }
+            assert(outerAcc.exists,
+                i"failure to construct path from ${ctx.owner.ownersIterator.toList}%/% to `this` of ${toCls.showLocated};\n${treeCls.showLocated} does not have an outer accessor")
+            loop(tree.select(outerAcc).ensureApplied, count - 1)
+
+        report.log(i"computing outerpath to $toCls from ${ctx.outersIterator.map(_.owner).toList}")
+        loop(start, count)
+      catch case ex: ClassCastException =>
+        throw new ClassCastException(i"no path exists from ${ctx.owner.enclosingClass} to $toCls")
+  }
+}
diff --git a/tests/pos-with-compiler-cc/dotc/transform/ExplicitSelf.scala b/tests/pos-with-compiler-cc/dotc/transform/ExplicitSelf.scala
new file mode 100644
index 000000000000..a6f7a29accd7
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/transform/ExplicitSelf.scala
@@ -0,0 +1,64 @@
+package dotty.tools.dotc
+package transform
+
+import core._
+import Contexts._, Types._, MegaPhase._, ast.Trees._, Symbols._, Decorators._, Flags._
+import SymUtils.*
+
+/** Transform references of the form
+ *
+ *     C.this.m
+ *
+ *  where `C` is a class with explicit self type and `C` is not a
+ *  subclass of the owner of `m` to
+ *
+ *     C.this.asInstanceOf[S & C.this.type].m
+ *
+ *  where `S` is the self type of `C`.
+ *  See run/i789.scala for a test case why this is needed.
+ *
+ *  Also replaces idents referring to the self type with ThisTypes.
+ */
+class ExplicitSelf extends MiniPhase {
+  import ast.tpd._
+
+  override def phaseName: String = ExplicitSelf.name
+
+  override def description: String = ExplicitSelf.description
+
+  private def needsCast(tree: RefTree, cls: ClassSymbol)(using Context) =
+    !cls.is(Package)
+    && cls.givenSelfType.exists
+    && tree.symbol.exists
+    && !cls.derivesFrom(tree.symbol.owner)
+
+  private def castQualifier(tree: RefTree, cls: ClassSymbol, thiz: Tree)(using Context) =
+    val selfType = cls.classInfo.selfType
+    if selfType.classSymbols.exists(_.isValueClass) && !cls.isUniversalTrait then
+      report.error(em"self type $selfType of $cls may not be a value class", thiz.srcPos)
+    cpy.Select(tree)(thiz.cast(AndType(selfType, thiz.tpe)), tree.name)
+
+  override def transformIdent(tree: Ident)(using Context): Tree = tree.tpe match {
+    case tp: ThisType =>
+      report.debuglog(s"owner = ${ctx.owner}, context = ${ctx}")
+      This(tp.cls).withSpan(tree.span)
+    case TermRef(thisTp: ThisType, _) =>
+      val cls = thisTp.cls
+      if needsCast(tree, cls) then castQualifier(tree, cls, This(cls))
+      else tree
+    case _ =>
+      tree
+  }
+
+  override def transformSelect(tree: Select)(using Context): Tree = tree match {
+    case Select(thiz: This, name) if name.isTermName =>
+      val cls = thiz.symbol.asClass
+      if needsCast(tree, cls) then castQualifier(tree, cls, thiz)
+      else tree
+    case _ => tree
+  }
+}
+
+object ExplicitSelf:
+  val  name: String = "explicitSelf"
+  val description: String = "make references to non-trivial self types explicit as casts"
diff --git a/tests/pos-with-compiler-cc/dotc/transform/ExtensionMethods.scala b/tests/pos-with-compiler-cc/dotc/transform/ExtensionMethods.scala
new file mode 100644
index 000000000000..9c580235a2e4
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/transform/ExtensionMethods.scala
@@ -0,0 +1,208 @@
+/* NSC -- new Scala compiler
+ * Copyright 2005-2013 LAMP/EPFL
+ * @author Martin Odersky
+ */
+package dotty.tools.dotc
+package transform
+
+import dotty.tools.dotc.transform.MegaPhase._
+import ValueClasses._
+import dotty.tools.dotc.ast.tpd
+import scala.collection.mutable
+import core._
+import Types._, Contexts._, Names._, Flags._, DenotTransformers._, Phases._
+import SymDenotations._, Symbols._, StdNames._, Denotations._
+import TypeErasure.{ valueErasure, ErasedValueType }
+import NameKinds.ExtMethName
+import Decorators._
+import TypeUtils._
+
+/**
+ * Perform Step 1 in the inline classes SIP: Creates extension methods for all
+ * methods in a value class, except parameter or super accessors, or constructors.
+ *
+ * Additionally, for a value class V, let U be the underlying type after erasure. We add
+ * to the companion module of V two cast methods:
+ *   def u2evt$(x0: U): ErasedValueType(V, U)
+ *   def evt2u$(x0: ErasedValueType(V, U)): U
+ * The casts are used in [[Erasure]] to make it typecheck, they are then removed
+ * in [[ElimErasedValueType]].
+ * This is different from the implementation of value classes in Scala 2
+ * (see SIP-15) which uses `asInstanceOf` which does not typecheck.
+ *
+ * Finally, if the constructor of a value class is private pr protected
+ * it is widened to public.
+ *
+ * Also, drop the Local flag from all private[this] and protected[this] members
+ * that will be moved to the companion object.
+ */
+class ExtensionMethods extends MiniPhase with DenotTransformer with FullParameterization { thisPhase =>
+
+  import tpd._
+  import ExtensionMethods._
+
+  override def phaseName: String = ExtensionMethods.name
+
+  override def description: String = ExtensionMethods.description
+
+  override def runsAfter: Set[String] = Set(
+    ElimRepeated.name,
+    ProtectedAccessors.name,  // protected accessors cannot handle code that is moved from class to companion object
+  )
+
+  override def runsAfterGroupsOf: Set[String] = Set(FirstTransform.name) // need companion objects to exist
+
+  override def changesMembers: Boolean = true // the phase adds extension methods
+
+  override def transform(ref: SingleDenotation)(using Context): SingleDenotation = ref match {
+    case moduleClassSym: ClassDenotation if moduleClassSym.is(ModuleClass) =>
+      moduleClassSym.linkedClass match {
+        case valueClass: ClassSymbol if isDerivedValueClass(valueClass) =>
+          val cinfo = moduleClassSym.classInfo
+          val decls1 = cinfo.decls.cloneScope
+          val moduleSym = moduleClassSym.symbol.asClass
+
+          def enterInModuleClass(sym: Symbol): Unit = {
+            decls1.enter(sym)
+            // This is tricky: in this denotation transformer, we transform
+            // companion modules of value classes by adding methods to them.
+            // Running the transformer will create these methods, but they're
+            // only valid once it has finished running. This means we cannot use
+            // `ctx.withPhase(thisPhase.next)` here without potentially running
+            // into cycles. Instead, we manually set their validity after having
+            // created them to match the validity of the owner transformed
+            // denotation.
+            sym.validFor = thisPhase.validFor
+          }
+
+          // Create extension methods, except if the class comes from Scala 2
+          // because it adds extension methods before pickling.
+          if (!(valueClass.is(Scala2x)))
+            for (decl <- valueClass.classInfo.decls)
+              if (isMethodWithExtension(decl))
+                enterInModuleClass(createExtensionMethod(decl, moduleClassSym.symbol))
+
+          // Create synthetic methods to cast values between the underlying type
+          // and the ErasedValueType. These methods are removed in ElimErasedValueType.
+          val underlying = valueErasure(underlyingOfValueClass(valueClass))
+          val evt = ErasedValueType(valueClass.typeRef, underlying)
+          val u2evtSym = newSymbol(moduleSym, nme.U2EVT, Synthetic | Method,
+            MethodType(List(nme.x_0), List(underlying), evt))
+          val evt2uSym = newSymbol(moduleSym, nme.EVT2U, Synthetic | Method,
+            MethodType(List(nme.x_0), List(evt), underlying))
+          enterInModuleClass(u2evtSym)
+          enterInModuleClass(evt2uSym)
+
+          moduleClassSym.copySymDenotation(info = cinfo.derivedClassInfo(decls = decls1))
+        case _ =>
+          moduleClassSym
+      }
+    case ref: SymDenotation =>
+      var ref1 = ref
+      if (isMethodWithExtension(ref.symbol) && ref.hasAnnotation(defn.TailrecAnnot)) {
+        ref1 = ref.copySymDenotation()
+        ref1.removeAnnotation(defn.TailrecAnnot)
+      }
+      else if (ref.isConstructor && isDerivedValueClass(ref.owner) && ref.isOneOf(AccessFlags)) {
+        ref1 = ref.copySymDenotation()
+        ref1.resetFlag(AccessFlags)
+      }
+      // Drop the Local flag from all private[this] and protected[this] members
+      // that will be moved to the companion object.
+      if (ref.is(Local) && isDerivedValueClass(ref.owner))
+        if (ref1 ne ref) ref1.resetFlag(Local)
+        else ref1 = ref1.copySymDenotation(initFlags = ref1.flags &~ Local)
+      ref1
+    case _ =>
+      ref.info match {
+        case ClassInfo(pre, cls, _, _, _) if cls is ModuleClass =>
+          cls.linkedClass match {
+            case valueClass: ClassSymbol if isDerivedValueClass(valueClass) =>
+              val info1 = atPhase(ctx.phase.next)(cls.denot).asClass.classInfo.derivedClassInfo(prefix = pre)
+              ref.derivedSingleDenotation(ref.symbol, info1)
+            case _ => ref
+          }
+        case _ => ref
+      }
+  }
+
+  protected def rewiredTarget(target: Symbol, derived: Symbol)(using Context): Symbol =
+    if (isMethodWithExtension(target) &&
+        target.owner.linkedClass == derived.owner) extensionMethod(target)
+    else NoSymbol
+
+  private def createExtensionMethod(imeth: Symbol, staticClass: Symbol)(using Context): TermSymbol = {
+    val extensionMeth = newSymbol(staticClass, extensionName(imeth),
+      (imeth.flags | Final) &~ (Override | Protected | AbsOverride),
+      fullyParameterizedType(imeth.info, imeth.owner.asClass),
+      privateWithin = imeth.privateWithin, coord = imeth.coord)
+    atPhase(thisPhase)(extensionMeth.addAnnotations(imeth.annotations))
+      // need to change phase to add tailrec annotation which gets removed from original method in the same phase.
+    extensionMeth
+  }
+
+  private val extensionDefs = MutableSymbolMap[mutable.ListBuffer[Tree]]()
+  // todo: check that when transformation finished map is empty
+
+  override def transformTemplate(tree: tpd.Template)(using Context): tpd.Tree =
+    if isDerivedValueClass(ctx.owner) then
+      /* This is currently redundant since value classes may not
+         wrap over other value classes anyway.
+        checkNonCyclic(ctx.owner.pos, Set(), ctx.owner) */
+      tree
+    else if ctx.owner.isStaticOwner then
+      extensionDefs.remove(tree.symbol.owner) match
+        case defns: mutable.ListBuffer[Tree] if defns.nonEmpty =>
+          cpy.Template(tree)(body = tree.body ++ defns.map(transformFollowing(_)))
+        case _ =>
+          tree
+    else tree
+
+  override def transformDefDef(tree: tpd.DefDef)(using Context): tpd.Tree =
+    if (isMethodWithExtension(tree.symbol)) {
+      val origMeth = tree.symbol
+      val origClass = ctx.owner.asClass
+      val staticClass = origClass.linkedClass
+      assert(staticClass.exists, s"$origClass lacks companion, ${origClass.owner.definedPeriodsString} ${origClass.owner.info.decls} ${origClass.owner.info.decls}")
+      val extensionMeth = extensionMethod(origMeth)
+      report.log(s"Value class $origClass spawns extension method.\n  Old: ${origMeth.showDcl}\n  New: ${extensionMeth.showDcl}")
+      val store = extensionDefs.getOrElseUpdate(staticClass, new mutable.ListBuffer[Tree])
+      store += fullyParameterizedDef(extensionMeth, tree)
+      cpy.DefDef(tree)(rhs = forwarder(extensionMeth, tree))
+    }
+    else tree
+}
+
+object ExtensionMethods {
+  val name: String = "extmethods"
+  val description: String = "expand methods of value classes with extension methods"
+
+  /** Name of the extension method that corresponds to given instance method `meth`. */
+  def extensionName(imeth: Symbol)(using Context): TermName =
+    ExtMethName(imeth.name.asTermName)
+
+  /** Return the extension method that corresponds to given instance method `meth`. */
+  def extensionMethod(imeth: Symbol)(using Context): TermSymbol =
+    atPhase(extensionMethodsPhase.next) {
+      // FIXME use toStatic instead?
+      val companion = imeth.owner.companionModule
+      val companionInfo = companion.info
+      val candidates = companionInfo.decl(extensionName(imeth)).alternatives
+      val matching =
+        // See the documentation of `memberSignature` to understand why `.stripPoly.ensureMethodic` is needed here.
+        candidates filter (c => FullParameterization.memberSignature(c.info) == imeth.info.stripPoly.ensureMethodic.signature)
+      assert(matching.nonEmpty,
+       i"""no extension method found for:
+          |
+          |  $imeth:${imeth.info.show} with signature ${imeth.info.signature} in ${companion.moduleClass}
+          |
+          | Candidates:
+          |
+          | ${candidates.map(c => s"${c.name}:${c.info.show}").mkString("\n")}
+          |
+          | Candidates (signatures normalized):
+          |
+          | ${candidates.map(c => s"${c.name}:${c.info.signature}:${FullParameterization.memberSignature(c.info)}").mkString("\n")}""")
+      matching.head.symbol.asTerm
+    }
+}
diff --git a/tests/pos-with-compiler-cc/dotc/transform/FirstTransform.scala b/tests/pos-with-compiler-cc/dotc/transform/FirstTransform.scala
new file mode 100644
index 000000000000..a7e0795ce195
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/transform/FirstTransform.scala
@@ -0,0 +1,219 @@
+package dotty.tools.dotc
+package transform
+
+import core._
+import Names._
+import dotty.tools.dotc.transform.MegaPhase._
+import ast.untpd
+import Flags._
+import Types._
+import Constants.Constant
+import Contexts._
+import Symbols._
+import Decorators._
+import scala.collection.mutable
+import DenotTransformers._
+import NameOps._
+import NameKinds.OuterSelectName
+import StdNames._
+import TypeUtils.isErasedValueType
+import config.Feature
+
+object FirstTransform {
+  val name: String = "firstTransform"
+  val description: String = "some transformations to put trees into a canonical form"
+}
+
+/** The first tree transform
+ *   - eliminates some kinds of trees: Imports other than language imports,
+ *     Exports, NamedArgs, type trees other than TypeTree
+ *   - stubs out native methods
+ *   - eliminates self tree in Template and self symbol in ClassInfo
+ *   - collapses all type trees to trees of class TypeTree
+ *   - converts idempotent expressions with constant types
+ *   - drops branches of ifs using the rules
+ *          if (true) A else B    ==> A
+ *          if (false) A else B   ==> B
+ */
+class FirstTransform extends MiniPhase with InfoTransformer { thisPhase =>
+  import ast.tpd._
+
+  override def phaseName: String = FirstTransform.name
+
+  override def description: String = FirstTransform.description
+
+  /** eliminate self symbol in ClassInfo */
+  override def transformInfo(tp: Type, sym: Symbol)(using Context): Type = tp match {
+    case tp @ ClassInfo(_, _, _, _, self: Symbol) =>
+      tp.derivedClassInfo(selfInfo = self.info)
+    case _ =>
+      tp
+  }
+
+  override protected def infoMayChange(sym: Symbol)(using Context): Boolean = sym.isClass
+
+  override def checkPostCondition(tree: Tree)(using Context): Unit =
+    tree match {
+      case Select(qual, name) if !name.is(OuterSelectName) && tree.symbol.exists =>
+        val qualTpe = qual.tpe
+        assert(
+          qualTpe.isErasedValueType || qualTpe.derivesFrom(tree.symbol.owner) ||
+            tree.symbol.is(JavaStatic) && qualTpe.derivesFrom(tree.symbol.enclosingClass),
+          i"non member selection of ${tree.symbol.showLocated} from ${qualTpe} in $tree")
+      case _: TypeTree =>
+      case _: Export | _: NamedArg | _: TypTree =>
+        assert(false, i"illegal tree: $tree")
+      case _ =>
+    }
+
+  /** Reorder statements so that module classes always come after their companion classes */
+  private def reorderAndComplete(stats: List[Tree])(using Context): List[Tree] = {
+    val moduleClassDefs, singleClassDefs = mutable.Map[Name, Tree]()
+
+    /* Returns the result of reordering stats and prepending revPrefix in reverse order to it.
+     * The result of reorder is equivalent to reorder(stats, revPrefix) = revPrefix.reverse ::: reorder(stats, Nil).
+     * This implementation is tail recursive as long as the element is not a module TypeDef.
+     */
+    def reorder(stats: List[Tree], revPrefix: List[Tree]): List[Tree] = stats match {
+      case (stat: TypeDef) :: stats1 if stat.symbol.isClass =>
+        if (stat.symbol.is(Flags.Module)) {
+          def pushOnTop(xs: List[Tree], ys: List[Tree]): List[Tree] =
+            xs.foldLeft(ys)((ys, x) => x :: ys)
+          moduleClassDefs += (stat.name -> stat)
+          singleClassDefs -= stat.name.stripModuleClassSuffix
+          val stats1r = reorder(stats1, Nil)
+          pushOnTop(revPrefix, if (moduleClassDefs contains stat.name) stat :: stats1r else stats1r)
+        }
+        else
+          reorder(
+            stats1,
+            moduleClassDefs remove stat.name.moduleClassName match {
+              case Some(mcdef) =>
+                mcdef :: stat :: revPrefix
+              case None =>
+                singleClassDefs += (stat.name -> stat)
+                stat :: revPrefix
+            }
+          )
+      case stat :: stats1 => reorder(stats1, stat :: revPrefix)
+      case Nil => revPrefix.reverse
+    }
+
+    reorder(stats, Nil)
+  }
+
+  /** Eliminate self in Template
+   *  Under captureChecking, we keep the self type `S` around in a type definition
+   *
+   *     private[this] type $this = S
+   *
+   *  This is so that the type can be checked for well-formedness in the CaptureCheck phase.
+   */
+  override def transformTemplate(impl: Template)(using Context): Tree =
+    impl.self match
+      case self: ValDef if !self.tpt.isEmpty && Feature.ccEnabled =>
+        val tsym = newSymbol(ctx.owner, tpnme.SELF, PrivateLocal, TypeAlias(self.tpt.tpe))
+        val tdef = untpd.cpy.TypeDef(self)(tpnme.SELF, self.tpt).withType(tsym.typeRef)
+        cpy.Template(impl)(self = EmptyValDef, body = tdef :: impl.body)
+      case _ =>
+        cpy.Template(impl)(self = EmptyValDef)
+
+  override def transformDefDef(ddef: DefDef)(using Context): Tree =
+    val meth = ddef.symbol.asTerm
+    if meth.hasAnnotation(defn.NativeAnnot) then
+      meth.resetFlag(Deferred)
+      DefDef(meth, _ =>
+        ref(defn.Sys_error.termRef).withSpan(ddef.span)
+          .appliedTo(Literal(Constant(s"native method stub"))))
+    else ddef
+
+  override def transformStats(trees: List[Tree])(using Context): List[Tree] =
+    ast.Trees.flatten(atPhase(thisPhase.next)(reorderAndComplete(trees)))
+
+  private object collectBinders extends TreeAccumulator[List[Ident]] {
+    def apply(annots: List[Ident], t: Tree)(using Context): List[Ident] = t match {
+      case t @ Bind(_, body) =>
+        val annot = untpd.Ident(tpnme.BOUNDTYPE_ANNOT).withType(t.symbol.typeRef)
+        apply(annot :: annots, body)
+      case _ =>
+        foldOver(annots, t)
+    }
+  }
+
+  /** Replace type tree `t` of type `T` with `TypeTree(T)`, but record all
+   *  nested Bind nodes in annotations. These are interpreted in TreeTypeMaps
+   *  so that bound symbols can be properly copied.
+   */
+  private def toTypeTree(tree: Tree)(using Context) = {
+    val binders = collectBinders.apply(Nil, tree)
+    val result: Tree = TypeTree(tree.tpe).withSpan(tree.span)
+    binders.foldLeft(result)(Annotated(_, _))
+  }
+
+  override def transformOther(tree: Tree)(using Context): Tree = tree match {
+    case tree: Export => EmptyTree
+    case tree: NamedArg => transformAllDeep(tree.arg)
+    case tree => if (tree.isType) toTypeTree(tree) else tree
+  }
+
+  override def transformIdent(tree: Ident)(using Context): Tree =
+    if (tree.isType) {
+      toTypeTree(tree)
+    } else if (tree.name != nme.WILDCARD) {
+      // We constant-fold all idents except wildcards.
+      // AFAIK, constant-foldable wildcard idents can only occur in patterns, for instance as `case _: "a"`.
+      // Constant-folding that would result in `case "a": "a"`, which changes the meaning of the pattern.
+      // Note that we _do_ want to constant-fold idents in patterns that _aren't_ wildcards -
+      // for example, @switch annotation needs to see inlined literals and not indirect references.
+      constToLiteral(tree)
+    } else tree
+
+  override def transformSelect(tree: Select)(using Context): Tree =
+    if (tree.isType) toTypeTree(tree) else constToLiteral(tree)
+
+  override def transformTypeApply(tree: TypeApply)(using Context): Tree =
+    constToLiteral(tree)
+
+  override def transformApply(tree: Apply)(using Context): Tree =
+    constToLiteral(foldCondition(tree))
+
+  override def transformTyped(tree: Typed)(using Context): Tree =
+    // Singleton type cases (such as `case _: "a"`) are constant-foldable.
+    // We avoid constant-folding those as doing so would change the meaning of the pattern (see transformIdent).
+    if (!ctx.mode.is(Mode.Pattern)) constToLiteral(tree) else tree
+
+  override def transformBlock(tree: Block)(using Context): Tree =
+    constToLiteral(tree)
+
+  override def transformIf(tree: If)(using Context): Tree =
+    tree.cond.tpe match {
+      case ConstantType(Constant(c: Boolean)) if isPureExpr(tree.cond) =>
+        if (c) tree.thenp else tree.elsep
+      case _ => tree
+    }
+
+  /** Perform one of the following simplification if applicable:
+   *
+   *      true  && y   ==>  y
+   *      false && y   ==>  false
+   *      true  || y   ==>  true
+   *      false || y   ==>  y
+   */
+  private def foldCondition(tree: Apply)(using Context) = tree.fun match {
+    case Select(x @ Literal(Constant(c: Boolean)), op) =>
+      tree.args match {
+        case y :: Nil if y.tpe.widen.isRef(defn.BooleanClass) =>
+          op match {
+            case nme.ZAND => if (c) y else x
+            case nme.ZOR  => if (c) x else y
+            case _ => tree
+          }
+        case _ => tree
+      }
+    case _ => tree
+  }
+
+  // invariants: all modules have companion objects
+  // all types are TypeTrees
+  // all this types are explicit
+}
diff --git a/tests/pos-with-compiler-cc/dotc/transform/Flatten.scala b/tests/pos-with-compiler-cc/dotc/transform/Flatten.scala
new file mode 100644
index 000000000000..25df51d0916d
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/transform/Flatten.scala
@@ -0,0 +1,66 @@
+package dotty.tools.dotc
+package transform
+
+import core._
+import DenotTransformers.SymTransformer
+import Contexts._
+import Flags._
+import SymDenotations.SymDenotation
+import collection.mutable
+import MegaPhase.MiniPhase
+import util.Store
+
+/** Lift nested classes to toplevel */
+class Flatten extends MiniPhase with SymTransformer {
+  import ast.tpd._
+
+  override def phaseName: String = Flatten.name
+
+  override def description: String = Flatten.description
+
+  // private[this] and protected[this] modifiers must be dropped
+  // before classes are lifted. Getters drop these modifiers.
+  override def runsAfter: Set[String] = Set(Getters.name)
+
+  override def changesMembers: Boolean = true // the phase removes inner classes
+
+  private var LiftedDefs: Store.Location[mutable.ListBuffer[Tree] | Null] = _
+  private def liftedDefs(using Context) = ctx.store(LiftedDefs)
+
+  override def initContext(ctx: FreshContext): Unit =
+    LiftedDefs = ctx.addLocation[mutable.ListBuffer[Tree] | Null](null)
+
+  def transformSym(ref: SymDenotation)(using Context): SymDenotation =
+    if (ref.isClass && !ref.is(Package) && !ref.owner.is(Package))
+      ref.copySymDenotation(
+        name = ref.flatName,
+        owner = ref.enclosingPackageClass)
+    else ref
+
+  override def prepareForPackageDef(tree: PackageDef)(using Context): FreshContext =
+    ctx.fresh.updateStore(LiftedDefs, new mutable.ListBuffer[Tree])
+
+  private def liftIfNested(tree: Tree)(using Context) =
+    if (ctx.owner.is(Package)) tree
+    else {
+      transformFollowing(tree).foreachInThicket(t => liftedDefs.nn += t)
+      EmptyTree
+    }
+
+  override def transformStats(stats: List[Tree])(using Context): List[Tree] =
+    if ctx.owner.is(Package) then
+      val defs = liftedDefs
+      if defs != null then
+        val liftedStats = stats ++ defs
+        defs.clear()
+        liftedStats
+      else stats
+    else stats
+
+  override def transformTypeDef(tree: TypeDef)(using Context): Tree =
+    liftIfNested(tree)
+}
+
+object Flatten:
+  val name: String = "flatten"
+  val description: String = "lift all inner classes to package scope"
diff --git a/tests/pos-with-compiler-cc/dotc/transform/ForwardDepChecks.scala b/tests/pos-with-compiler-cc/dotc/transform/ForwardDepChecks.scala
new file mode 100644
index 000000000000..25e8b49cc1ba
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/transform/ForwardDepChecks.scala
@@ -0,0 +1,134 @@
+package dotty.tools
+package dotc
+package transform
+
+import core.*
+import Symbols.*, Types.*, Contexts.*, Flags.*, Decorators.*, reporting.*
+import util.Spans.Span
+import util.Store
+import collection.immutable
+import ast.tpd
+import MegaPhase.MiniPhase
+
+object ForwardDepChecks:
+
+  import tpd.*
+
+  val name: String = "forwardDepChecks"
+  val description: String = "ensure no forward references to local vals"
+
+  type LevelAndIndex = immutable.Map[Symbol, (LevelInfo, Int)]
+
+  class OptLevelInfo {
+    def levelAndIndex: LevelAndIndex = Map()
+    def enterReference(sym: Symbol, span: Span): Unit = ()
+  }
+
+  /** A class to help in forward reference checking */
+  class LevelInfo(val outer: OptLevelInfo, val owner: Symbol, stats: List[Tree])(using Context)
+  extends OptLevelInfo, caps.Pure {
+    override val levelAndIndex: LevelAndIndex =
+      stats.foldLeft(outer.levelAndIndex, 0) {(mi, stat) =>
+        val (m, idx) = mi
+        val m1 = stat match {
+          case stat: MemberDef => m.updated(stat.symbol, (this: @unchecked, idx))
+          case _ => m
+        }
+        (m1, idx + 1)
+      }._1
+    var maxIndex: Int = Int.MinValue
+    var refSpan: Span = _
+    var refSym: Symbol = _
+
+    override def enterReference(sym: Symbol, span: Span): Unit =
+      if (sym.exists && sym.owner.isTerm)
+        levelAndIndex.get(sym) match {
+          case Some((level, idx)) if (level.maxIndex < idx) =>
+            level.maxIndex = idx
+            level.refSpan = span
+            level.refSym = sym
+          case _ =>
+        }
+  }
+
+  val NoLevelInfo: OptLevelInfo = new OptLevelInfo()
+
+class ForwardDepChecks extends MiniPhase:
+  import ForwardDepChecks.*
+  import tpd.*
+
+  override def phaseName: String = ForwardDepChecks.name
+
+  override def description: String = ForwardDepChecks.description
+
+  override def runsAfter: Set[String] = Set(ElimByName.name)
+
+  private var LevelInfo: Store.Location[OptLevelInfo] = _
+  private def currentLevel(using Context): OptLevelInfo = ctx.store(LevelInfo)
+
+  override def initContext(ctx: FreshContext): Unit =
+    LevelInfo = ctx.addLocation(NoLevelInfo)
+
+  override def prepareForStats(trees: List[Tree])(using Context): Context =
+    if (ctx.owner.isTerm)
+      ctx.fresh.updateStore(LevelInfo, new LevelInfo(currentLevel, ctx.owner, trees))
+    else ctx
+
+  override def transformValDef(tree: ValDef)(using Context): ValDef =
+    val sym = tree.symbol
+    if sym.exists && sym.owner.isTerm && !sym.is(Lazy) then
+      currentLevel.levelAndIndex.get(sym) match
+        case Some((level, symIdx)) if symIdx <= level.maxIndex =>
+          report.error(ForwardReferenceExtendsOverDefinition(sym, level.refSym),
+            ctx.source.atSpan(level.refSpan))
+        case _ =>
+    tree
+
+  override def transformIdent(tree: Ident)(using Context): Ident = {
+    currentLevel.enterReference(tree.symbol, tree.span)
+    tree
+  }
+
+  /** Check that self constructor call does not contain references to vals or defs
+   *  defined later in the secondary constructor's right hand side. This is tricky
+   *  since the complete self constructor might itself be a block that originated from
+   *  expanding named and default parameters. In that case we have to go outwards
+   *  and find the enclosing expression that consists of that block. Test cases in
+   *  {pos,neg}/complex-self-call.scala.
+   */
+  private def checkSelfConstructorCall()(using Context): Unit =
+    // Find level info corresponding to constructor's RHS. This is the info of the
+    // outermost LevelInfo that has the constructor as owner.
+    def rhsLevelInfo(l: OptLevelInfo): OptLevelInfo = l match
+      case l: LevelInfo if l.owner == ctx.owner =>
+        rhsLevelInfo(l.outer) match
+          case l1: LevelInfo => l1
+          case _ => l
+      case _ =>
+        NoLevelInfo
+
+    rhsLevelInfo(currentLevel) match
+      case level: LevelInfo =>
+        if level.maxIndex > 0 then
+          report.debuglog("refsym = " + level.refSym.showLocated)
+          report.error("forward reference not allowed from self constructor invocation",
+            ctx.source.atSpan(level.refSpan))
+      case _ =>
+        assert(false, s"${ctx.owner.showLocated}")
+  end checkSelfConstructorCall
+
+  override def transformApply(tree: Apply)(using Context): Apply =
+    if (isSelfConstrCall(tree))
+      assert(ctx.owner.isConstructor)
+      checkSelfConstructorCall()
+    tree
+
+  override def transformNew(tree: New)(using Context): New = {
+    currentLevel.enterReference(tree.tpe.typeSymbol, tree.span)
+    tree.tpe.dealias.foreachPart {
+      case TermRef(_, s: Symbol) => currentLevel.enterReference(s, tree.span)
+      case _ =>
+    }
+    tree
+  }
+end ForwardDepChecks
diff --git a/tests/pos-with-compiler-cc/dotc/transform/FullParameterization.scala b/tests/pos-with-compiler-cc/dotc/transform/FullParameterization.scala
new file mode 100644
index 000000000000..8ca600577244
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/transform/FullParameterization.scala
@@ -0,0 +1,270 @@
+package dotty.tools.dotc
+package transform
+
+import core._
+import Types._
+import Contexts._
+import Symbols._
+import Decorators._
+import TypeUtils._
+import StdNames.nme
+import ast._
+
+/** Provides methods to produce fully parameterized versions of instance methods,
+ *  where the `this` of the enclosing class is abstracted out in an extra leading
+ *  `$this` parameter and type parameters of the class become additional type
+ *  parameters of the fully parameterized method.
+ *
+ *  Example usage scenarios are:
+ *
+ *    - extension methods of value classes
+ *    - implementations of trait methods
+ *    - static protected accessors
+ *    - local methods produced by tailrec transform
+ *
+ *  Note that the methods lift out type parameters of the class containing
+ *  the instance method, but not type parameters of enclosing classes. The
+ *  fully instantiated method therefore needs to be put in a scope "close"
+ *  to the original method, i.e. they need to share the same outer pointer.
+ *  Examples of legal positions are: in the companion object, or as a local
+ *  method inside the original method.
+ *
+ *  Note: The scheme does not handle yet methods where type parameter bounds
+ *  depend on value parameters of the enclosing class, as in:
+ *
+ *      class C(val a: String) extends AnyVal {
+ *        def foo[U <: a.type]: Unit = ...
+ *      }
+ *
+ *  The expansion of method `foo` would lead to
+ *
+ *      def foo$extension[U <: $this.a.type]($this: C): Unit = ...
+ *
+ *  which is not typable. Not clear yet what to do. Maybe allow PolyTypes
+ *  to follow method parameters and translate to the following:
+ *
+ *      def foo$extension($this: C)[U <: $this.a.type]: Unit = ...
+ *
+ *  @see class-dependent-extension-method.scala in pending/pos.
+ */
+trait FullParameterization {
+
+  import tpd._
+
+  /** If references to original symbol `referenced` from within fully parameterized method
+   *  `derived` should be rewired to some fully parameterized method, the rewiring target symbol,
+   *  otherwise NoSymbol.
+   */
+  protected def rewiredTarget(referenced: Symbol, derived: Symbol)(using Context): Symbol
+
+  /** If references to some original symbol from given tree node within fully parameterized method
+   *  `derived` should be rewired to some fully parameterized method, the rewiring target symbol,
+   *  otherwise NoSymbol. By default implemented as
+   *
+   *      rewiredTarget(tree.symbol, derived)
+   *
+   *  but can be overridden.
+   */
+  protected def rewiredTarget(tree: Tree, derived: Symbol)(using Context): Symbol =
+    rewiredTarget(tree.symbol, derived)
+
+  /** Converts the type `info` of a member of class `clazz` to a method type that
+   *  takes the `this` of the class and any type parameters of the class
+   *  as additional parameters. Example:
+   *
+   *    class Foo[+A <: AnyRef](val xs: List[A]) extends AnyVal {
+   *      def baz[B >: A](x: B): List[B] = ...
+   *    }
+   *
+   *  leads to:
+   *
+   *    object Foo {
+   *      def extension$baz[B >: A <: Any, A >: Nothing <: AnyRef]($this: Foo[A])(x: B): List[B]
+   *    }
+   *
+   *  If a self type is present, $this has this self type as its type.
+   *
+   *  @param abstractOverClass  if true, include the type parameters of the class in the method's list of type parameters.
+   *  @param liftThisType       if true, require created $this to be $this: (Foo[A] & Foo,this).
+   *                            This is needed if created member stays inside scope of Foo(as in tailrec)
+   */
+  def fullyParameterizedType(info: Type, clazz: ClassSymbol, abstractOverClass: Boolean = true, liftThisType: Boolean = false)(using Context): Type = {
+    val (mtparamCount, origResult) = info match {
+      case info: PolyType => (info.paramNames.length, info.resultType)
+      case info: ExprType => (0, info.resultType)
+      case _ => (0, info)
+    }
+    val ctparams = if (abstractOverClass) clazz.typeParams else Nil
+    val ctnames = ctparams.map(_.name)
+
+    /** The method result type */
+    def resultType(mapClassParams: Type => Type) = {
+      val thisParamType = mapClassParams(clazz.classInfo.selfType)
+      val firstArgType = if (liftThisType) thisParamType & clazz.thisType else thisParamType
+      MethodType(nme.SELF :: Nil)(
+          mt => firstArgType :: Nil,
+          mt => mapClassParams(origResult).substThisUnlessStatic(clazz, mt.newParamRef(0)))
+    }
+
+    /** Replace class type parameters by the added type parameters of the polytype `pt` */
+    def mapClassParams(tp: Type, pt: PolyType): Type = {
+      val classParamsRange = (mtparamCount until mtparamCount + ctparams.length).toList
+      tp.subst(ctparams, classParamsRange map (pt.paramRefs(_)))
+    }
+
+    /** The bounds for the added type parameters of the polytype `pt` */
+    def mappedClassBounds(pt: PolyType): List[TypeBounds] =
+      ctparams.map(tparam => mapClassParams(tparam.info, pt).bounds)
+
+    info match {
+      case info: PolyType =>
+        PolyType(info.paramNames ++ ctnames)(
+          pt =>
+            (info.paramInfos.map(mapClassParams(_, pt).bounds) ++
+             mappedClassBounds(pt)).mapConserve(_.subst(info, pt).bounds),
+          pt => resultType(mapClassParams(_, pt)).subst(info, pt))
+      case _ =>
+        if (ctparams.isEmpty) resultType(identity)
+        else PolyType(ctnames)(mappedClassBounds, pt => resultType(mapClassParams(_, pt)))
+    }
+  }
+
+  /** The type parameters (skolems) of the method definition `originalDef`,
+   *  followed by the class parameters of its enclosing class.
+   */
+  private def allInstanceTypeParams(originalDef: DefDef, abstractOverClass: Boolean)(using Context): List[Symbol] =
+    if (abstractOverClass)
+      originalDef.leadingTypeParams.map(_.symbol) ::: originalDef.symbol.enclosingClass.typeParams
+    else
+      originalDef.leadingTypeParams.map(_.symbol)
+
+  /** Given an instance method definition `originalDef`, return a
+   *  fully parameterized method definition derived from `originalDef`, which
+   *  has `derived` as symbol and `fullyParameterizedType(originalDef.symbol.info)`
+   *  as info.
+   *  `abstractOverClass` defines weather the DefDef should abstract over type parameters
+   *  of class that contained original defDef
+   */
+  def fullyParameterizedDef(derived: TermSymbol, originalDef: DefDef, abstractOverClass: Boolean = true)(using Context): Tree =
+    DefDef(derived, prefss => {
+      val (trefs, vrefss) = splitArgs(prefss)
+      val origMeth = originalDef.symbol
+      val origClass = origMeth.enclosingClass.asClass
+      val origLeadingTypeParamSyms = allInstanceTypeParams(originalDef, abstractOverClass)
+      val origOtherParamSyms = originalDef.trailingParamss.flatten.map(_.symbol)
+      val thisRef :: argRefs = vrefss.flatten: @unchecked
+
+      /** If tree should be rewired, the rewired tree, otherwise EmptyTree.
+       *  @param   targs  Any type arguments passed to the rewired tree.
+       */
+      def rewireTree(tree: Tree, targs: List[Tree])(using Context): Tree = {
+        def rewireCall(thisArg: Tree): Tree = {
+          val rewired = rewiredTarget(tree, derived)
+          if (rewired.exists) {
+            val base = thisArg.tpe.baseType(origClass)
+            assert(base.exists)
+            ref(rewired.termRef)
+              .appliedToTypeTrees(targs ++ base.argInfos.map(TypeTree(_)))
+              .appliedTo(thisArg)
+          } else EmptyTree
+        }
+        tree match {
+          case Return(expr, from) if !from.isEmpty =>
+            val rewired = rewiredTarget(from, derived)
+            if (rewired.exists)
+              tpd.cpy.Return(tree)(expr, Ident(rewired.termRef))
+            else
+              EmptyTree
+          case Ident(_) => rewireCall(thisRef)
+          case Select(qual, _) => rewireCall(qual)
+          case tree @ TypeApply(fn, targs1) =>
+            assert(targs.isEmpty)
+            rewireTree(fn, targs1)
+          case _ => EmptyTree
+        }
+      }
+
+      /** Type rewiring is needed because a previous reference to an instance
+       *  method might still persist in the types of enclosing nodes. Example:
+       *
+       *     if (true) this.imeth else this.imeth
+       *
+       *  is rewritten to
+       *
+       *      if (true) xmeth($this) else xmeth($this)
+       *
+       *  but the type `this.imeth` still persists as the result type of the `if`,
+       *  because it is kept by the `cpy` operation of the tree transformer.
+       *  It needs to be rewritten to the common result type of `imeth` and `xmeth`.
+       */
+      def rewireType(tpe: Type) = tpe match {
+        case tpe: TermRef if rewiredTarget(tpe.symbol, derived).exists => tpe.widen
+        case _ => tpe
+      }
+
+      new TreeTypeMap(
+        typeMap = rewireType(_)
+          .subst(origLeadingTypeParamSyms ++ origOtherParamSyms, (trefs ++ argRefs).tpes)
+          .substThisUnlessStatic(origClass, thisRef.tpe),
+        treeMap = {
+          case tree: This if tree.symbol == origClass => thisRef
+          case tree => rewireTree(tree, Nil) orElse tree
+        },
+        oldOwners = origMeth :: Nil,
+        newOwners = derived :: Nil
+      ).transform(originalDef.rhs)
+    })
+
+  /** A forwarder expression which calls `derived`, passing along
+   *  - if `abstractOverClass` the type parameters and enclosing class parameters of originalDef`,
+   *  - the `this` of the enclosing class,
+   *  - the value parameters of the original method `originalDef`.
+   */
+  def forwarder(derived: TermSymbol, originalDef: DefDef, abstractOverClass: Boolean = true, liftThisType: Boolean = false)(using Context): Tree = {
+    val fun: Tree =
+      ref(derived.termRef)
+        .appliedToTypes(allInstanceTypeParams(originalDef, abstractOverClass).map(_.typeRef))
+        .appliedTo(This(originalDef.symbol.enclosingClass.asClass))
+    val fwd =
+      if !liftThisType then
+        fun.appliedToArgss(originalDef.trailingParamss.nestedMap(param => ref(param.symbol)))
+      else
+        // this type could have changed on forwarding. Need to insert a cast.
+        originalDef.trailingParamss.foldLeft(fun)((acc, params) => {
+        val meth = acc.tpe.asInstanceOf[MethodType]
+        val paramTypes = meth.instantiateParamInfos(params.tpes)
+        acc.appliedToArgs(
+          params.lazyZip(paramTypes).map((param, paramType) => {
+            assert(param.tpe <:< paramType.widen) // type should still conform to widened type
+            ref(param.symbol).ensureConforms(paramType)
+          }))
+       })
+    fwd.withSpan(originalDef.rhs.span)
+  }
+}
+
+object FullParameterization {
+
+  /** Assuming `info` is a result of a `fullyParameterizedType` call, the signature of the
+   *  original method type `X` after stripping its leading type parameters section,
+   *  such that:
+   *    info.stripPoly.ensureMethodic = fullyParameterizedType(X, ...).stripPoly.ensureMethodic
+   *
+   *  NOTE: Keeping the polymorphic part of the signature would be more precise,
+   *  but we cannot distinguish which type parameters of `info` are also type
+   *  parameters of`X`. This could be fixed by using a specific NameKind for the
+   *  extra type parameters, but that wouldn't help for extension methods
+   *  unpickled from Scala 2 (because Scala 2 extmeths phase happens before
+   *  pickling, which is maybe something we should change for 2.14).
+   */
+  def memberSignature(info: Type)(using Context): Signature = info match {
+    case info: PolyType =>
+      memberSignature(info.resultType)
+    case MethodTpe(nme.SELF :: Nil, _, restpe) =>
+      restpe.ensureMethodic.signature
+    case info @ MethodTpe(nme.SELF :: otherNames, thisType :: otherTypes, restpe) =>
+      info.derivedLambdaType(otherNames, otherTypes, restpe).signature
+    case _ =>
+      Signature.NotAMethod
+  }
+}
diff --git a/tests/pos-with-compiler-cc/dotc/transform/FunctionXXLForwarders.scala b/tests/pos-with-compiler-cc/dotc/transform/FunctionXXLForwarders.scala
new file mode 100644
index 000000000000..cc1c0048b68f
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/transform/FunctionXXLForwarders.scala
@@ -0,0 +1,66 @@
+package dotty.tools.dotc
+package transform
+
+import core._
+import Constants.Constant
+import Contexts._
+import Flags._
+import Definitions._
+import DenotTransformers._
+import StdNames._
+import Symbols._
+import MegaPhase._
+import Types._
+
+
+/** This phase adds forwarder for XXL functions `apply` methods that are implemented with a method
+ *  with explicit parameters (not in Array[Object]).
+ *
+ *  In particular for every method
+ *    `def apply(x1: T1, ... xn: Tn): R` in class `M` subtype of `FunctionN[T1, ..., Tn, R]` with `N` > 22
+ *  a forwarder
+ *    `def apply(xs: Array[Object]): R = this.apply(xs(0).asInstanceOf[T1], ..., xs(n-1).asInstanceOf[Tn]).asInstanceOf[R]`
+ *  is generated.
+ */
+class FunctionXXLForwarders extends MiniPhase with IdentityDenotTransformer {
+  import ast.tpd._
+
+  override def phaseName: String = FunctionXXLForwarders.name
+
+  override def description: String = FunctionXXLForwarders.description
+
+  override def transformTemplate(impl: Template)(using Context): Template = {
+
+    def forwarderRhs(receiver: Tree, xsTree: Tree): Tree = {
+      val argsApply = ref(xsTree.symbol).select(nme.apply)
+      var idx = -1
+      val argss = receiver.tpe.widenDealias.paramInfoss.map(_.map { param =>
+        idx += 1
+        argsApply.appliedToTermArgs(List(Literal(Constant(idx)))).cast(param)
+      })
+      ref(receiver.symbol).appliedToArgss(argss).cast(defn.ObjectType)
+    }
+
+    if impl.symbol.owner.is(Trait) then return impl
+
+    val forwarders =
+      for {
+        case (ddef: DefDef) <- impl.body
+        if ddef.name == nme.apply && ddef.symbol.is(Method) &&
+           ddef.symbol.signature.paramsSig.size > MaxImplementedFunctionArity &&
+           ddef.symbol.allOverriddenSymbols.exists(sym => defn.isXXLFunctionClass(sym.owner))
+      }
+      yield {
+        val xsType = defn.ArrayType.appliedTo(List(defn.ObjectType))
+        val methType = MethodType(List(nme.args))(_ => List(xsType), _ => defn.ObjectType)
+        val meth = newSymbol(ddef.symbol.owner, nme.apply, Synthetic | Method, methType)
+        DefDef(meth, paramss => forwarderRhs(ddef, paramss.head.head))
+      }
+
+    cpy.Template(impl)(body = forwarders ::: impl.body)
+  }
+}
+
+object FunctionXXLForwarders:
+  val name: String = "functionXXLForwarders"
+  val description: String = "add forwarders for FunctionXXL apply methods"
diff --git a/tests/pos-with-compiler-cc/dotc/transform/GenericSignatures.scala b/tests/pos-with-compiler-cc/dotc/transform/GenericSignatures.scala
new file mode 100644
index 000000000000..9a6ab233e239
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/transform/GenericSignatures.scala
@@ -0,0 +1,481 @@
+package dotty.tools
+package dotc
+package transform
+
+import core.Annotations._
+import core.Contexts._
+import core.Phases._
+import core.Definitions
+import core.Flags._
+import core.Names.Name
+import core.Symbols._
+import core.TypeApplications.{EtaExpansion, TypeParamInfo}
+import core.TypeErasure.{erasedGlb, erasure, isGenericArrayElement}
+import core.Types._
+import core.classfile.ClassfileConstants
+import SymUtils._
+import TypeUtils._
+import java.lang.StringBuilder
+
+import scala.collection.mutable.ListBuffer
+
+/** Helper object to generate generic java signatures, as defined in
+ *  the Java Virtual Machine Specification, §4.3.4
+ */
+object GenericSignatures {
+
+  /** Generate the signature for `sym0`, with type `info`, as defined in
+   *  the Java Virtual Machine Specification, §4.3.4
+   *
+   *  @param sym0 The symbol for which to define the signature
+   *  @param info The type of the symbol
+   *  @return The signature if it could be generated, `None` otherwise.
+   */
+  def javaSig(sym0: Symbol, info: Type)(using Context): Option[String] =
+    // Avoid generating a signature for non-class local symbols.
+    if (sym0.isLocal && !sym0.isClass) None
+    else atPhase(erasurePhase)(javaSig0(sym0, info))
+
+  @noinline
+  private final def javaSig0(sym0: Symbol, info: Type)(using Context): Option[String] = {
+    val builder = new StringBuilder(64)
+    val isTraitSignature = sym0.enclosingClass.is(Trait)
+
+    def superSig(cls: Symbol, parents: List[Type]): Unit = {
+      def isInterfaceOrTrait(sym: Symbol) = sym.is(PureInterface) || sym.is(Trait)
+
+      // a signature should always start with a class
+      def ensureClassAsFirstParent(tps: List[Type]) = tps match {
+        case Nil => defn.ObjectType :: Nil
+        case head :: tail if isInterfaceOrTrait(head.typeSymbol) => defn.ObjectType :: tps
+        case _ => tps
+      }
+
+      val minParents = minimizeParents(cls, parents)
+      val validParents =
+        if (isTraitSignature)
+          // java is unthrilled about seeing interfaces inherit from classes
+          minParents filter (p => isInterfaceOrTrait(p.classSymbol))
+        else minParents
+
+      val ps = ensureClassAsFirstParent(validParents)
+      ps.foreach(boxedSig)
+    }
+
+    def boxedSig(tp: Type): Unit = jsig(tp.widenDealias, primitiveOK = false)
+
+    /** The signature of the upper-bound of a type parameter.
+     *
+     *  @pre none of the bounds are themselves type parameters.
+     *       TODO: Remove this restriction so we can support things like:
+     *
+     *           class Foo[A]:
+     *              def foo[S <: A & Object](...): ...
+     *
+     *        Which should emit a signature `S <: A`. See the handling
+     *        of `AndType` in `jsig` which already supports `def foo(x: A & Object)`.
+     */
+    def boundsSig(bounds: List[Type]): Unit = {
+      val (repr :: _, others) = splitIntersection(bounds): @unchecked
+      builder.append(':')
+
+      // In Java, intersections always erase to their first member, so put
+      // whatever parent erases to the Scala intersection erasure first in the
+      // signature.
+      if repr.classSymbol.is(Trait) then
+        // An initial ':' is needed if the intersection starts with an interface
+        // (cf https://docs.oracle.com/javase/specs/jvms/se8/html/jvms-4.html#jvms-TypeParameter)
+        builder.append(':')
+      boxedSig(repr)
+      others.filter(_.classSymbol.is(Trait)).foreach { tp =>
+        builder.append(':')
+        boxedSig(tp)
+      }
+    }
+
+    /** The parents of this intersection where type parameters
+     *  that cannot appear in the signature have been replaced
+     *  by their upper-bound.
+     */
+    def flattenedIntersection(tp: AndType)(using Context): List[Type] =
+      val parents = ListBuffer[Type]()
+
+      def collect(parent: Type, parents: ListBuffer[Type]): Unit = parent.widenDealias match
+        case AndType(tp1, tp2) =>
+          collect(tp1, parents)
+          collect(tp2, parents)
+        case parent: TypeRef =>
+          if parent.symbol.isClass || isTypeParameterInSig(parent.symbol, sym0) then
+            parents += parent
+          else
+            collect(parent.superType, parents)
+        case parent =>
+          parents += parent
+
+      collect(tp, parents)
+      parents.toList
+    end flattenedIntersection
+
+    /** Split the `parents` of an intersection into two subsets:
+     *  those whose individual erasure matches the overall erasure
+     *  of the intersection and the others.
+     */
+    def splitIntersection(parents: List[Type])(using Context): (List[Type], List[Type]) =
+      val erasedParents = parents.map(erasure)
+      val erasedTp = erasedGlb(erasedParents)
+      parents.zip(erasedParents)
+        .partitionMap((parent, erasedParent) =>
+          if erasedParent =:= erasedTp then
+            Left(parent)
+          else
+            Right(parent))
+
+    def paramSig(param: LambdaParam): Unit = {
+      builder.append(sanitizeName(param.paramName))
+      boundsSig(hiBounds(param.paramInfo.bounds))
+    }
+
+    def polyParamSig(tparams: List[LambdaParam]): Unit =
+      if (tparams.nonEmpty) {
+        builder.append('<')
+        tparams.foreach(paramSig)
+        builder.append('>')
+      }
+
+    def typeParamSig(name: Name): Unit = {
+      builder.append(ClassfileConstants.TVAR_TAG)
+      builder.append(sanitizeName(name))
+      builder.append(';')
+    }
+
+    def methodResultSig(restpe: Type): Unit = {
+      val finalType = restpe.finalResultType
+      val sym = finalType.typeSymbol
+      if (sym == defn.UnitClass || sym == defn.BoxedUnitModule || sym0.isConstructor)
+        builder.append(ClassfileConstants.VOID_TAG)
+      else
+        jsig(finalType)
+    }
+
+    // This works as long as mangled names are always valid valid Java identifiers,
+    // if we change our name encoding, we'll have to `throw new UnknownSig` here for
+    // names which are not valid Java identifiers (see git history of this method).
+    def sanitizeName(name: Name): String = name.mangledString
+
+    // Anything which could conceivably be a module (i.e. isn't known to be
+    // a type parameter or similar) must go through here or the signature is
+    // likely to end up with Foo<T>.Empty where it needs Foo<T>.Empty$.
+    def fullNameInSig(sym: Symbol): Unit = {
+      assert(sym.isClass)
+      val name = atPhase(genBCodePhase) { sanitizeName(sym.fullName).replace('.', '/') }
+      builder.append('L').nn.append(name)
+    }
+
+    def classSig(sym: Symbol, pre: Type = NoType, args: List[Type] = Nil): Unit = {
+      def argSig(tp: Type): Unit =
+        tp match {
+          case bounds: TypeBounds =>
+            if (!(defn.AnyType <:< bounds.hi)) {
+              builder.append('+')
+              boxedSig(bounds.hi)
+            }
+            else if (!(bounds.lo <:< defn.NothingType)) {
+              builder.append('-')
+              boxedSig(bounds.lo)
+            }
+            else builder.append('*')
+          case EtaExpansion(tp) =>
+            argSig(tp)
+          case _: HKTypeLambda =>
+            builder.append('*')
+          case _ =>
+            boxedSig(tp.widenDealias.widenNullaryMethod)
+              // `tp` might be a singleton type referring to a getter.
+              // Hence the widenNullaryMethod.
+        }
+
+      if (pre.exists) {
+        val preRebound = pre.baseType(sym.owner) // #2585
+        if (needsJavaSig(preRebound, Nil)) {
+          val i = builder.length()
+          jsig(preRebound)
+          if (builder.charAt(i) == 'L') {
+            builder.delete(builder.length() - 1, builder.length())// delete ';'
+                                                                  // If the prefix is a module, drop the '$'. Classes (or modules) nested in modules
+                                                                  // are separated by a single '$' in the filename: `object o { object i }` is o$i$.
+            if (preRebound.typeSymbol.is(ModuleClass))
+              builder.delete(builder.length() - 1, builder.length())
+
+            // Ensure every '.' in the generated signature immediately follows
+            // a close angle bracket '>'.  Any which do not are replaced with '$'.
+            // This arises due to multiply nested classes in the face of the
+            // rewriting explained at rebindInnerClass.
+
+            // TODO revisit this. Does it align with javac for code that can be expressed in both languages?
+            val delimiter = if (builder.charAt(builder.length() - 1) == '>') '.' else '$'
+            builder.append(delimiter).nn.append(sanitizeName(sym.name))
+          }
+          else fullNameInSig(sym)
+        }
+        else fullNameInSig(sym)
+      }
+      else fullNameInSig(sym)
+
+      if (args.nonEmpty) {
+        builder.append('<')
+        args foreach argSig
+        builder.append('>')
+      }
+      builder.append(';')
+    }
+
+    @noinline
+    def jsig(tp0: Type, toplevel: Boolean = false, primitiveOK: Boolean = true): Unit = {
+
+      val tp = tp0.dealias
+      tp match {
+
+        case ref @ TypeParamRef(_: PolyType, _) =>
+          typeParamSig(ref.paramName.lastPart)
+
+        case defn.ArrayOf(elemtp) =>
+          if (isGenericArrayElement(elemtp, isScala2 = false))
+            jsig(defn.ObjectType)
+          else
+            builder.append(ClassfileConstants.ARRAY_TAG)
+            elemtp match
+              case TypeBounds(lo, hi) => jsig(hi.widenDealias)
+              case _ => jsig(elemtp)
+
+        case RefOrAppliedType(sym, pre, args) =>
+          if (sym == defn.PairClass && tp.tupleArity > Definitions.MaxTupleArity)
+            jsig(defn.TupleXXLClass.typeRef)
+          else if (isTypeParameterInSig(sym, sym0)) {
+            assert(!sym.isAliasType, "Unexpected alias type: " + sym)
+            typeParamSig(sym.name.lastPart)
+          }
+          else if (defn.specialErasure.contains(sym))
+            jsig(defn.specialErasure(sym).nn.typeRef)
+          else if (sym == defn.UnitClass || sym == defn.BoxedUnitModule)
+            jsig(defn.BoxedUnitClass.typeRef)
+          else if (sym == defn.NothingClass)
+            builder.append("Lscala/runtime/Nothing$;")
+          else if (sym == defn.NullClass)
+            builder.append("Lscala/runtime/Null$;")
+          else if (sym.isPrimitiveValueClass)
+            if (!primitiveOK) jsig(defn.ObjectType)
+            else if (sym == defn.UnitClass) jsig(defn.BoxedUnitClass.typeRef)
+            else builder.append(defn.typeTag(sym.info))
+          else if (ValueClasses.isDerivedValueClass(sym)) {
+            val erasedUnderlying = core.TypeErasure.fullErasure(tp)
+            if (erasedUnderlying.isPrimitiveValueType && !primitiveOK)
+              classSig(sym, pre, args)
+            else
+              jsig(erasedUnderlying, toplevel, primitiveOK)
+          }
+          else if (defn.isSyntheticFunctionClass(sym)) {
+            val erasedSym = defn.functionTypeErasure(sym).typeSymbol
+            classSig(erasedSym, pre, if (erasedSym.typeParams.isEmpty) Nil else args)
+          }
+          else if sym.isClass then
+            classSig(sym, pre, args)
+          else
+            jsig(erasure(tp), toplevel, primitiveOK)
+
+        case ExprType(restpe) if toplevel =>
+          builder.append("()")
+          methodResultSig(restpe)
+
+        case ExprType(restpe) =>
+          jsig(defn.FunctionType(0).appliedTo(restpe))
+
+        case PolyType(tparams, mtpe: MethodType) =>
+          assert(tparams.nonEmpty)
+          if (toplevel && !sym0.isConstructor) polyParamSig(tparams)
+          jsig(mtpe)
+
+        // Nullary polymorphic method
+        case PolyType(tparams, restpe) =>
+          assert(tparams.nonEmpty)
+          if (toplevel) polyParamSig(tparams)
+          builder.append("()")
+          methodResultSig(restpe)
+
+        case mtpe: MethodType =>
+          // erased method parameters do not make it to the bytecode.
+          def effectiveParamInfoss(t: Type)(using Context): List[List[Type]] = t match {
+            case t: MethodType if t.isErasedMethod => effectiveParamInfoss(t.resType)
+            case t: MethodType => t.paramInfos :: effectiveParamInfoss(t.resType)
+            case _ => Nil
+          }
+          val params = effectiveParamInfoss(mtpe).flatten
+          val restpe = mtpe.finalResultType
+          builder.append('(')
+          // TODO: Update once we support varargs
+          params.foreach { tp =>
+            jsig(tp)
+          }
+          builder.append(')')
+          methodResultSig(restpe)
+
+        case tp: AndType =>
+          // Only intersections appearing as the upper-bound of a type parameter
+          // can be preserved in generic signatures and those are already
+          // handled by `boundsSig`, so here we fallback to picking a parent of
+          // the intersection to determine its overall signature. We must pick a
+          // parent whose erasure matches the erasure of the intersection
+          // because javac relies on the generic signature to determine the
+          // bytecode signature. Additionally, we prefer picking a type
+          // parameter since that will likely lead to a more precise type.
+          val parents = flattenedIntersection(tp)
+          val (reprParents, _) = splitIntersection(parents)
+          val repr =
+            reprParents.find(_.typeSymbol.is(TypeParam)).getOrElse(reprParents.head)
+          jsig(repr, primitiveOK = primitiveOK)
+
+        case ci: ClassInfo =>
+          def polyParamSig(tparams: List[TypeParamInfo]): Unit =
+            if (tparams.nonEmpty) {
+              builder.append('<')
+              tparams.foreach { tp =>
+                builder.append(sanitizeName(tp.paramName.lastPart))
+                boundsSig(hiBounds(tp.paramInfo.bounds))
+              }
+              builder.append('>')
+            }
+          val tParams = tp.typeParams
+          if (toplevel) polyParamSig(tParams)
+          superSig(ci.typeSymbol, ci.parents)
+
+        case AnnotatedType(atp, _) =>
+          jsig(atp, toplevel, primitiveOK)
+
+        case hktl: HKTypeLambda =>
+          jsig(hktl.finalResultType, toplevel, primitiveOK)
+
+        case _ =>
+          val etp = erasure(tp)
+          if (etp eq tp) throw new UnknownSig
+          else jsig(etp, toplevel, primitiveOK)
+      }
+    }
+    val throwsArgs = sym0.annotations flatMap ThrownException.unapply
+    if (needsJavaSig(info, throwsArgs))
+      try {
+        jsig(info, toplevel = true)
+        throwsArgs.foreach { t =>
+          builder.append('^')
+          jsig(t, toplevel = true)
+        }
+        Some(builder.toString)
+      }
+      catch { case _: UnknownSig => None }
+    else None
+  }
+
+  private class UnknownSig extends Exception
+
+  /* Drop redundant types (ones which are implemented by some other parent) from the immediate parents.
+   * This is important on Android because there is otherwise an interface explosion.
+   */
+  private def minimizeParents(cls: Symbol, parents: List[Type])(using Context): List[Type] = if (parents.isEmpty) parents else {
+    // val requiredDirect: Symbol => Boolean = requiredDirectInterfaces.getOrElse(cls, Set.empty)
+    var rest   = parents.tail
+    var leaves = collection.mutable.ListBuffer.empty[Type] += parents.head
+    while (rest.nonEmpty) {
+      val candidate = rest.head
+      val candidateSym = candidate.typeSymbol
+      // val required = requiredDirect(candidateSym) || !leaves.exists(t => t.typeSymbol isSubClass candidateSym)
+      val required = !leaves.exists(t => t.typeSymbol.isSubClass(candidateSym))
+      if (required) {
+        leaves = leaves filter { t =>
+          val ts = t.typeSymbol
+          !(ts.is(Trait) || ts.is(PureInterface)) || !candidateSym.isSubClass(ts)
+          // requiredDirect(ts) || !ts.isTraitOrInterface || !candidateSym.isSubClass(ts)
+        }
+        leaves += candidate
+      }
+      rest = rest.tail
+    }
+    leaves.toList
+  }
+
+  private def hiBounds(bounds: TypeBounds)(using Context): List[Type] = bounds.hi.widenDealias match {
+    case AndType(tp1, tp2) => hiBounds(tp1.bounds) ::: hiBounds(tp2.bounds)
+    case tp => tp :: Nil
+  }
+
+
+  // only refer to type params that will actually make it into the sig, this excludes:
+  // * higher-order type parameters
+  // * type parameters appearing in method parameters
+  // * type members not visible in an enclosing template
+  private def isTypeParameterInSig(sym: Symbol, initialSymbol: Symbol)(using Context) =
+    !sym.maybeOwner.isTypeParam &&
+      sym.isTypeParam && (
+      sym.isContainedIn(initialSymbol.topLevelClass) ||
+        (initialSymbol.is(Method) && initialSymbol.typeParams.contains(sym))
+      )
+
+  // @M #2585 when generating a java generic signature that includes
+  // a selection of an inner class p.I, (p = `pre`, I = `cls`) must
+  // rewrite to p'.I, where p' refers to the class that directly defines
+  // the nested class I.
+  //
+  // See also #2585 marker in javaSig: there, type arguments must be
+  // included (use pre.baseType(cls.owner)).
+  //
+  // This requires that cls.isClass.
+  private def rebindInnerClass(pre: Type, cls: Symbol)(using Context): Type = {
+    val owner = cls.owner
+    if (owner.is(PackageClass) || owner.isTerm) pre else cls.owner.info /* .tpe_* */
+  }
+
+  private object RefOrAppliedType {
+    def unapply(tp: Type)(using Context): Option[(Symbol, Type, List[Type])] = tp match {
+      case TypeParamRef(_, _) =>
+        Some((tp.typeSymbol, tp, Nil))
+      case TermParamRef(_, _) =>
+        Some((tp.termSymbol, tp, Nil))
+      case TypeRef(pre, _) if !tp.typeSymbol.isAliasType =>
+        val sym = tp.typeSymbol
+        Some((sym, pre, Nil))
+      case AppliedType(pre, args) =>
+        Some((pre.typeSymbol, pre, args))
+      case _ =>
+        None
+    }
+  }
+
+  private def needsJavaSig(tp: Type, throwsArgs: List[Type])(using Context): Boolean = !ctx.settings.YnoGenericSig.value && {
+      def needs(tp: Type) = (new NeedsSigCollector).apply(false, tp)
+      needs(tp) || throwsArgs.exists(needs)
+  }
+
+  private class NeedsSigCollector(using Context) extends TypeAccumulator[Boolean] {
+    override def apply(x: Boolean, tp: Type): Boolean =
+      if (!x)
+        tp.dealias match {
+          case RefinedType(parent, refinedName, refinedInfo) =>
+            val sym = parent.typeSymbol
+            if (sym == defn.ArrayClass) foldOver(x, refinedInfo)
+            else true
+          case tref @ TypeRef(pre, name) =>
+            val sym = tref.typeSymbol
+            if (sym.is(TypeParam) || sym.typeParams.nonEmpty) true
+            else if (sym.isClass) foldOver(x, rebindInnerClass(pre, sym)) // #2585
+            else foldOver(x, pre)
+          case PolyType(_, _) =>
+            true
+          case ClassInfo(_, _, parents, _, _) =>
+            foldOver(tp.typeParams.nonEmpty, parents)
+          case AnnotatedType(tpe, _) =>
+            foldOver(x, tpe)
+          case ExprType(tpe) =>
+            true
+          case tp =>
+            foldOver(x, tp)
+        }
+      else x
+  }
+}
diff --git a/tests/pos-with-compiler-cc/dotc/transform/Getters.scala b/tests/pos-with-compiler-cc/dotc/transform/Getters.scala
new file mode 100644
index 000000000000..ad06bfb0a504
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/transform/Getters.scala
@@ -0,0 +1,125 @@
+package dotty.tools.dotc
+package transform
+
+import core._
+import DenotTransformers.SymTransformer
+import Contexts._
+import SymDenotations.SymDenotation
+import Types._
+import Symbols._
+import MegaPhase._
+import Flags._
+import ValueClasses._
+import SymUtils._
+import NameOps._
+
+
+/** Performs the following rewritings for fields of a class:
+ *
+ *    <mods> val x: T = e
+ *      -->  <mods> <stable> <accessor> def x: T = e
+ *    <mods> var x: T = e
+ *      -->  <mods> <accessor> def x: T = e
+ *
+ *    <mods> val x: T
+ *      -->  <mods> <stable> <accessor> def x: T
+ *
+ *    <mods> lazy val x: T = e
+ *      -->  <mods> <accessor> lazy def x: T =e
+ *
+ *    <mods> var x: T
+ *      -->  <mods> <accessor> def x: T
+ *
+ *    <mods> non-static <module> val x$ = e
+ *      -->  <mods> <module> <accessor> def x$ = e
+ *
+ *  Also, generate setters for fields that are private but not private[this]
+ *  The form of a setter is
+ *
+ *     <mods> def x_=(init: T): Unit = ()
+ *
+ *  Omitted from the rewritings are
+ *
+ *   - private[this] fields in classes (excluding traits, value classes)
+ *   - fields generated for static modules (TODO: needed?)
+ *   - parameters, static fields, and fields coming from Java
+ *
+ *  The rhs is computed later, in phase Memoize.
+ *
+ *  Furthermore, assignments to mutable vars with setters are replaced by setter calls
+ *
+ *     p.x = e
+ *      -->  p.x_=(e)
+ *
+ *  No fields are generated yet. This is done later in phase Memoize.
+ *
+ *  Also, drop the Local flag from all private[this] and protected[this] members.
+ *  This allows subsequent code motions in Flatten.
+ */
+class Getters extends MiniPhase with SymTransformer { thisPhase =>
+  import ast.tpd._
+
+  override def phaseName: String = Getters.name
+
+  override def description: String = Getters.description
+
+  override def transformSym(d: SymDenotation)(using Context): SymDenotation = {
+    def noGetterNeeded =
+      d.isOneOf(NoGetterNeededFlags) ||
+      d.isAllOf(PrivateLocal) && !d.owner.is(Trait) && !isDerivedValueClass(d.owner) && !d.is(Lazy) ||
+      d.is(Module) && d.isStatic ||
+      d.hasAnnotation(defn.ScalaStaticAnnot) ||
+      d.isSelfSym
+
+    var d1 =
+      if (d.isTerm && (d.is(Lazy) || d.owner.isClass) && d.info.isValueType && !noGetterNeeded) {
+        val maybeStable = if (d.isStableMember) StableRealizable else EmptyFlags
+        d.copySymDenotation(
+          initFlags = d.flags | maybeStable | AccessorCreationFlags,
+          info = ExprType(d.info))
+            // Note: This change will only affect the SymDenotation itself, not
+            // SingleDenotations referring to a getter. In this case it does not
+            // seem to be a problem since references to a getter don't care whether
+            // it's a `T` or a `=> T`
+      }
+      else d
+
+    // Drop the Local flag from all private[this] and protected[this] members.
+    if (d1.is(Local))
+      if (d1 ne d) d1.resetFlag(Local)
+      else d1 = d1.copySymDenotation(initFlags = d1.flags &~ Local)
+    d1
+  }
+  private val NoGetterNeededFlags = Method | Param | JavaDefined | JavaStatic
+
+  val newSetters = util.HashSet[Symbol]()
+
+  def ensureSetter(sym: TermSymbol)(using Context) =
+    if !sym.setter.exists then
+      newSetters += sym.copy(
+        name = sym.name.setterName,
+        info = MethodType(sym.info.widenExpr :: Nil, defn.UnitType)
+      ).enteredAfter(thisPhase)
+
+  override def transformValDef(tree: ValDef)(using Context): Tree =
+    val sym = tree.symbol
+    if !sym.is(Method) then return tree
+    val getterDef = DefDef(sym.asTerm, tree.rhs).withSpan(tree.span)
+    if !sym.is(Mutable) then return getterDef
+    ensureSetter(sym.asTerm)
+    if !newSetters.contains(sym.setter) then return getterDef
+    val setterDef = DefDef(sym.setter.asTerm, unitLiteral)
+    Thicket(getterDef, setterDef)
+
+  override def transformAssign(tree: Assign)(using Context): Tree =
+    val lsym = tree.lhs.symbol.asTerm
+    if lsym.is(Method) then
+      ensureSetter(lsym)
+      tree.lhs.becomes(tree.rhs).withSpan(tree.span)
+    else tree
+}
+
+object Getters {
+  val name: String = "getters"
+  val description: String = "replace non-private vals and vars with getter defs"
+}
diff --git a/tests/pos-with-compiler-cc/dotc/transform/HoistSuperArgs.scala b/tests/pos-with-compiler-cc/dotc/transform/HoistSuperArgs.scala
new file mode 100644
index 000000000000..84dbf3a0dcd1
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/transform/HoistSuperArgs.scala
@@ -0,0 +1,242 @@
+package dotty.tools.dotc
+package transform
+
+import MegaPhase._
+import core.DenotTransformers._
+import core.Symbols._
+import core.Contexts._
+import ast.TreeTypeMap
+import core.Types._
+import core.Flags._
+import core.Decorators._
+import collection.mutable
+import ast.Trees._
+import core.NameKinds.SuperArgName
+import SymUtils._
+
+object HoistSuperArgs {
+  val name: String = "hoistSuperArgs"
+  val description: String = "hoist complex arguments of supercalls to enclosing scope"
+}
+
+/** This phase hoists complex arguments of supercalls and this-calls out of the enclosing class.
+ *  Example:
+ *
+ *      class B(y: Int) extends A({ def f(x: Int) = x * x; f(y)})
+ *
+ *  is translated to
+ *
+ *      class B(y: Int) extends A(B#B$superArg$1(this.y)) {
+ *        private <static> def B$superArg$1(y: Int): Int = {
+ *          def f(x: Int): Int = x.*(x); f(y)
+ *        }
+ *      }
+ *
+ *  An argument is complex if it contains a method or template definition, a this or a new,
+ *  or it contains an identifier which needs a `this` prefix to be accessed. This is the case
+ *  if the identifier has neither a global reference nor a reference to a parameter of the enclosing class.
+ *  @see needsHoist for an implementation.
+ *
+ *  A hoisted argument definition gets the parameters of the class it is hoisted from
+ *  as method parameters. The definition is installed in the scope enclosing the class,
+ *  or, if that is a package, it is made a static method of the class itself.
+ */
+class HoistSuperArgs extends MiniPhase, IdentityDenotTransformer { thisPhase =>
+  import ast.tpd._
+
+  override def phaseName: String = HoistSuperArgs.name
+
+  override def description: String = HoistSuperArgs.description
+
+  override def runsAfter: Set[String] = Set(ElimByName.name)
+    // By name closures need to be introduced first in order to be hoisted out here.
+
+  /** Defines methods for hoisting complex supercall arguments out of
+   *  parent super calls and constructor definitions.
+   *  Hoisted superarg methods are collected in `superArgDefs`
+   */
+  class Hoister(cls: Symbol)(using Context) {
+    val superArgDefs: mutable.ListBuffer[DefDef] = new mutable.ListBuffer
+
+    /** If argument is complex, hoist it out into its own method and refer to the
+     *  method instead.
+     *  @param   arg    The argument that might be hoisted
+     *  @param   cdef   The definition of the constructor from which the call is made
+     *  @param   lifted Argument definitions that were lifted out in a call prefix
+     *  @return  The argument after possible hoisting
+     */
+    private def hoistSuperArg(arg: Tree, cdef: DefDef, lifted: List[Symbol]): Tree = {
+      val constr = cdef.symbol
+      lazy val origParams = // The parameters that can be accessed in the supercall
+        if (constr == cls.primaryConstructor)
+          cls.info.decls.filter(d => d.is(TypeParam) || d.is(ParamAccessor) && !d.isSetter)
+        else
+          allParamSyms(cdef)
+
+      /** The parameter references defined by the constructor info */
+      def allParamRefs(tp: Type): List[ParamRef] = tp match {
+        case tp: LambdaType => tp.paramRefs ++ allParamRefs(tp.resultType)
+        case _              => Nil
+      }
+
+      /** Splice `restpe` in final result type position of `tp` */
+      def replaceResult(tp: Type, restpe: Type): Type = tp match {
+        case tp: LambdaType =>
+          tp.derivedLambdaType(resType = replaceResult(tp.resultType, restpe))
+        case _ => restpe
+      }
+
+      /** A method representing a hoisted supercall argument */
+      def newSuperArgMethod(argType: Type) = {
+        val (staticFlag, methOwner) =
+          if (cls.owner.is(Package)) (JavaStatic, cls) else (EmptyFlags, cls.owner)
+        val argTypeWrtConstr = argType.widenTermRefExpr.subst(origParams, allParamRefs(constr.info))
+        // argType with references to paramRefs of the primary constructor instead of
+        // local parameter accessors
+        val abstractedArgType =
+          if lifted.isEmpty then argTypeWrtConstr
+          else MethodType.fromSymbols(lifted, argTypeWrtConstr)
+        newSymbol(
+          owner = methOwner,
+          name = SuperArgName.fresh(cls.name.toTermName),
+          flags = Synthetic | Private | Method | staticFlag,
+          info = replaceResult(constr.info, abstractedArgType),
+          coord = constr.coord
+        ).enteredAfter(thisPhase)
+      }
+
+      /** Type of a reference implies that it needs to be hoisted */
+      def refNeedsHoist(tp: Type): Boolean = tp match {
+        case tp: ThisType => !tp.cls.isStaticOwner && !cls.isContainedIn(tp.cls)
+        case tp: TermRef  => refNeedsHoist(tp.prefix)
+        case _            => false
+      }
+
+      /** Super call argument is complex, needs to be hoisted */
+      def needsHoist(tree: Tree) = tree match
+        case _: DefDef            => true
+        case _: Template          => true
+        case _: New               => !tree.tpe.typeSymbol.isStatic
+        case _: RefTree | _: This => refNeedsHoist(tree.tpe)
+        case _                    => false
+
+      /** Only rewire types that are owned by the current Hoister and is an param or accessor */
+      def needsRewire(tp: Type) = tp match {
+        case ntp: NamedType =>
+          val owner = ntp.symbol.maybeOwner
+          (owner == cls || owner == constr) && ntp.symbol.isParamOrAccessor
+          || lifted.contains(ntp.symbol)
+        case _ => false
+      }
+
+      // begin hoistSuperArg
+      arg match {
+        case _ if arg.existsSubTree(needsHoist) =>
+          val superMeth = newSuperArgMethod(arg.tpe)
+          val superArgDef = DefDef(superMeth, prefss => {
+            val paramSyms = prefss.flatten.map(pref =>
+              if pref.isType then pref.tpe.typeSymbol else pref.symbol)
+            val tmap = new TreeTypeMap(
+              typeMap = new TypeMap {
+                lazy val origToParam = (origParams ::: lifted).zip(paramSyms).toMap
+                def apply(tp: Type) = tp match {
+                  case tp: NamedType if needsRewire(tp) =>
+                    origToParam.get(tp.symbol) match {
+                      case Some(mappedSym) => if (tp.symbol.isType) mappedSym.typeRef else mappedSym.termRef
+                      case None => mapOver(tp)
+                    }
+                  case _ =>
+                    mapOver(tp)
+                }
+              },
+              treeMap = {
+                case tree: RefTree if needsRewire(tree.tpe) =>
+                  cpy.Ident(tree)(tree.name).withType(tree.tpe)
+                case tree =>
+                  tree
+              })
+            tmap(arg).changeOwnerAfter(constr, superMeth, thisPhase)
+          })
+          superArgDefs += superArgDef
+          def termParamRefs(tp: Type, params: List[Symbol]): List[List[Tree]] = tp match {
+            case tp: PolyType =>
+              termParamRefs(tp.resultType, params)
+            case tp: MethodType =>
+              val (thisParams, otherParams) = params.splitAt(tp.paramNames.length)
+              thisParams.map(ref) :: termParamRefs(tp.resultType, otherParams)
+            case _ =>
+              Nil
+          }
+          val (typeParams, termParams) = origParams.span(_.isType)
+          var res = ref(superMeth)
+            .appliedToTypes(typeParams.map(_.typeRef))
+            .appliedToArgss(termParamRefs(constr.info, termParams))
+          if lifted.nonEmpty then
+            res = res.appliedToArgs(lifted.map(ref))
+          report.log(i"hoist $arg, cls = $cls = $res")
+          res
+        case _ => arg
+      }
+    }
+
+    /** Hoist complex arguments in super call out of the class. */
+    def hoistSuperArgsFromCall(superCall: Tree, cdef: DefDef, lifted: mutable.ListBuffer[Symbol]): Tree = superCall match
+      case Block(defs, expr) =>
+        cpy.Block(superCall)(
+          stats = defs.mapconserve { (t: Tree) => t match // !cc! explicity typed scrutinee is needed
+            case vdef: ValDef =>
+              try cpy.ValDef(vdef)(rhs = hoistSuperArg(vdef.rhs, cdef, lifted.toList))
+              finally lifted += vdef.symbol
+            case ddef: DefDef =>
+              try cpy.DefDef(ddef)(rhs = hoistSuperArg(ddef.rhs, cdef, lifted.toList))
+              finally lifted += ddef.symbol
+            case stat =>
+              stat
+          },
+          expr = hoistSuperArgsFromCall(expr, cdef, lifted))
+      case Apply(fn, args) =>
+        cpy.Apply(superCall)(
+          hoistSuperArgsFromCall(fn, cdef, lifted),
+          args.mapconserve(hoistSuperArg(_, cdef, lifted.toList)))
+      case _ =>
+        superCall
+
+    /** Hoist complex arguments in this-constructor call of secondary constructor out of the class. */
+    def hoistSuperArgsFromConstr(stat: Tree): Tree = stat match {
+      case constr: DefDef if constr.symbol.isClassConstructor =>
+        val lifted = new mutable.ListBuffer[Symbol]
+        cpy.DefDef(constr)(rhs =
+          constr.rhs match
+            case Block(stats @ (superCall :: stats1), expr: Literal) =>
+              cpy.Block(constr.rhs)(
+                stats.derivedCons(hoistSuperArgsFromCall(superCall, constr, lifted), stats1),
+                expr)
+            case _ =>
+              hoistSuperArgsFromCall(constr.rhs, constr, lifted)
+          )
+      case _ =>
+        stat
+    }
+  }
+
+  override def transformTypeDef(tdef: TypeDef)(using Context): Tree =
+    tdef.rhs match {
+      case impl @ Template(cdef, superCall :: others, _, _) =>
+        val hoist = new Hoister(tdef.symbol)
+        val hoistedSuperCall = hoist.hoistSuperArgsFromCall(superCall, cdef, new mutable.ListBuffer)
+        val hoistedBody = impl.body.mapconserve(hoist.hoistSuperArgsFromConstr)
+        if (hoist.superArgDefs.isEmpty) tdef
+        else {
+          val (staticSuperArgDefs, enclSuperArgDefs) =
+            hoist.superArgDefs.toList.partition(_.symbol.is(JavaStatic))
+          flatTree(
+              cpy.TypeDef(tdef)(
+                  rhs = cpy.Template(impl)(
+                      parents = hoistedSuperCall :: others,
+                      body = hoistedBody ++ staticSuperArgDefs)) ::
+              enclSuperArgDefs)
+        }
+      case _ =>
+        tdef
+    }
+}
diff --git a/tests/pos-with-compiler-cc/dotc/transform/InlinePatterns.scala b/tests/pos-with-compiler-cc/dotc/transform/InlinePatterns.scala
new file mode 100644
index 000000000000..6edb60a77245
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/transform/InlinePatterns.scala
@@ -0,0 +1,65 @@
+package dotty.tools
+package dotc
+package transform
+
+import core._
+import MegaPhase._
+import Symbols._, Contexts._, Types._, Decorators._
+import NameOps._
+import Names._
+
+/** Rewrite an application
+ *
+ *    {new { def unapply(x0: X0)(x1: X1,..., xn: Xn) = b }}.unapply(y0)(y1, ..., yn)
+ *
+ *  where
+ *
+ *    - the method is `unapply` or `unapplySeq`
+ *    - the method does not have type parameters
+ *
+ *  to
+ *
+ *    [xi := yi]b
+ *
+ *  This removes placeholders added by inline `unapply`/`unapplySeq` patterns.
+ */
+class InlinePatterns extends MiniPhase:
+  import ast.tpd._
+
+  override def phaseName: String = InlinePatterns.name
+
+  override def description: String = InlinePatterns.description
+
+  // This phase needs to run after because it need to transform trees that are generated
+  // by the pattern matcher but are still not visible in that group of phases.
+  override def runsAfterGroupsOf: Set[String] = Set(PatternMatcher.name)
+
+  override def transformApply(app: Apply)(using Context): Tree =
+    if app.symbol.name.isUnapplyName && !app.tpe.isInstanceOf[MethodicType] then
+      app match
+        case App(Select(fn, name), argss) =>
+          val app1 = betaReduce(app, fn, name, argss.flatten)
+          if app1 ne app then report.log(i"beta reduce $app -> $app1")
+          app1
+        case _ =>
+          app
+    else app
+
+  private object App:
+    def unapply(app: Tree): (Tree, List[List[Tree]]) =
+      app match
+        case Apply(App(fn, argss), args) => (fn, argss :+ args)
+        case _ => (app, Nil)
+
+  private def betaReduce(tree: Apply, fn: Tree, name: Name, args: List[Tree])(using Context): Tree =
+    fn match
+      case Block(TypeDef(_, template: Template) :: Nil, Apply(Select(New(_),_), Nil)) if template.constr.rhs.isEmpty =>
+        template.body match
+          case List(ddef @ DefDef(`name`, _, _, _)) => BetaReduce(ddef, args)
+          case _ => tree
+      case _ => tree
+
+object InlinePatterns:
+  val name: String = "inlinePatterns"
+  val description: String = "remove placeholders of inlined patterns"
+
diff --git a/tests/pos-with-compiler-cc/dotc/transform/InlineVals.scala b/tests/pos-with-compiler-cc/dotc/transform/InlineVals.scala
new file mode 100644
index 000000000000..65212ec2c0cc
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/transform/InlineVals.scala
@@ -0,0 +1,59 @@
+package dotty.tools
+package dotc
+package transform
+
+import dotty.tools.dotc.core.Contexts._
+import dotty.tools.dotc.core.Decorators._
+import dotty.tools.dotc.core.Symbols._
+import dotty.tools.dotc.core.Flags._
+import dotty.tools.dotc.core.Types._
+import dotty.tools.dotc.transform.MegaPhase.MiniPhase
+import dotty.tools.dotc.inlines.Inlines
+
+/** Check that `tree.rhs` can be right hand-side of an `inline` value definition. */
+class InlineVals extends MiniPhase:
+  import ast.tpd._
+
+  override def phaseName: String = InlineVals.name
+
+  override def description: String = InlineVals.description
+
+  override def checkPostCondition(tree: Tree)(using Context): Unit =
+    if !ctx.erasedTypes then
+      tree match
+        case tree: ValDef => checkInlineConformant(tree)
+        case _ =>
+
+  override def transformValDef(tree: ValDef)(using Context): Tree =
+    checkInlineConformant(tree)
+    tree
+
+  /** Check that `tree.rhs` can be right hand-side of an `inline` value definition. */
+  private def checkInlineConformant(tree: ValDef)(using Context): Unit = {
+    if tree.symbol.is(Inline, butNot = DeferredOrTermParamOrAccessor)
+      && !Inlines.inInlineMethod
+    then
+      val rhs = tree.rhs
+      val tpt = tree.tpt
+      tpt.tpe.widenTermRefExpr.dealiasKeepOpaques.normalized match
+        case tp: ConstantType =>
+          if !isPureExpr(rhs) then
+            val details = if enclosingInlineds.isEmpty then "" else em"but was: $rhs"
+            report.error(s"inline value must be pure$details", rhs.srcPos)
+        case tp =>
+          if tp.typeSymbol.is(Opaque) then
+            report.error(em"The type of an `inline val` cannot be an opaque type.\n\nTo inline, consider using `inline def` instead", rhs)
+          else if tp.derivesFrom(defn.UnitClass) then
+            report.error(em"`inline val` of type `Unit` is not supported.\n\nTo inline a `Unit` consider using `inline def`", rhs)
+          else if tp.derivesFrom(defn.StringClass) || defn.ScalaValueClasses().exists(tp.derivesFrom(_)) then
+            val pos = if tpt.span.isZeroExtent then rhs.srcPos else tpt.srcPos
+            report.error(em"inline value must have a literal constant type", pos)
+          else if tp.derivesFrom(defn.NullClass) then
+            report.error(em"`inline val` with `null` is not supported.\n\nTo inline a `null` consider using `inline def`", rhs)
+          else
+            report.error(em"inline value must contain a literal constant value.\n\nTo inline more complex types consider using `inline def`", rhs)
+  }
+
+object InlineVals:
+  val name: String = "inlineVals"
+  val description: String = "check right hand-sides of an `inline val`s"
diff --git a/tests/pos-with-compiler-cc/dotc/transform/Inlining.scala b/tests/pos-with-compiler-cc/dotc/transform/Inlining.scala
new file mode 100644
index 000000000000..5ddcf600c63a
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/transform/Inlining.scala
@@ -0,0 +1,83 @@
+package dotty.tools.dotc
+package transform
+
+import core._
+import Flags._
+import Contexts._
+import Symbols._
+import SymUtils._
+import dotty.tools.dotc.ast.tpd
+
+import dotty.tools.dotc.core.StagingContext._
+import dotty.tools.dotc.inlines.Inlines
+import dotty.tools.dotc.ast.TreeMapWithImplicits
+
+
+/** Inlines all calls to inline methods that are not in an inline method or a quote */
+class Inlining extends MacroTransform {
+  import tpd._
+
+  override def phaseName: String = Inlining.name
+
+  override def description: String = Inlining.description
+
+  override def allowsImplicitSearch: Boolean = true
+
+  override def run(using Context): Unit =
+    if ctx.compilationUnit.needsInlining then
+      try super.run
+      catch case _: CompilationUnit.SuspendException => ()
+
+  override def runOn(units: List[CompilationUnit])(using Context): List[CompilationUnit] =
+    val newUnits = super.runOn(units).filterNot(_.suspended)
+    ctx.run.nn.checkSuspendedUnits(newUnits)
+    newUnits
+
+  override def checkPostCondition(tree: Tree)(using Context): Unit =
+    tree match {
+      case PackageDef(pid, _) if tree.symbol.owner == defn.RootClass =>
+        new TreeTraverser {
+          def traverse(tree: Tree)(using Context): Unit =
+            tree match
+              case _: GenericApply if tree.symbol.isQuote =>
+                traverseChildren(tree)(using StagingContext.quoteContext)
+              case _: GenericApply if tree.symbol.isExprSplice =>
+                traverseChildren(tree)(using StagingContext.spliceContext)
+              case tree: RefTree if !Inlines.inInlineMethod && StagingContext.level == 0 =>
+                assert(!tree.symbol.isInlineMethod, tree.show)
+              case _ =>
+                traverseChildren(tree)
+        }.traverse(tree)
+      case _ =>
+    }
+
+  def newTransformer(using Context): Transformer = new Transformer {
+    override def transform(tree: tpd.Tree)(using Context): tpd.Tree =
+      new InliningTreeMap().transform(tree)
+  }
+
+  private class InliningTreeMap extends TreeMapWithImplicits {
+    override def transform(tree: Tree)(using Context): Tree = {
+      tree match
+        case tree: DefTree =>
+          if tree.symbol.is(Inline) then tree
+          else super.transform(tree)
+        case _: Typed | _: Block =>
+          super.transform(tree)
+        case _ if Inlines.needsInlining(tree) =>
+          val tree1 = super.transform(tree)
+          if tree1.tpe.isError then tree1
+          else Inlines.inlineCall(tree1)
+        case _: GenericApply if tree.symbol.isQuote =>
+          super.transform(tree)(using StagingContext.quoteContext)
+        case _: GenericApply if tree.symbol.isExprSplice =>
+          super.transform(tree)(using StagingContext.spliceContext)
+        case _ =>
+          super.transform(tree)
+    }
+  }
+}
+
+object Inlining:
+  val name: String = "inlining"
+  val description: String = "inline and execute macros"
diff --git a/tests/pos-with-compiler-cc/dotc/transform/InstrumentCoverage.scala b/tests/pos-with-compiler-cc/dotc/transform/InstrumentCoverage.scala
new file mode 100644
index 000000000000..c69b342b9a01
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/transform/InstrumentCoverage.scala
@@ -0,0 +1,528 @@
+package dotty.tools.dotc
+package transform
+
+import java.io.File
+
+import ast.tpd.*
+import collection.mutable
+import core.Flags.*
+import core.Contexts.{Context, ctx, inContext}
+import core.DenotTransformers.IdentityDenotTransformer
+import core.Symbols.{defn, Symbol}
+import core.Constants.Constant
+import core.NameOps.isContextFunction
+import core.Types.*
+import coverage.*
+import typer.LiftCoverage
+import util.{SourcePosition, SourceFile}
+import util.Spans.Span
+import localopt.StringInterpolatorOpt
+import inlines.Inlines
+
+/** Implements code coverage by inserting calls to scala.runtime.coverage.Invoker
+  * ("instruments" the source code).
+  * The result can then be consumed by the Scoverage tool.
+  */
+class InstrumentCoverage extends MacroTransform with IdentityDenotTransformer:
+  import InstrumentCoverage.{InstrumentedParts, ExcludeMethodFlags}
+
+  override def phaseName = InstrumentCoverage.name
+
+  override def description = InstrumentCoverage.description
+
+  // Enabled by argument "-coverage-out OUTPUT_DIR"
+  override def isEnabled(using ctx: Context) =
+    ctx.settings.coverageOutputDir.value.nonEmpty
+
+  // counter to assign a unique id to each statement
+  private var statementId = 0
+
+  // stores all instrumented statements
+  private val coverage = Coverage()
+
+  override def run(using ctx: Context): Unit =
+    val outputPath = ctx.settings.coverageOutputDir.value
+
+    // Ensure the dir exists
+    val dataDir = File(outputPath)
+    val newlyCreated = dataDir.mkdirs()
+
+    if !newlyCreated then
+      // If the directory existed before, let's clean it up.
+      dataDir.listFiles.nn
+        .filter(_.nn.getName.nn.startsWith("scoverage"))
+        .foreach(_.nn.delete())
+    end if
+    super.run
+
+    Serializer.serialize(coverage, outputPath, ctx.settings.sourceroot.value)
+
+  override protected def newTransformer(using Context) =
+    CoverageTransformer(ctx.settings.coverageOutputDir.value)
+
+  /** Transforms trees to insert calls to Invoker.invoked to compute the coverage when the code is called */
+  private class CoverageTransformer(outputPath: String) extends Transformer:
+    private val ConstOutputPath = Constant(outputPath)
+
+    /** Generates the tree for:
+      * ```
+      * Invoker.invoked(id, DIR)
+      * ```
+      * where DIR is the _outputPath_ defined by the coverage settings.
+      */
+    private def invokeCall(id: Int, span: Span)(using Context): Apply =
+      ref(defn.InvokedMethodRef).withSpan(span)
+        .appliedToArgs(
+          Literal(Constant(id)) :: Literal(ConstOutputPath) :: Nil
+        ).withSpan(span)
+        .asInstanceOf[Apply]
+
+    /**
+      * Records information about a new coverable statement. Generates a unique id for it.
+      *
+      * @param tree the tree to add to the coverage report
+      * @param pos the position to save in the report
+      * @param branch true if it's a branch (branches are considered differently by most coverage analysis tools)
+      * @param ctx the current context
+      * @return the statement's id
+      */
+    private def recordStatement(tree: Tree, pos: SourcePosition, branch: Boolean)(using ctx: Context): Int =
+      val id = statementId
+      statementId += 1
+
+      val sourceFile = pos.source
+      val statement = Statement(
+        location = Location(tree, sourceFile),
+        id = id,
+        start = pos.start,
+        end = pos.end,
+        line = pos.line,
+        desc = sourceFile.content.slice(pos.start, pos.end).mkString,
+        symbolName = tree.symbol.name.toSimpleName.toString,
+        treeName = tree.getClass.getSimpleName.nn,
+        branch
+      )
+      coverage.addStatement(statement)
+      id
+
+    /**
+      * Adds a new statement to the current `Coverage` and creates a corresponding call
+      * to `Invoker.invoke` with its id, and the given position.
+      *
+      * Note that the entire tree won't be saved in the coverage analysis, only some
+      * data related to the tree is recorded (e.g. its type, its parent class, ...).
+      *
+      * @param tree the tree to add to the coverage report
+      * @param pos the position to save in the report
+      * @param branch true if it's a branch
+      * @return the tree corresponding to the call to `Invoker.invoke`
+      */
+    private def createInvokeCall(tree: Tree, pos: SourcePosition, branch: Boolean = false)(using Context): Apply =
+      val statementId = recordStatement(tree, pos, branch)
+      val span = pos.span.toSynthetic
+      invokeCall(statementId, span)
+
+    /**
+      * Tries to instrument an `Apply`.
+      * These "tryInstrument" methods are useful to tweak the generation of coverage instrumentation,
+      * in particular in `case TypeApply` in the [[transform]] method.
+      *
+      * @param tree the tree to instrument
+      * @return instrumentation result, with the preparation statement, coverage call and tree separated
+      */
+    private def tryInstrument(tree: Apply)(using Context): InstrumentedParts =
+      if canInstrumentApply(tree) then
+        // Create a call to Invoker.invoked(coverageDirectory, newStatementId)
+        val coverageCall = createInvokeCall(tree, tree.sourcePos)
+
+        if needsLift(tree) then
+          // Transform args and fun, i.e. instrument them if needed (and if possible)
+          val app = cpy.Apply(tree)(transform(tree.fun), tree.args.map(transform))
+
+          // Lifts the arguments. Note that if only one argument needs to be lifted, we lift them all.
+          // Also, tree.fun can be lifted too.
+          // See LiftCoverage for the internal working of this lifting.
+          val liftedDefs = mutable.ListBuffer[Tree]()
+          val liftedApp = LiftCoverage.liftForCoverage(liftedDefs, app)
+
+          InstrumentedParts(liftedDefs.toList, coverageCall, liftedApp)
+        else
+          // Instrument without lifting
+          val transformed = cpy.Apply(tree)(transform(tree.fun), transform(tree.args))
+          InstrumentedParts.singleExpr(coverageCall, transformed)
+      else
+        // Transform recursively but don't instrument the tree itself
+        val transformed = cpy.Apply(tree)(transform(tree.fun), transform(tree.args))
+        InstrumentedParts.notCovered(transformed)
+
+    private def tryInstrument(tree: Ident)(using Context): InstrumentedParts =
+      val sym = tree.symbol
+      if canInstrumentParameterless(sym) then
+        // call to a local parameterless method f
+        val coverageCall = createInvokeCall(tree, tree.sourcePos)
+        InstrumentedParts.singleExpr(coverageCall, tree)
+      else
+        InstrumentedParts.notCovered(tree)
+
+    private def tryInstrument(tree: Select)(using Context): InstrumentedParts =
+      val sym = tree.symbol
+      val transformed = cpy.Select(tree)(transform(tree.qualifier), tree.name)
+      if canInstrumentParameterless(sym) then
+        // call to a parameterless method
+        val coverageCall = createInvokeCall(tree, tree.sourcePos)
+        InstrumentedParts.singleExpr(coverageCall, transformed)
+      else
+        InstrumentedParts.notCovered(transformed)
+
+    /** Generic tryInstrument */
+    private def tryInstrument(tree: Tree)(using Context): InstrumentedParts =
+      tree match
+        case t: Apply => tryInstrument(t)
+        case t: Ident => tryInstrument(t)
+        case t: Select => tryInstrument(t)
+        case _ => InstrumentedParts.notCovered(transform(tree))
+
+    /**
+     * Transforms and instruments a branch if it's non-empty.
+     * If the tree is empty, return itself and don't instrument.
+     */
+    private def transformBranch(tree: Tree)(using Context): Tree =
+      import dotty.tools.dotc.core.Decorators.{show,i}
+      if tree.isEmpty || tree.span.isSynthetic then
+        // - If t.isEmpty then `transform(t) == t` always hold,
+        //   so we can avoid calling transform in that case.
+        // - If tree.span.isSynthetic then the branch has been generated
+        //   by the frontend phases, so we don't want to instrument it.
+        tree
+      else
+        val transformed = transform(tree)
+        val coverageCall = createInvokeCall(tree, tree.sourcePos, branch = true)
+        InstrumentedParts.singleExprTree(coverageCall, transformed)
+
+    override def transform(tree: Tree)(using Context): Tree =
+      inContext(transformCtx(tree)) { // necessary to position inlined code properly
+        tree match
+          // simple cases
+          case tree: (Import | Export | Literal | This | Super | New) => tree
+          case tree if tree.isEmpty || tree.isType => tree // empty Thicket, Ident (referring to a type), TypeTree, ...
+          case tree if !tree.span.exists || tree.span.isZeroExtent => tree // no meaningful position
+
+          // identifier
+          case tree: Ident =>
+            tryInstrument(tree).toTree
+
+          // branches
+          case tree: If =>
+            cpy.If(tree)(
+              cond = transform(tree.cond),
+              thenp = transformBranch(tree.thenp),
+              elsep = transformBranch(tree.elsep)
+            )
+          case tree: Try =>
+            cpy.Try(tree)(
+              expr = transformBranch(tree.expr),
+              cases = tree.cases.map(transformCaseDef),
+              finalizer = transformBranch(tree.finalizer)
+            )
+
+          // f(args)
+          case tree: Apply =>
+            tryInstrument(tree).toTree
+
+          // (fun)[args]
+          case TypeApply(fun, args) =>
+            // Here is where `InstrumentedParts` becomes useful!
+            // We extract its components and act carefully.
+            val InstrumentedParts(pre, coverageCall, expr) = tryInstrument(fun)
+
+            if coverageCall.isEmpty then
+              // `fun` cannot be instrumented, and `args` is a type so we keep this tree as it is
+              tree
+            else
+              // expr[T] shouldn't be transformed to:
+              // {invoked(...), expr}[T]
+              //
+              // but to:
+              // {invoked(...), expr[T]}
+              //
+              // This is especially important for trees like (expr[T])(args),
+              // for which the wrong transformation crashes the compiler.
+              // See tests/coverage/pos/PolymorphicExtensions.scala
+              Block(
+                pre :+ coverageCall,
+                cpy.TypeApply(tree)(expr, args)
+              )
+
+          // a.b
+          case tree: Select =>
+            tryInstrument(tree).toTree
+
+          case tree: CaseDef =>
+            transformCaseDef(tree)
+
+          case tree: ValDef =>
+            // only transform the rhs
+            val rhs = transform(tree.rhs)
+            cpy.ValDef(tree)(rhs = rhs)
+
+          case tree: DefDef =>
+            transformDefDef(tree)
+
+          case tree: PackageDef =>
+            // only transform the statements of the package
+            cpy.PackageDef(tree)(tree.pid, transform(tree.stats))
+
+          case tree: Assign =>
+            // only transform the rhs
+            cpy.Assign(tree)(tree.lhs, transform(tree.rhs))
+
+          case tree: Return =>
+            // only transform the expr, because `from` is a "pointer"
+            // to the enclosing method, not a tree to instrument.
+            cpy.Return(tree)(expr = transform(tree.expr), from = tree.from)
+
+          case tree: Template =>
+            // only transform:
+            // - the arguments of the `Apply` trees in the parents
+            // - the template body
+            cpy.Template(tree)(
+              transformSub(tree.constr),
+              transformTemplateParents(tree.parents)(using ctx.superCallContext),
+              tree.derived,
+              tree.self,
+              transformStats(tree.body, tree.symbol)
+            )
+
+          case tree: Inlined =>
+            // Ideally, tree.call would provide precise information about the inlined call,
+            // and we would use this information for the coverage report.
+            // But PostTyper simplifies tree.call, so we can't report the actual method that was inlined.
+            // In any case, the subtrees need to be repositioned right now, otherwise the
+            // coverage statement will point to a potentially unreachable source file.
+            val dropped = Inlines.dropInlined(tree) // drop and reposition
+            transform(dropped) // transform the content of the Inlined
+
+          // For everything else just recurse and transform
+          case _ =>
+            super.transform(tree)
+        }
+
+    /** Transforms a `def lhs = rhs` and instruments its body (rhs).
+      *
+      * The rhs is always transformed recursively.
+      *
+      * If possible, a coverage call is inserted at the beginning of the body
+      * (never outside of the DefDef tree). Therefore, this method always returns a `DefDef`.
+      * Thanks to this, it doesn't need to be wrapped in an`InstrumentedParts`.
+      */
+    private def transformDefDef(tree: DefDef)(using Context): DefDef =
+      val sym = tree.symbol
+      if sym.isOneOf(Inline | Erased) then
+        // Inline and erased definitions will not be in the generated code and therefore do not need to be instrumented.
+        // (Note that a retained inline method will have a `$retained` variant that will be instrumented.)
+        tree
+      else
+        // Only transform the params (for the default values) and the rhs, not the name and tpt.
+        val transformedParamss = transformParamss(tree.paramss)
+        val transformedRhs =
+          if !sym.isOneOf(Accessor | Artifact | Synthetic) && !tree.rhs.isEmpty then
+            // If the body can be instrumented, do it (i.e. insert a "coverage call" at the beginning)
+            // This is useful because methods can be stored and called later, or called by reflection,
+            // and if the rhs is too simple to be instrumented (like `def f = this`),
+            // the method won't show up as covered if we don't insert a call at its beginning.
+            instrumentBody(tree, transform(tree.rhs))
+          else
+            transform(tree.rhs)
+
+        cpy.DefDef(tree)(tree.name, transformedParamss, tree.tpt, transformedRhs)
+
+    /** Transforms a `case ...` and instruments the parts that can be. */
+    private def transformCaseDef(tree: CaseDef)(using Context): CaseDef =
+      val pat = tree.pat
+      val guard = tree.guard
+
+      // compute a span that makes sense for the user that will read the coverage results
+      val friendlyEnd = if guard.span.exists then guard.span.end else pat.span.end
+      val pos = tree.sourcePos.withSpan(tree.span.withEnd(friendlyEnd)) // user-friendly span
+
+      // recursively transform the guard, but keep the pat
+      val transformedGuard = transform(guard)
+
+      // ensure that the body is always instrumented by inserting a call to Invoker.invoked at its beginning
+      val coverageCall = createInvokeCall(tree.body, pos)
+      val transformedBody = transform(tree.body)
+      val instrumentedBody = InstrumentedParts.singleExprTree(coverageCall, transformedBody)
+
+      cpy.CaseDef(tree)(pat, transformedGuard, instrumentedBody)
+
+    /** Transforms the parents of a Template. */
+    private def transformTemplateParents(parents: List[Tree])(using Context): List[Tree] =
+      def transformParent(parent: Tree): Tree = parent match
+        case tree: Apply =>
+          // only instrument the args, not the constructor call
+          cpy.Apply(tree)(tree.fun, tree.args.mapConserve(transform))
+        case tree: TypeApply =>
+          // args are types, instrument the fun with transformParent
+          cpy.TypeApply(tree)(transformParent(tree.fun), tree.args)
+        case other =>
+          // should always be a TypeTree, nothing to instrument
+          other
+
+      parents.mapConserve(transformParent)
+
+    /** Instruments the body of a DefDef. Handles corner cases.
+     * Given a DefDef f like this:
+     * ```
+     * def f(params) = rhs
+     * ```
+     *
+     * It generally inserts a "coverage call" before rhs:
+     * ```
+     * def f(params) =
+     *   Invoker.invoked(id, DIR)
+     *   rhs
+     * ```
+     *
+     * But in some cases (e.g. closures), this would be invalid (see the comment below),
+     * and the call is inserted at another place.
+     */
+    private def instrumentBody(parent: DefDef, body: Tree)(using Context): Tree =
+      /* recurse on closures, so that we insert the call at the leaf:
+
+         def g: (a: Ta) ?=> (b: Tb) = {
+           // nothing here             <-- not here!
+           def $anonfun(using a: Ta) =
+             Invoked.invoked(id, DIR)  <-- here
+             <userCode>
+           closure($anonfun)
+         }
+      */
+      body match
+        case b @ Block((meth: DefDef) :: Nil, closure: Closure)
+        if meth.symbol == closure.meth.symbol && defn.isContextFunctionType(body.tpe) =>
+          val instr = cpy.DefDef(meth)(rhs = instrumentBody(parent, meth.rhs))
+          cpy.Block(b)(instr :: Nil, closure)
+        case _ =>
+          // compute user-friendly position to highlight more text in the coverage UI
+          val namePos = parent.namePos
+          val pos = namePos.withSpan(namePos.span.withStart(parent.span.start))
+          // record info and insert call to Invoker.invoked
+          val coverageCall = createInvokeCall(parent, pos)
+          InstrumentedParts.singleExprTree(coverageCall, body)
+
+    /**
+     * Checks if the apply needs a lift in the coverage phase.
+     * In case of a nested application, we have to lift all arguments
+     * Example:
+     * ```
+     * def T(x:Int)(y:Int)
+     * T(f())(1)
+     * ```
+     * should not be changed to {val $x = f(); T($x)}(1) but to {val $x = f(); val $y = 1; T($x)($y)}
+     */
+    private def needsLift(tree: Apply)(using Context): Boolean =
+      def isShortCircuitedOp(sym: Symbol) =
+        sym == defn.Boolean_&& || sym == defn.Boolean_||
+
+      def isUnliftableFun(fun: Tree) =
+        /*
+         * We don't want to lift a || getB(), to avoid calling getB if a is true.
+         * Same idea with a && getB(): if a is false, getB shouldn't be called.
+         *
+         * On top of that, the `s`, `f` and `raw` string interpolators are special-cased
+         * by the compiler and will disappear in phase StringInterpolatorOpt, therefore
+         * they shouldn't be lifted.
+         */
+        val sym = fun.symbol
+        sym.exists && (isShortCircuitedOp(sym) || StringInterpolatorOpt.isCompilerIntrinsic(sym))
+      end
+
+      val fun = tree.fun
+      val nestedApplyNeedsLift = fun match
+        case a: Apply => needsLift(a)
+        case _ => false
+
+      nestedApplyNeedsLift ||
+      !isUnliftableFun(fun) && !tree.args.isEmpty && !tree.args.forall(LiftCoverage.noLift)
+
+    /** Check if an Apply can be instrumented. Prevents this phase from generating incorrect code. */
+    private def canInstrumentApply(tree: Apply)(using Context): Boolean =
+      val sym = tree.symbol
+      !sym.isOneOf(ExcludeMethodFlags)
+      && !isCompilerIntrinsicMethod(sym)
+      && (tree.typeOpt match
+        case AppliedType(tycon: NamedType, _) =>
+          /* If the last expression in a block is a context function, we'll try to
+             summon its arguments at the current point, even if the expected type
+             is a function application. Therefore, this is not valid:
+            ```
+            def f = (t: Exception) ?=> (c: String) ?=> result
+
+            ({
+              invoked()
+              f(using e)
+            })(using s)
+            ```
+          */
+          !tycon.name.isContextFunction
+        case m: MethodType =>
+          /* def f(a: Ta)(b: Tb)
+             f(a)(b)
+
+             Here, f(a)(b) cannot be rewritten to {invoked();f(a)}(b)
+          */
+          false
+        case _ =>
+          true
+      )
+
+    /** Is this the symbol of a parameterless method that we can instrument?
+      * Note: it is crucial that `asInstanceOf` and `isInstanceOf`, among others,
+      * do NOT get instrumented, because that would generate invalid code and crash
+      * in post-erasure checking.
+      */
+    private def canInstrumentParameterless(sym: Symbol)(using Context): Boolean =
+      sym.is(Method, butNot = ExcludeMethodFlags)
+      && sym.info.isParameterless
+      && !isCompilerIntrinsicMethod(sym)
+      && !sym.info.typeSymbol.name.isContextFunction // exclude context functions like in canInstrumentApply
+
+    /** Does sym refer to a "compiler intrinsic" method, which only exist during compilation,
+      * like Any.isInstanceOf?
+      * If this returns true, the call souldn't be instrumented.
+      */
+    private def isCompilerIntrinsicMethod(sym: Symbol)(using Context): Boolean =
+      val owner = sym.maybeOwner
+      owner.exists && (
+        owner.eq(defn.AnyClass) ||
+        owner.isPrimitiveValueClass ||
+        owner.maybeOwner == defn.CompiletimePackageClass
+      )
+
+object InstrumentCoverage:
+  val name: String = "instrumentCoverage"
+  val description: String = "instrument code for coverage checking"
+  val ExcludeMethodFlags: FlagSet = Synthetic | Artifact | Erased
+
+  /**
+   * An instrumented Tree, in 3 parts.
+   * @param pre preparation code, e.g. lifted arguments. May be empty.
+   * @param invokeCall call to Invoker.invoked(dir, id), or an empty tree.
+   * @param expr the instrumented expression, executed just after the invokeCall
+   */
+  case class InstrumentedParts(pre: List[Tree], invokeCall: Apply | EmptyTree.type, expr: Tree):
+    require(pre.isEmpty || (pre.nonEmpty && !invokeCall.isEmpty), "if pre isn't empty then invokeCall shouldn't be empty")
+
+    /** Turns this into an actual Tree. */
+    def toTree(using Context): Tree =
+      if invokeCall.isEmpty then expr
+      else if pre.isEmpty then Block(invokeCall :: Nil, expr)
+      else Block(pre :+ invokeCall, expr)
+
+  object InstrumentedParts:
+    def notCovered(expr: Tree) = InstrumentedParts(Nil, EmptyTree, expr)
+    def singleExpr(invokeCall: Apply, expr: Tree) = InstrumentedParts(Nil, invokeCall, expr)
+
+    /** Shortcut for `singleExpr(call, expr).toTree` */
+    def singleExprTree(invokeCall: Apply, expr: Tree)(using Context): Tree =
+      Block(invokeCall :: Nil, expr)
diff --git a/tests/pos-with-compiler-cc/dotc/transform/Instrumentation.scala b/tests/pos-with-compiler-cc/dotc/transform/Instrumentation.scala
new file mode 100644
index 000000000000..046147f20d82
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/transform/Instrumentation.scala
@@ -0,0 +1,110 @@
+package dotty.tools
+package dotc
+package transform
+
+import core._
+import Contexts._
+import Symbols._
+import Flags._
+
+import Decorators._
+import MegaPhase._
+import Names._
+import Constants.Constant
+
+
+/** The phase is enabled if the -Yinstrument option is set.
+ *  If enabled, it counts the number of closures or allocations for each source position.
+ *  It does this by generating a call to dotty.tools.dotc.util.Stats.doRecord.
+ */
+class Instrumentation extends MiniPhase { thisPhase =>
+  import ast.tpd._
+
+  override def phaseName: String = Instrumentation.name
+
+  override def description: String = Instrumentation.description
+
+  override def isEnabled(using Context) =
+    ctx.settings.Yinstrument.value
+
+  private val collectionNamesOfInterest = List(
+    "map", "flatMap", "filter", "filterNot", "withFilter", "collect", "flatten", "foldLeft", "foldRight", "take",
+    "reverse", "zip", "++", ":::", ":+", "distinct", "dropRight", "takeRight", "groupBy", "groupMap", "init", "inits",
+    "interect", "mkString", "partition", "reverse_:::", "scanLeft", "scanRight",
+    "sortBy", "sortWith", "sorted", "span", "splitAt", "takeWhile", "transpose", "unzip", "unzip3",
+    "updated", "zipAll", "zipWithIndex",
+    "mapConserve", "mapconserve", "filterConserve", "zipWithConserve", "mapWithIndexConserve"
+  )
+
+  private val namesOfInterest = collectionNamesOfInterest ++ List(
+    "::", "+=", "toString", "newArray", "box", "toCharArray", "termName", "typeName",
+    "slice", "staticRef", "requiredClass")
+
+  private var namesToRecord: Set[Name] = _
+  private var collectionNamesToRecord: Set[Name] = _
+  private var Stats_doRecord: Symbol = _
+  private var Stats_doRecordSize: Symbol = _
+  private var CollectionIterableClass: ClassSymbol = _
+
+  override def prepareForUnit(tree: Tree)(using Context): Context =
+    namesToRecord = namesOfInterest.map(_.toTermName).toSet
+    collectionNamesToRecord = collectionNamesOfInterest.map(_.toTermName).toSet
+    val StatsModule = requiredModule("dotty.tools.dotc.util.Stats")
+    Stats_doRecord = StatsModule.requiredMethod("doRecord")
+    Stats_doRecordSize = StatsModule.requiredMethod("doRecordSize")
+    CollectionIterableClass = requiredClass("scala.collection.Iterable")
+    ctx
+
+  private def record(category: String, tree: Tree)(using Context): Tree = {
+    val key = Literal(Constant(s"$category@${tree.sourcePos.show}"))
+    ref(Stats_doRecord).appliedTo(key, Literal(Constant(1)))
+  }
+
+  private def recordSize(tree: Apply)(using Context): Tree = tree.fun match
+    case sel @ Select(qual, name)
+    if collectionNamesToRecord.contains(name)
+       && qual.tpe.widen.derivesFrom(CollectionIterableClass) =>
+      val key = Literal(Constant(s"totalSize/${name} in ${qual.tpe.widen.classSymbol.name}@${tree.sourcePos.show}"))
+      val qual1 = ref(Stats_doRecordSize).appliedTo(key, qual).cast(qual.tpe.widen)
+      cpy.Apply(tree)(cpy.Select(sel)(qual1, name), tree.args)
+    case _ =>
+      tree
+
+  private def ok(using Context) =
+    !ctx.owner.ownersIterator.exists(_.name.toString.startsWith("Stats"))
+
+  override def transformDefDef(tree: DefDef)(using Context): Tree =
+    val sym = tree.symbol
+    if ctx.settings.YinstrumentDefs.value
+      && ok
+      && sym.exists
+      && !sym.isOneOf(Synthetic | Artifact)
+    then
+      def icall = record(i"method/${sym.fullName}", tree)
+      def rhs1 = tree.rhs match
+        case rhs @ Block(stats, expr) => cpy.Block(rhs)(icall :: stats, expr)
+        case _: Match | _: If | _: Try | _: Labeled => cpy.Block(tree.rhs)(icall :: Nil, tree.rhs)
+        case rhs => rhs
+      cpy.DefDef(tree)(rhs = rhs1)
+    else tree
+
+  override def transformApply(tree: Apply)(using Context): Tree = tree.fun match {
+    case Select(nu: New, _) =>
+      cpy.Block(tree)(record(i"alloc/${nu.tpe}", tree) :: Nil, tree)
+    case ref: RefTree if namesToRecord.contains(ref.name) && ok =>
+      cpy.Block(tree)(record(i"call/${ref.name}", tree) :: Nil, recordSize(tree))
+    case _ =>
+      tree
+  }
+
+  override def transformBlock(tree: Block)(using Context): Block = tree.expr match {
+    case _: Closure =>
+      cpy.Block(tree)(record("closure/", tree) :: tree.stats, tree.expr)
+    case _ =>
+      tree
+  }
+}
+
+object Instrumentation:
+  val name: String = "instrumentation"
+  val description: String = "count calls and allocations under -Yinstrument"
diff --git a/tests/pos-with-compiler-cc/dotc/transform/InterceptedMethods.scala b/tests/pos-with-compiler-cc/dotc/transform/InterceptedMethods.scala
new file mode 100644
index 000000000000..ad068b84c041
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/transform/InterceptedMethods.scala
@@ -0,0 +1,82 @@
+package dotty.tools.dotc
+package transform
+
+import dotty.tools.dotc.ast.tpd
+import dotty.tools.dotc.core.Constants.Constant
+import dotty.tools.dotc.core.Contexts._
+import dotty.tools.dotc.core.Names.TermName
+import dotty.tools.dotc.core.StdNames._
+import dotty.tools.dotc.core.Symbols._
+import dotty.tools.dotc.core.Types._
+import dotty.tools.dotc.transform.MegaPhase.MiniPhase
+
+object InterceptedMethods {
+  val name: String = "intercepted"
+  val description: String = "rewrite universal `!=`, `##` methods"
+}
+
+/** Replace member references as follows:
+  *
+  * - `x != y` for != in class Any becomes `!(x == y)` with == in class Any.
+  * - `x.##` for ## in NullClass becomes `0`
+  * - `x.##` for ## in Any becomes calls to ScalaRunTime.hash,
+  *     using the most precise overload available
+  */
+class InterceptedMethods extends MiniPhase {
+  import tpd._
+
+  override def phaseName: String = InterceptedMethods.name
+
+  override def description: String = InterceptedMethods.description
+
+  // this should be removed if we have guarantee that ## will get Apply node
+  override def transformSelect(tree: tpd.Select)(using Context): Tree =
+    transformRefTree(tree)
+
+  override def transformIdent(tree: tpd.Ident)(using Context): Tree =
+    transformRefTree(tree)
+
+  private def transformRefTree(tree: RefTree)(using Context): Tree =
+    if (tree.symbol.isTerm && (defn.Any_## eq tree.symbol)) {
+      val qual = tree match {
+        case id: Ident => tpd.desugarIdentPrefix(id)
+        case sel: Select => sel.qualifier
+      }
+      val rewritten = poundPoundValue(qual)
+      report.log(s"$phaseName rewrote $tree to $rewritten")
+      rewritten
+    }
+    else tree
+
+  // TODO: add missing cases from scalac
+  private def poundPoundValue(tree: Tree)(using Context) = {
+    val s = tree.tpe.typeSymbol
+
+    def staticsCall(methodName: TermName): Tree =
+      ref(defn.staticsMethodRef(methodName)).appliedTo(tree)
+
+    if (s == defn.NullClass) Literal(Constant(0))
+    else if (s == defn.DoubleClass) staticsCall(nme.doubleHash)
+    else if (s == defn.LongClass) staticsCall(nme.longHash)
+    else if (s == defn.FloatClass) staticsCall(nme.floatHash)
+    else staticsCall(nme.anyHash)
+  }
+
+  override def transformApply(tree: Apply)(using Context): Tree = {
+    lazy val qual = tree.fun match {
+      case Select(qual, _) => qual
+      case ident @ Ident(_) =>
+        ident.tpe match {
+          case TermRef(prefix: TermRef, _) =>
+            tpd.ref(prefix)
+          case TermRef(prefix: ThisType, _) =>
+            tpd.This(prefix.cls)
+        }
+    }
+
+    if tree.fun.symbol == defn.Any_!= then
+      qual.select(defn.Any_==).appliedToTermArgs(tree.args).select(defn.Boolean_!).withSpan(tree.span)
+    else
+      tree
+  }
+}
diff --git a/tests/pos-with-compiler-cc/dotc/transform/IsInstanceOfEvaluator.scala.disabled b/tests/pos-with-compiler-cc/dotc/transform/IsInstanceOfEvaluator.scala.disabled
new file mode 100644
index 000000000000..68b493a0b9db
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/transform/IsInstanceOfEvaluator.scala.disabled
@@ -0,0 +1,172 @@
+package dotty.tools.dotc
+package transform
+
+import dotty.tools.dotc.util.Positions._
+import MegaPhase.MiniPhase
+import core._
+import Contexts._, Types._, Constants._, Decorators._, Symbols._
+import TypeUtils._, TypeErasure._, Flags._
+
+/** Implements partial evaluation of `sc.isInstanceOf[Sel]` according to:
+ *
+ *  | Sel\sc      | trait                      | class                      | final class      |
+ *  | ----------: | :------------------------: | :------------------------: | :--------------: |
+ *  | trait       |               ?            |               ?            | statically known |
+ *  | class       |               ?            | false if classes unrelated | statically known |
+ *  | final class | false if classes unrelated | false if classes unrelated | statically known |
+ *
+ *  This is a generalized solution to raising an error on unreachable match
+ *  cases and warnings on other statically known results of `isInstanceOf`.
+ *
+ *  Steps taken:
+ *
+ *  1. `evalTypeTest` will establish the matrix and choose the appropriate
+ *     handling for the case:
+ *      - Sel/sc is a value class or scrutinee is `Any`
+ *      - `handleStaticallyKnown`
+ *      - `falseIfUnrelated` with `scrutinee <:< selector`
+ *      - `handleFalseUnrelated`
+ *      - leave as is (`happens`)
+ *  2. Rewrite according to steps taken in 1
+ */
+class IsInstanceOfEvaluator extends MiniPhase {
+
+  import dotty.tools.dotc.ast.tpd._
+
+  val phaseName = "isInstanceOfEvaluator"
+
+  /** Transforms a [TypeApply](dotty.tools.dotc.ast.Trees.TypeApply) in order to
+   *  evaluate an `isInstanceOf` check according to the rules defined above.
+   */
+  override def transformTypeApply(tree: TypeApply)(using Context): Tree = {
+    val defn = ctx.definitions
+
+    /** Handles the four cases of statically known `isInstanceOf`s and gives
+     *  the correct warnings, or an error if statically known to be false in
+     *  match
+     */
+    def handleStaticallyKnown(qualifier: Tree, scrutinee: Type, selector: Type, inMatch: Boolean, pos: Position): Tree = {
+      val scrutineeSubSelector = scrutinee <:< selector
+      if (!scrutineeSubSelector && inMatch) {
+        report.error(
+          s"this case is unreachable due to `${selector.show}` not being a subclass of `${scrutinee.show}`",
+          Span(pos.start - 5, pos.end - 5)
+        )
+        rewrite(qualifier, to = false)
+      } else if (!scrutineeSubSelector && !inMatch) {
+        report.warning(
+          s"this will always yield false since `${scrutinee.show}` is not a subclass of `${selector.show}` (will be optimized away)",
+          pos
+        )
+        rewrite(qualifier, to = false)
+      } else if (scrutineeSubSelector && !inMatch) {
+        report.warning(
+          s"this will always yield true if the scrutinee is non-null, since `${scrutinee.show}` is a subclass of `${selector.show}` (will be optimized away)",
+          pos
+        )
+        rewrite(qualifier, to = true)
+      } else /* if (scrutineeSubSelector && inMatch) */ rewrite(qualifier, to = true)
+    }
+
+    /** Rewrites cases with unrelated types */
+    def handleFalseUnrelated(qualifier: Tree, scrutinee: Type, selector: Type, inMatch: Boolean) =
+      if (inMatch) {
+        report.error(
+          s"will never match since `${selector.show}` is not a subclass of `${scrutinee.show}`",
+          Span(qualifier.pos.start - 5, qualifier.pos.end - 5) // WHY 5?
+        )
+        rewrite(qualifier, to = false)
+      } else {
+        report.warning(
+          s"will always yield false since `${scrutinee.show}` is not a subclass of `${selector.show}`",
+          tree.pos
+        )
+        rewrite(qualifier, to = false)
+      }
+
+    /** Rewrites the qualifier of a type test to a boolean if `to` is false or if the qualifier
+     *  is a value class.
+     *
+     *  If `to` is set to true and the qualifier is not a primitive, the
+     *  instanceOf is replaced by a null check, since:
+     *
+     *  `scutinee == null` implies `!scrutinee.isInstanceOf[Selector]`
+     */
+    def rewrite(qualifier: Tree, to: Boolean): Tree =
+      if (to && !qualifier.tpe.isNotNull) qualifier.testNotNull
+      else {
+        val literal = Literal(Constant(to))
+        if (!isPureExpr(qualifier)) Block(List(qualifier), literal)
+        else literal
+      }
+
+    /** Attempts to rewrite type test to either `scrutinee ne null` or a
+     *  constant. Any_typeTest nodes have been rewritten to Any_isInstanceOf at this point.
+     *  @param   tree       the whole type test <qualifier>.asInstanceOf[T]
+     *  @param   qualifier  the <qualifier> part
+     *  @param   inMatch    tree was a type test generated by a pattern match.
+     */
+    def evalTypeTest(tree: TypeApply, qualifier: Tree, inMatch: Boolean) = {
+      val scrutinee = erasure(qualifier.tpe.widen)
+      val selector  = erasure(tree.args.head.tpe.widen)
+
+      val scTrait = scrutinee.typeSymbol is Trait
+      val scClass =
+        scrutinee.typeSymbol.isClass &&
+        !(scrutinee.typeSymbol is Trait) &&
+        !(scrutinee.typeSymbol is Module)
+
+      val scClassNonFinal = scClass && !(scrutinee.typeSymbol is Final)
+      val scFinalClass    = scClass && (scrutinee.typeSymbol is Final)
+
+      val selTrait = selector.typeSymbol is Trait
+      val selClass =
+        selector.typeSymbol.isClass &&
+        !(selector.typeSymbol is Trait) &&
+        !(selector.typeSymbol is Module)
+
+      val selClassNonFinal = selClass && !(selector.typeSymbol is Final)
+      val selFinalClass    = selClass && (selector.typeSymbol is Final)
+
+      // Cases ---------------------------------
+      val valueClassesOrAny =
+        ValueClasses.isDerivedValueClass(scrutinee.typeSymbol) ||
+        ValueClasses.isDerivedValueClass(selector.typeSymbol)  ||
+        scrutinee == defn.ObjectType
+
+      val knownStatically = scFinalClass
+
+      val falseIfUnrelated =
+        (scClassNonFinal && selClassNonFinal) ||
+        (scClassNonFinal && selFinalClass)    ||
+        (scTrait && selFinalClass)
+
+      val happens =
+        (scClassNonFinal && selClassNonFinal) ||
+        (scTrait && selClassNonFinal)         ||
+        (scTrait && selTrait)
+
+      if (valueClassesOrAny) tree
+      else if (knownStatically)
+        handleStaticallyKnown(qualifier, scrutinee, selector, inMatch, tree.pos)
+      else if (falseIfUnrelated && scrutinee <:< selector)
+        // scrutinee is a subtype of the selector, safe to rewrite
+        rewrite(qualifier, to = true)
+      else if (falseIfUnrelated && !(selector <:< scrutinee))
+        // selector and scrutinee are unrelated
+        handleFalseUnrelated(qualifier, scrutinee, selector, inMatch)
+      else if (happens) tree
+      else tree
+    }
+
+    tree.fun match {
+      case fn: Select if fn.symbol == defn.Any_typeTest =>
+        evalTypeTest(
+          cpy.TypeApply(tree)(fn.qualifier.select(defn.Any_isInstanceOf), tree.args),
+          fn.qualifier, inMatch = true)
+      case fn: Select if fn.symbol == defn.Any_isInstanceOf =>
+        evalTypeTest(tree, fn.qualifier, inMatch = false)
+      case _ => tree
+    }
+  }
+}
diff --git a/tests/pos-with-compiler-cc/dotc/transform/LambdaLift.scala b/tests/pos-with-compiler-cc/dotc/transform/LambdaLift.scala
new file mode 100644
index 000000000000..6ec0f330efff
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/transform/LambdaLift.scala
@@ -0,0 +1,341 @@
+package dotty.tools.dotc
+package transform
+
+import MegaPhase._
+import core.Denotations.NonSymSingleDenotation
+import core.DenotTransformers._
+import core.Symbols._
+import core.Contexts._
+import core.Types._
+import core.Flags._
+import core.Decorators._
+import core.StdNames.nme
+import core.Names._
+import core.NameOps._
+import core.NameKinds.ExpandPrefixName
+import SymUtils._
+import ExplicitOuter.outer
+import util.Store
+import collection.mutable.{HashMap, LinkedHashMap, ListBuffer}
+
+object LambdaLift:
+  import ast.tpd._
+
+  val name: String = "lambdaLift"
+  val description: String = "lifts out nested functions to class scope"
+
+  /** The core lambda lift functionality. */
+  class Lifter(thisPhase: MiniPhase & DenotTransformer)(using Context):
+
+    /** The outer parameter of a constructor */
+    private val outerParam = new HashMap[Symbol, Symbol]
+
+    /** Buffers for lifted out classes and methods, indexed by owner */
+    val liftedDefs: HashMap[Symbol, ListBuffer[Tree]] = new HashMap
+
+    val deps = new Dependencies(ctx.compilationUnit.tpdTree, ctx.withPhase(thisPhase)):
+      def isExpr(sym: Symbol)(using Context): Boolean = sym.is(Method)
+      def enclosure(using Context) = ctx.owner.enclosingMethod
+
+      override def process(tree: Tree)(using Context): Unit =
+        super.process(tree)
+        tree match
+          case tree: DefDef if tree.symbol.isConstructor =>
+            tree.termParamss.head.find(_.name == nme.OUTER) match
+              case Some(vdef) => outerParam(tree.symbol) = vdef.symbol
+              case _ =>
+          case tree: Template =>
+            liftedDefs(tree.symbol.owner) = new ListBuffer
+          case _ =>
+    end deps
+
+    /** A map storing the free variable proxies of functions and classes.
+     *  For every function and class, this is a map from the free variables
+     *  of that function or class to the proxy symbols accessing them.
+     */
+    private val proxyMap = new LinkedHashMap[Symbol, Map[Symbol, Symbol]]
+
+    def proxyOf(sym: Symbol, fv: Symbol): Symbol = proxyMap.getOrElse(sym, Map.empty)(fv)
+
+    def proxies(sym: Symbol): List[Symbol] =
+      deps.freeVars(sym).toList.map(proxyOf(sym, _))
+
+    private def newName(sym: Symbol)(using Context): Name =
+      if (sym.isAnonymousFunction && sym.owner.is(Method))
+        sym.name.replace {
+          case name: SimpleName => ExpandPrefixName(sym.owner.name.asTermName, name)
+        }.freshened
+      else sym.name.freshened
+
+    private def generateProxies()(using Context): Unit =
+      for owner <- deps.tracked do
+        val fvs = deps.freeVars(owner).toList
+        val newFlags = Synthetic | (if (owner.isClass) PrivateParamAccessor else Param)
+        report.debuglog(i"free var proxy of ${owner.showLocated}: $fvs%, %")
+        val freeProxyPairs =
+          for fv <- fvs yield
+            val proxyName = newName(fv)
+            val proxy =
+              newSymbol(owner, proxyName.asTermName, newFlags, fv.info, coord = fv.coord)
+                .enteredAfter(thisPhase)
+            (fv, proxy)
+        proxyMap(owner) = freeProxyPairs.toMap
+
+    private def liftedInfo(local: Symbol)(using Context): Type = local.info match {
+      case MethodTpe(pnames, ptypes, restpe) =>
+        val ps = proxies(local)
+        MethodType(
+          ps.map(_.name.asTermName) ++ pnames,
+          ps.map(_.info) ++ ptypes,
+          restpe)
+      case info => info
+    }
+
+    private def liftLocals()(using Context): Unit = {
+      for ((local, lOwner) <- deps.logicalOwner) {
+        val (newOwner, maybeStatic) =
+          if lOwner is Package then (local.topLevelClass, JavaStatic)
+          else (lOwner, EmptyFlags)
+        // Drop Module because class is no longer a singleton in the lifted context.
+        var initFlags = local.flags &~ Module | Private | Lifted | maybeStatic
+        if (local is Method)
+          if (newOwner is Trait)
+            // Drop Final when a method is lifted into a trait.
+            // According to the JVM specification, a method declared inside interface cannot have the final flag.
+            // "Methods of interfaces may have any of the flags in Table 4.6-A set except ACC_PROTECTED, ACC_FINAL, ..."
+            // (https://docs.oracle.com/javase/specs/jvms/se8/html/jvms-4.html#jvms-4.6)
+            initFlags = initFlags &~ Final
+          else
+            // Add Final when a method is lifted into a class.
+            initFlags = initFlags | Final
+        local.copySymDenotation(
+          owner = newOwner,
+          name = newName(local),
+          initFlags = initFlags,
+          info = liftedInfo(local)).installAfter(thisPhase)
+      }
+      for (local <- deps.tracked)
+        if (!deps.logicalOwner.contains(local))
+          local.copySymDenotation(info = liftedInfo(local)).installAfter(thisPhase)
+    }
+
+    def currentEnclosure(using Context): Symbol =
+      ctx.owner.enclosingMethodOrClass
+
+    private def inCurrentOwner(sym: Symbol)(using Context) =
+      sym.enclosure == currentEnclosure
+
+    private def proxy(sym: Symbol)(using Context): Symbol = {
+      def liftedEnclosure(sym: Symbol) =
+        deps.logicalOwner.getOrElse(sym, sym.enclosure)
+      def searchIn(enclosure: Symbol): Symbol = {
+        if (!enclosure.exists) {
+          def enclosures(encl: Symbol): List[Symbol] =
+            if (encl.exists) encl :: enclosures(liftedEnclosure(encl)) else Nil
+          throw new IllegalArgumentException(i"Could not find proxy for ${sym.showDcl} in ${sym.ownersIterator.toList}, encl = $currentEnclosure, owners = ${currentEnclosure.ownersIterator.toList}%, %; enclosures = ${enclosures(currentEnclosure)}%, %")
+        }
+        report.debuglog(i"searching for $sym(${sym.owner}) in $enclosure")
+        proxyMap get enclosure match {
+          case Some(pmap) =>
+            pmap get sym match {
+              case Some(proxy) => return proxy
+              case none =>
+            }
+          case none =>
+        }
+        searchIn(liftedEnclosure(enclosure))
+      }
+      if (inCurrentOwner(sym)) sym else searchIn(currentEnclosure)
+    }
+
+    def memberRef(sym: Symbol)(using Context): Tree = {
+      val clazz = sym.enclosingClass
+      val qual =
+        if (clazz.isStaticOwner || ctx.owner.enclosingClass == clazz)
+          singleton(clazz.thisType)
+        else if (ctx.owner.isConstructor)
+          outerParam.get(ctx.owner) match {
+            case Some(param) => outer.path(start = Ident(param.termRef), toCls = clazz)
+            case _ => outer.path(toCls = clazz)
+          }
+        else outer.path(toCls = clazz)
+      thisPhase.transformFollowingDeep(qual.select(sym))
+    }
+
+    def proxyRef(sym: Symbol)(using Context): Tree = {
+      val psym = atPhase(thisPhase)(proxy(sym))
+      thisPhase.transformFollowingDeep(if (psym.owner.isTerm) ref(psym) else memberRef(psym))
+    }
+
+    def addFreeArgs(sym: Symbol, args: List[Tree])(using Context): List[Tree] =
+      val fvs = deps.freeVars(sym)
+      if fvs.nonEmpty then fvs.toList.map(proxyRef(_)) ++ args else args
+
+    def addFreeParams(tree: Tree, proxies: List[Symbol])(using Context): Tree = proxies match {
+      case Nil => tree
+      case proxies =>
+        val sym = tree.symbol
+        val freeParamDefs = proxies.map(proxy =>
+          thisPhase.transformFollowingDeep(ValDef(proxy.asTerm).withSpan(tree.span)).asInstanceOf[ValDef])
+        def proxyInit(field: Symbol, param: Symbol) =
+          thisPhase.transformFollowingDeep(memberRef(field).becomes(ref(param)))
+
+        /** Initialize proxy fields from proxy parameters and map `rhs` from fields to parameters */
+        def copyParams(rhs: Tree) = {
+          val fvs = deps.freeVars(sym.owner).toList
+          val classProxies = fvs.map(proxyOf(sym.owner, _))
+          val constrProxies = fvs.map(proxyOf(sym, _))
+          report.debuglog(i"copy params ${constrProxies.map(_.showLocated)}%, % to ${classProxies.map(_.showLocated)}%, %}")
+          seq(classProxies.lazyZip(constrProxies).map(proxyInit), rhs)
+        }
+
+        tree match {
+          case tree: DefDef =>
+            cpy.DefDef(tree)(
+                paramss = tree.termParamss.map(freeParamDefs ++ _),
+                rhs =
+                  if (sym.isPrimaryConstructor && !sym.owner.is(Trait)) copyParams(tree.rhs)
+                  else tree.rhs)
+          case tree: Template =>
+            cpy.Template(tree)(body = freeParamDefs ++ tree.body)
+        }
+    }
+
+    def liftDef(tree: MemberDef)(using Context): Tree = {
+      val buf = liftedDefs(tree.symbol.owner)
+      thisPhase.transformFollowing(rename(tree, tree.symbol.name)).foreachInThicket(buf += _)
+      EmptyTree
+    }
+
+    def needsLifting(sym: Symbol): Boolean = deps.logicalOwner.contains(sym)
+
+    // initialization
+    atPhase(thisPhase.next) {
+      generateProxies()
+      liftLocals()
+    }
+  end Lifter
+end LambdaLift
+
+/** This phase performs the necessary rewritings to eliminate classes and methods
+ *  nested in other methods. In detail:
+ *   1. It adds all free variables of local functions as additional parameters (proxies).
+ *   2. It rebinds references to free variables to the corresponding proxies,
+ *   3. It lifts all local functions and classes out as far as possible, but at least
+ *      to the enclosing class.
+ *   4. It stores free variables of non-trait classes as additional fields of the class.
+ *      The fields serve as proxies for methods in the class, which avoids the need
+ *      of passing additional parameters to these methods.
+ *
+ *  A particularly tricky case are local traits. These cannot store free variables
+ *  as field proxies, because LambdaLift runs after Mixin, so the fields cannot be
+ *  expanded anymore. Instead, methods of local traits get free variables of
+ *  the trait as additional proxy parameters. The difference between local classes
+ *  and local traits is illustrated by the two rewritings below.
+ *
+ *     def f(x: Int) = {           def f(x: Int) = new C(x).f2
+ *       class C {          ==>    class C(x$1: Int) {
+ *         def f2 = x                def f2 = x$1
+ *       }                         }
+ *       new C().f2
+ *     }
+ *
+ *     def f(x: Int) = {           def f(x: Int) = new C().f2(x)
+ *       trait T {          ==>    trait T
+ *         def f2 = x                def f2(x$1: Int) = x$1
+ *       }                         }
+ *       class C extends T         class C extends T
+ *       new C().f2
+ *     }
+ */
+class LambdaLift extends MiniPhase with IdentityDenotTransformer { thisPhase =>
+  import LambdaLift._
+  import ast.tpd._
+
+  override def phaseName: String = LambdaLift.name
+
+  override def description: String = LambdaLift.description
+
+  override def relaxedTypingInGroup: Boolean = true
+    // Because it adds free vars as additional proxy parameters
+
+  override def runsAfterGroupsOf: Set[String] = Set(Constructors.name, HoistSuperArgs.name)
+    // Constructors has to happen before LambdaLift because the lambda lift logic
+    // becomes simpler if it can assume that parameter accessors have already been
+    // converted to parameters in super calls. Without this it is very hard to get
+    // lambda lift for super calls right. Witness the implementation restrictions to
+    // this effect in scalac.
+
+  private var Lifter: Store.Location[Lifter] = _
+  private def lifter(using Context) = ctx.store(Lifter)
+
+  override def initContext(ctx: FreshContext): Unit =
+    Lifter = ctx.addLocation[Lifter]()
+
+  override def prepareForUnit(tree: Tree)(using Context): Context =
+    ctx.fresh.updateStore(Lifter, new Lifter(thisPhase))
+
+  override def transformIdent(tree: Ident)(using Context): Tree = {
+    val sym = tree.symbol
+    tree.tpe match {
+      case tpe @ TermRef(prefix, _) =>
+        val lft = lifter
+        if (prefix eq NoPrefix)
+          if (sym.enclosure != lft.currentEnclosure && !sym.isStatic)
+            (if (sym is Method) lft.memberRef(sym) else lft.proxyRef(sym)).withSpan(tree.span)
+          else if (sym.owner.isClass) // sym was lifted out
+            ref(sym).withSpan(tree.span)
+          else
+            tree
+        else if (!prefixIsElidable(tpe)) ref(tpe)
+        else tree
+      case _ =>
+        tree
+    }
+  }
+
+  override def transformSelect(tree: Select)(using Context): Tree =
+    val denot = tree.denot
+    val sym = tree.symbol
+    // The Lifter updates the type of symbols using `installAfter` to give them a
+    // new `SymDenotation`, but that doesn't affect non-sym denotations, so we
+    // reload them manually here.
+    // Note: If you tweak this code, make sure to test your changes with
+    // `Config.reuseSymDenotations` set to false to exercise this path more.
+    if denot.isInstanceOf[NonSymSingleDenotation] && lifter.deps.freeVars(sym).nonEmpty then
+      tree.qualifier.select(sym).withSpan(tree.span)
+    else tree
+
+  override def transformApply(tree: Apply)(using Context): Apply =
+    cpy.Apply(tree)(tree.fun, lifter.addFreeArgs(tree.symbol, tree.args)).withSpan(tree.span)
+
+  override def transformClosure(tree: Closure)(using Context): Closure =
+    cpy.Closure(tree)(env = lifter.addFreeArgs(tree.meth.symbol, tree.env))
+
+  override def transformDefDef(tree: DefDef)(using Context): Tree = {
+    val sym = tree.symbol
+    val lft = lifter
+    val paramsAdded =
+      if lft.deps.freeVars(sym).nonEmpty then lft.addFreeParams(tree, lft.proxies(sym)).asInstanceOf[DefDef]
+      else tree
+    if (lft.needsLifting(sym)) lft.liftDef(paramsAdded)
+    else paramsAdded
+  }
+
+  override def transformReturn(tree: Return)(using Context): Tree = tree.expr match {
+    case Block(stats, value) =>
+      Block(stats, Return(value, tree.from)).withSpan(tree.span)
+    case _ =>
+      tree
+  }
+
+  override def transformTemplate(tree: Template)(using Context): Template = {
+    val cls = ctx.owner
+    val lft = lifter
+    val impl = lft.addFreeParams(tree, lft.proxies(cls)).asInstanceOf[Template]
+    cpy.Template(impl)(body = impl.body ++ lft.liftedDefs.remove(cls).get)
+  }
+
+  override def transformTypeDef(tree: TypeDef)(using Context): Tree =
+    if (lifter.needsLifting(tree.symbol)) lifter.liftDef(tree) else tree
+}
diff --git a/tests/pos-with-compiler-cc/dotc/transform/LazyVals.scala b/tests/pos-with-compiler-cc/dotc/transform/LazyVals.scala
new file mode 100644
index 000000000000..c32ea61cff2b
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/transform/LazyVals.scala
@@ -0,0 +1,470 @@
+package dotty.tools.dotc
+package transform
+
+import java.util.IdentityHashMap
+
+import ast.tpd
+import core.Annotations.Annotation
+import core.Constants.Constant
+import core.Contexts._
+import core.Decorators._
+import core.DenotTransformers.IdentityDenotTransformer
+import core.Flags._
+import core.NameKinds.{LazyBitMapName, LazyLocalInitName, LazyLocalName, ExpandedName}
+import core.StdNames.nme
+import core.Symbols._
+import core.Types._
+import core.{Names, StdNames}
+import transform.MegaPhase.MiniPhase
+import transform.SymUtils._
+import scala.collection.mutable
+
+class LazyVals extends MiniPhase with IdentityDenotTransformer {
+  import LazyVals._
+  import tpd._
+
+  /** this map contains mutable state of transformation: OffsetDefs to be appended to companion object definitions,
+    * and number of bits currently used */
+  class OffsetInfo(var defs: List[Tree], var ord:Int)
+  private val appendOffsetDefs = mutable.Map.empty[Symbol, OffsetInfo]
+
+  override def phaseName: String = LazyVals.name
+
+  override def description: String = LazyVals.description
+
+  /** List of names of phases that should have finished processing of tree
+    * before this phase starts processing same tree */
+  override def runsAfter: Set[String] = Set(Mixin.name, CollectNullableFields.name)
+
+  override def changesMembers: Boolean = true  // the phase adds lazy val accessors
+
+  val containerFlags: FlagSet = Synthetic | Mutable | Lazy
+  val initFlags: FlagSet      = Synthetic | Method
+
+  val containerFlagsMask: FlagSet = Method | Lazy | Accessor | Module
+
+  /** A map of lazy values to the fields they should null after initialization. */
+  private var lazyValNullables: IdentityHashMap[Symbol, mutable.ListBuffer[Symbol]] | Null = _
+  private def nullableFor(sym: Symbol)(using Context) = {
+    // optimisation: value only used once, we can remove the value from the map
+    val nullables = lazyValNullables.nn.remove(sym)
+    if (nullables == null) Nil
+    else nullables.toList
+  }
+
+
+  override def prepareForUnit(tree: Tree)(using Context): Context = {
+    if (lazyValNullables == null)
+      lazyValNullables = ctx.base.collectNullableFieldsPhase.asInstanceOf[CollectNullableFields].lazyValNullables
+    ctx
+  }
+
+  override def transformDefDef(tree: DefDef)(using Context): Tree =
+   transformLazyVal(tree)
+
+
+  override def transformValDef(tree: ValDef)(using Context): Tree =
+    transformLazyVal(tree)
+
+  def transformLazyVal(tree: ValOrDefDef)(using Context): Tree = {
+    val sym = tree.symbol
+    if (!sym.is(Lazy) ||
+        sym.owner.is(Trait) || // val is accessor, lazy field will be implemented in subclass
+        (sym.isStatic && sym.is(Module, butNot = Method))) // static module vals are implemented in the JVM by lazy loading
+      tree
+    else {
+      val isField = sym.owner.isClass
+      if (isField)
+        if sym.isAllOf(SyntheticModule)
+           && sym.allOverriddenSymbols.isEmpty
+           && !sym.name.is(ExpandedName) then
+          // I am not sure what the conditions for this optimization should be.
+          // It was applied for all synthetic objects, but this is clearly false, as t704 demonstrates.
+          // It seems we have to at least exclude synthetic objects that derive from mixins.
+          // This is done by demanding that the object does not override anything.
+          // Figuring out whether a symbol implements a trait module is not so simple.
+          // For non-private trait members we can check whether there is an overridden symbol.
+          // For private trait members this does not work, since `ensureNotPrivate` in phase Mixins
+          // does change the name but does not update the owner's scope, so `allOverriddenSymbols` does
+          // not work in that case. However, we can check whether the name is an ExpandedName instead.
+          transformSyntheticModule(tree)
+        else if (sym.isThreadUnsafe || ctx.settings.scalajs.value)
+          if (sym.is(Module) && !ctx.settings.scalajs.value) {
+            report.error(em"@threadUnsafe is only supported on lazy vals", sym.srcPos)
+            transformMemberDefThreadSafe(tree)
+          }
+          else
+            transformMemberDefThreadUnsafe(tree)
+        else
+          transformMemberDefThreadSafe(tree)
+      else transformLocalDef(tree)
+    }
+  }
+
+
+  /** Append offset fields to companion objects
+    */
+  override def transformTemplate(template: Template)(using Context): Tree = {
+    val cls = ctx.owner.asClass
+
+    appendOffsetDefs.get(cls) match {
+      case None => template
+      case Some(data) =>
+        data.defs.foreach(_.symbol.addAnnotation(Annotation(defn.ScalaStaticAnnot)))
+        cpy.Template(template)(body = addInFront(data.defs, template.body))
+    }
+  }
+
+
+  private def addInFront(prefix: List[Tree], stats: List[Tree]) = stats match {
+    case first :: rest if isSuperConstrCall(first) => first :: prefix ::: rest
+    case _ => prefix ::: stats
+  }
+
+  /** Make an eager val that would implement synthetic module.
+    * Eager val ensures thread safety and has less code generated.
+    *
+    */
+  def transformSyntheticModule(tree: ValOrDefDef)(using Context): Thicket = {
+    val sym = tree.symbol
+    val holderSymbol = newSymbol(sym.owner, LazyLocalName.fresh(sym.asTerm.name),
+      Synthetic, sym.info.widen.resultType).enteredAfter(this)
+    val field = ValDef(holderSymbol, tree.rhs.changeOwnerAfter(sym, holderSymbol, this))
+    val getter = DefDef(sym.asTerm, ref(holderSymbol))
+    Thicket(field, getter)
+  }
+
+  /** Desugar a local `lazy val x: Int = <RHS>` into:
+   *
+   *  ```
+   *  val x$lzy = new scala.runtime.LazyInt()
+   *
+   *  def x$lzycompute(): Int = x$lzy.synchronized {
+   *    if (x$lzy.initialized()) x$lzy.value()
+   *    else x$lzy.initialize(<RHS>)
+   *      // TODO: Implement Unit-typed lazy val optimization described below
+   *      // for a Unit-typed lazy val, this becomes `{ rhs ; x$lzy.initialize() }`
+   *      // to avoid passing around BoxedUnit
+   *  }
+   *
+   *  def x(): Int = if (x$lzy.initialized()) x$lzy.value() else x$lzycompute()
+   *  ```
+   */
+  def transformLocalDef(x: ValOrDefDef)(using Context): Thicket = {
+    val xname = x.name.asTermName
+    val tpe = x.tpe.widen.resultType.widen
+
+    // val x$lzy = new scala.runtime.LazyInt()
+    val holderName = LazyLocalName.fresh(xname)
+    val holderImpl = defn.LazyHolder()(tpe.typeSymbol)
+    val holderSymbol = newSymbol(x.symbol.owner, holderName, containerFlags, holderImpl.typeRef, coord = x.span)
+    val holderTree = ValDef(holderSymbol, New(holderImpl.typeRef, Nil))
+
+    val holderRef = ref(holderSymbol)
+    val getValue = holderRef.select(lazyNme.value).ensureApplied.withSpan(x.span)
+    val initialized = holderRef.select(lazyNme.initialized).ensureApplied
+
+    // def x$lzycompute(): Int = x$lzy.synchronized {
+    //   if (x$lzy.initialized()) x$lzy.value()
+    //   else x$lzy.initialize(<RHS>)
+    // }
+    val initName = LazyLocalInitName.fresh(xname)
+    val initSymbol = newSymbol(x.symbol.owner, initName, initFlags, MethodType(Nil, tpe), coord = x.span)
+    val rhs = x.rhs.changeOwnerAfter(x.symbol, initSymbol, this)
+    val initialize = holderRef.select(lazyNme.initialize).appliedTo(rhs)
+    val initBody = holderRef
+      .select(defn.Object_synchronized)
+      .appliedToType(tpe)
+      .appliedTo(If(initialized, getValue, initialize).ensureConforms(tpe))
+    val initTree = DefDef(initSymbol, initBody)
+
+    // def x(): Int = if (x$lzy.initialized()) x$lzy.value() else x$lzycompute()
+    val accessorBody = If(initialized, getValue, ref(initSymbol).ensureApplied).ensureConforms(tpe)
+    val accessor = DefDef(x.symbol.asTerm, accessorBody)
+
+    report.debuglog(s"found a lazy val ${x.show},\nrewrote with ${holderTree.show}")
+    Thicket(holderTree, initTree, accessor)
+  }
+
+
+  override def transformStats(trees: List[tpd.Tree])(using Context): List[Tree] = {
+    // backend requires field usage to be after field definition
+    // need to bring containers to start of method
+    val (holders, stats) =
+      trees.partition {
+        _.symbol.flags.&~(Touched) == containerFlags
+        // Filtering out Touched is not required currently, as there are no LazyTypes involved here
+        // but just to be more safe
+      }
+    holders:::stats
+  }
+
+  private def nullOut(nullables: List[Symbol])(using Context): List[Tree] =
+    nullables.map { field =>
+      assert(field.isField)
+      field.setFlag(Mutable)
+      ref(field).becomes(nullLiteral)
+    }
+
+  /** Create thread-unsafe lazy accessor equivalent to such code
+    * ```
+    * def methodSymbol() = {
+    *   if (!flag) {
+    *     target = rhs
+    *     flag = true
+    *     nullable = null
+    *   }
+    *   target
+    * }
+    * ```
+    */
+  def mkThreadUnsafeDef(sym: Symbol, flag: Symbol, target: Symbol, rhs: Tree)(using Context): DefDef = {
+    val targetRef = ref(target)
+    val flagRef = ref(flag)
+    val stats = targetRef.becomes(rhs) :: flagRef.becomes(Literal(Constant(true))) :: nullOut(nullableFor(sym))
+    val init = If(
+      flagRef.ensureApplied.select(nme.UNARY_!).ensureApplied,
+      Block(stats.init, stats.last),
+      unitLiteral
+    )
+    DefDef(sym.asTerm, Block(List(init), targetRef.ensureApplied))
+  }
+
+  /** Create thread-unsafe lazy accessor for not-nullable types  equivalent to such code
+    * ```
+    * def methodSymbol() = {
+    *   if (target eq null) {
+    *     target = rhs
+    *     nullable = null
+    *   }
+    *   target
+    * }
+    * ```
+    */
+  def mkDefThreadUnsafeNonNullable(sym: Symbol, target: Symbol, rhs: Tree)(using Context): DefDef = {
+    val targetRef = ref(target)
+    val stats = targetRef.becomes(rhs) :: nullOut(nullableFor(sym))
+    val init = If(
+      targetRef.select(nme.eq).appliedTo(nullLiteral),
+      Block(stats.init, stats.last),
+      unitLiteral
+    )
+    DefDef(sym.asTerm, Block(List(init), targetRef.ensureApplied))
+  }
+
+  def transformMemberDefThreadUnsafe(x: ValOrDefDef)(using Context): Thicket = {
+    val claz = x.symbol.owner.asClass
+    val tpe = x.tpe.widen.resultType.widen
+    assert(!(x.symbol is Mutable))
+    val containerName = LazyLocalName.fresh(x.name.asTermName)
+    val containerSymbol = newSymbol(claz, containerName,
+      x.symbol.flags &~ containerFlagsMask | containerFlags | Private,
+      tpe, coord = x.symbol.coord
+    ).enteredAfter(this)
+
+    val containerTree = ValDef(containerSymbol, defaultValue(tpe))
+    if (x.tpe.isNotNull && tpe <:< defn.ObjectType)
+      // can use 'null' value instead of flag
+      Thicket(containerTree, mkDefThreadUnsafeNonNullable(x.symbol, containerSymbol, x.rhs))
+    else {
+      val flagName = LazyBitMapName.fresh(x.name.asTermName)
+      val flagSymbol = newSymbol(x.symbol.owner, flagName,  containerFlags | Private, defn.BooleanType).enteredAfter(this)
+      val flag = ValDef(flagSymbol, Literal(Constant(false)))
+      Thicket(containerTree, flag, mkThreadUnsafeDef(x.symbol, flagSymbol, containerSymbol, x.rhs))
+    }
+  }
+
+  /** Create a threadsafe lazy accessor equivalent to such code
+    * ```
+    * def methodSymbol(): Int = {
+    *   while (true) {
+    *     val flag = LazyVals.get(this, bitmap_offset)
+    *     val state = LazyVals.STATE(flag, <field-id>)
+    *
+    *     if (state == <state-3>) {
+    *       return value_0
+    *     } else if (state == <state-0>) {
+    *       if (LazyVals.CAS(this, bitmap_offset, flag, <state-1>, <field-id>)) {
+    *         try {
+    *           val result = <RHS>
+    *           value_0 = result
+    *           nullable = null
+    *           LazyVals.setFlag(this, bitmap_offset, <state-3>, <field-id>)
+    *           return result
+    *         }
+    *         catch {
+    *           case ex =>
+    *             LazyVals.setFlag(this, bitmap_offset, <state-0>, <field-id>)
+    *             throw ex
+    *         }
+    *       }
+    *     } else /* if (state == <state-1> || state == <state-2>) */ {
+    *       LazyVals.wait4Notification(this, bitmap_offset, flag, <field-id>)
+    *     }
+    *   }
+    * }
+    * ```
+    */
+  def mkThreadSafeDef(methodSymbol: TermSymbol,
+                      claz: ClassSymbol,
+                      ord: Int,
+                      target: Symbol,
+                      rhs: Tree,
+                      tp: Type,
+                      offset: Tree,
+                      getFlag: Tree,
+                      stateMask: Tree,
+                      casFlag: Tree,
+                      setFlagState: Tree,
+                      waitOnLock: Tree)(using Context): DefDef = {
+    val initState = Literal(Constant(0))
+    val computeState = Literal(Constant(1))
+    val computedState = Literal(Constant(3))
+
+    val thiz = This(claz)
+    val fieldId = Literal(Constant(ord))
+
+    val flagSymbol = newSymbol(methodSymbol, lazyNme.flag, Synthetic, defn.LongType)
+    val flagDef = ValDef(flagSymbol, getFlag.appliedTo(thiz, offset))
+    val flagRef = ref(flagSymbol)
+
+    val stateSymbol = newSymbol(methodSymbol, lazyNme.state, Synthetic, defn.LongType)
+    val stateDef = ValDef(stateSymbol, stateMask.appliedTo(ref(flagSymbol), Literal(Constant(ord))))
+    val stateRef = ref(stateSymbol)
+
+    val compute = {
+      val resultSymbol = newSymbol(methodSymbol, lazyNme.result, Synthetic, tp)
+      val resultRef = ref(resultSymbol)
+      val stats = (
+        ValDef(resultSymbol, rhs) ::
+        ref(target).becomes(resultRef) ::
+        (nullOut(nullableFor(methodSymbol)) :+
+        setFlagState.appliedTo(thiz, offset, computedState, fieldId))
+      )
+      Block(stats, Return(resultRef, methodSymbol))
+    }
+
+    val retryCase = {
+      val caseSymbol = newSymbol(methodSymbol, nme.DEFAULT_EXCEPTION_NAME, SyntheticCase, defn.ThrowableType)
+      val triggerRetry = setFlagState.appliedTo(thiz, offset, initState, fieldId)
+      CaseDef(
+        Bind(caseSymbol, ref(caseSymbol)),
+        EmptyTree,
+        Block(List(triggerRetry), Throw(ref(caseSymbol)))
+      )
+    }
+
+    val initialize = If(
+      casFlag.appliedTo(thiz, offset, flagRef, computeState, fieldId),
+      Try(compute, List(retryCase), EmptyTree),
+      unitLiteral
+    )
+
+    val condition = If(
+      stateRef.equal(computedState),
+      Return(ref(target), methodSymbol),
+      If(
+        stateRef.equal(initState),
+        initialize,
+        waitOnLock.appliedTo(thiz, offset, flagRef, fieldId)
+      )
+    )
+
+    val loop = WhileDo(EmptyTree, Block(List(flagDef, stateDef), condition))
+    DefDef(methodSymbol, loop)
+  }
+
+  def transformMemberDefThreadSafe(x: ValOrDefDef)(using Context): Thicket = {
+    assert(!(x.symbol is Mutable))
+
+    val tpe = x.tpe.widen.resultType.widen
+    val claz = x.symbol.owner.asClass
+    val thizClass = Literal(Constant(claz.info))
+    val helperModule = requiredModule("scala.runtime.LazyVals")
+    val getOffset = Select(ref(helperModule), lazyNme.RLazyVals.getOffset)
+    val getOffsetStatic = Select(ref(helperModule), lazyNme.RLazyVals.getOffsetStatic)
+    var offsetSymbol: TermSymbol | Null = null
+    var flag: Tree = EmptyTree
+    var ord = 0
+
+    def offsetName(id: Int) = s"${StdNames.nme.LAZY_FIELD_OFFSET}${if (x.symbol.owner.is(Module)) "_m_" else ""}$id".toTermName
+
+    // compute or create appropriate offsetSymbol, bitmap and bits used by current ValDef
+    appendOffsetDefs.get(claz) match {
+      case Some(info) =>
+        val flagsPerLong = (64 / scala.runtime.LazyVals.BITS_PER_LAZY_VAL).toInt
+        info.ord += 1
+        ord = info.ord % flagsPerLong
+        val id = info.ord / flagsPerLong
+        val offsetById = offsetName(id)
+        if (ord != 0) // there are unused bits in already existing flag
+          offsetSymbol = claz.info.decl(offsetById)
+            .suchThat(sym => sym.is(Synthetic) && sym.isTerm)
+             .symbol.asTerm
+        else { // need to create a new flag
+          offsetSymbol = newSymbol(claz, offsetById, Synthetic, defn.LongType).enteredAfter(this)
+          offsetSymbol.nn.addAnnotation(Annotation(defn.ScalaStaticAnnot))
+          val flagName = LazyBitMapName.fresh(id.toString.toTermName)
+          val flagSymbol = newSymbol(claz, flagName, containerFlags, defn.LongType).enteredAfter(this)
+          flag = ValDef(flagSymbol, Literal(Constant(0L)))
+          val fieldTree = thizClass.select(lazyNme.RLazyVals.getDeclaredField).appliedTo(Literal(Constant(flagName.toString)))
+          val offsetTree = ValDef(offsetSymbol.nn, getOffsetStatic.appliedTo(fieldTree))
+          info.defs = offsetTree :: info.defs
+        }
+
+      case None =>
+        offsetSymbol = newSymbol(claz, offsetName(0), Synthetic, defn.LongType).enteredAfter(this)
+        offsetSymbol.nn.addAnnotation(Annotation(defn.ScalaStaticAnnot))
+        val flagName = LazyBitMapName.fresh("0".toTermName)
+        val flagSymbol = newSymbol(claz, flagName, containerFlags, defn.LongType).enteredAfter(this)
+        flag = ValDef(flagSymbol, Literal(Constant(0L)))
+        val fieldTree = thizClass.select(lazyNme.RLazyVals.getDeclaredField).appliedTo(Literal(Constant(flagName.toString)))
+        val offsetTree = ValDef(offsetSymbol.nn, getOffsetStatic.appliedTo(fieldTree))
+        appendOffsetDefs += (claz -> new OffsetInfo(List(offsetTree), ord))
+    }
+
+    val containerName = LazyLocalName.fresh(x.name.asTermName)
+    val containerSymbol = newSymbol(claz, containerName, x.symbol.flags &~ containerFlagsMask | containerFlags, tpe, coord = x.symbol.coord).enteredAfter(this)
+
+    val containerTree = ValDef(containerSymbol, defaultValue(tpe))
+
+    val offset =  ref(offsetSymbol.nn)
+    val getFlag = Select(ref(helperModule), lazyNme.RLazyVals.get)
+    val setFlag = Select(ref(helperModule), lazyNme.RLazyVals.setFlag)
+    val wait =    Select(ref(helperModule), lazyNme.RLazyVals.wait4Notification)
+    val state =   Select(ref(helperModule), lazyNme.RLazyVals.state)
+    val cas =     Select(ref(helperModule), lazyNme.RLazyVals.cas)
+
+    val accessor = mkThreadSafeDef(x.symbol.asTerm, claz, ord, containerSymbol, x.rhs, tpe, offset, getFlag, state, cas, setFlag, wait)
+    if (flag eq EmptyTree)
+      Thicket(containerTree, accessor)
+    else Thicket(containerTree, flag, accessor)
+  }
+}
+
+object LazyVals {
+  val name: String = "lazyVals"
+  val description: String = "expand lazy vals"
+
+  object lazyNme {
+    import Names.TermName
+    object RLazyVals {
+      import scala.runtime.LazyVals.{Names => N}
+      val get: TermName               = N.get.toTermName
+      val setFlag: TermName           = N.setFlag.toTermName
+      val wait4Notification: TermName = N.wait4Notification.toTermName
+      val state: TermName             = N.state.toTermName
+      val cas: TermName               = N.cas.toTermName
+      val getOffset: TermName         = N.getOffset.toTermName
+      val getOffsetStatic: TermName   = "getOffsetStatic".toTermName
+      val getDeclaredField: TermName  = "getDeclaredField".toTermName
+    }
+    val flag: TermName        = "flag".toTermName
+    val state: TermName       = "state".toTermName
+    val result: TermName      = "result".toTermName
+    val value: TermName       = "value".toTermName
+    val initialized: TermName = "initialized".toTermName
+    val initialize: TermName  = "initialize".toTermName
+    val retry: TermName       = "retry".toTermName
+  }
+}
diff --git a/tests/pos-with-compiler-cc/dotc/transform/LetOverApply.scala b/tests/pos-with-compiler-cc/dotc/transform/LetOverApply.scala
new file mode 100644
index 000000000000..e7ff6d10c222
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/transform/LetOverApply.scala
@@ -0,0 +1,37 @@
+package dotty.tools
+package dotc
+package transform
+
+import core._
+import Contexts._, Symbols._, Decorators._
+import MegaPhase._
+
+/** Rewrite `{ stats; expr}.f(args)` to `{ stats; expr.f(args) }` and
+ *  `{ stats; expr }(args)` to `{ stats; expr(args) }` before proceeding,
+ *  but leave closures alone. This is necessary to be able to
+ *  collapse applies of IFTs (this is done in Erasure).
+ */
+class LetOverApply extends MiniPhase:
+  import ast.tpd._
+
+  override def phaseName: String = LetOverApply.name
+
+  override def description: String = LetOverApply.description
+
+  override def transformApply(tree: Apply)(using Context): Tree =
+    tree.fun match
+      case Select(blk @ Block(stats, expr), name) if !expr.isInstanceOf[Closure] =>
+        cpy.Block(blk)(stats,
+          cpy.Apply(tree)(
+            cpy.Select(tree.fun)(expr, name), tree.args))
+      case Block(stats, expr) =>
+        cpy.Block(tree.fun)(stats,
+          cpy.Apply(tree)(expr, tree.args))
+      case _ =>
+        tree
+
+end LetOverApply
+
+object LetOverApply:
+  val name: String = "letOverApply"
+  val description: String = "lift blocks from receivers of applications"
diff --git a/tests/pos-with-compiler-cc/dotc/transform/LiftTry.scala b/tests/pos-with-compiler-cc/dotc/transform/LiftTry.scala
new file mode 100644
index 000000000000..6acb1013d509
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/transform/LiftTry.scala
@@ -0,0 +1,88 @@
+package dotty.tools.dotc
+package transform
+
+import MegaPhase._
+import core.DenotTransformers._
+import core.Symbols._
+import core.Contexts._
+import core.Types._
+import core.Flags._
+import core.Decorators._
+import core.NameKinds.LiftedTreeName
+import NonLocalReturns._
+import util.Store
+
+/** Lifts try's that might be executed on non-empty expression stacks
+ *  to their own methods. I.e.
+ *
+ *      try body catch handler
+ *
+ *  is lifted to
+ *
+ *      { def liftedTree$n() = try body catch handler; liftedTree$n() }
+ *
+ *  However, don't lift try's without catch expressions (try-finally).
+ *  Lifting is needed only for try-catch expressions that are evaluated in a context
+ *  where the stack might not be empty. `finally` does not attempt to continue evaluation
+ *  after an exception, so the fact that values on the stack are 'lost' does not matter
+ *  (copied from https://github.com/scala/scala/pull/922).
+ */
+class LiftTry extends MiniPhase with IdentityDenotTransformer { thisPhase =>
+  import ast.tpd._
+
+  override def phaseName: String = LiftTry.name
+
+  override def description: String = LiftTry.description
+
+  private var NeedLift: Store.Location[Boolean] = _
+  private def needLift(using Context): Boolean = ctx.store(NeedLift)
+
+  override def initContext(ctx: FreshContext): Unit =
+    NeedLift = ctx.addLocation(false)
+
+  private def liftingCtx(p: Boolean)(using Context) =
+    if (needLift == p) ctx else ctx.fresh.updateStore(NeedLift, p)
+
+  override def prepareForApply(tree: Apply)(using Context): Context =
+    liftingCtx(true)
+
+  override def prepareForDefDef(tree: DefDef)(using Context): Context =
+    liftingCtx(false)
+
+  override def prepareForValDef(tree: ValDef)(using Context): Context =
+    if !tree.symbol.exists
+       || tree.symbol.isSelfSym
+       || tree.symbol.owner == ctx.owner.enclosingMethod
+          && !tree.symbol.is(Lazy)
+            // The current implementation wraps initializers of lazy vals in
+            // calls to an initialize method, which means that a `try` in the
+            // initializer needs to be lifted. Note that the new scheme proposed
+            // in #6979 would avoid this.
+    then ctx
+    else liftingCtx(true)
+
+  override def prepareForAssign(tree: Assign)(using Context): Context =
+    if (tree.lhs.symbol.maybeOwner == ctx.owner.enclosingMethod) ctx
+    else liftingCtx(true)
+
+  override def prepareForReturn(tree: Return)(using Context): Context =
+    if (!isNonLocalReturn(tree)) ctx
+    else liftingCtx(true)
+
+  override def prepareForTemplate(tree: Template)(using Context): Context =
+    liftingCtx(false)
+
+  override def transformTry(tree: Try)(using Context): Tree =
+    if (needLift && tree.cases.nonEmpty) {
+      report.debuglog(i"lifting tree at ${tree.span}, current owner = ${ctx.owner}")
+      val fn = newSymbol(
+        ctx.owner, LiftedTreeName.fresh(), Synthetic | Method,
+        MethodType(Nil, tree.tpe.widenIfUnstable), coord = tree.span)
+      tree.changeOwnerAfter(ctx.owner, fn, thisPhase)
+      Block(DefDef(fn, tree) :: Nil, ref(fn).appliedToNone)
+    }
+    else tree
+}
+object LiftTry:
+  val name = "liftTry"
+  val description: String = "lift any try that might be executed on a non-empty expression stack"
diff --git a/tests/pos-with-compiler-cc/dotc/transform/Literalize.scala.disabled b/tests/pos-with-compiler-cc/dotc/transform/Literalize.scala.disabled
new file mode 100644
index 000000000000..626cb9687df4
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/transform/Literalize.scala.disabled
@@ -0,0 +1,95 @@
+package dotty.tools.dotc
+package transform
+
+import MegaPhase._
+import core.DenotTransformers._
+import core.Symbols._
+import core.Contexts._
+import core.Types._
+import core.Flags._
+import core.Decorators._
+import core.StdNames.nme
+import ast.Trees._
+import dotty.tools.dotc.ast.tpd
+import dotty.tools.dotc.core.Constants._
+
+/** This phase rewrites idempotent expressions with constant types to Literals.
+ *  The constant types are eliminated by erasure, so we need to keep
+ *  the info about constantness in the trees.
+ *
+ *  The phase also makes sure that the constant of a literal is the same as the constant
+ *  in the type of the literal.
+ */
+class Literalize extends MiniPhase { thisTransform =>
+  import ast.tpd._
+
+  override def phaseName: String = "literalize"
+
+  /** Note: Demanding idempotency instead of purity is strictly speaking too loose.
+   *  Example
+   *
+   *    object O { final val x = 42; println("43") }
+   *    O.x
+   *
+   *  Strictly speaking we can't replace `O.x` with `42`.  But this would make
+   *  most expressions non-constant. Maybe we can change the spec to accept this
+   *  kind of eliding behavior. Or else enforce true purity in the compiler.
+   *  The choice will be affected by what we will do with `inline` and with
+   *  Singleton type bounds (see SIP 23). Presumably
+   *
+   *     object O1 { val x: Singleton = 42; println("43") }
+   *     object O2 { inline val x = 42; println("43") }
+   *
+   *  should behave differently.
+   *
+   *     O1.x  should have the same effect as   { println("43"; 42 }
+   *
+   *  whereas
+   *
+   *     O2.x = 42
+   *
+   *  Revisit this issue once we have implemented `inline`. Then we can demand
+   *  purity of the prefix unless the selection goes to an inline val.
+   */
+  def literalize(tree: Tree)(using Context): Tree = {
+    def recur(tp: Type): Tree = tp match {
+      case ConstantType(value) if isIdempotentExpr(tree) => Literal(value)
+      case tp: TermRef if tp.symbol.isStable => recur(tp.info.widenExpr)
+      case _ => tree
+    }
+    recur(tree.tpe)
+  }
+
+  override def transformIdent(tree: Ident)(using Context): Tree =
+    literalize(tree)
+
+  override def transformSelect(tree: Select)(using Context): Tree =
+    literalize(tree)
+
+  override def transformApply(tree: Apply)(using Context): Tree =
+    literalize(tree)
+
+  override def transformTypeApply(tree: TypeApply)(using Context): Tree =
+    literalize(tree)
+
+  override def transformLiteral(tree: Literal)(using Context): Tree = tree.tpe match {
+    case ConstantType(const) if tree.const.value != const.value || (tree.const.tag != const.tag) => Literal(const)
+    case _ => tree
+  }
+
+  /** Check that all literals have types match underlying constants
+    */
+  override def checkPostCondition(tree: Tree)(using Context): Unit = {
+    tree match {
+      case Literal(c @ Constant(treeValue)) =>
+        tree.tpe match {
+          case ConstantType(c2 @ Constant(typeValue)) =>
+            assert(treeValue == typeValue && c2.tag == c.tag,
+              i"Type of Literal $tree is inconsistent with underlying constant")
+          case tpe =>
+            assert(c.tpe =:= tpe, i"Type of Literal $tree is inconsistent with underlying constant type ${c.tpe}")
+        }
+      case _ =>
+    }
+  }
+}
diff --git a/tests/pos-with-compiler-cc/dotc/transform/MacroTransform.scala b/tests/pos-with-compiler-cc/dotc/transform/MacroTransform.scala
new file mode 100644
index 000000000000..bff0e8340c0b
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/transform/MacroTransform.scala
@@ -0,0 +1,60 @@
+package dotty.tools.dotc
+package transform
+
+import core._
+import Phases._
+import ast.Trees._
+import Contexts._
+
+/** A base class for transforms.
+ *  A transform contains a compiler phase which applies a tree transformer.
+ */
+abstract class MacroTransform extends Phase, caps.Pure {
+
+  import ast.tpd._
+
+  override def run(using Context): Unit = {
+    val unit = ctx.compilationUnit
+    unit.tpdTree = atPhase(transformPhase)(newTransformer.transform(unit.tpdTree))
+  }
+
+  protected def newTransformer(using Context): Transformer
+
+  /** The phase in which the transformation should be run.
+   *  By default this is the phase given by the this macro transformer,
+   *  but it could be overridden to be the phase following that one.
+   */
+  protected def transformPhase(using Context): Phase = this
+
+  class Transformer extends TreeMapWithPreciseStatContexts(cpy = cpyBetweenPhases):
+
+    protected def localCtx(tree: Tree)(using Context): FreshContext =
+      ctx.fresh.setTree(tree).setOwner(localOwner(tree))
+
+    override def transform(tree: Tree)(using Context): Tree =
+      try
+        tree match {
+          case EmptyValDef =>
+            tree
+          case _: PackageDef | _: MemberDef =>
+            super.transform(tree)(using localCtx(tree))
+          case impl @ Template(constr, parents, self, _) =>
+            cpy.Template(tree)(
+              transformSub(constr),
+              transform(parents)(using ctx.superCallContext),
+              Nil,
+              transformSelf(self),
+              transformStats(impl.body, tree.symbol))
+          case _ =>
+            super.transform(tree)
+        }
+      catch {
+        case ex: TypeError =>
+          report.error(ex, tree.srcPos)
+          tree
+      }
+
+    def transformSelf(vd: ValDef)(using Context): ValDef =
+      cpy.ValDef(vd)(tpt = transform(vd.tpt))
+  end Transformer
+}
diff --git a/tests/pos-with-compiler-cc/dotc/transform/MegaPhase.scala b/tests/pos-with-compiler-cc/dotc/transform/MegaPhase.scala
new file mode 100644
index 000000000000..2543a89af4d7
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/transform/MegaPhase.scala
@@ -0,0 +1,1066 @@
+package dotty.tools
+package dotc
+package transform
+
+import core._
+import Contexts._, Phases._, Symbols._, Decorators._
+import Flags.PackageVal
+
+/** A MegaPhase combines a number of mini-phases which are all executed in
+ *  a single tree traversal.
+ *
+ *  This is an evolution of the previous "TreeTransformers.scala", which was written by @DarkDimius and
+ *  is described in his thesis.
+ */
+object MegaPhase {
+  import ast.tpd._
+
+  /** The base class of tree transforms. For each kind of tree K, there are
+   *  two methods which can be overridden:
+   *
+   *  prepareForK: return a new Context which gets passed to the node and its children
+   *  transformK // transform node of type K
+   *
+   *  There are also prepare/transform hooks for
+   *
+   *   - Stats: to prepare/transform a statement sequence in a block, template, or package def,
+   *   - Unit : to prepare/transform a whole compilation unit
+   *   - Other: to prepape/transform a tree that does not have a specific prepare/transform
+   *     method pair.
+   */
+  abstract class MiniPhase extends Phase, caps.Pure {
+
+    private[MegaPhase] var superPhase: MegaPhase = _
+    private[MegaPhase] var idxInGroup: Int = _
+
+    /** List of names of phases that should have finished their processing of all compilation units
+     *  before this phase starts
+     */
+    def runsAfterGroupsOf: Set[String] = Set.empty
+
+    final override def relaxedTyping: Boolean = superPhase.relaxedTyping
+
+    /** If set, use relaxed typing for all phases in group */
+    def relaxedTypingInGroup: Boolean = false
+
+    val cpy: TypedTreeCopier = cpyBetweenPhases
+
+    def prepareForIdent(tree: Ident)(using Context): Context = ctx
+    def prepareForSelect(tree: Select)(using Context): Context = ctx
+    def prepareForThis(tree: This)(using Context): Context = ctx
+    def prepareForSuper(tree: Super)(using Context): Context = ctx
+    def prepareForApply(tree: Apply)(using Context): Context = ctx
+    def prepareForTypeApply(tree: TypeApply)(using Context): Context = ctx
+    def prepareForLiteral(tree: Literal)(using Context): Context = ctx
+    def prepareForNew(tree: New)(using Context): Context = ctx
+    def prepareForTyped(tree: Typed)(using Context): Context = ctx
+    def prepareForAssign(tree: Assign)(using Context): Context = ctx
+    def prepareForBlock(tree: Block)(using Context): Context = ctx
+    def prepareForIf(tree: If)(using Context): Context = ctx
+    def prepareForClosure(tree: Closure)(using Context): Context = ctx
+    def prepareForMatch(tree: Match)(using Context): Context = ctx
+    def prepareForCaseDef(tree: CaseDef)(using Context): Context = ctx
+    def prepareForLabeled(tree: Labeled)(using Context): Context = ctx
+    def prepareForReturn(tree: Return)(using Context): Context = ctx
+    def prepareForWhileDo(tree: WhileDo)(using Context): Context = ctx
+    def prepareForTry(tree: Try)(using Context): Context = ctx
+    def prepareForSeqLiteral(tree: SeqLiteral)(using Context): Context = ctx
+    def prepareForInlined(tree: Inlined)(using Context): Context = ctx
+    def prepareForTypeTree(tree: TypeTree)(using Context): Context = ctx
+    def prepareForBind(tree: Bind)(using Context): Context = ctx
+    def prepareForAlternative(tree: Alternative)(using Context): Context = ctx
+    def prepareForUnApply(tree: UnApply)(using Context): Context = ctx
+    def prepareForValDef(tree: ValDef)(using Context): Context = ctx
+    def prepareForDefDef(tree: DefDef)(using Context): Context = ctx
+    def prepareForTypeDef(tree: TypeDef)(using Context): Context = ctx
+    def prepareForTemplate(tree: Template)(using Context): Context = ctx
+    def prepareForPackageDef(tree: PackageDef)(using Context): Context = ctx
+    def prepareForStats(trees: List[Tree])(using Context): Context = ctx
+    def prepareForUnit(tree: Tree)(using Context): Context = ctx
+    def prepareForOther(tree: Tree)(using Context): Context = ctx
+
+    def transformIdent(tree: Ident)(using Context): Tree = tree
+    def transformSelect(tree: Select)(using Context): Tree = tree
+    def transformThis(tree: This)(using Context): Tree = tree
+    def transformSuper(tree: Super)(using Context): Tree = tree
+    def transformApply(tree: Apply)(using Context): Tree = tree
+    def transformTypeApply(tree: TypeApply)(using Context): Tree = tree
+    def transformLiteral(tree: Literal)(using Context): Tree = tree
+    def transformNew(tree: New)(using Context): Tree = tree
+    def transformTyped(tree: Typed)(using Context): Tree = tree
+    def transformAssign(tree: Assign)(using Context): Tree = tree
+    def transformBlock(tree: Block)(using Context): Tree = tree
+    def transformIf(tree: If)(using Context): Tree = tree
+    def transformClosure(tree: Closure)(using Context): Tree = tree
+    def transformMatch(tree: Match)(using Context): Tree = tree
+    def transformCaseDef(tree: CaseDef)(using Context): Tree = tree
+    def transformLabeled(tree: Labeled)(using Context): Tree = tree
+    def transformReturn(tree: Return)(using Context): Tree = tree
+    def transformWhileDo(tree: WhileDo)(using Context): Tree = tree
+    def transformTry(tree: Try)(using Context): Tree = tree
+    def transformSeqLiteral(tree: SeqLiteral)(using Context): Tree = tree
+    def transformInlined(tree: Inlined)(using Context): Tree = tree
+    def transformTypeTree(tree: TypeTree)(using Context): Tree = tree
+    def transformBind(tree: Bind)(using Context): Tree = tree
+    def transformAlternative(tree: Alternative)(using Context): Tree = tree
+    def transformUnApply(tree: UnApply)(using Context): Tree = tree
+    def transformValDef(tree: ValDef)(using Context): Tree = tree
+    def transformDefDef(tree: DefDef)(using Context): Tree = tree
+    def transformTypeDef(tree: TypeDef)(using Context): Tree = tree
+    def transformTemplate(tree: Template)(using Context): Tree = tree
+    def transformPackageDef(tree: PackageDef)(using Context): Tree = tree
+    def transformStats(trees: List[Tree])(using Context): List[Tree] = trees
+    def transformUnit(tree: Tree)(using Context): Tree = tree
+    def transformOther(tree: Tree)(using Context): Tree = tree
+
+    /** Transform tree using all transforms of current group (including this one) */
+    def transformAllDeep(tree: Tree)(using Context): Tree =
+      superPhase.transformTree(tree, 0)
+
+    /** Transform tree using all transforms following the current one in this group */
+    def transformFollowingDeep(tree: Tree)(using Context): Tree =
+      superPhase.transformTree(tree, idxInGroup + 1)
+
+    /** Transform single node using all transforms following the current one in this group */
+    def transformFollowing(tree: Tree)(using Context): Tree =
+      superPhase.transformNode(tree, idxInGroup + 1)
+
+    protected def singletonGroup: MegaPhase = new MegaPhase(Array(this))
+
+    override def run(using Context): Unit =
+      singletonGroup.run
+  }
+}
+import MegaPhase._
+
+class MegaPhase(val miniPhases: Array[MiniPhase]) extends Phase {
+  import ast.tpd._
+
+  override val phaseName: String =
+    if (miniPhases.length == 1) miniPhases(0).phaseName
+    else miniPhases.map(_.phaseName).mkString("MegaPhase{", ", ", "}")
+
+  private var relaxedTypingCache: Boolean = _
+  private var relaxedTypingKnown = false
+
+  override final def relaxedTyping: Boolean = {
+    if (!relaxedTypingKnown) {
+      relaxedTypingCache = miniPhases.exists(_.relaxedTypingInGroup)
+      relaxedTypingKnown = true
+    }
+    relaxedTypingCache
+  }
+
+  private val cpy: TypedTreeCopier = cpyBetweenPhases
+
+  /** Transform node using all phases in this group that have idxInGroup >= start */
+  def transformNode(tree: Tree, start: Int)(using Context): Tree = {
+    def goNamed(tree: Tree, start: Int) =
+      try
+        tree match {
+          case tree: Ident => goIdent(tree, start)
+          case tree: Select => goSelect(tree, start)
+          case tree: ValDef => goValDef(tree, start)
+          case tree: DefDef => goDefDef(tree, start)
+          case tree: TypeDef => goTypeDef(tree, start)
+          case tree: Labeled => goLabeled(tree, start)
+          case tree: Bind => goBind(tree, start)
+          case _ => goOther(tree, start)
+        }
+      catch {
+        case ex: TypeError =>
+          report.error(ex, tree.srcPos)
+          tree
+      }
+    def goUnnamed(tree: Tree, start: Int) =
+      try
+        tree match {
+          case tree: Apply => goApply(tree, start)
+          case tree: TypeTree => goTypeTree(tree, start)
+          case tree: Thicket =>
+            cpy.Thicket(tree)(tree.trees.mapConserve(transformNode(_, start)))
+          case tree: This => goThis(tree, start)
+          case tree: Literal => goLiteral(tree, start)
+          case tree: Block => goBlock(tree, start)
+          case tree: TypeApply => goTypeApply(tree, start)
+          case tree: If => goIf(tree, start)
+          case tree: New => goNew(tree, start)
+          case tree: Typed => goTyped(tree, start)
+          case tree: CaseDef => goCaseDef(tree, start)
+          case tree: Closure => goClosure(tree, start)
+          case tree: Assign => goAssign(tree, start)
+          case tree: SeqLiteral => goSeqLiteral(tree, start)
+          case tree: Super => goSuper(tree, start)
+          case tree: Template => goTemplate(tree, start)
+          case tree: Match => goMatch(tree, start)
+          case tree: UnApply => goUnApply(tree, start)
+          case tree: PackageDef => goPackageDef(tree, start)
+          case tree: Try => goTry(tree, start)
+          case tree: Inlined => goInlined(tree, start)
+          case tree: Return => goReturn(tree, start)
+          case tree: WhileDo => goWhileDo(tree, start)
+          case tree: Alternative => goAlternative(tree, start)
+          case tree => goOther(tree, start)
+        }
+      catch {
+        case ex: TypeError =>
+          report.error(ex, tree.srcPos)
+          tree
+      }
+    if (tree.isInstanceOf[NameTree]) goNamed(tree, start) else goUnnamed(tree, start)
+  }
+
+  /** Transform full tree using all phases in this group that have idxInGroup >= start */
+  def transformTree(tree: Tree, start: Int)(using Context): Tree = {
+
+    inline def inLocalContext[T](inline op: Context ?=> T)(using Context): T =
+      val sym = tree.symbol
+      runWithOwner(if (sym.is(PackageVal)) sym.moduleClass else sym)(op)
+
+    def transformNamed(tree: Tree, start: Int, outerCtx: Context): Tree = tree match {
+      case tree: Ident =>
+        inContext(prepIdent(tree, start)(using outerCtx)) {
+          goIdent(tree, start)
+        }
+      case tree: Select =>
+        inContext(prepSelect(tree, start)(using outerCtx)) {
+          val qual = transformTree(tree.qualifier, start)
+          goSelect(cpy.Select(tree)(qual, tree.name), start)
+        }
+      case tree: ValDef =>
+        inContext(prepValDef(tree, start)(using outerCtx)) {
+          def mapValDef(using Context) = {
+            val tpt = transformTree(tree.tpt, start)
+            val rhs = transformTree(tree.rhs, start)
+            cpy.ValDef(tree)(tree.name, tpt, rhs)
+          }
+          if tree.isEmpty then tree
+          else goValDef(
+            if tree.symbol.exists then inLocalContext(mapValDef) else mapValDef,
+            start)
+        }
+      case tree: DefDef =>
+        inContext(prepDefDef(tree, start)(using outerCtx)) {
+          def mapDefDef(using Context) = {
+            val paramss = tree.paramss.mapConserve(transformSpecificTrees(_, start))
+              .asInstanceOf[List[ParamClause]]
+            val tpt = transformTree(tree.tpt, start)
+            val rhs = transformTree(tree.rhs, start)
+            cpy.DefDef(tree)(tree.name, paramss, tpt, rhs)
+          }
+          goDefDef(inLocalContext(mapDefDef), start)
+        }
+      case tree: TypeDef =>
+        inContext(prepTypeDef(tree, start)(using outerCtx)) {
+          val rhs = inLocalContext(transformTree(tree.rhs, start))
+          goTypeDef(cpy.TypeDef(tree)(tree.name, rhs), start)
+        }
+      case tree: Labeled =>
+        inContext(prepLabeled(tree, start)(using outerCtx)) {
+          val bind = transformTree(tree.bind, start).asInstanceOf[Bind]
+          val expr = transformTree(tree.expr, start)
+          goLabeled(cpy.Labeled(tree)(bind, expr), start)
+        }
+      case tree: Bind =>
+        inContext(prepBind(tree, start)(using outerCtx)) {
+          val body = transformTree(tree.body, start)
+          goBind(cpy.Bind(tree)(tree.name, body), start)
+        }
+      case _ =>
+        inContext(prepOther(tree, start)(using outerCtx)) {
+          goOther(tree, start)
+        }
+    }
+
+    def transformUnnamed(tree: Tree, start: Int, outerCtx: Context): Tree = tree match {
+      case tree: Apply =>
+        inContext(prepApply(tree, start)(using outerCtx)) {
+          val fun = transformTree(tree.fun, start)
+          val args = transformTrees(tree.args, start)
+          goApply(cpy.Apply(tree)(fun, args), start)
+        }
+      case tree: TypeTree =>
+        inContext(prepTypeTree(tree, start)(using outerCtx)) {
+          goTypeTree(tree, start)
+        }
+      case tree: Thicket =>
+        cpy.Thicket(tree)(transformTrees(tree.trees, start))
+      case tree: This =>
+        inContext(prepThis(tree, start)(using outerCtx)) {
+          goThis(tree, start)
+        }
+      case tree: Literal =>
+        inContext(prepLiteral(tree, start)(using outerCtx)) {
+          goLiteral(tree, start)
+        }
+      case tree: Block =>
+        inContext(prepBlock(tree, start)(using outerCtx)) {
+          transformBlock(tree, start)
+        }
+      case tree: TypeApply =>
+        inContext(prepTypeApply(tree, start)(using outerCtx)) {
+          val fun = transformTree(tree.fun, start)
+          val args = transformTrees(tree.args, start)
+          goTypeApply(cpy.TypeApply(tree)(fun, args), start)
+        }
+      case tree: If =>
+        inContext(prepIf(tree, start)(using outerCtx)) {
+          val cond = transformTree(tree.cond, start)
+          val thenp = transformTree(tree.thenp, start)
+          val elsep = transformTree(tree.elsep, start)
+          goIf(cpy.If(tree)(cond, thenp, elsep), start)
+        }
+      case tree: New =>
+        inContext(prepNew(tree, start)(using outerCtx)) {
+          val tpt = transformTree(tree.tpt, start)
+          goNew(cpy.New(tree)(tpt), start)
+        }
+      case tree: Typed =>
+        inContext(prepTyped(tree, start)(using outerCtx)) {
+          val expr = transformTree(tree.expr, start)
+          val tpt = transformTree(tree.tpt, start)
+          goTyped(cpy.Typed(tree)(expr, tpt), start)
+        }
+      case tree: CaseDef =>
+        inContext(prepCaseDef(tree, start)(using outerCtx)) {
+          val pat = withMode(Mode.Pattern)(transformTree(tree.pat, start))
+          val guard = transformTree(tree.guard, start)
+          val body = transformTree(tree.body, start)
+          goCaseDef(cpy.CaseDef(tree)(pat, guard, body), start)
+        }
+      case tree: Closure =>
+        inContext(prepClosure(tree, start)(using outerCtx)) {
+          val env = transformTrees(tree.env, start)
+          val meth = transformTree(tree.meth, start)
+          val tpt = transformTree(tree.tpt, start)
+          goClosure(cpy.Closure(tree)(env, meth, tpt), start)
+        }
+      case tree: Assign =>
+        inContext(prepAssign(tree, start)(using outerCtx)) {
+          val lhs = transformTree(tree.lhs, start)
+          val rhs = transformTree(tree.rhs, start)
+          goAssign(cpy.Assign(tree)(lhs, rhs), start)
+        }
+      case tree: SeqLiteral =>
+        inContext(prepSeqLiteral(tree, start)(using outerCtx)) {
+          val elems = transformTrees(tree.elems, start)
+          val elemtpt = transformTree(tree.elemtpt, start)
+          goSeqLiteral(cpy.SeqLiteral(tree)(elems, elemtpt), start)
+        }
+      case tree: Super =>
+        inContext(prepSuper(tree, start)(using outerCtx)) {
+          goSuper(tree, start)
+        }
+      case tree: Template =>
+        inContext(prepTemplate(tree, start)(using outerCtx)) {
+          val constr = transformSpecificTree(tree.constr, start)
+          val parents = transformTrees(tree.parents, start)(using ctx.superCallContext)
+          val self = transformSpecificTree(tree.self, start)
+          val body = transformStats(tree.body, tree.symbol, start)
+          goTemplate(cpy.Template(tree)(constr, parents, Nil, self, body), start)
+        }
+      case tree: Match =>
+        inContext(prepMatch(tree, start)(using outerCtx)) {
+          val selector = transformTree(tree.selector, start)
+          val cases = transformSpecificTrees(tree.cases, start)
+          goMatch(cpy.Match(tree)(selector, cases), start)
+        }
+      case tree: UnApply =>
+        inContext(prepUnApply(tree, start)(using outerCtx)) {
+          val fun = transformTree(tree.fun, start)
+          val implicits = transformTrees(tree.implicits, start)
+          val patterns = transformTrees(tree.patterns, start)
+          goUnApply(cpy.UnApply(tree)(fun, implicits, patterns), start)
+        }
+      case tree: PackageDef =>
+        inContext(prepPackageDef(tree, start)(using outerCtx)) {
+          def mapPackage(using Context) = {
+            val pid = transformSpecificTree(tree.pid, start)
+            val stats = transformStats(tree.stats, tree.symbol, start)
+            cpy.PackageDef(tree)(pid, stats)
+          }
+          goPackageDef(inLocalContext(mapPackage), start)
+        }
+      case tree: Try =>
+        inContext(prepTry(tree, start)(using outerCtx)) {
+          val expr = transformTree(tree.expr, start)
+          val cases = transformSpecificTrees(tree.cases, start)
+          val finalizer = transformTree(tree.finalizer, start)
+          goTry(cpy.Try(tree)(expr, cases, finalizer), start)
+        }
+      case tree: Inlined =>
+        inContext(prepInlined(tree, start)(using outerCtx)) {
+          val bindings = transformSpecificTrees(tree.bindings, start)
+          val expansion = transformTree(tree.expansion, start)(using inlineContext(tree.call))
+          goInlined(cpy.Inlined(tree)(tree.call, bindings, expansion), start)
+        }
+      case tree: Return =>
+        inContext(prepReturn(tree, start)(using outerCtx)) {
+          val expr = transformTree(tree.expr, start)
+          goReturn(cpy.Return(tree)(expr, tree.from), start)
+            // don't transform `tree.from`, as this is not a normal ident, but
+            // a pointer to the enclosing method.
+        }
+      case tree: WhileDo =>
+        inContext(prepWhileDo(tree, start)(using outerCtx)) {
+          val cond = transformTree(tree.cond, start)
+          val body = transformTree(tree.body, start)
+          goWhileDo(cpy.WhileDo(tree)(cond, body), start)
+        }
+      case tree: Alternative =>
+        inContext(prepAlternative(tree, start)(using outerCtx)) {
+          val trees = transformTrees(tree.trees, start)
+          goAlternative(cpy.Alternative(tree)(trees), start)
+        }
+      case tree =>
+        inContext(prepOther(tree, start)(using outerCtx)) {
+          goOther(tree, start)
+        }
+    }
+
+    // try
+      if (tree.source != ctx.source && tree.source.exists)
+        transformTree(tree, start)(using ctx.withSource(tree.source))
+      else if (tree.isInstanceOf[NameTree])
+        transformNamed(tree, start, ctx)
+      else
+        transformUnnamed(tree, start, ctx)
+    // catch case ex: AssertionError =>
+    //  println(i"error while transforming $tree")
+    //  throw ex
+  }
+
+  def transformSpecificTree[T <: Tree](tree: T, start: Int)(using Context): T =
+    transformTree(tree, start).asInstanceOf[T]
+
+  def transformStats(trees: List[Tree], exprOwner: Symbol, start: Int)(using Context): List[Tree] =
+    val nestedCtx = prepStats(trees, start)
+    val trees1 = trees.mapStatements(exprOwner, transformTree(_, start), stats1 => stats1)(using nestedCtx)
+    goStats(trees1, start)(using nestedCtx)
+
+  def transformBlock(tree: Block, start: Int)(using Context): Tree =
+    val nestedCtx = prepStats(tree.stats, start)
+    val block1 = tree.stats.mapStatements(ctx.owner,
+      transformTree(_, start),
+      stats1 => ctx ?=> {
+        val stats2 = goStats(stats1, start)(using nestedCtx)
+        val expr2 = transformTree(tree.expr, start)
+        cpy.Block(tree)(stats2, expr2)
+      })(using nestedCtx)
+    goBlock(block1, start)
+
+  def transformUnit(tree: Tree)(using Context): Tree = {
+    val nestedCtx = prepUnit(tree, 0)
+    val tree1 = transformTree(tree, 0)(using nestedCtx)
+    goUnit(tree1, 0)(using nestedCtx)
+  }
+
+  def transformTrees(trees: List[Tree], start: Int)(using Context): List[Tree] =
+    trees.mapInline(transformTree(_, start))
+
+  def transformSpecificTrees[T <: Tree](trees: List[T], start: Int)(using Context): List[T] =
+    transformTrees(trees, start).asInstanceOf[List[T]]
+
+  override def run(using Context): Unit =
+    ctx.compilationUnit.tpdTree =
+      atPhase(miniPhases.last.next)(transformUnit(ctx.compilationUnit.tpdTree))
+
+  // Initialization code
+
+  /** Class#getDeclaredMethods is slow, so we cache its output */
+  private val clsMethodsCache = new java.util.IdentityHashMap[Class[?], Array[java.lang.reflect.Method | Null]]
+
+  /** Does `phase` contain a redefinition of method `name`?
+   *  (which is a method of MiniPhase)
+   */
+  private def defines(phase: MiniPhase, name: String) = {
+    def hasRedefinedMethod(cls: Class[?]): Boolean =
+      if (cls.eq(classOf[MiniPhase])) false
+      else {
+        var clsMethods = clsMethodsCache.get(cls)
+        if (clsMethods == null) {
+          clsMethods = cls.getDeclaredMethods
+          clsMethodsCache.put(cls, clsMethods)
+        }
+        clsMethods.nn.exists(_.nn.getName == name) ||
+        hasRedefinedMethod(cls.getSuperclass.nn)
+      }
+    hasRedefinedMethod(phase.getClass)
+  }
+
+  private def newNxArray = new Array[MiniPhase | Null](miniPhases.length + 1)
+  private val emptyNxArray = newNxArray
+
+  private def init(methName: String): Array[MiniPhase | Null] = {
+    var nx: Array[MiniPhase | Null] = emptyNxArray
+    for (idx <- miniPhases.length - 1 to 0 by -1) {
+      val subPhase = miniPhases(idx)
+      if (defines(subPhase, methName)) {
+        if (nx eq emptyNxArray) nx = newNxArray
+        nx(idx) = subPhase
+      }
+      else if (nx ne emptyNxArray) nx(idx) = nx(idx + 1)
+    }
+    nx
+  }
+
+  private val nxIdentPrepPhase = init("prepareForIdent")
+  private val nxIdentTransPhase = init("transformIdent")
+  private val nxSelectPrepPhase = init("prepareForSelect")
+  private val nxSelectTransPhase = init("transformSelect")
+  private val nxThisPrepPhase = init("prepareForThis")
+  private val nxThisTransPhase = init("transformThis")
+  private val nxSuperPrepPhase = init("prepareForSuper")
+  private val nxSuperTransPhase = init("transformSuper")
+  private val nxApplyPrepPhase = init("prepareForApply")
+  private val nxApplyTransPhase = init("transformApply")
+  private val nxTypeApplyPrepPhase = init("prepareForTypeApply")
+  private val nxTypeApplyTransPhase = init("transformTypeApply")
+  private val nxLiteralPrepPhase = init("prepareForLiteral")
+  private val nxLiteralTransPhase = init("transformLiteral")
+  private val nxNewPrepPhase = init("prepareForNew")
+  private val nxNewTransPhase = init("transformNew")
+  private val nxTypedPrepPhase = init("prepareForTyped")
+  private val nxTypedTransPhase = init("transformTyped")
+  private val nxAssignPrepPhase = init("prepareForAssign")
+  private val nxAssignTransPhase = init("transformAssign")
+  private val nxBlockPrepPhase = init("prepareForBlock")
+  private val nxBlockTransPhase = init("transformBlock")
+  private val nxIfPrepPhase = init("prepareForIf")
+  private val nxIfTransPhase = init("transformIf")
+  private val nxClosurePrepPhase = init("prepareForClosure")
+  private val nxClosureTransPhase = init("transformClosure")
+  private val nxMatchPrepPhase = init("prepareForMatch")
+  private val nxMatchTransPhase = init("transformMatch")
+  private val nxCaseDefPrepPhase = init("prepareForCaseDef")
+  private val nxCaseDefTransPhase = init("transformCaseDef")
+  private val nxLabeledPrepPhase = init("prepareForLabeled")
+  private val nxLabeledTransPhase = init("transformLabeled")
+  private val nxReturnPrepPhase = init("prepareForReturn")
+  private val nxReturnTransPhase = init("transformReturn")
+  private val nxWhileDoPrepPhase = init("prepareForWhileDo")
+  private val nxWhileDoTransPhase = init("transformWhileDo")
+  private val nxTryPrepPhase = init("prepareForTry")
+  private val nxTryTransPhase = init("transformTry")
+  private val nxSeqLiteralPrepPhase = init("prepareForSeqLiteral")
+  private val nxSeqLiteralTransPhase = init("transformSeqLiteral")
+  private val nxInlinedPrepPhase = init("prepareForInlined")
+  private val nxInlinedTransPhase = init("transformInlined")
+  private val nxTypeTreePrepPhase = init("prepareForTypeTree")
+  private val nxTypeTreeTransPhase = init("transformTypeTree")
+  private val nxBindPrepPhase = init("prepareForBind")
+  private val nxBindTransPhase = init("transformBind")
+  private val nxAlternativePrepPhase = init("prepareForAlternative")
+  private val nxAlternativeTransPhase = init("transformAlternative")
+  private val nxUnApplyPrepPhase = init("prepareForUnApply")
+  private val nxUnApplyTransPhase = init("transformUnApply")
+  private val nxValDefPrepPhase = init("prepareForValDef")
+  private val nxValDefTransPhase = init("transformValDef")
+  private val nxDefDefPrepPhase = init("prepareForDefDef")
+  private val nxDefDefTransPhase = init("transformDefDef")
+  private val nxTypeDefPrepPhase = init("prepareForTypeDef")
+  private val nxTypeDefTransPhase = init("transformTypeDef")
+  private val nxTemplatePrepPhase = init("prepareForTemplate")
+  private val nxTemplateTransPhase = init("transformTemplate")
+  private val nxPackageDefPrepPhase = init("prepareForPackageDef")
+  private val nxPackageDefTransPhase = init("transformPackageDef")
+  private val nxStatsPrepPhase = init("prepareForStats")
+  private val nxStatsTransPhase = init("transformStats")
+  private val nxUnitPrepPhase = init("prepareForUnit")
+  private val nxUnitTransPhase = init("transformUnit")
+  private val nxOtherPrepPhase = init("prepareForOther")
+  private val nxOtherTransPhase = init("transformOther")
+
+  for ((phase, idx) <- miniPhases.zipWithIndex) {
+    phase.superPhase = this
+    phase.idxInGroup = idx
+  }
+
+  // Boilerplate snippets
+
+  def prepIdent(tree: Ident, start: Int)(using Context): Context = {
+    val phase = nxIdentPrepPhase(start)
+    if (phase == null) ctx
+    else prepIdent(tree, phase.idxInGroup + 1)(using phase.prepareForIdent(tree))
+  }
+
+  def goIdent(tree: Ident, start: Int)(using Context): Tree = {
+    val phase = nxIdentTransPhase(start)
+    if (phase == null) tree
+    else phase.transformIdent(tree) match {
+      case tree1: Ident => goIdent(tree1, phase.idxInGroup + 1)
+      case tree1 => transformNode(tree1, phase.idxInGroup + 1)
+    }
+  }
+
+  def prepSelect(tree: Select, start: Int)(using Context): Context = {
+    val phase = nxSelectPrepPhase(start)
+    if (phase == null) ctx
+    else prepSelect(tree, phase.idxInGroup + 1)(using phase.prepareForSelect(tree))
+  }
+
+  def goSelect(tree: Select, start: Int)(using Context): Tree = {
+    val phase = nxSelectTransPhase(start)
+    if (phase == null) tree
+    else phase.transformSelect(tree) match {
+      case tree1: Select => goSelect(tree1, phase.idxInGroup + 1)
+      case tree1 => transformNode(tree1, phase.idxInGroup + 1)
+    }
+  }
+
+  def prepThis(tree: This, start: Int)(using Context): Context = {
+    val phase = nxThisPrepPhase(start)
+    if (phase == null) ctx
+    else prepThis(tree, phase.idxInGroup + 1)(using phase.prepareForThis(tree))
+  }
+
+  def goThis(tree: This, start: Int)(using Context): Tree = {
+    val phase = nxThisTransPhase(start)
+    if (phase == null) tree
+    else phase.transformThis(tree) match {
+      case tree1: This => goThis(tree1, phase.idxInGroup + 1)
+      case tree1 => transformNode(tree1, phase.idxInGroup + 1)
+    }
+  }
+
+  def prepSuper(tree: Super, start: Int)(using Context): Context = {
+    val phase = nxSuperPrepPhase(start)
+    if (phase == null) ctx
+    else prepSuper(tree, phase.idxInGroup + 1)(using phase.prepareForSuper(tree))
+  }
+
+  def goSuper(tree: Super, start: Int)(using Context): Tree = {
+    val phase = nxSuperTransPhase(start)
+    if (phase == null) tree
+    else phase.transformSuper(tree) match {
+      case tree1: Super => goSuper(tree1, phase.idxInGroup + 1)
+      case tree1 => transformNode(tree1, phase.idxInGroup + 1)
+    }
+  }
+
+  def prepApply(tree: Apply, start: Int)(using Context): Context = {
+    val phase = nxApplyPrepPhase(start)
+    if (phase == null) ctx
+    else prepApply(tree, phase.idxInGroup + 1)(using phase.prepareForApply(tree))
+  }
+
+  def goApply(tree: Apply, start: Int)(using Context): Tree = {
+    val phase = nxApplyTransPhase(start)
+    if (phase == null) tree
+    else phase.transformApply(tree) match {
+      case tree1: Apply => goApply(tree1, phase.idxInGroup + 1)
+      case tree1 => transformNode(tree1, phase.idxInGroup + 1)
+    }
+  }
+
+  def prepTypeApply(tree: TypeApply, start: Int)(using Context): Context = {
+    val phase = nxTypeApplyPrepPhase(start)
+    if (phase == null) ctx
+    else prepTypeApply(tree, phase.idxInGroup + 1)(using phase.prepareForTypeApply(tree))
+  }
+
+  def goTypeApply(tree: TypeApply, start: Int)(using Context): Tree = {
+    val phase = nxTypeApplyTransPhase(start)
+    if (phase == null) tree
+    else phase.transformTypeApply(tree) match {
+      case tree1: TypeApply => goTypeApply(tree1, phase.idxInGroup + 1)
+      case tree1 => transformNode(tree1, phase.idxInGroup + 1)
+    }
+  }
+
+  def prepLiteral(tree: Literal, start: Int)(using Context): Context = {
+    val phase = nxLiteralPrepPhase(start)
+    if (phase == null) ctx
+    else prepLiteral(tree, phase.idxInGroup + 1)(using phase.prepareForLiteral(tree))
+  }
+
+  def goLiteral(tree: Literal, start: Int)(using Context): Tree = {
+    val phase = nxLiteralTransPhase(start)
+    if (phase == null) tree
+    else phase.transformLiteral(tree) match {
+      case tree1: Literal => goLiteral(tree1, phase.idxInGroup + 1)
+      case tree1 => transformNode(tree1, phase.idxInGroup + 1)
+    }
+  }
+
+  def prepNew(tree: New, start: Int)(using Context): Context = {
+    val phase = nxNewPrepPhase(start)
+    if (phase == null) ctx
+    else prepNew(tree, phase.idxInGroup + 1)(using phase.prepareForNew(tree))
+  }
+
+  def goNew(tree: New, start: Int)(using Context): Tree = {
+    val phase = nxNewTransPhase(start)
+    if (phase == null) tree
+    else phase.transformNew(tree) match {
+      case tree1: New => goNew(tree1, phase.idxInGroup + 1)
+      case tree1 => transformNode(tree1, phase.idxInGroup + 1)
+    }
+  }
+
+  def prepTyped(tree: Typed, start: Int)(using Context): Context = {
+    val phase = nxTypedPrepPhase(start)
+    if (phase == null) ctx
+    else prepTyped(tree, phase.idxInGroup + 1)(using phase.prepareForTyped(tree))
+  }
+
+  def goTyped(tree: Typed, start: Int)(using Context): Tree = {
+    val phase = nxTypedTransPhase(start)
+    if (phase == null) tree
+    else phase.transformTyped(tree) match {
+      case tree1: Typed => goTyped(tree1, phase.idxInGroup + 1)
+      case tree1 => transformNode(tree1, phase.idxInGroup + 1)
+    }
+  }
+
+  def prepAssign(tree: Assign, start: Int)(using Context): Context = {
+    val phase = nxAssignPrepPhase(start)
+    if (phase == null) ctx
+    else prepAssign(tree, phase.idxInGroup + 1)(using phase.prepareForAssign(tree))
+  }
+
+  def goAssign(tree: Assign, start: Int)(using Context): Tree = {
+    val phase = nxAssignTransPhase(start)
+    if (phase == null) tree
+    else phase.transformAssign(tree) match {
+      case tree1: Assign => goAssign(tree1, phase.idxInGroup + 1)
+      case tree1 => transformNode(tree1, phase.idxInGroup + 1)
+    }
+  }
+
+  def prepBlock(tree: Block, start: Int)(using Context): Context = {
+    val phase = nxBlockPrepPhase(start)
+    if (phase == null) ctx
+    else prepBlock(tree, phase.idxInGroup + 1)(using phase.prepareForBlock(tree))
+  }
+
+  def goBlock(tree: Block, start: Int)(using Context): Tree = {
+    val phase = nxBlockTransPhase(start)
+    if (phase == null) tree
+    else phase.transformBlock(tree) match {
+      case tree1: Block => goBlock(tree1, phase.idxInGroup + 1)
+      case tree1 => transformNode(tree1, phase.idxInGroup + 1)
+    }
+  }
+
+  def prepIf(tree: If, start: Int)(using Context): Context = {
+    val phase = nxIfPrepPhase(start)
+    if (phase == null) ctx
+    else prepIf(tree, phase.idxInGroup + 1)(using phase.prepareForIf(tree))
+  }
+
+  def goIf(tree: If, start: Int)(using Context): Tree = {
+    val phase = nxIfTransPhase(start)
+    if (phase == null) tree
+    else phase.transformIf(tree) match {
+      case tree1: If => goIf(tree1, phase.idxInGroup + 1)
+      case tree1 => transformNode(tree1, phase.idxInGroup + 1)
+    }
+  }
+
+  def prepClosure(tree: Closure, start: Int)(using Context): Context = {
+    val phase = nxClosurePrepPhase(start)
+    if (phase == null) ctx
+    else prepClosure(tree, phase.idxInGroup + 1)(using phase.prepareForClosure(tree))
+  }
+
+  def goClosure(tree: Closure, start: Int)(using Context): Tree = {
+    val phase = nxClosureTransPhase(start)
+    if (phase == null) tree
+    else phase.transformClosure(tree) match {
+      case tree1: Closure => goClosure(tree1, phase.idxInGroup + 1)
+      case tree1 => transformNode(tree1, phase.idxInGroup + 1)
+    }
+  }
+
+  def prepMatch(tree: Match, start: Int)(using Context): Context = {
+    val phase = nxMatchPrepPhase(start)
+    if (phase == null) ctx
+    else prepMatch(tree, phase.idxInGroup + 1)(using phase.prepareForMatch(tree))
+  }
+
+  def goMatch(tree: Match, start: Int)(using Context): Tree = {
+    val phase = nxMatchTransPhase(start)
+    if (phase == null) tree
+    else phase.transformMatch(tree) match {
+      case tree1: Match => goMatch(tree1, phase.idxInGroup + 1)
+      case tree1 => transformNode(tree1, phase.idxInGroup + 1)
+    }
+  }
+
+  def prepCaseDef(tree: CaseDef, start: Int)(using Context): Context = {
+    val phase = nxCaseDefPrepPhase(start)
+    if (phase == null) ctx
+    else prepCaseDef(tree, phase.idxInGroup + 1)(using phase.prepareForCaseDef(tree))
+  }
+
+  def goCaseDef(tree: CaseDef, start: Int)(using Context): Tree = {
+    val phase = nxCaseDefTransPhase(start)
+    if (phase == null) tree
+    else phase.transformCaseDef(tree) match {
+      case tree1: CaseDef => goCaseDef(tree1, phase.idxInGroup + 1)
+      case tree1 => transformNode(tree1, phase.idxInGroup + 1)
+    }
+  }
+
+  def prepLabeled(tree: Labeled, start: Int)(using Context): Context = {
+    val phase = nxLabeledPrepPhase(start)
+    if (phase == null) ctx
+    else prepLabeled(tree, phase.idxInGroup + 1)(using phase.prepareForLabeled(tree))
+  }
+
+  def goLabeled(tree: Labeled, start: Int)(using Context): Tree = {
+    val phase = nxLabeledTransPhase(start)
+    if (phase == null) tree
+    else phase.transformLabeled(tree) match {
+      case tree1: Labeled => goLabeled(tree1, phase.idxInGroup + 1)
+      case tree1 => transformNode(tree1, phase.idxInGroup + 1)
+    }
+  }
+
+  def prepReturn(tree: Return, start: Int)(using Context): Context = {
+    val phase = nxReturnPrepPhase(start)
+    if (phase == null) ctx
+    else prepReturn(tree, phase.idxInGroup + 1)(using phase.prepareForReturn(tree))
+  }
+
+  def goReturn(tree: Return, start: Int)(using Context): Tree = {
+    val phase = nxReturnTransPhase(start)
+    if (phase == null) tree
+    else phase.transformReturn(tree) match {
+      case tree1: Return => goReturn(tree1, phase.idxInGroup + 1)
+      case tree1 => transformNode(tree1, phase.idxInGroup + 1)
+    }
+  }
+
+  def prepWhileDo(tree: WhileDo, start: Int)(using Context): Context = {
+    val phase = nxWhileDoPrepPhase(start)
+    if (phase == null) ctx
+    else prepWhileDo(tree, phase.idxInGroup + 1)(using phase.prepareForWhileDo(tree))
+  }
+
+  def goWhileDo(tree: WhileDo, start: Int)(using Context): Tree = {
+    val phase = nxWhileDoTransPhase(start)
+    if (phase == null) tree
+    else phase.transformWhileDo(tree) match {
+      case tree1: WhileDo => goWhileDo(tree1, phase.idxInGroup + 1)
+      case tree1 => transformNode(tree1, phase.idxInGroup + 1)
+    }
+  }
+
+  def prepTry(tree: Try, start: Int)(using Context): Context = {
+    val phase = nxTryPrepPhase(start)
+    if (phase == null) ctx
+    else prepTry(tree, phase.idxInGroup + 1)(using phase.prepareForTry(tree))
+  }
+
+  def goTry(tree: Try, start: Int)(using Context): Tree = {
+    val phase = nxTryTransPhase(start)
+    if (phase == null) tree
+    else phase.transformTry(tree) match {
+      case tree1: Try => goTry(tree1, phase.idxInGroup + 1)
+      case tree1 => transformNode(tree1, phase.idxInGroup + 1)
+    }
+  }
+
+  def prepSeqLiteral(tree: SeqLiteral, start: Int)(using Context): Context = {
+    val phase = nxSeqLiteralPrepPhase(start)
+    if (phase == null) ctx
+    else prepSeqLiteral(tree, phase.idxInGroup + 1)(using phase.prepareForSeqLiteral(tree))
+  }
+
+  def goSeqLiteral(tree: SeqLiteral, start: Int)(using Context): Tree = {
+    val phase = nxSeqLiteralTransPhase(start)
+    if (phase == null) tree
+    else phase.transformSeqLiteral(tree) match {
+      case tree1: SeqLiteral => goSeqLiteral(tree1, phase.idxInGroup + 1)
+      case tree1 => transformNode(tree1, phase.idxInGroup + 1)
+    }
+  }
+
+  def prepInlined(tree: Inlined, start: Int)(using Context): Context = {
+    val phase = nxInlinedPrepPhase(start)
+    if (phase == null) ctx
+    else prepInlined(tree, phase.idxInGroup + 1)(using phase.prepareForInlined(tree))
+  }
+
+  def goInlined(tree: Inlined, start: Int)(using Context): Tree = {
+    val phase = nxInlinedTransPhase(start)
+    if (phase == null) tree
+    else phase.transformInlined(tree) match {
+      case tree1: Inlined => goInlined(tree1, phase.idxInGroup + 1)
+      case tree1 => transformNode(tree1, phase.idxInGroup + 1)
+    }
+  }
+
+  def prepTypeTree(tree: TypeTree, start: Int)(using Context): Context = {
+    val phase = nxTypeTreePrepPhase(start)
+    if (phase == null) ctx
+    else prepTypeTree(tree, phase.idxInGroup + 1)(using phase.prepareForTypeTree(tree))
+  }
+
+  def goTypeTree(tree: TypeTree, start: Int)(using Context): Tree = {
+    val phase = nxTypeTreeTransPhase(start)
+    if (phase == null) tree
+    else phase.transformTypeTree(tree) match {
+      case tree1: TypeTree => goTypeTree(tree1, phase.idxInGroup + 1)
+      case tree1 => transformNode(tree1, phase.idxInGroup + 1)
+    }
+  }
+
+  def prepBind(tree: Bind, start: Int)(using Context): Context = {
+    val phase = nxBindPrepPhase(start)
+    if (phase == null) ctx
+    else prepBind(tree, phase.idxInGroup + 1)(using phase.prepareForBind(tree))
+  }
+
+  def goBind(tree: Bind, start: Int)(using Context): Tree = {
+    val phase = nxBindTransPhase(start)
+    if (phase == null) tree
+    else phase.transformBind(tree) match {
+      case tree1: Bind => goBind(tree1, phase.idxInGroup + 1)
+      case tree1 => transformNode(tree1, phase.idxInGroup + 1)
+    }
+  }
+
+  def prepAlternative(tree: Alternative, start: Int)(using Context): Context = {
+    val phase = nxAlternativePrepPhase(start)
+    if (phase == null) ctx
+    else prepAlternative(tree, phase.idxInGroup + 1)(using phase.prepareForAlternative(tree))
+  }
+
+  def goAlternative(tree: Alternative, start: Int)(using Context): Tree = {
+    val phase = nxAlternativeTransPhase(start)
+    if (phase == null) tree
+    else phase.transformAlternative(tree) match {
+      case tree1: Alternative => goAlternative(tree1, phase.idxInGroup + 1)
+      case tree1 => transformNode(tree1, phase.idxInGroup + 1)
+    }
+  }
+
+  def prepUnApply(tree: UnApply, start: Int)(using Context): Context = {
+    val phase = nxUnApplyPrepPhase(start)
+    if (phase == null) ctx
+    else prepUnApply(tree, phase.idxInGroup + 1)(using phase.prepareForUnApply(tree))
+  }
+
+  def goUnApply(tree: UnApply, start: Int)(using Context): Tree = {
+    val phase = nxUnApplyTransPhase(start)
+    if (phase == null) tree
+    else phase.transformUnApply(tree) match {
+      case tree1: UnApply => goUnApply(tree1, phase.idxInGroup + 1)
+      case tree1 => transformNode(tree1, phase.idxInGroup + 1)
+    }
+  }
+
+  def prepValDef(tree: ValDef, start: Int)(using Context): Context = {
+    val phase = nxValDefPrepPhase(start)
+    if (phase == null) ctx
+    else prepValDef(tree, phase.idxInGroup + 1)(using phase.prepareForValDef(tree))
+  }
+
+  def goValDef(tree: ValDef, start: Int)(using Context): Tree = {
+    val phase = nxValDefTransPhase(start)
+    if (phase == null) tree
+    else phase.transformValDef(tree) match {
+      case tree1: ValDef => goValDef(tree1, phase.idxInGroup + 1)
+      case tree1 => transformNode(tree1, phase.idxInGroup + 1)
+    }
+  }
+
+  def prepDefDef(tree: DefDef, start: Int)(using Context): Context = {
+    val phase = nxDefDefPrepPhase(start)
+    if (phase == null) ctx
+    else prepDefDef(tree, phase.idxInGroup + 1)(using phase.prepareForDefDef(tree))
+  }
+
+  def goDefDef(tree: DefDef, start: Int)(using Context): Tree = {
+    val phase = nxDefDefTransPhase(start)
+    if (phase == null) tree
+    else phase.transformDefDef(tree) match {
+      case tree1: DefDef => goDefDef(tree1, phase.idxInGroup + 1)
+      case tree1 => transformNode(tree1, phase.idxInGroup + 1)
+    }
+  }
+
+  def prepTypeDef(tree: TypeDef, start: Int)(using Context): Context = {
+    val phase = nxTypeDefPrepPhase(start)
+    if (phase == null) ctx
+    else prepTypeDef(tree, phase.idxInGroup + 1)(using phase.prepareForTypeDef(tree))
+  }
+
+  def goTypeDef(tree: TypeDef, start: Int)(using Context): Tree = {
+    val phase = nxTypeDefTransPhase(start)
+    if (phase == null) tree
+    else phase.transformTypeDef(tree) match {
+      case tree1: TypeDef => goTypeDef(tree1, phase.idxInGroup + 1)
+      case tree1 => transformNode(tree1, phase.idxInGroup + 1)
+    }
+  }
+
+  def prepTemplate(tree: Template, start: Int)(using Context): Context = {
+    val phase = nxTemplatePrepPhase(start)
+    if (phase == null) ctx
+    else prepTemplate(tree, phase.idxInGroup + 1)(using phase.prepareForTemplate(tree))
+  }
+
+  def goTemplate(tree: Template, start: Int)(using Context): Tree = {
+    val phase = nxTemplateTransPhase(start)
+    if (phase == null) tree
+    else phase.transformTemplate(tree) match {
+      case tree1: Template => goTemplate(tree1, phase.idxInGroup + 1)
+      case tree1 => transformNode(tree1, phase.idxInGroup + 1)
+    }
+  }
+
+  def prepPackageDef(tree: PackageDef, start: Int)(using Context): Context = {
+    val phase = nxPackageDefPrepPhase(start)
+    if (phase == null) ctx
+    else prepPackageDef(tree, phase.idxInGroup + 1)(using phase.prepareForPackageDef(tree))
+  }
+
+  def goPackageDef(tree: PackageDef, start: Int)(using Context): Tree = {
+    val phase = nxPackageDefTransPhase(start)
+    if (phase == null) tree
+    else phase.transformPackageDef(tree) match {
+      case tree1: PackageDef => goPackageDef(tree1, phase.idxInGroup + 1)
+      case tree1 => transformNode(tree1, phase.idxInGroup + 1)
+    }
+  }
+
+  def prepStats(trees: List[Tree], start: Int)(using Context): Context = {
+    val phase = nxStatsPrepPhase(start)
+    if (phase == null) ctx
+    else prepStats(trees, phase.idxInGroup + 1)(using phase.prepareForStats(trees))
+  }
+
+  def goStats(trees: List[Tree], start: Int)(using Context): List[Tree] = {
+    val phase = nxStatsTransPhase(start)
+    if (phase == null) trees
+    else goStats(phase.transformStats(trees), phase.idxInGroup + 1)
+  }
+
+  def prepUnit(tree: Tree, start: Int)(using Context): Context = {
+    val phase = nxUnitPrepPhase(start)
+    if (phase == null) ctx
+    else prepUnit(tree, phase.idxInGroup + 1)(using phase.prepareForUnit(tree))
+  }
+
+  def goUnit(tree: Tree, start: Int)(using Context): Tree = {
+    val phase = nxUnitTransPhase(start)
+    if (phase == null) tree
+    else goUnit(phase.transformUnit(tree), phase.idxInGroup + 1)
+  }
+
+  def prepOther(tree: Tree, start: Int)(using Context): Context = {
+    val phase = nxOtherPrepPhase(start)
+    if (phase == null) ctx
+    else prepOther(tree, phase.idxInGroup + 1)(using phase.prepareForOther(tree))
+  }
+
+  def goOther(tree: Tree, start: Int)(using Context): Tree = {
+    val phase = nxOtherTransPhase(start)
+    if (phase == null) tree
+    else goOther(phase.transformOther(tree), phase.idxInGroup + 1)
+  }
+}
diff --git a/tests/pos-with-compiler-cc/dotc/transform/Memoize.scala b/tests/pos-with-compiler-cc/dotc/transform/Memoize.scala
new file mode 100644
index 000000000000..3552d08e81f2
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/transform/Memoize.scala
@@ -0,0 +1,222 @@
+package dotty.tools.dotc
+package transform
+
+import core._
+import DenotTransformers._
+import Contexts._
+import Phases.phaseOf
+import SymDenotations.SymDenotation
+import Denotations._
+import Symbols._
+import SymUtils._
+import Constants._
+import MegaPhase._
+import NameOps._
+import Flags._
+import Decorators._
+import StdNames.nme
+
+import sjs.JSSymUtils._
+
+import util.Store
+
+import dotty.tools.backend.sjs.JSDefinitions.jsdefn
+
+object Memoize {
+  val name: String = "memoize"
+  val description: String = "add private fields to getters and setters"
+
+  private final class MyState {
+    val classesThatNeedReleaseFence: util.HashSet[Symbol] = new util.HashSet()
+  }
+}
+
+/** Provides the implementations of all getters and setters, introducing
+ *  fields to hold the value accessed by them.
+ *  TODO: Make LazyVals a part of this phase?
+ *
+ *    <accessor> <stable> <mods> def x(): T = e
+ *      -->  private val x: T = e
+ *           <accessor> <stable> <mods> def x(): T = x
+ *
+ *    <accessor> <mods> def x(): T = e
+ *      -->  private[this] var x: T = e
+ *           <accessor> <mods> def x(): T = x
+ *
+ *    <accessor> <mods> def x_=(y: T): Unit = ()
+ *      --> <accessor> <mods> def x_=(y: T): Unit = x = y
+ */
+class Memoize extends MiniPhase with IdentityDenotTransformer { thisPhase =>
+  import Memoize.MyState
+  import ast.tpd._
+
+  override def phaseName: String = Memoize.name
+
+  override def description: String = Memoize.description
+
+  private var MyState: Store.Location[MyState] = _
+  private def myState(using Context): MyState = ctx.store(MyState)
+
+  override def initContext(ctx: FreshContext): Unit =
+    MyState = ctx.addLocation[MyState]()
+
+  /* Makes sure that, after getters and constructors gen, there doesn't
+   * exist non-deferred definitions that are not implemented. */
+  override def checkPostCondition(tree: Tree)(using Context): Unit = {
+    def errorLackImplementation(t: Tree) = {
+      val definingPhase = phaseOf(t.symbol.initial.validFor.firstPhaseId)
+      throw new AssertionError(
+        i"Non-deferred definition introduced by $definingPhase lacks implementation: $t")
+    }
+    tree match {
+      case ddef: DefDef
+        if !ddef.symbol.is(Deferred) &&
+           !ddef.symbol.isConstructor && // constructors bodies are added later at phase Constructors
+           ddef.rhs == EmptyTree =>
+        errorLackImplementation(ddef)
+      case tdef: TypeDef
+        if tdef.symbol.isClass && !tdef.symbol.is(Deferred) && tdef.rhs == EmptyTree =>
+        errorLackImplementation(tdef)
+      case _ =>
+    }
+    super.checkPostCondition(tree)
+  }
+
+  /** Should run after mixin so that fields get generated in the
+   *  class that contains the concrete getter rather than the trait
+   *  that defines it.
+   */
+  override def runsAfter: Set[String] = Set(Mixin.name)
+
+  override def prepareForUnit(tree: Tree)(using Context): Context =
+    ctx.fresh.updateStore(MyState, new MyState())
+
+  override def transformTemplate(tree: Template)(using Context): Tree =
+    val cls = ctx.owner.asClass
+    if myState.classesThatNeedReleaseFence.contains(cls) then
+      val releaseFenceCall = ref(defn.staticsMethodRef(nme.releaseFence)).appliedToNone
+      cpy.Template(tree)(tree.constr, tree.parents, Nil, tree.self, tree.body :+ releaseFenceCall)
+    else
+      tree
+
+  override def transformDefDef(tree: DefDef)(using Context): Tree = {
+    val sym = tree.symbol
+
+    def newField = {
+      assert(!sym.hasAnnotation(defn.ScalaStaticAnnot))
+      val fieldType =
+        if (sym.isGetter) sym.info.resultType
+        else /*sym.isSetter*/ sym.info.firstParamTypes.head
+
+      newSymbol(
+        owner = ctx.owner,
+        name  = sym.name.asTermName.fieldName,
+        flags = Private | (if (sym.is(StableRealizable)) EmptyFlags else Mutable),
+        info  = fieldType,
+        coord = tree.span
+      ).withAnnotationsCarrying(sym, defn.FieldMetaAnnot)
+       .enteredAfter(thisPhase)
+    }
+
+    def addAnnotations(denot: Denotation): Unit =
+      denot match {
+        case fieldDenot: SymDenotation if sym.annotations.nonEmpty =>
+          val cpy = fieldDenot.copySymDenotation()
+          cpy.annotations = sym.annotations
+          cpy.installAfter(thisPhase)
+        case _ => ()
+      }
+
+    def removeUnwantedAnnotations(denot: SymDenotation, metaAnnotSym: ClassSymbol): Unit =
+      if (sym.annotations.nonEmpty) {
+        val cpy = sym.copySymDenotation()
+        cpy.filterAnnotations(_.symbol.hasAnnotation(metaAnnotSym))
+        cpy.installAfter(thisPhase)
+      }
+
+    val NoFieldNeeded = Lazy | Deferred | JavaDefined | Inline
+
+    def erasedBottomTree(sym: Symbol) =
+      if (sym eq defn.NothingClass) Throw(nullLiteral)
+      else if (sym eq defn.NullClass) nullLiteral
+      else if (sym eq defn.BoxedUnitClass) ref(defn.BoxedUnit_UNIT)
+      else {
+        assert(false, s"$sym has no erased bottom tree")
+        EmptyTree
+      }
+
+    if sym.is(Accessor, butNot = NoFieldNeeded) then
+      /* Tests whether the semantics of Scala.js require a field for this symbol, irrespective of any
+       * optimization we think we can do. This is the case if one of the following is true:
+       * - it is a member of a JS type, since it needs to be visible as a JavaScript field
+       * - is is exported as static member of the companion class, since it needs to be visible as a JavaScript static field
+       * - it is exported to the top-level, since that can only be done as a true top-level variable, i.e., a field
+       */
+      def sjsNeedsField: Boolean =
+        ctx.settings.scalajs.value && (
+          sym.owner.isJSType
+            || sym.hasAnnotation(jsdefn.JSExportTopLevelAnnot)
+            || sym.hasAnnotation(jsdefn.JSExportStaticAnnot)
+        )
+
+      def adaptToField(field: Symbol, tree: Tree): Tree =
+        if (tree.isEmpty) tree else tree.ensureConforms(field.info.widen)
+
+      def isErasableBottomField(field: Symbol, cls: Symbol): Boolean =
+        !field.isVolatile
+          && ((cls eq defn.NothingClass) || (cls eq defn.NullClass) || (cls eq defn.BoxedUnitClass))
+          && !sjsNeedsField
+
+      if sym.isGetter then
+        val constantFinalVal =
+          sym.isAllOf(Accessor | Final, butNot = Mutable) && tree.rhs.isInstanceOf[Literal] && !sjsNeedsField
+        if constantFinalVal then
+          // constant final vals do not need to be transformed at all, and do not need a field
+          tree
+        else
+          val field = newField.asTerm
+          var rhs = tree.rhs.changeOwnerAfter(sym, field, thisPhase)
+          if (isWildcardArg(rhs)) rhs = EmptyTree
+          val fieldDef = transformFollowing(ValDef(field, adaptToField(field, rhs)))
+          val rhsClass = tree.tpt.tpe.widenDealias.classSymbol
+          val getterRhs =
+            if isErasableBottomField(field, rhsClass) then erasedBottomTree(rhsClass)
+            else transformFollowingDeep(ref(field))(using ctx.withOwner(sym))
+          val getterDef = cpy.DefDef(tree)(rhs = getterRhs)
+          addAnnotations(fieldDef.denot)
+          removeUnwantedAnnotations(sym, defn.GetterMetaAnnot)
+          Thicket(fieldDef, getterDef)
+      else if sym.isSetter then
+        if (!sym.is(ParamAccessor)) { val Literal(Constant(())) = tree.rhs: @unchecked } // This is intended as an assertion
+        val field = sym.field
+        if !field.exists then
+          // When transforming the getter, we determined that no field was needed.
+          // In that case we can keep the setter as is, with a () rhs.
+          tree
+        else if field.getter.is(ParamAccessor, butNot = Mutable) then
+          // This is a trait setter (because not Mutable) for a param accessor.
+          // We must keep the () rhs of the trait setter, otherwise the value
+          // inherited from the trait will overwrite the value of the parameter.
+          // See tests/run/traitValOverriddenByParamAccessor.scala
+          tree
+        else
+          if !field.is(Mutable) then
+            // This is a val mixed in from a trait.
+            // We make it mutable, and mark the class as needing a releaseFence() in the constructor
+            field.setFlag(Mutable)
+            myState.classesThatNeedReleaseFence += sym.owner
+          val initializer =
+            if isErasableBottomField(field, tree.termParamss.head.head.tpt.tpe.classSymbol)
+            then Literal(Constant(()))
+            else Assign(ref(field), adaptToField(field, ref(tree.termParamss.head.head.symbol)))
+          val setterDef = cpy.DefDef(tree)(rhs = transformFollowingDeep(initializer)(using ctx.withOwner(sym)))
+          removeUnwantedAnnotations(sym, defn.SetterMetaAnnot)
+          setterDef
+      else
+        // Curiously, some accessors from Scala2 have ' ' suffixes.
+        // They count as neither getters nor setters.
+        tree
+    else
+      tree
+  }
+}
diff --git a/tests/pos-with-compiler-cc/dotc/transform/Mixin.scala b/tests/pos-with-compiler-cc/dotc/transform/Mixin.scala
new file mode 100644
index 000000000000..9a220d9c4f8c
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/transform/Mixin.scala
@@ -0,0 +1,329 @@
+package dotty.tools
+package dotc
+package transform
+
+import core._
+import MegaPhase._
+import Contexts._
+import Flags._
+import SymUtils._
+import Symbols._
+import SymDenotations._
+import Types._
+import Decorators._
+import DenotTransformers._
+import StdNames._
+import Names._
+import NameKinds._
+import NameOps._
+import ast.Trees._
+
+object Mixin {
+  val name: String = "mixin"
+  val description: String = "expand trait fields and trait initializers"
+
+  def traitSetterName(getter: TermSymbol)(using Context): TermName =
+    extension (name: Name) def qualifiedToSimple = name.replace {
+      case n @ AnyQualifiedName(_, _) => n.toSimpleName
+    }
+    getter.ensureNotPrivate.name
+      .qualifiedToSimple  // TODO: Find out why TraitSetterNames can't be defined over QualifiedNames
+      .expandedName(getter.owner, TraitSetterName)
+      .asTermName.syntheticSetterName
+}
+
+/** This phase performs the following transformations:
+ *
+ *   1. (done in `traitDefs` and `transformSym`) For every concrete trait getter
+ *
+ *       <mods> def x(): T = expr
+ *
+ *   make it non-private, and add the definition of its trait setter:
+ *
+ *       <mods> def TraitName$_setter_$x(v: T): Unit
+ *
+ *   2. (done in `traitDefs`) Make every concrete trait setter
+ *
+ *      <mods> def x_=(y: T) = ()
+ *
+ *     deferred by mapping it to
+ *
+ *      <mods> def x_=(y: T)
+ *
+ *   3. (done in `transformSym`) For every module class constructor in traits,
+ *      remove its Private flag (but do not expand its name), since it will have
+ *      to be instantiated in the classes that mix in the trait.
+ *
+ *   4. For a non-trait class C:
+ *
+ *        For every trait M directly implemented by the class (see SymUtils.mixin), in
+ *        reverse linearization order, add the following definitions to C:
+ *
+ *          4.1 (done in `traitInits`) For every parameter accessor `<mods> def x(): T` in M,
+ *              in order of textual occurrence, add
+ *
+ *               <mods> def x() = e
+ *
+ *              where `e` is the constructor argument in C that corresponds to `x`. Issue
+ *              an error if no such argument exists.
+ *
+ *          4.2 (done in `traitInits`) For every concrete trait getter `<mods> def x(): T` in M
+ *              which is not a parameter accessor, in order of textual occurrence, produce the following:
+ *
+ *              4.2.1 If `x` is also a member of `C`, and is a lazy val,
+ *
+ *                <mods> lazy val x: T = super[M].x
+ *
+ *              4.2.2 If `x` is also a member of `C`, and is a module,
+ *
+ *                <mods> lazy module val x: T = new T$(this)
+ *
+ *              4.2.3 If `x` is also a member of `C`, and is something else:
+ *
+ *                <mods> def x(): T = _
+ *
+ *              4.2.5 If `x` is not a member of `C`, nothing gets added.
+ *
+ *          4.3 (done in `superCallOpt`) The call:
+ *
+ *                super[M].$init$()
+ *
+ *          4.4 (done in `setters`) For every concrete setter `<mods> def x_=(y: T)` in M:
+ *
+ *                <mods> def x_=(y: T) = ()
+ *
+ *          4.5 (done in `mixinForwarders`) For every method
+ *          `<mods> def f[Ts](ps1)...(psN): U` imn M` that needs to be disambiguated:
+ *
+ *                <mods> def f[Ts](ps1)...(psN): U = super[M].f[Ts](ps1)...(psN)
+ *
+ *          A method in M needs to be disambiguated if it is concrete, not overridden in C,
+ *          and if it overrides another concrete method.
+ *
+ *   5. (done in `transformTemplate` and `transformSym`) Drop all parameters from trait
+ *      constructors, and rename them to `nme.TRAIT_CONSTRUCTOR`.
+ *
+ *   6. (done in `transformSym`) Drop ParamAccessor flag from all parameter accessors in traits.
+ *
+ *  Conceptually, this is the second half of the previous mixin phase. It needs to run
+ *  after erasure because it copies references to possibly private inner classes and objects
+ *  into enclosing classes where they are not visible. This can only be done if all references
+ *  are symbolic.
+ */
+class Mixin extends MiniPhase with SymTransformer { thisPhase =>
+  import ast.tpd._
+
+  override def phaseName: String = Mixin.name
+
+  override def description: String = Mixin.description
+
+  override def relaxedTypingInGroup: Boolean = true
+    // Because it changes number of parameters in trait initializers
+
+  override def runsAfter: Set[String] = Set(
+    Erasure.name,
+    CompleteJavaEnums.name // This phase changes constructor parameters which Mixin translates into super-calls
+  )
+
+  override def changesMembers: Boolean = true  // the phase adds implementions of mixin accessors
+
+  override def transformSym(sym: SymDenotation)(using Context): SymDenotation =
+    def ownerIsTrait: Boolean = was(sym.owner, Trait, butNot = JavaDefined)
+
+    if (sym.is(Accessor, butNot = Deferred) && ownerIsTrait) {
+      val sym1 =
+        if (sym.is(Lazy) || sym.symbol.isConstExprFinalVal) sym
+        else sym.copySymDenotation(initFlags = sym.flags &~ (ParamAccessor | Inline) | Deferred)
+      sym1.ensureNotPrivate
+    }
+    else if sym.isAllOf(ModuleClass | Private) && ownerIsTrait then
+      // modules in trait will be instantiated in the classes mixing in the trait; they must be made non-private
+      // do not use ensureNotPrivate because the `name` must not be expanded in this case
+      sym.copySymDenotation(initFlags = sym.flags &~ Private)
+    else if (sym.isConstructor && ownerIsTrait)
+      sym.copySymDenotation(
+        name = nme.TRAIT_CONSTRUCTOR,
+        info = MethodType(Nil, sym.info.resultType))
+    else if sym.is(Trait, butNot = JavaDefined) then
+      val classInfo = sym.asClass.classInfo
+      lazy val decls1 = classInfo.decls.cloneScope
+      var modified: Boolean = false
+      for (decl <- classInfo.decls)
+        // !decl.isClass avoids forcing nested traits, preventing cycles
+        if !decl.isClass && needsTraitSetter(decl) then
+          val setter = makeTraitSetter(decl.asTerm)
+          setter.validFor = thisPhase.validFor // validity of setter = next phase up to next transformer afterwards
+          decls1.enter(setter)
+          modified = true
+      if modified then
+        sym.copySymDenotation(
+          info = classInfo.derivedClassInfo(decls = decls1))
+      else
+        sym
+    else
+      sym
+  end transformSym
+
+  private def wasOneOf(sym: Symbol, flags: FlagSet)(using Context): Boolean =
+    atPhase(thisPhase) { sym.isOneOf(flags) }
+
+  private def was(sym: Symbol, flag: Flag, butNot: FlagSet)(using Context): Boolean =
+    atPhase(thisPhase) { sym.is(flag, butNot) }
+
+  private def needsTraitSetter(sym: Symbol)(using Context): Boolean =
+    sym.isGetter && !wasOneOf(sym, DeferredOrLazy | ParamAccessor)
+      && atPhase(thisPhase) { !sym.setter.exists }
+      && !sym.isConstExprFinalVal
+
+  private def makeTraitSetter(getter: TermSymbol)(using Context): Symbol =
+    getter.copy(
+      name = Mixin.traitSetterName(getter),
+      flags = Method | Accessor | Deferred,
+      info = MethodType(getter.info.resultType :: Nil, defn.UnitType))
+
+  override def transformTemplate(impl: Template)(using Context): Template = {
+    val cls = impl.symbol.owner.asClass
+    val ops = new MixinOps(cls, thisPhase)
+    import ops._
+
+    def traitDefs(stats: List[Tree]): List[Tree] = {
+      stats.flatMap {
+        case stat: DefDef if needsTraitSetter(stat.symbol) =>
+          // add a trait setter for this getter
+          stat :: DefDef(stat.symbol.traitSetter.asTerm, EmptyTree) :: Nil
+        case stat: DefDef if stat.symbol.isSetter =>
+          cpy.DefDef(stat)(rhs = EmptyTree) :: Nil
+        case stat =>
+          stat :: Nil
+      }
+    }
+
+    /** Map constructor call to a triple of a supercall, and if the target
+     *  is a trait
+     *   - a list of val defs used in arguments (these can arise
+     *     due to reorderings with named and/or default parameters).
+     *   - a list of arguments to be used as initializers of trait parameters
+     */
+    def transformConstructor(tree: Tree): (Tree, List[Tree], List[Tree]) = tree match {
+      case Block(stats, expr) =>
+        val (scall, inits, args) = transformConstructor(expr)
+        if args.isEmpty then
+          (cpy.Block(tree)(stats, scall), inits, args)
+        else // it's a trait constructor with parameters, lift all prefix statements to class context
+             // so that they precede argument definitions.
+          stats.foreach {
+            case stat: ValDef =>
+              stat.symbol.copySymDenotation(
+                owner = cls,
+                initFlags = stat.symbol.flags | PrivateLocal
+              ).installAfter(thisPhase)
+              stat.symbol.enteredAfter(thisPhase)
+            case _ =>
+          }
+          (scall, stats ::: inits, args)
+      case _ =>
+        val Apply(sel @ Select(New(_), nme.CONSTRUCTOR), args) = tree: @unchecked
+        val (callArgs, initArgs) = if (tree.symbol.owner.is(Trait)) (Nil, args) else (args, Nil)
+        (superRef(tree.symbol, tree.span).appliedToTermArgs(callArgs), Nil, initArgs)
+    }
+
+    val superCallsAndArgs: Map[Symbol, (Tree, List[Tree], List[Tree])] = (
+      for
+        p: Tree <- impl.parents  // !cc! explicit type on `p` is needed
+        constr = stripBlock(p).symbol
+        if constr.isConstructor
+      yield constr.owner -> transformConstructor(p)
+    ).toMap
+
+    def superCallOpt(baseCls: Symbol): List[Tree] = superCallsAndArgs.get(baseCls) match
+      case Some((call, _, _)) =>
+        if (defn.NotRuntimeClasses.contains(baseCls) || baseCls.isAllOf(NoInitsTrait)) Nil
+        else call :: Nil
+      case None =>
+        if baseCls.isAllOf(NoInitsTrait) || defn.NoInitClasses.contains(baseCls) || defn.isFunctionClass(baseCls) then
+          Nil
+        else
+          //println(i"synth super call ${baseCls.primaryConstructor}: ${baseCls.primaryConstructor.info}")
+          transformFollowingDeep(superRef(baseCls.primaryConstructor).appliedToNone) :: Nil
+
+    def traitInits(mixin: ClassSymbol): List[Tree] = {
+      val argsIt = superCallsAndArgs.get(mixin) match
+        case Some((_, _, args)) => args.iterator
+        case _ => Iterator.empty
+      def nextArgument() =
+        if argsIt.hasNext then argsIt.next
+        else
+          assert(
+              impl.parents.forall(_.tpe.typeSymbol != mixin),
+              i"missing parameters for $mixin from $impl should have been caught in typer")
+          report.error(
+              em"""parameterized $mixin is indirectly implemented,
+                  |needs to be implemented directly so that arguments can be passed""",
+              cls.srcPos)
+          EmptyTree
+
+      for
+        getter <- mixin.info.decls.toList
+        if getter.isGetter
+           && !getter.isEffectivelyErased
+           && !wasOneOf(getter, Deferred)
+           && !getter.isConstExprFinalVal
+      yield
+        if (isInImplementingClass(getter) || getter.name.is(ExpandedName)) {
+          val rhs =
+            if (wasOneOf(getter, ParamAccessor))
+              nextArgument()
+            else if (getter.is(Lazy, butNot = Module))
+              transformFollowing(superRef(getter).appliedToNone)
+            else if (getter.is(Module))
+              New(getter.info.resultType, List(This(cls)))
+            else
+              Underscore(getter.info.resultType)
+          // transformFollowing call is needed to make memoize & lazy vals run
+          transformFollowing(DefDef(mkForwarderSym(getter.asTerm), rhs))
+        }
+        else if wasOneOf(getter, ParamAccessor) then
+          // mixin parameter field is defined by an override; evaluate the argument and throw it away
+          nextArgument()
+        else EmptyTree
+    }
+
+    def setters(mixin: ClassSymbol): List[Tree] =
+      val mixinSetters = mixin.info.decls.filter { sym =>
+        sym.isSetter && (!wasOneOf(sym, Deferred) || sym.name.is(TraitSetterName))
+      }
+      for (setter <- mixinSetters)
+      yield transformFollowing(DefDef(mkForwarderSym(setter.asTerm), unitLiteral.withSpan(cls.span)))
+
+    def mixinForwarders(mixin: ClassSymbol): List[Tree] =
+      for (meth <- mixin.info.decls.toList if needsMixinForwarder(meth))
+      yield {
+        util.Stats.record("mixin forwarders")
+        transformFollowing(DefDef(mkForwarderSym(meth.asTerm, Bridge), forwarderRhsFn(meth)))
+      }
+
+    cpy.Template(impl)(
+      constr =
+        if (cls.is(Trait)) cpy.DefDef(impl.constr)(paramss = Nil :: Nil)
+        else impl.constr,
+      parents = impl.parents.map(p => TypeTree(p.tpe).withSpan(p.span)),
+      body =
+        if (cls.is(Trait)) traitDefs(impl.body)
+        else if (!cls.isPrimitiveValueClass) {
+          val mixInits = mixins.flatMap { mixin =>
+            val prefix = superCallsAndArgs.get(mixin) match
+              case Some((_, inits, _)) => inits
+              case _ => Nil
+            prefix
+            ::: flatten(traitInits(mixin))
+            ::: superCallOpt(mixin)
+            ::: setters(mixin)
+            ::: mixinForwarders(mixin)
+          }
+          superCallOpt(superCls)
+          ::: mixInits
+          ::: impl.body
+        }
+        else impl.body)
+  }
+}
diff --git a/tests/pos-with-compiler-cc/dotc/transform/MixinOps.scala b/tests/pos-with-compiler-cc/dotc/transform/MixinOps.scala
new file mode 100644
index 000000000000..fa1c09806893
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/transform/MixinOps.scala
@@ -0,0 +1,104 @@
+package dotty.tools.dotc
+package transform
+
+import core._
+import Symbols._, Types._, Contexts._, DenotTransformers._, Flags._
+import util.Spans._
+import SymUtils._
+import StdNames._, NameOps._
+import typer.Nullables
+
+class MixinOps(cls: ClassSymbol, thisPhase: DenotTransformer)(using Context) {
+  import ast.tpd._
+
+  val superCls: Symbol = cls.superClass
+  val mixins: List[ClassSymbol] = cls.mixins
+
+  lazy val JUnit4Annotations: List[Symbol] = List("Test", "Ignore", "Before", "After", "BeforeClass", "AfterClass").
+    map(n => getClassIfDefined("org.junit." + n)).
+    filter(_.exists)
+
+  def mkForwarderSym(member: TermSymbol, extraFlags: FlagSet = EmptyFlags): TermSymbol = {
+    val res = member.copy(
+      owner = cls,
+      name = member.name.stripScala2LocalSuffix,
+      flags = member.flags &~ Deferred &~ Module | Synthetic | extraFlags,
+      info = cls.thisType.memberInfo(member)).enteredAfter(thisPhase).asTerm
+    res.addAnnotations(member.annotations.filter(_.symbol != defn.TailrecAnnot))
+    res
+  }
+
+  def superRef(target: Symbol, span: Span = cls.span): Tree = {
+    val sup = if (target.isConstructor && !target.owner.is(Trait))
+      Super(This(cls), tpnme.EMPTY)
+    else
+      Super(This(cls), target.owner.name.asTypeName, target.owner)
+    //println(i"super ref $target on $sup")
+    ast.untpd.Select(sup.withSpan(span), target.name)
+      .withType(NamedType(sup.tpe, target))
+    //sup.select(target)
+  }
+
+  /** Is `sym` a member of implementing class `cls`?
+   *  The test is performed at phase `thisPhase`.
+   */
+  def isInImplementingClass(sym: Symbol): Boolean =
+    atPhase(thisPhase) {
+      cls.info.nonPrivateMember(sym.name).hasAltWith(_.symbol == sym)
+    }
+
+  /** Does `method` need a forwarder to in  class `cls`
+   *  Method needs a forwarder in those cases:
+   *   - there's a class defining a method with same signature
+   *   - there are multiple traits defining method with same signature
+   */
+  def needsMixinForwarder(meth: Symbol): Boolean = {
+    lazy val competingMethods = competingMethodsIterator(meth).toList
+
+    def needsDisambiguation = competingMethods.exists(x=> !x.is(Deferred)) // multiple implementations are available
+    def hasNonInterfaceDefinition = competingMethods.exists(!_.owner.is(Trait)) // there is a definition originating from class
+
+    // JUnit 4 won't recognize annotated default methods, so always generate a forwarder for them.
+    def generateJUnitForwarder: Boolean =
+      meth.annotations.nonEmpty && JUnit4Annotations.exists(annot => meth.hasAnnotation(annot)) &&
+        ctx.settings.mixinForwarderChoices.isAtLeastJunit
+
+    // Similarly, Java serialization won't take into account a readResolve/writeReplace default method.
+    def generateSerializationForwarder: Boolean =
+       (meth.name == nme.readResolve || meth.name == nme.writeReplace) && meth.info.paramNamess.flatten.isEmpty
+
+    !meth.isConstructor &&
+    meth.is(Method, butNot = PrivateOrAccessorOrDeferred) &&
+    (ctx.settings.mixinForwarderChoices.isTruthy || meth.owner.is(Scala2x) || needsDisambiguation || hasNonInterfaceDefinition ||
+     generateJUnitForwarder || generateSerializationForwarder) &&
+    isInImplementingClass(meth)
+  }
+
+  final val PrivateOrAccessor: FlagSet = Private | Accessor
+  final val PrivateOrAccessorOrDeferred: FlagSet = Private | Accessor | Deferred
+
+  def forwarderRhsFn(target: Symbol): List[List[Tree]] => Tree =
+    prefss =>
+      val (targs, vargss) = splitArgs(prefss)
+      val tapp = superRef(target).appliedToTypeTrees(targs)
+      val rhs = vargss match
+        case Nil | List(Nil) =>
+          // Overriding is somewhat loose about `()T` vs `=> T`, so just pick
+          // whichever makes sense for `target`
+          tapp.ensureApplied
+        case _ =>
+          tapp.appliedToArgss(vargss)
+      if ctx.explicitNulls && target.is(JavaDefined) && !ctx.phase.erasedTypes then
+        // We may forward to a super Java member in resolveSuper phase.
+        // Since this is still before erasure, the type can be nullable
+        // and causes error during checking. So we need to enable
+        // unsafe-nulls to construct the rhs.
+        Block(Nullables.importUnsafeNulls :: Nil, rhs)
+      else rhs
+
+  private def competingMethodsIterator(meth: Symbol): Iterator[Symbol] =
+    cls.baseClasses.iterator
+      .filter(_ ne meth.owner)
+      .map(base => meth.overriddenSymbol(base, cls))
+      .filter(_.exists)
+}
diff --git a/tests/pos-with-compiler-cc/dotc/transform/MoveStatics.scala b/tests/pos-with-compiler-cc/dotc/transform/MoveStatics.scala
new file mode 100644
index 000000000000..c50a96dc8b81
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/transform/MoveStatics.scala
@@ -0,0 +1,93 @@
+package dotty.tools.dotc
+package transform
+
+import core._
+import Flags._
+import Contexts._
+import Symbols._
+import DenotTransformers.SymTransformer
+import Types.MethodType
+import Annotations.Annotation
+import SymDenotations.SymDenotation
+import Names.Name
+import StdNames.nme
+import NameOps._
+
+import ast._
+
+import SymUtils._
+import MegaPhase._
+
+/** Move static methods from companion to the class itself */
+class MoveStatics extends MiniPhase with SymTransformer {
+  import ast.tpd._
+
+  override def phaseName: String = MoveStatics.name
+
+  override def description: String = MoveStatics.description
+
+  def transformSym(sym: SymDenotation)(using Context): SymDenotation =
+    if (sym.hasAnnotation(defn.ScalaStaticAnnot) && sym.owner.is(Flags.Module) && sym.owner.companionClass.exists &&
+        (sym.is(Flags.Method) || !(sym.is(Flags.Mutable) && sym.owner.companionClass.is(Flags.Trait)))) {
+      sym.owner.asClass.delete(sym.symbol)
+      sym.owner.companionClass.asClass.enter(sym.symbol)
+      sym.copySymDenotation(owner = sym.owner.companionClass)
+    }
+    else sym
+
+  override def transformStats(trees: List[Tree])(using Context): List[Tree] =
+    if (ctx.owner.is(Flags.Package)) {
+      val (classes, others) = trees.partition(x => x.isInstanceOf[TypeDef] && x.symbol.isClass)
+      val pairs = classes.groupBy(cls => cls.symbol.name.stripModuleClassSuffix: Name).asInstanceOf[Map[Name, List[TypeDef]]]
+        // !cc! type ascription `: Name` needed to make it compile under captureChecking
+
+      def rebuild(orig: TypeDef, newBody: List[Tree]): Tree = {
+        val staticFields = newBody.filter(x => x.isInstanceOf[ValDef] && x.symbol.hasAnnotation(defn.ScalaStaticAnnot)).asInstanceOf[List[ValDef]]
+        val newBodyWithStaticConstr =
+          if (staticFields.nonEmpty) {
+            /* do NOT put Flags.JavaStatic here. It breaks .enclosingClass */
+            val staticCostructor = newSymbol(orig.symbol, nme.STATIC_CONSTRUCTOR, Flags.Synthetic | Flags.Method | Flags.Private, MethodType(Nil, defn.UnitType))
+            staticCostructor.addAnnotation(Annotation(defn.ScalaStaticAnnot))
+            staticCostructor.entered
+
+            val staticAssigns = staticFields.map(x => Assign(ref(x.symbol), x.rhs.changeOwner(x.symbol, staticCostructor)))
+            tpd.DefDef(staticCostructor, Block(staticAssigns, tpd.unitLiteral)) :: newBody
+          }
+          else newBody
+
+        val oldTemplate = orig.rhs.asInstanceOf[Template]
+        cpy.TypeDef(orig)(rhs = cpy.Template(oldTemplate)(body = newBodyWithStaticConstr))
+      }
+
+      def move(module: TypeDef, companion: TypeDef): List[Tree] = {
+        assert(companion != module)
+        if (!module.symbol.is(Flags.Module)) move(companion, module)
+        else {
+          val moduleTmpl = module.rhs.asInstanceOf[Template]
+          val companionTmpl = companion.rhs.asInstanceOf[Template]
+          val (staticDefs, remainingDefs) = moduleTmpl.body.partition {
+            case memberDef: MemberDef => memberDef.symbol.isScalaStatic
+            case _ => false
+          }
+
+          rebuild(companion, companionTmpl.body ++ staticDefs) :: rebuild(module, remainingDefs) :: Nil
+        }
+      }
+      val newPairs =
+        for ((name, classes) <- pairs)
+          yield
+            if (classes.tail.isEmpty) {
+              val classDef = classes.head
+              val tmpl = classDef.rhs.asInstanceOf[Template]
+              rebuild(classDef, tmpl.body) :: Nil
+            }
+            else move(classes.head, classes.tail.head)
+      Trees.flatten(newPairs.toList.flatten ++ others)
+    }
+    else trees
+}
+
+object MoveStatics {
+  val name: String = "moveStatic"
+  val description: String = "move static methods from companion to the class itself"
+}
diff --git a/tests/pos-with-compiler-cc/dotc/transform/NonLocalReturns.scala b/tests/pos-with-compiler-cc/dotc/transform/NonLocalReturns.scala
new file mode 100644
index 000000000000..7e1ae9e661f6
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/transform/NonLocalReturns.scala
@@ -0,0 +1,105 @@
+package dotty.tools.dotc
+package transform
+
+import core._
+import Contexts._, Symbols._, Types._, Flags._, StdNames._
+import MegaPhase._
+import NameKinds.NonLocalReturnKeyName
+import config.SourceVersion.*
+
+object NonLocalReturns {
+  import ast.tpd._
+
+  val name: String = "nonLocalReturns"
+  val description: String = "expand non-local returns"
+
+  def isNonLocalReturn(ret: Return)(using Context): Boolean =
+    !ret.from.symbol.is(Label) && (ret.from.symbol != ctx.owner.enclosingMethod || ctx.owner.is(Lazy))
+}
+
+/** Implement non-local returns using NonLocalReturnControl exceptions.
+ */
+class NonLocalReturns extends MiniPhase {
+
+  override def phaseName: String = NonLocalReturns.name
+
+  override def description: String = NonLocalReturns.description
+
+  import NonLocalReturns._
+  import ast.tpd._
+
+  override def runsAfter: Set[String] = Set(ElimByName.name)
+
+  private def ensureConforms(tree: Tree, pt: Type)(using Context) =
+    if (tree.tpe <:< pt) tree
+    else Erasure.Boxing.adaptToType(tree, pt)
+
+  private def nonLocalReturnControl(using Context) = defn.NonLocalReturnControlClass.typeRef
+
+  /** The type of a non-local return expression with given argument type */
+  private def nonLocalReturnExceptionType(argtype: Type)(using Context) =
+    nonLocalReturnControl.appliedTo(argtype)
+
+  /** A hashmap from method symbols to non-local return keys */
+  private val nonLocalReturnKeys = MutableSymbolMap[TermSymbol]()
+
+  /** Return non-local return key for given method */
+  private def nonLocalReturnKey(meth: Symbol)(using Context) =
+    nonLocalReturnKeys.getOrElseUpdate(meth,
+      newSymbol(
+        meth, NonLocalReturnKeyName.fresh(), Synthetic, defn.ObjectType, coord = meth.span))
+
+  /** Generate a non-local return throw with given return expression from given method.
+   *  I.e. for the method's non-local return key, generate:
+   *
+   *    throw new NonLocalReturnControl(key, expr)
+   *  todo: maybe clone a pre-existing exception instead?
+   *  (but what to do about exceptions that miss their targets?)
+   */
+  private def nonLocalReturnThrow(expr: Tree, meth: Symbol)(using Context) =
+    Throw(
+      New(
+        nonLocalReturnControl,
+        ref(nonLocalReturnKey(meth)) :: expr.ensureConforms(defn.ObjectType) :: Nil))
+
+  /** Transform (body, key) to:
+   *
+   *  {
+   *    val key = new Object()
+   *    try {
+   *      body
+   *    } catch {
+   *      case ex: NonLocalReturnControl =>
+   *        if (ex.key().eq(key)) ex.value().asInstanceOf[T]
+   *        else throw ex
+   *    }
+   *  }
+   */
+  private def nonLocalReturnTry(body: Tree, key: TermSymbol, meth: Symbol)(using Context) = {
+    val keyDef = ValDef(key, New(defn.ObjectType, Nil))
+    val ex = newSymbol(meth, nme.ex, Case, nonLocalReturnControl, coord = body.span)
+    val pat = BindTyped(ex, nonLocalReturnControl)
+    val rhs = If(
+        ref(ex).select(nme.key).appliedToNone.select(nme.eq).appliedTo(ref(key)),
+        ref(ex).select(nme.value).ensureConforms(meth.info.finalResultType),
+        Throw(ref(ex)))
+    val catches = CaseDef(pat, EmptyTree, rhs) :: Nil
+    val tryCatch = Try(body, catches, EmptyTree)
+    Block(keyDef :: Nil, tryCatch)
+  }
+
+  override def transformDefDef(tree: DefDef)(using Context): Tree =
+    nonLocalReturnKeys.remove(tree.symbol) match
+      case key: TermSymbol => cpy.DefDef(tree)(rhs = nonLocalReturnTry(tree.rhs, key, tree.symbol))
+      case null => tree
+
+  override def transformReturn(tree: Return)(using Context): Tree =
+    if isNonLocalReturn(tree) then
+      report.gradualErrorOrMigrationWarning(
+          "Non local returns are no longer supported; use scala.util.control.NonLocalReturns instead",
+          tree.srcPos,
+          warnFrom = `3.2`,
+          errorFrom = future)
+      nonLocalReturnThrow(tree.expr, tree.from.symbol).withSpan(tree.span)
+    else tree
+}
diff --git a/tests/pos-with-compiler-cc/dotc/transform/OverridingPairs.scala b/tests/pos-with-compiler-cc/dotc/transform/OverridingPairs.scala
new file mode 100644
index 000000000000..b27a75436d86
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/transform/OverridingPairs.scala
@@ -0,0 +1,227 @@
+package dotty.tools
+package dotc
+package transform
+
+import core._
+import Flags._, Symbols._, Contexts._, Scopes._, Decorators._, Types.Type
+import NameKinds.DefaultGetterName
+import NullOpsDecorator._
+import collection.immutable.BitSet
+import scala.annotation.tailrec
+
+/** A module that can produce a kind of iterator (`Cursor`),
+ *  which yields all pairs of overriding/overridden symbols
+ *  that are visible in some baseclass, unless there's a parent class
+ *  that already contains the same pairs.
+ *
+ *  Adapted from the 2.9 version of OverridingPairs. The 2.10 version is IMO
+ *  way too unwieldy to be maintained.
+ */
+object OverridingPairs:
+
+  /** The cursor class
+   *  @param base   the base class that contains the overriding pairs
+   */
+  class Cursor(base: Symbol)(using Context):
+
+    private val self = base.thisType
+
+    /** Symbols to exclude: Here these are constructors and private locals.
+     *  But it may be refined in subclasses.
+     */
+    protected def exclude(sym: Symbol): Boolean =
+      !sym.memberCanMatchInheritedSymbols
+      || ctx.phase == Phases.checkCapturesPhase && sym.is(Recheck.ResetPrivate)
+
+    /** The parents of base that are checked when deciding whether an overriding
+     *  pair has already been treated in a parent class.
+     *  This may be refined in subclasses. @see Bridges for a use case.
+     */
+    protected def parents: Array[Symbol] = base.info.parents.toArray.map(_.classSymbol)
+
+    /** Does `sym1` match `sym2` so that it qualifies as overriding when both symbols are
+     *  seen as members of `self`? Types always match. Term symbols match if their membertypes
+     *  relative to `self` do.
+     */
+    protected def matches(sym1: Symbol, sym2: Symbol): Boolean =
+      sym1.isType || sym1.asSeenFrom(self).matches(sym2.asSeenFrom(self))
+
+    /** The symbols that can take part in an overriding pair */
+    private val decls = {
+      val decls = newScope
+      // fill `decls` with overriding shadowing overridden */
+      def fillDecls(bcs: List[Symbol], deferred: Boolean): Unit = bcs match {
+        case bc :: bcs1 =>
+          fillDecls(bcs1, deferred)
+          var e = bc.info.decls.lastEntry
+          while (e != null) {
+            if (e.sym.is(Deferred) == deferred && !exclude(e.sym))
+              decls.enter(e.sym)
+            e = e.prev
+          }
+        case nil =>
+      }
+      // first, deferred (this will need to change if we change lookup rules!
+      fillDecls(base.info.baseClasses, deferred = true)
+      // then, concrete.
+      fillDecls(base.info.baseClasses, deferred = false)
+      decls
+    }
+
+    /** Is `parent` a qualified sub-parent of `bc`?
+     *  @pre `parent` is a parent class of `base` and it derives from `bc`.
+     *  @return true if the `bc`-basetype of the parent's type is the same as
+     *               the `bc`-basetype of base. In that case, overriding checks
+     *               relative to `parent` already subsume overriding checks
+     *               relative to `base`. See neg/11719a.scala for where this makes
+     *               a difference.
+     */
+    protected def isSubParent(parent: Symbol, bc: Symbol)(using Context) =
+      bc.typeParams.isEmpty
+      || self.baseType(parent).baseType(bc) == self.baseType(bc)
+
+    private val subParents = MutableSymbolMap[BitSet]()
+
+    for bc <- base.info.baseClasses do
+      var bits = BitSet.empty
+      for i <- 0 until parents.length do
+        if parents(i).derivesFrom(bc) && isSubParent(parents(i), bc)
+        then bits += i
+      subParents(bc) = bits
+
+    /** Is the override of `sym1` and `sym2` already handled when checking
+     *  a parent of `self`?
+     */
+    private def isHandledByParent(sym1: Symbol, sym2: Symbol): Boolean =
+      val commonParents = subParents(sym1.owner).intersect(subParents(sym2.owner))
+      commonParents.nonEmpty
+      && commonParents.exists(i => canBeHandledByParent(sym1, sym2, parents(i)))
+
+    /** Can pair `sym1`/`sym2` be handled by parent `parentType` which is a common subtype
+     *  of both symbol's owners? Assumed to be true by default, but overridden in RefChecks.
+     */
+    protected def canBeHandledByParent(sym1: Symbol, sym2: Symbol, parent: Symbol): Boolean =
+      true
+
+    /** The scope entries that have already been visited as overridden
+     *  (maybe excluded because of already handled by a parent).
+     *  These will not appear as overriding
+     */
+    private val visited = util.HashSet[Symbol]()
+
+    /** The current entry candidate for overriding
+     */
+    private var curEntry = decls.lastEntry
+
+    /** The current entry candidate for overridden */
+    private var nextEntry = curEntry
+
+    /** The current candidate symbol for overriding */
+    var overriding: Symbol = _
+
+    /** If not null: The symbol overridden by overriding */
+    var overridden: Symbol = _
+
+    //@M: note that next is called once during object initialization
+    final def hasNext: Boolean = nextEntry != null
+
+    /**  @post
+     *     curEntry   = the next candidate that may override something else
+     *     nextEntry  = curEntry
+     *     overriding = curEntry.sym
+     */
+    private def nextOverriding(): Unit = {
+      @tailrec def loop(): Unit =
+        if (curEntry != null) {
+          overriding = curEntry.uncheckedNN.sym
+          if (visited.contains(overriding)) {
+            curEntry = curEntry.uncheckedNN.prev
+            loop()
+          }
+        }
+      loop()
+      nextEntry = curEntry
+    }
+
+    /** @post
+     *    hasNext    = there is another overriding pair
+     *    overriding = overriding member of the pair, provided hasNext is true
+     *    overridden = overridden member of the pair, provided hasNext is true
+     */
+    @tailrec final def next(): Unit =
+      if nextEntry != null then
+        nextEntry = decls.lookupNextEntry(nextEntry.uncheckedNN)
+        if nextEntry != null then
+          try
+            overridden = nextEntry.uncheckedNN.sym
+            if overriding.owner != overridden.owner && matches(overriding, overridden) then
+              visited += overridden
+              if !isHandledByParent(overriding, overridden) then return
+          catch case ex: TypeError =>
+            // See neg/i1750a for an example where a cyclic error can arise.
+            // The root cause in this example is an illegal "override" of an inner trait
+            report.error(ex, base.srcPos)
+        else
+          curEntry = curEntry.nn.prev
+          nextOverriding()
+        next()
+
+    nextOverriding()
+    next()
+  end Cursor
+
+  /** Is this `sym1` considered an override of `sym2` (or vice versa) if both are
+   *  seen as members of `site`?
+   *  We declare a match if either we have a full match including matching names
+   *  or we have a loose match with different target name but the types are the same.
+   *  We leave out pairs of methods in Java classes under the assumption since these
+   *  have already been checked and handled by javac.
+   *  This leaves two possible sorts of discrepancies to be reported as errors
+   *  in `RefChecks`:
+   *
+   *    - matching names, target names, and signatures but different types
+   *    - matching names and types, but different target names
+   *
+   *  This method is used as a replacement of `matches` in some subclasses of
+   *  OverridingPairs.
+   */
+  def isOverridingPair(sym1: Symbol, sym2: Symbol, self: Type)(using Context): Boolean =
+    if     sym1.owner.is(JavaDefined, butNot = Trait)
+        && sym2.owner.is(JavaDefined, butNot = Trait)
+    then false // javac already handles these checks and inserts bridges
+    else if sym1.isType then true
+    else
+      val sd1 = sym1.asSeenFrom(self)
+      val sd2 = sym2.asSeenFrom(self)
+      sd1.matchesLoosely(sd2)
+        && (sym1.hasTargetName(sym2.targetName)
+            || isOverridingPair(sym1, sd1.info, sym2, sd2.info))
+
+  /** Let `member` and `other` be members of some common class C with types
+   *  `memberTp` and `otherTp` in C. Are the two symbols considered an overriding
+   *  pair in C? We assume that names already match so we test only the types here.
+   *  @param fallBack  A function called if the initial test is false and
+   *                   `member` and `other` are term symbols.
+   */
+  def isOverridingPair(member: Symbol, memberTp: Type, other: Symbol, otherTp: Type, fallBack: => Boolean = false)(using Context): Boolean =
+    if member.isType then // intersection of bounds to refined types must be nonempty
+      memberTp.bounds.hi.hasSameKindAs(otherTp.bounds.hi)
+      && (
+        (memberTp frozen_<:< otherTp)
+        || !member.owner.derivesFrom(other.owner)
+            && {
+              // if member and other come from independent classes or traits, their
+              // bounds must have non-empty-intersection
+              val jointBounds = (memberTp.bounds & otherTp.bounds).bounds
+              jointBounds.lo frozen_<:< jointBounds.hi
+            }
+      )
+    else
+      // releaxed override check for explicit nulls if one of the symbols is Java defined,
+      // force `Null` to be a subtype of non-primitive value types during override checking.
+      val relaxedOverriding = ctx.explicitNulls && (member.is(JavaDefined) || other.is(JavaDefined))
+      member.name.is(DefaultGetterName) // default getters are not checked for compatibility
+      || memberTp.overrides(otherTp, relaxedOverriding,
+            member.matchNullaryLoosely || other.matchNullaryLoosely || fallBack)
+
+end OverridingPairs
diff --git a/tests/pos-with-compiler-cc/dotc/transform/PCPCheckAndHeal.scala b/tests/pos-with-compiler-cc/dotc/transform/PCPCheckAndHeal.scala
new file mode 100644
index 000000000000..263b0040eb24
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/transform/PCPCheckAndHeal.scala
@@ -0,0 +1,305 @@
+package dotty.tools.dotc
+package transform
+
+import dotty.tools.dotc.ast.{tpd, untpd}
+import dotty.tools.dotc.core.Annotations.BodyAnnotation
+import dotty.tools.dotc.core.Contexts._
+import dotty.tools.dotc.core.Decorators._
+import dotty.tools.dotc.core.Flags._
+import dotty.tools.dotc.core.NameKinds._
+import dotty.tools.dotc.core.StagingContext._
+import dotty.tools.dotc.core.StdNames._
+import dotty.tools.dotc.core.Symbols._
+import dotty.tools.dotc.core.Types._
+import dotty.tools.dotc.util.SrcPos
+import dotty.tools.dotc.util.Spans._
+import dotty.tools.dotc.transform.SymUtils._
+import dotty.tools.dotc.typer.Checking
+import dotty.tools.dotc.typer.Implicits.SearchFailureType
+import dotty.tools.dotc.core.Annotations._
+
+import dotty.tools.dotc.util.Property
+
+import scala.annotation.constructorOnly
+
+/** Checks that the Phase Consistency Principle (PCP) holds and heals types.
+ *
+ *  Local term references are phase consistent if and only if they are used at the same level as their definition.
+ *
+ *  Local type references can be used at the level of their definition or lower. If used used at a higher level,
+ *  it will be healed if possible, otherwise it is inconsistent.
+ *
+ *  Type healing consists in transforming a phase inconsistent type `T` into `summon[Type[T]].Underlying`.
+ *
+ *  As references to types do not necessarily have an associated tree it is not always possible to replace the types directly.
+ *  Instead we always generate a type alias for it and place it at the start of the surrounding quote. This also avoids duplication.
+ *  For example:
+ *    '{
+ *      val x: List[T] = List[T]()
+ *      ()
+ *    }
+ *
+ *  is transformed to
+ *
+ *    '{
+ *      type t$1 = summon[Type[T]].Underlying
+ *      val x: List[t$1] = List[t$1]();
+ *      ()
+ *     }
+ *
+ */
+class PCPCheckAndHeal(@constructorOnly ictx: Context) extends TreeMapWithStages(ictx) with Checking {
+  import tpd._
+
+  private val InAnnotation = Property.Key[Unit]()
+
+  override def transform(tree: Tree)(using Context): Tree =
+    if (tree.source != ctx.source && tree.source.exists)
+      transform(tree)(using ctx.withSource(tree.source))
+    else if !isInQuoteOrSplice then
+      checkAnnotations(tree)
+      super.transform(tree)
+    else tree match {
+
+      case _: TypeTree | _: RefTree if tree.isType  =>
+        val healedType = healType(tree.srcPos)(tree.tpe)
+        if healedType == tree.tpe then tree
+        else TypeTree(healedType).withSpan(tree.span)
+      case _: AppliedTypeTree =>
+        super.transform(tree) match
+          case tree1: AppliedTypeTree if tree1 ne tree =>
+            // propagate healed types
+            tree1.withType(tree1.tpt.tpe.appliedTo(tree1.args.map(_.tpe)))
+          case tree1 => tree1
+
+      case _: Ident | _: This =>
+        tree.withType(healTypeOfTerm(tree.srcPos)(tree.tpe))
+
+      // Remove inline defs in quoted code. Already fully inlined.
+      case tree: DefDef if tree.symbol.is(Inline) && level > 0 =>
+        EmptyTree
+
+      case tree: ValOrDefDef =>
+        checkAnnotations(tree)
+        healInfo(tree, tree.tpt.srcPos)
+        super.transform(tree)
+      case tree: Bind =>
+        checkAnnotations(tree)
+        healInfo(tree, tree.srcPos)
+        super.transform(tree)
+      case tree: UnApply =>
+        super.transform(tree).withType(healTypeOfTerm(tree.srcPos)(tree.tpe))
+      case tree: TypeDef if tree.symbol.is(Case) && level > 0 =>
+        report.error(reporting.CaseClassInInlinedCode(tree), tree)
+        super.transform(tree)
+      case _ =>
+        super.transform(tree)
+    }
+
+  /** Transform quoted trees while maintaining phase correctness */
+  override protected def transformQuotation(body: Tree, quote: Apply)(using Context): Tree = {
+    val taggedTypes = new PCPCheckAndHeal.QuoteTypeTags(quote.span)
+
+    if (ctx.property(InAnnotation).isDefined)
+      report.error("Cannot have a quote in an annotation", quote.srcPos)
+
+    val contextWithQuote =
+      if level == 0 then contextWithQuoteTypeTags(taggedTypes)(using quoteContext)
+      else quoteContext
+    val body1 = transform(body)(using contextWithQuote)
+    val body2 =
+      taggedTypes.getTypeTags match
+        case Nil  => body1
+        case tags => tpd.Block(tags, body1).withSpan(body.span)
+
+    if body.isTerm then
+      // `quoted.runtime.Expr.quote[T](<body>)`  --> `quoted.runtime.Expr.quote[T2](<body2>)`
+      val TypeApply(fun, targs) = quote.fun: @unchecked
+      val targs2 = targs.map(targ => TypeTree(healTypeOfTerm(quote.fun.srcPos)(targ.tpe)))
+      cpy.Apply(quote)(cpy.TypeApply(quote.fun)(fun, targs2), body2 :: Nil)
+    else
+      val quotes = quote.args.mapConserve(transform)
+      body.tpe match
+        case tp @ TypeRef(x: TermRef, _) if tp.symbol == defn.QuotedType_splice =>
+          // Optimization: `quoted.Type.of[x.Underlying](quotes)`  -->  `x`
+          ref(x)
+        case _ =>
+          // `quoted.Type.of[<body>](quotes)`  --> `quoted.Type.of[<body2>](quotes)`
+          val TypeApply(fun, _) = quote.fun: @unchecked
+          cpy.Apply(quote)(cpy.TypeApply(quote.fun)(fun, body2 :: Nil), quotes)
+  }
+
+  /** Transform splice
+   *  - If inside a quote, transform the contents of the splice.
+   *  - If inside inlined code, expand the macro code.
+   *  - If inside of a macro definition, check the validity of the macro.
+   */
+  protected def transformSplice(body: Tree, splice: Apply)(using Context): Tree = {
+    val body1 = transform(body)(using spliceContext)
+    splice.fun match {
+      case fun @ TypeApply(_, _ :: Nil) =>
+        // Type of the splice itself must also be healed
+        // `quoted.runtime.Expr.quote[F[T]](... T ...)`  -->  `internal.Quoted.expr[F[$t]](... T ...)`
+        val tp = healType(splice.srcPos)(splice.tpe.widenTermRefExpr)
+        cpy.Apply(splice)(cpy.TypeApply(fun)(fun.fun, tpd.TypeTree(tp) :: Nil), body1 :: Nil)
+      case f @ Apply(fun @ TypeApply(_, _), qctx :: Nil) =>
+        // Type of the splice itself must also be healed
+        // `quoted.runtime.Expr.quote[F[T]](... T ...)`  -->  `internal.Quoted.expr[F[$t]](... T ...)`
+        val tp = healType(splice.srcPos)(splice.tpe.widenTermRefExpr)
+        cpy.Apply(splice)(cpy.Apply(f)(cpy.TypeApply(fun)(fun.fun, tpd.TypeTree(tp) :: Nil), qctx :: Nil), body1 :: Nil)
+    }
+  }
+
+  protected def transformSpliceType(body: Tree, splice: Select)(using Context): Tree = {
+    val body1 = transform(body)(using spliceContext)
+    if ctx.reporter.hasErrors then
+      splice
+    else
+      val tagRef = getQuoteTypeTags.getTagRef(splice.qualifier.tpe.asInstanceOf[TermRef])
+      ref(tagRef).withSpan(splice.span)
+  }
+
+  /** Check that annotations do not contain quotes and and that splices are valid */
+  private def checkAnnotations(tree: Tree)(using Context): Unit =
+    tree match
+      case tree: DefTree =>
+        lazy val annotCtx = ctx.fresh.setProperty(InAnnotation, true).withOwner(tree.symbol)
+        for (annot <- tree.symbol.annotations) annot match
+          case annot: BodyAnnotation => annot // already checked in PrepareInlineable before the creation of the BodyAnnotation
+          case annot => transform(annot.tree)(using annotCtx)
+      case _ =>
+
+  /** Heal types in the info of the given tree */
+  private def healInfo(tree: Tree, pos: SrcPos)(using Context): Unit =
+    tree.symbol.info = healType(pos)(tree.symbol.info)
+
+  /** If the type refers to a locally defined symbol (either directly, or in a pickled type),
+   *  check that its staging level matches the current level.
+   *  - Static types and term are allowed at any level.
+   *  - If a type reference is used a higher level, then it is inconsistent. Will attempt to heal before failing.
+   *  - If a term reference is used a different level, then it is inconsistent.
+   *
+   *  If `T` is a reference to a type at the wrong level, try to heal it by replacing it with
+   *  a type tag of type `quoted.Type[T]`.
+   *  The tag is generated by an instance of `QuoteTypeTags` directly if the splice is explicit
+   *  or indirectly by `tryHeal`.
+   */
+  private def healType(pos: SrcPos)(using Context) = new TypeMap {
+    def apply(tp: Type): Type =
+      tp match
+        case tp: TypeRef =>
+          tp.prefix match
+            case NoPrefix if level > levelOf(tp.symbol) && !tp.typeSymbol.hasAnnotation(defn.QuotedRuntime_SplicedTypeAnnot) =>
+              val tp1 = tp.dealias
+              if tp1 != tp then apply(tp1)
+              else tryHeal(tp.symbol, tp, pos)
+            case prefix: ThisType if !tp.symbol.isStatic && level > levelOf(prefix.cls) =>
+              tryHeal(tp.symbol, tp, pos)
+            case prefix: TermRef if tp.symbol.isTypeSplice =>
+              prefix.symbol.info.argInfos match
+                case (tb: TypeBounds) :: _ =>
+                  report.error(em"Cannot splice $tp because it is a wildcard type", pos)
+                case _ =>
+              // Heal explicit type splice in the code
+              if level > 0 then getQuoteTypeTags.getTagRef(prefix) else tp
+            case prefix: TermRef if !prefix.symbol.isStatic && level > levelOf(prefix.symbol) =>
+              tryHeal(prefix.symbol, tp, pos)
+            case _ =>
+              mapOver(tp)
+        case tp: ThisType if level != -1 && level != levelOf(tp.cls) =>
+          levelError(tp.cls, tp, pos)
+        case tp: AnnotatedType =>
+          val newAnnotTree = transform(tp.annot.tree)
+          derivedAnnotatedType(tp, apply(tp.parent), tp.annot.derivedAnnotation(newAnnotTree))
+        case _ =>
+          mapOver(tp)
+  }
+
+  /** Check phase consistency of terms and heal inconsistent type references. */
+  private def healTypeOfTerm(pos: SrcPos)(using Context) = new TypeMap {
+    def apply(tp: Type): Type =
+      tp match
+        case tp @ TypeRef(NoPrefix, _) if level > levelOf(tp.symbol) =>
+          tryHeal(tp.symbol, tp, pos)
+        case tp @ TermRef(NoPrefix, _) if !tp.symbol.isStatic && level != levelOf(tp.symbol) =>
+          levelError(tp.symbol, tp, pos)
+        case tp: ThisType if level != -1 && level != levelOf(tp.cls) =>
+          levelError(tp.cls, tp, pos)
+        case tp: AnnotatedType =>
+          derivedAnnotatedType(tp, apply(tp.parent), tp.annot)
+        case _ =>
+          if tp.typeSymbol.is(Package) then tp
+          else mapOver(tp)
+  }
+
+  /** Try to heal reference to type `T` used in a higher level than its definition.
+   *  Returns a reference to a type tag generated by `QuoteTypeTags` that contains a
+   *  reference to a type alias containing the equivalent of `${summon[quoted.Type[T]]}`.
+   *  Emits and error if `T` cannot be healed and returns `T`.
+   */
+  protected def tryHeal(sym: Symbol, tp: TypeRef, pos: SrcPos)(using Context): TypeRef = {
+    val reqType = defn.QuotedTypeClass.typeRef.appliedTo(tp)
+    val tag = ctx.typer.inferImplicitArg(reqType, pos.span)
+    tag.tpe match
+
+      case tp: TermRef =>
+        checkStable(tp, pos, "type witness")
+        getQuoteTypeTags.getTagRef(tp)
+      case _: SearchFailureType =>
+        report.error(i"""Reference to $tp within quotes requires a given $reqType in scope.
+                     |${ctx.typer.missingArgMsg(tag, reqType, "")}
+                     |
+                     |""", pos)
+        tp
+      case _ =>
+        report.error(i"""Reference to $tp within quotes requires a given $reqType in scope.
+                     |
+                     |""", pos)
+        tp
+  }
+
+  private def levelError(sym: Symbol, tp: Type, pos: SrcPos)(using Context): tp.type = {
+    def symStr =
+      if (!tp.isInstanceOf[ThisType]) sym.show
+      else if (sym.is(ModuleClass)) sym.sourceModule.show
+      else i"${sym.name}.this"
+    report.error(
+      em"""access to $symStr from wrong staging level:
+          | - the definition is at level ${levelOf(sym)},
+          | - but the access is at level $level.""", pos)
+    tp
+  }
+
+}
+
+object PCPCheckAndHeal {
+  import tpd._
+
+  class QuoteTypeTags(span: Span)(using Context) {
+
+    private val tags = collection.mutable.LinkedHashMap.empty[Symbol, TypeDef]
+
+    def getTagRef(spliced: TermRef): TypeRef = {
+      val typeDef = tags.getOrElseUpdate(spliced.symbol, mkTagSymbolAndAssignType(spliced))
+      typeDef.symbol.typeRef
+    }
+
+    def getTypeTags: List[TypeDef] = tags.valuesIterator.toList
+
+    private def mkTagSymbolAndAssignType(spliced: TermRef): TypeDef = {
+      val splicedTree = tpd.ref(spliced).withSpan(span)
+      val rhs = splicedTree.select(tpnme.Underlying).withSpan(span)
+      val alias = ctx.typeAssigner.assignType(untpd.TypeBoundsTree(rhs, rhs), rhs, rhs, EmptyTree)
+      val local = newSymbol(
+        owner = ctx.owner,
+        name = UniqueName.fresh((splicedTree.symbol.name.toString + "$_").toTermName).toTypeName,
+        flags = Synthetic,
+        info = TypeAlias(splicedTree.tpe.select(tpnme.Underlying)),
+        coord = span).asType
+      local.addAnnotation(Annotation(defn.QuotedRuntime_SplicedTypeAnnot))
+      ctx.typeAssigner.assignType(untpd.TypeDef(local.name, alias), local)
+    }
+
+  }
+
+}
diff --git a/tests/pos-with-compiler-cc/dotc/transform/ParamForwarding.scala b/tests/pos-with-compiler-cc/dotc/transform/ParamForwarding.scala
new file mode 100644
index 000000000000..8c93ffb90232
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/transform/ParamForwarding.scala
@@ -0,0 +1,87 @@
+package dotty.tools
+package dotc
+package transform
+
+import core._
+import Contexts._, Types._, Symbols._, Flags._, TypeUtils._, DenotTransformers._, StdNames._
+import Decorators._
+import MegaPhase._
+import NameKinds.ParamAccessorName
+
+/** For all private parameter accessors
+ *
+ *      private val x: T = ...
+ *
+ *  If there is a chain of parameter accessors starting with `x` such that
+ *  (1) The last parameter accessor in the chain is a field that's accessible
+ *      from the current class, and
+ *  (2) each preceding parameter is forwarded in the supercall of its class
+ *      to a parameter that's also named `x`
+ *  then change the accessor to
+ *
+ *      private def x$accessor: T = super.x'.asInstanceOf[T]
+ *
+ *  where x' is a reference to the final parameter in the chain.
+ *  Property (1) is established by the @see forwardParamAccessors method in PostTyper.
+ *
+ *  The reason for renaming `x` to `x$accessor` is that private methods in the JVM
+ *  cannot override public ones.
+ *
+ *  The aim of this transformation is to avoid redundant parameter accessor fields.
+ */
+class ParamForwarding extends MiniPhase with IdentityDenotTransformer:
+  import ast.tpd.*
+  import ParamForwarding.inheritedAccessor
+
+  private def thisPhase: ParamForwarding = this
+
+  override def phaseName: String = ParamForwarding.name
+
+  override def description: String = ParamForwarding.description
+
+  def transformIfParamAlias(mdef: ValOrDefDef)(using Context): Tree =
+    val sym = mdef.symbol.asTerm
+    if sym.is(SuperParamAlias) then
+      assert(sym.is(ParamAccessor, butNot = Mutable))
+      val alias = atPhase(thisPhase)(inheritedAccessor(sym))
+      if alias.exists then
+        sym.copySymDenotation(
+            name = ParamAccessorName(sym.name),
+            initFlags = sym.flags | StableMethod,
+            info = sym.info.ensureMethodic
+          ).installAfter(thisPhase)
+        val superAcc =
+          Super(This(currentClass), tpnme.EMPTY)
+            .withSpan(mdef.span)
+            .select(alias)
+            .ensureApplied
+            .ensureConforms(sym.info.finalResultType)
+        report.log(i"adding param forwarder $superAcc")
+        DefDef(sym, superAcc)
+      else mdef
+    else mdef
+  end transformIfParamAlias
+
+  override def transformValDef(mdef: ValDef)(using Context): Tree =
+    transformIfParamAlias(mdef)
+
+  override def transformDefDef(mdef: DefDef)(using Context): Tree =
+    transformIfParamAlias(mdef)
+
+object ParamForwarding:
+  val name: String = "paramForwarding"
+  val description: String = "add forwarders for aliases of superclass parameters"
+
+  def inheritedAccessor(sym: Symbol)(using Context): Symbol =
+    val candidate = sym.owner.asClass.superClass
+      .info.decl(sym.name).suchThat(_.is(ParamAccessor, butNot = Mutable))
+      .symbol
+    if !candidate.is(Private)  // candidate might be private and accessible if it is in an outer class
+        && candidate.isAccessibleFrom(currentClass.thisType, superAccess = true)
+    then
+      candidate
+    else if candidate.is(SuperParamAlias) then
+      inheritedAccessor(candidate)
+    else
+      NoSymbol
+end ParamForwarding
\ No newline at end of file
diff --git a/tests/pos-with-compiler-cc/dotc/transform/PatternMatcher.scala b/tests/pos-with-compiler-cc/dotc/transform/PatternMatcher.scala
new file mode 100644
index 000000000000..6004f376b7b4
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/transform/PatternMatcher.scala
@@ -0,0 +1,1055 @@
+package dotty.tools
+package dotc
+package transform
+
+import scala.annotation.tailrec
+import core._
+import MegaPhase._
+import collection.mutable
+import Symbols._, Contexts._, Types._, StdNames._, NameOps._
+import util.Spans._
+import typer.Applications.*
+import SymUtils._
+import TypeUtils.*
+import Flags._, Constants._
+import Decorators._
+import NameKinds.{PatMatStdBinderName, PatMatAltsName, PatMatResultName}
+import config.Printers.patmatch
+import reporting._
+import dotty.tools.dotc.ast._
+import util.Property._
+import language.experimental.pureFunctions
+
+/** The pattern matching transform.
+ *  After this phase, the only Match nodes remaining in the code are simple switches
+ *  where every pattern is an integer or string constant
+ */
+class PatternMatcher extends MiniPhase {
+  import ast.tpd._
+  import PatternMatcher._
+
+  override def phaseName: String = PatternMatcher.name
+
+  override def description: String = PatternMatcher.description
+
+  override def runsAfter: Set[String] = Set(ElimRepeated.name)
+
+  override def transformMatch(tree: Match)(using Context): Tree =
+    if (tree.isInstanceOf[InlineMatch]) tree
+    else {
+      // Widen termrefs with underlying `=> T` types. Otherwise ElimByName will produce
+      // inconsistent types. See i7743.scala.
+      // Question: Does this need to be done more systematically, not just for pattern matches?
+      val matchType = tree.tpe.widenSingleton match
+        case ExprType(rt) => rt
+        case rt => tree.tpe
+      val translated = new Translator(matchType, this).translateMatch(tree)
+
+      // check exhaustivity and unreachability
+      val engine = new patmat.SpaceEngine
+      engine.checkExhaustivity(tree)
+      engine.checkRedundancy(tree)
+
+      translated.ensureConforms(matchType)
+    }
+}
+
+object PatternMatcher {
+  import ast.tpd._
+
+  val name: String = "patternMatcher"
+  val description: String = "compile pattern matches"
+
+  inline val selfCheck = false // debug option, if on we check that no case gets generated twice
+
+  /** Minimal number of cases to emit a switch */
+  inline val MinSwitchCases = 4
+
+  val TrustedTypeTestKey: Key[Unit] = new StickyKey[Unit]
+
+  /** Was symbol generated by pattern matcher? */
+  def isPatmatGenerated(sym: Symbol)(using Context): Boolean =
+    sym.is(Synthetic) && sym.name.is(PatMatStdBinderName)
+
+  /** The pattern matching translator.
+   *  Its general structure is a pipeline:
+   *
+   *     Match tree ---matchPlan---> Plan ---optimize---> Plan ---emit---> Tree
+   *
+   *  The pipeline consists of three steps:
+   *
+   *    - build a plan, using methods `matchPlan`, `caseDefPlan`, `patternPlan`.
+   *    - optimize the plan, using methods listed in `optimization`,
+   *    - emit the translated tree, using methods `emit`, `collectSwitchCases`,
+   *      `emitSwitchCases`, and `emitCondition`.
+   *
+   *  A plan represents the underlying decision graph. It consists of tests,
+   *  let bindings, labeled blocks, return from said labeled blocks and code blocks.
+   *  It's represented by its own data type. Plans are optimized by merging common
+   *  tests and eliminating dead code.
+   */
+  class Translator(resultType: Type, thisPhase: MiniPhase)(using Context) {
+
+    // ------- Bindings for variables and labels ---------------------
+
+    private val resultLabel =
+      newSymbol(ctx.owner, PatMatResultName.fresh(), Synthetic | Label, resultType)
+
+    /** A map from variable symbols to their defining trees
+     *  and from labels to their defining plans
+     */
+    private val initializer = MutableSymbolMap[Tree]()
+
+    private def newVar(rhs: Tree, flags: FlagSet, tpe: Type): TermSymbol =
+      newSymbol(ctx.owner, PatMatStdBinderName.fresh(), SyntheticCase | flags,
+        sanitize(tpe), coord = rhs.span)
+        // TODO: Drop Case once we use everywhere else `isPatmatGenerated`.
+
+    /** The plan `let x = rhs in body(x)` where `x` is a fresh variable */
+    private def letAbstract(rhs: Tree, tpe: Type = NoType)(body: Symbol -> Plan): Plan = {
+      val declTpe = if tpe.exists then tpe else rhs.tpe
+      val vble = newVar(rhs, EmptyFlags, declTpe)
+      initializer(vble) = rhs
+      LetPlan(vble, body(vble))
+    }
+
+    /** The plan `l: { expr(l) }` where `l` is a fresh label */
+    private def altsLabeledAbstract(expr: (-> Plan) -> Plan): Plan = {
+      val label = newSymbol(ctx.owner, PatMatAltsName.fresh(), Synthetic | Label,
+        defn.UnitType)
+      LabeledPlan(label, expr(ReturnPlan(label)))
+    }
+
+    /** Test whether a type refers to a pattern-generated variable */
+    private val refersToInternal = new TypeAccumulator[Boolean] {
+      def apply(x: Boolean, tp: Type) =
+        x || {
+          tp match {
+            case tp: TermRef => isPatmatGenerated(tp.symbol)
+            case _ => false
+          }
+        } || foldOver(x, tp)
+    }
+
+    /** Widen type as far as necessary so that it does not refer to a pattern-
+     *  generated variable.
+     */
+    private def sanitize(tp: Type): Type = tp.widenIfUnstable match {
+      case tp: TermRef if refersToInternal(false, tp) => sanitize(tp.underlying)
+      case tp => tp
+    }
+
+    // ------- Plan and test types ------------------------
+
+    /** Counter to display plans nicely, for debugging */
+    private var nxId = 0
+
+    /** The different kinds of plans */
+    sealed abstract class Plan { val id: Int = nxId; nxId += 1 }
+
+    case class TestPlan(test: Test, var scrutinee: Tree, span: Span,
+                        var onSuccess: Plan) extends Plan {
+      override def equals(that: Any): Boolean = that match {
+        case that: TestPlan => this.scrutinee === that.scrutinee && this.test == that.test
+        case _ => false
+      }
+      override def hashCode: Int = scrutinee.hash * 41 + test.hashCode
+    }
+
+    case class LetPlan(sym: TermSymbol, var body: Plan) extends Plan
+    case class LabeledPlan(sym: TermSymbol, var expr: Plan) extends Plan
+    case class ReturnPlan(var label: TermSymbol) extends Plan
+    case class SeqPlan(var head: Plan, var tail: Plan) extends Plan
+    case class ResultPlan(var tree: Tree) extends Plan
+
+    object TestPlan {
+      def apply(test: Test, sym: Symbol, span: Span, ons: Plan): TestPlan =
+        TestPlan(test, ref(sym), span, ons)
+    }
+
+    /** The different kinds of tests */
+    sealed abstract class Test
+    case class TypeTest(tpt: Tree, trusted: Boolean) extends Test {  // scrutinee.isInstanceOf[tpt]
+      override def equals(that: Any): Boolean = that match {
+        case that: TypeTest => this.tpt.tpe =:= that.tpt.tpe
+        case _ => false
+      }
+      override def hashCode: Int = tpt.tpe.hash
+    }
+    case class EqualTest(tree: Tree) extends Test {                  // scrutinee == tree
+      override def equals(that: Any): Boolean = that match {
+        case that: EqualTest => this.tree === that.tree
+        case _ => false
+      }
+      override def hashCode: Int = tree.hash
+    }
+    case class LengthTest(len: Int, exact: Boolean) extends Test     // scrutinee (== | >=) len
+    case object NonEmptyTest extends Test                            // !scrutinee.isEmpty
+    case object NonNullTest extends Test                             // scrutinee ne null
+    case object GuardTest extends Test                               // scrutinee
+
+    // ------- Generating plans from trees ------------------------
+
+    /** A set of variabes that are known to be not null */
+    private val nonNull = mutable.Set[Symbol]()
+
+    /** A conservative approximation of which patterns do not discern anything.
+      * They are discarded during the translation.
+      */
+    private object WildcardPattern {
+      def unapply(pat: Tree): Boolean = pat match {
+        case Typed(_, tpt) if tpt.tpe.isRepeatedParam => true
+        case Bind(nme.WILDCARD, WildcardPattern()) => true // don't skip when binding an interesting symbol!
+        case t if isWildcardArg(t)                 => true
+        case x: Ident                              => x.name.isVarPattern && !isBackquoted(x)
+        case Alternative(ps)                       => ps.forall(unapply)
+        case EmptyTree                             => true
+        case _                                     => false
+      }
+    }
+
+    private object VarArgPattern {
+      def unapply(pat: Tree): Option[Tree] = swapBind(pat) match {
+        case Typed(pat1, tpt) if tpt.tpe.isRepeatedParam => Some(pat1)
+        case _ => None
+      }
+    }
+
+    /** Rewrite (repeatedly) `x @ (p: T)` to `(x @ p): T`
+     *  This brings out the type tests to where they can be analyzed.
+     */
+    private def swapBind(tree: Tree): Tree = tree match {
+      case Bind(name, pat0) =>
+        swapBind(pat0) match {
+          case Typed(pat, tpt) => Typed(cpy.Bind(tree)(name, pat), tpt)
+          case _ => tree
+        }
+      case _ => tree
+    }
+
+    /** Plan for matching `scrutinee` symbol against `tree` pattern */
+    private def patternPlan(scrutinee: Symbol, tree: Tree, onSuccess: Plan): Plan = {
+
+      extension (tree: Tree) def avoidPatBoundType(): Type =
+        tree.tpe.widen match
+        case tref: TypeRef if tref.symbol.isPatternBound =>
+          defn.AnyType
+        case _ =>
+          tree.tpe
+
+      /** Plan for matching `components` against argument patterns `args` */
+      def matchArgsPlan(components: List[Tree], args: List[Tree], onSuccess: Plan): Plan = {
+        /* For a case with arguments that have some test on them such as
+         * ```
+         * case Foo(1, 2) => someCode
+         * ```
+         * all arguments values are extracted before the checks are performed. This shape is expected by `emit`
+         * to avoid generating deep trees.
+         * ```
+         * val x1: Foo = ...
+         * val x2: Int = x1._1
+         * val x3: Int = x1._2
+         * if (x2 == 1) {
+         *   if (x3 == 2) someCode
+         *   else ()
+         * } else ()
+         * ```
+         */
+        def matchArgsComponentsPlan(components: List[Tree], syms: List[Symbol]): Plan =
+          components match {
+            case component :: components1 => letAbstract(component, component.avoidPatBoundType())(sym => matchArgsComponentsPlan(components1, sym :: syms))
+            case Nil => matchArgsPatternPlan(args, syms.reverse)
+          }
+        def matchArgsPatternPlan(args: List[Tree], syms: List[Symbol]): Plan =
+          args match {
+            case arg :: args1 =>
+              val sym :: syms1 = syms: @unchecked
+              patternPlan(sym, arg, matchArgsPatternPlan(args1, syms1))
+            case Nil =>
+              assert(syms.isEmpty)
+              onSuccess
+          }
+        matchArgsComponentsPlan(components, Nil)
+      }
+
+      /** Plan for matching the sequence in `seqSym` against sequence elements `args`.
+       *  If `exact` is true, the sequence is not permitted to have any elements following `args`.
+       */
+      def matchElemsPlan(seqSym: Symbol, args: List[Tree], exact: Boolean, onSuccess: Plan) = {
+        val selectors = args.indices.toList.map(idx =>
+          ref(seqSym).select(defn.Seq_apply.matchingMember(seqSym.info)).appliedTo(Literal(Constant(idx))))
+        TestPlan(LengthTest(args.length, exact), seqSym, seqSym.span,
+          matchArgsPlan(selectors, args, onSuccess))
+      }
+
+      /** Plan for matching the sequence in `getResult` against sequence elements
+       *  and a possible last varargs argument `args`.
+       */
+      def unapplySeqPlan(getResult: Symbol, args: List[Tree]): Plan = args.lastOption match {
+        case Some(VarArgPattern(arg)) =>
+          val matchRemaining =
+            if (args.length == 1) {
+              val toSeq = ref(getResult)
+                .select(defn.Seq_toSeq.matchingMember(getResult.info))
+              letAbstract(toSeq) { toSeqResult =>
+                patternPlan(toSeqResult, arg, onSuccess)
+              }
+            }
+            else {
+              val dropped = ref(getResult)
+                .select(defn.Seq_drop.matchingMember(getResult.info))
+                .appliedTo(Literal(Constant(args.length - 1)))
+              letAbstract(dropped) { droppedResult =>
+                patternPlan(droppedResult, arg, onSuccess)
+              }
+            }
+          matchElemsPlan(getResult, args.init, exact = false, matchRemaining)
+        case _ =>
+          matchElemsPlan(getResult, args, exact = true, onSuccess)
+      }
+
+      /** Plan for matching the sequence in `getResult`
+       *
+       *  `getResult` is a product, where the last element is a sequence of elements.
+       */
+      def unapplyProductSeqPlan(getResult: Symbol, args: List[Tree], arity: Int): Plan = {
+        assert(arity <= args.size + 1)
+        val selectors = productSelectors(getResult.info).map(ref(getResult).select(_))
+
+        val matchSeq =
+          letAbstract(selectors.last) { seqResult =>
+            unapplySeqPlan(seqResult, args.drop(arity - 1))
+          }
+        matchArgsPlan(selectors.take(arity - 1), args.take(arity - 1), matchSeq)
+      }
+
+      /** Plan for matching the result of an unapply against argument patterns `args` */
+      def unapplyPlan(unapp: Tree, args: List[Tree]): Plan = {
+        def caseClass = unapp.symbol.owner.linkedClass
+        lazy val caseAccessors = caseClass.caseAccessors.filter(_.is(Method))
+
+        def isSyntheticScala2Unapply(sym: Symbol) =
+          sym.isAllOf(SyntheticCase) && sym.owner.is(Scala2x)
+
+        def tupleApp(i: Int, receiver: Tree) = // manually inlining the call to NonEmptyTuple#apply, because it's an inline method
+          ref(defn.RuntimeTuplesModule)
+            .select(defn.RuntimeTuples_apply)
+            .appliedTo(receiver, Literal(Constant(i)))
+
+        if (isSyntheticScala2Unapply(unapp.symbol) && caseAccessors.length == args.length)
+          def tupleSel(sym: Symbol) = ref(scrutinee).select(sym)
+          val isGenericTuple = defn.isTupleClass(caseClass) &&
+            !defn.isTupleNType(tree.tpe match { case tp: OrType => tp.join case tp => tp }) // widen even hard unions, to see if it's a union of tuples
+          val components = if isGenericTuple then caseAccessors.indices.toList.map(tupleApp(_, ref(scrutinee))) else caseAccessors.map(tupleSel)
+          matchArgsPlan(components, args, onSuccess)
+        else if (unapp.tpe <:< (defn.BooleanType))
+          TestPlan(GuardTest, unapp, unapp.span, onSuccess)
+        else
+          letAbstract(unapp) { unappResult =>
+            val isUnapplySeq = unapp.symbol.name == nme.unapplySeq
+            if (isProductMatch(unapp.tpe.widen, args.length) && !isUnapplySeq) {
+              val selectors = productSelectors(unapp.tpe).take(args.length)
+                .map(ref(unappResult).select(_))
+              matchArgsPlan(selectors, args, onSuccess)
+            }
+            else if (isUnapplySeq && isProductSeqMatch(unapp.tpe.widen, args.length, unapp.srcPos)) {
+              val arity = productArity(unapp.tpe.widen, unapp.srcPos)
+              unapplyProductSeqPlan(unappResult, args, arity)
+            }
+            else if (isUnapplySeq && unapplySeqTypeElemTp(unapp.tpe.widen.finalResultType).exists) {
+              unapplySeqPlan(unappResult, args)
+            }
+            else if unappResult.info <:< defn.NonEmptyTupleTypeRef then
+              val components = (0 until foldApplyTupleType(unappResult.denot.info).length).toList.map(tupleApp(_, ref(unappResult)))
+              matchArgsPlan(components, args, onSuccess)
+            else {
+              assert(isGetMatch(unapp.tpe))
+              val argsPlan = {
+                val get = ref(unappResult).select(nme.get, _.info.isParameterless)
+                val arity = productArity(get.tpe, unapp.srcPos)
+                if (isUnapplySeq)
+                  letAbstract(get) { getResult =>
+                    if (arity > 0) unapplyProductSeqPlan(getResult, args, arity)
+                    else unapplySeqPlan(getResult, args)
+                  }
+                else
+                  letAbstract(get) { getResult =>
+                    val selectors =
+                      if (args.tail.isEmpty) ref(getResult) :: Nil
+                      else productSelectors(get.tpe).map(ref(getResult).select(_))
+                    matchArgsPlan(selectors, args, onSuccess)
+                  }
+              }
+              TestPlan(NonEmptyTest, unappResult, unapp.span, argsPlan)
+            }
+          }
+      }
+
+      // begin patternPlan
+      swapBind(tree) match {
+        case Typed(pat, tpt) =>
+          val isTrusted = pat match {
+            case UnApply(extractor, _, _) =>
+              extractor.symbol.is(Synthetic)
+              && extractor.symbol.owner.linkedClass.is(Case)
+              && !hasExplicitTypeArgs(extractor)
+            case _ => false
+          }
+          TestPlan(TypeTest(tpt, isTrusted), scrutinee, tree.span,
+            letAbstract(ref(scrutinee).cast(tpt.tpe)) { casted =>
+              nonNull += casted
+              patternPlan(casted, pat, onSuccess)
+            })
+        case UnApply(extractor, implicits, args) =>
+          val unappPlan = if (scrutinee.info.isBottomType)
+            // Generate a throwaway but type-correct plan.
+            // This plan will never execute because it'll be guarded by a `NonNullTest`.
+            ResultPlan(tpd.Throw(tpd.nullLiteral))
+          else {
+            def applyImplicits(acc: Tree, implicits: List[Tree], mt: Type): Tree = mt match {
+              case mt: MethodType =>
+                assert(mt.isImplicitMethod)
+                val (args, rest) = implicits.splitAt(mt.paramNames.size)
+                applyImplicits(acc.appliedToTermArgs(args), rest, mt.resultType)
+              case _ =>
+                assert(implicits.isEmpty)
+                acc
+            }
+            val mt @ MethodType(_) = extractor.tpe.widen: @unchecked
+            val unapp0 = extractor.appliedTo(ref(scrutinee).ensureConforms(mt.paramInfos.head))
+            val unapp = applyImplicits(unapp0, implicits, mt.resultType)
+            unapplyPlan(unapp, args)
+          }
+          if (scrutinee.info.isNotNull || nonNull(scrutinee)) unappPlan
+          else TestPlan(NonNullTest, scrutinee, tree.span, unappPlan)
+        case Bind(name, body) =>
+          if (name == nme.WILDCARD) patternPlan(scrutinee, body, onSuccess)
+          else {
+            // The type of `name` may refer to val in `body`, therefore should come after `body`
+            val bound = tree.symbol.asTerm
+            initializer(bound) = ref(scrutinee)
+            patternPlan(scrutinee, body, LetPlan(bound, onSuccess))
+          }
+        case Alternative(alts) =>
+          altsLabeledAbstract { onf =>
+            SeqPlan(
+              altsLabeledAbstract { ons =>
+                alts.foldRight(onf) { (alt, next) =>
+                  SeqPlan(patternPlan(scrutinee, alt, ons), next)
+                }
+              },
+              onSuccess
+            )
+          }
+        case WildcardPattern() =>
+          onSuccess
+        case SeqLiteral(pats, _) =>
+          matchElemsPlan(scrutinee, pats, exact = true, onSuccess)
+        case _ =>
+          TestPlan(EqualTest(tree), scrutinee, tree.span, onSuccess)
+      }
+    }
+
+    private def caseDefPlan(scrutinee: Symbol, cdef: CaseDef): Plan = {
+      var onSuccess: Plan = ResultPlan(cdef.body)
+      if (!cdef.guard.isEmpty)
+        onSuccess = TestPlan(GuardTest, cdef.guard, cdef.guard.span, onSuccess)
+      patternPlan(scrutinee, cdef.pat, onSuccess)
+    }
+
+    private def matchPlan(tree: Match): Plan =
+      letAbstract(tree.selector) { scrutinee =>
+        val matchError: Plan = ResultPlan(Throw(New(defn.MatchErrorClass.typeRef, ref(scrutinee) :: Nil)))
+        tree.cases.foldRight(matchError) { (cdef, next) =>
+          SeqPlan(caseDefPlan(scrutinee, cdef), next)
+        }
+      }
+
+    // ----- Optimizing plans ---------------
+
+    /** A superclass for plan transforms */
+    class PlanTransform extends (Plan -> Plan) {
+      protected val treeMap: TreeMap = new TreeMap {
+        override def transform(tree: Tree)(using Context) = tree
+      }
+      def apply(tree: Tree): Tree = treeMap.transform(tree)
+      def apply(plan: TestPlan): Plan = {
+        plan.scrutinee = apply(plan.scrutinee)
+        plan.onSuccess = apply(plan.onSuccess)
+        plan
+      }
+      def apply(plan: LetPlan): Plan = {
+        plan.body = apply(plan.body)
+        initializer(plan.sym) = apply(initializer(plan.sym))
+        plan
+      }
+      def apply(plan: LabeledPlan): Plan = {
+        plan.expr = apply(plan.expr)
+        plan
+      }
+      def apply(plan: ReturnPlan): Plan = plan
+      def apply(plan: SeqPlan): Plan = {
+        plan.head = apply(plan.head)
+        plan.tail = apply(plan.tail)
+        plan
+      }
+      def apply(plan: Plan): Plan = plan match {
+        case plan: TestPlan => apply(plan)
+        case plan: LetPlan => apply(plan)
+        case plan: LabeledPlan => apply(plan)
+        case plan: ReturnPlan => apply(plan)
+        case plan: SeqPlan => apply(plan)
+        case plan: ResultPlan => plan
+      }
+    }
+
+    private class RefCounter extends PlanTransform {
+      val count = new mutable.HashMap[Symbol, Int] {
+        override def default(key: Symbol) = 0
+      }
+    }
+
+    /** Reference counts for all labels */
+    private def labelRefCount(plan: Plan): collection.Map[Symbol, Int] = {
+      object refCounter extends RefCounter {
+        override def apply(plan: LabeledPlan): Plan = {
+          apply(plan.expr)
+          plan
+        }
+        override def apply(plan: ReturnPlan): Plan = {
+          count(plan.label) += 1
+          plan
+        }
+      }
+      refCounter(plan)
+      refCounter.count
+    }
+
+    /** Reference counts for all variables */
+    private def varRefCount(plan: Plan): collection.Map[Symbol, Int] = {
+      object refCounter extends RefCounter {
+        override val treeMap = new TreeMap {
+          override def transform(tree: Tree)(using Context) = tree match {
+            case tree: Ident =>
+              if (isPatmatGenerated(tree.symbol)) count(tree.symbol) += 1
+              tree
+            case _ =>
+              super.transform(tree)
+          }
+        }
+        override def apply(plan: LetPlan): Plan = {
+          apply(plan.body)
+          if (count(plan.sym) != 0 || !isPatmatGenerated(plan.sym))
+            apply(initializer(plan.sym))
+          plan
+        }
+        override def apply(plan: SeqPlan): Plan = {
+          apply(plan.head)
+          if (canFallThrough(plan.head))
+            apply(plan.tail)
+          plan
+        }
+      }
+      refCounter(plan)
+      refCounter.count
+    }
+
+    /** Merge identical consecutive tests.
+     *
+     *  When we have the following shape:
+     *
+     *  if (testA) plan1
+     *  if (testA) plan2
+     *  nextPlan?
+     *
+     *  transform it to
+     *
+     *  if (testA) {
+     *    plan1
+     *    plan2
+     *  }
+     *  nextPlan?
+     *
+     *  Similarly, when we have equivalent let bindings:
+     *
+     *  let x1 = rhs1 in plan1
+     *  let x2 = rhs2 in plan2
+     *  nextPlan?
+     *
+     *  and rhs1 and rhs2 are equivalent, transform it to
+     *
+     *  let x1 = rhs1 in {
+     *    plan1
+     *    plan2[x1/x2]
+     *  }
+     *
+     *  where plan2[x1/x2] means substituting x1 for x2 in plan2.
+     *
+     *  There are some tricks to "ignore" non-patmat-generated let bindings, i.e.,
+     *  captures written in the source code, while identifying common subplans.
+     */
+    def mergeTests(plan: Plan): Plan = {
+      class SubstituteIdent(from: TermSymbol, to: TermSymbol) extends PlanTransform {
+        override val treeMap = new TreeMap {
+          override def transform(tree: Tree)(using Context) = tree match {
+            case tree: Ident if tree.symbol == from => ref(to)
+            case _ => super.transform(tree)
+          }
+        }
+      }
+
+      class MergeTests extends PlanTransform {
+        override def apply(plan: SeqPlan): Plan = {
+          def tryMerge(plan1: Plan, plan2: Plan): Option[Plan] = {
+            def skipNonPatmatGenedLets(plan: Plan): Plan = plan match {
+              case LetPlan(sym, body) if !isPatmatGenerated(sym) =>
+                skipNonPatmatGenedLets(body)
+              case _ =>
+                plan
+            }
+
+            def transferNonPatmatGenedLets(originalPlan: Plan, newPlan: Plan): Plan = originalPlan match {
+              case originalPlan: LetPlan if !isPatmatGenerated(originalPlan.sym) =>
+                originalPlan.body = transferNonPatmatGenedLets(originalPlan.body, newPlan)
+                originalPlan
+              case _ =>
+                newPlan
+            }
+
+            (skipNonPatmatGenedLets(plan1), skipNonPatmatGenedLets(plan2)) match {
+              case (testPlan1: TestPlan, testPlan2: TestPlan) if testPlan1 == testPlan2 =>
+                /* Because testPlan2 is the same as testPlan1, it cannot possibly refer to
+                 * the symbols defined by any of the skipped lets.
+                 */
+                testPlan1.onSuccess = SeqPlan(testPlan1.onSuccess,
+                  transferNonPatmatGenedLets(plan2, testPlan2.onSuccess))
+                Some(plan1) // that's the original plan1, on purpose
+
+              case (letPlan1: LetPlan, letPlan2: LetPlan) if initializer(letPlan1.sym) === initializer(letPlan2.sym) =>
+                // By construction, letPlan1.sym and letPlan2.sym are patmat-generated
+                val newPlan2Body = new SubstituteIdent(letPlan2.sym, letPlan1.sym)(letPlan2.body)
+                letPlan1.body = SeqPlan(letPlan1.body,
+                  transferNonPatmatGenedLets(plan2, newPlan2Body))
+                Some(plan1) // that's the original plan1, on purpose
+
+              case _ =>
+                None
+            }
+          }
+
+          plan.head = apply(plan.head)
+          plan.tail = apply(plan.tail)
+          plan.tail match {
+            case SeqPlan(tailHead, tailTail) =>
+              tryMerge(plan.head, tailHead) match {
+                case Some(merged) => SeqPlan(apply(merged), tailTail)
+                case none => plan
+              }
+            case tail =>
+              tryMerge(plan.head, tail) match {
+                case Some(merged) => apply(merged)
+                case none => plan
+              }
+          }
+        }
+      }
+      new MergeTests()(plan)
+    }
+
+    /** Inline let-bound trees that are referenced only once and eliminate dead code.
+     *
+     *  - Drop all variables that are not referenced anymore after inlining.
+     *  - Drop the `tail` of `SeqPlan`s whose `head` cannot fall through.
+     */
+    private def inlineVars(plan: Plan): Plan = {
+      val refCount = varRefCount(plan)
+      val LetPlan(topSym, _) = plan: @unchecked
+
+      def toDrop(sym: Symbol) = initializer.get(sym) match {
+        case Some(rhs) =>
+          isPatmatGenerated(sym) && refCount(sym) <= 1 && sym != topSym && isPureExpr(rhs)
+        case none =>
+          false
+      }
+
+      object Inliner extends PlanTransform {
+        override val treeMap = new TreeMap {
+          override def transform(tree: Tree)(using Context) = tree match {
+            case tree: Ident =>
+              val sym = tree.symbol
+              if (toDrop(sym)) transform(initializer(sym))
+              else tree
+            case _ =>
+              super.transform(tree)
+          }
+        }
+        override def apply(plan: LetPlan): Plan =
+          if (toDrop(plan.sym)) apply(plan.body)
+          else {
+            initializer(plan.sym) = apply(initializer(plan.sym))
+            plan.body = apply(plan.body)
+            plan
+          }
+        override def apply(plan: SeqPlan): Plan = {
+          val newHead = apply(plan.head)
+          if (!canFallThrough(newHead))
+            // If the head cannot fall through, the tail is dead code
+            newHead
+          else {
+            plan.head = newHead
+            plan.tail = apply(plan.tail)
+            plan
+          }
+        }
+      }
+      Inliner(plan)
+    }
+
+    // ----- Generating trees from plans ---------------
+
+    /** The condition a test plan rewrites to */
+    private def emitCondition(plan: TestPlan): Tree = {
+      val scrutinee = plan.scrutinee
+      (plan.test: @unchecked) match {
+        case NonEmptyTest =>
+          constToLiteral(
+            scrutinee
+              .select(nme.isEmpty, _.info.isParameterless)
+              .select(nme.UNARY_!, _.info.isParameterless))
+        case NonNullTest =>
+          scrutinee.testNotNull
+        case GuardTest =>
+          scrutinee
+        case EqualTest(tree) =>
+          tree.equal(scrutinee)
+        case LengthTest(len, exact) =>
+          val lengthCompareSym = defn.Seq_lengthCompare.matchingMember(scrutinee.tpe)
+          if (lengthCompareSym.exists)
+            scrutinee
+              .select(defn.Seq_lengthCompare.matchingMember(scrutinee.tpe))
+              .appliedTo(Literal(Constant(len)))
+              .select(if (exact) defn.Int_== else defn.Int_>=)
+              .appliedTo(Literal(Constant(0)))
+          else // try length
+            scrutinee
+              .select(defn.Seq_length.matchingMember(scrutinee.tpe))
+              .select(if (exact) defn.Int_== else defn.Int_>=)
+              .appliedTo(Literal(Constant(len)))
+        case TypeTest(tpt, trusted) =>
+          val expectedTp = tpt.tpe
+
+          // An outer test is needed in a situation like  `case x: y.Inner => ...`
+          def outerTestNeeded: Boolean = {
+            def go(expected: Type): Boolean = expected match {
+              case tref @ TypeRef(pre: SingletonType, _) =>
+                tref.symbol.isClass &&
+                ExplicitOuter.needsOuterIfReferenced(tref.symbol.asClass)
+              case AppliedType(tpe, _) => go(tpe)
+              case _ =>
+                false
+            }
+            // See the test for SI-7214 for motivation for dealias. Later `treeCondStrategy#outerTest`
+            // generates an outer test based on `patType.prefix` with automatically dealises.
+            go(expectedTp.dealias)
+          }
+
+          def outerTest: Tree = thisPhase.transformFollowingDeep {
+            val expectedOuter = singleton(expectedTp.normalizedPrefix)
+            val expectedClass = expectedTp.dealias.classSymbol.asClass
+            ExplicitOuter.ensureOuterAccessors(expectedClass)
+            scrutinee.ensureConforms(expectedTp)
+              .outerSelect(1, expectedClass.owner.typeRef)
+              .select(defn.Object_eq)
+              .appliedTo(expectedOuter)
+          }
+
+          expectedTp.dealias match {
+            case expectedTp: SingletonType =>
+              scrutinee.isInstance(expectedTp)  // will be translated to an equality test
+            case _ =>
+              val typeTest = scrutinee.select(defn.Any_typeTest).appliedToType(expectedTp)
+              if (trusted) typeTest.pushAttachment(TrustedTypeTestKey, ())
+              if (outerTestNeeded) typeTest.and(outerTest) else typeTest
+          }
+      }
+    }
+
+    @tailrec
+    private def canFallThrough(plan: Plan): Boolean = plan match {
+      case _:ReturnPlan | _:ResultPlan => false
+      case _:TestPlan | _:LabeledPlan => true
+      case LetPlan(_, body) => canFallThrough(body)
+      case SeqPlan(_, tail) => canFallThrough(tail)
+    }
+
+    /** Collect longest list of plans that represent possible cases of
+     *  a switch, including a last default case, by starting with this
+     *  plan and following onSuccess plans.
+     */
+    private def collectSwitchCases(scrutinee: Tree, plan: SeqPlan): List[(List[Tree], Plan)] = {
+      def isSwitchableType(tpe: Type): Boolean =
+        (tpe isRef defn.IntClass) ||
+        (tpe isRef defn.ByteClass) ||
+        (tpe isRef defn.ShortClass) ||
+        (tpe isRef defn.CharClass) ||
+        (tpe isRef defn.StringClass)
+
+      val seen = mutable.Set[Any]()
+
+      def isNewSwitchableConst(tree: Tree) = tree match {
+        case Literal(const)
+        if (const.isIntRange || const.tag == Constants.StringTag) && !seen.contains(const.value) =>
+          seen += const.value
+          true
+        case _ =>
+          false
+      }
+
+      // An extractor to recover the shape of plans that can become alternatives
+      object AlternativesPlan {
+        def unapply(plan: LabeledPlan): Option[(List[Tree], Plan)] =
+          plan.expr match {
+            case SeqPlan(LabeledPlan(innerLabel, innerPlan), ons) if !canFallThrough(ons) =>
+              val outerLabel = plan.sym
+              val alts = List.newBuilder[Tree]
+              def rec(innerPlan: Plan): Boolean = innerPlan match {
+                case SeqPlan(TestPlan(EqualTest(tree), scrut, _, ReturnPlan(`innerLabel`)), tail)
+                if scrut === scrutinee && isNewSwitchableConst(tree) =>
+                  alts += tree
+                  rec(tail)
+                case ReturnPlan(`outerLabel`) =>
+                  true
+                case _ =>
+                  false
+              }
+              if (rec(innerPlan))
+                Some((alts.result(), ons))
+              else
+                None
+
+            case _ =>
+              None
+          }
+      }
+
+      def recur(plan: Plan): List[(List[Tree], Plan)] = plan match {
+        case SeqPlan(testPlan @ TestPlan(EqualTest(tree), scrut, _, ons), tail)
+        if scrut === scrutinee && !canFallThrough(ons) && isNewSwitchableConst(tree) =>
+          (tree :: Nil, ons) :: recur(tail)
+        case SeqPlan(AlternativesPlan(alts, ons), tail) =>
+          (alts, ons) :: recur(tail)
+        case _ =>
+          (Nil, plan) :: Nil
+      }
+
+      if (isSwitchableType(scrutinee.tpe.widen)) recur(plan)
+      else Nil
+    }
+
+    private def hasEnoughSwitchCases(cases: List[(List[Tree], Plan)], required: Int): Boolean =
+      // 1 because of the default case
+      required <= 1 || {
+        cases match {
+          case (alts, _) :: cases1 => hasEnoughSwitchCases(cases1, required - alts.size)
+          case _ => false
+        }
+      }
+
+    /** Emit a switch-match */
+    private def emitSwitchMatch(scrutinee: Tree, cases: List[(List[Tree], Plan)]): Match = {
+      /* Make sure to adapt the scrutinee to Int or String, as well as all the
+       * alternatives, so that only Matches on pritimive Ints or Strings survive
+       * this phase.
+       */
+
+      val (primScrutinee, scrutineeTpe) =
+        if (scrutinee.tpe.widen.isRef(defn.IntClass)) (scrutinee, defn.IntType)
+        else if (scrutinee.tpe.widen.isRef(defn.StringClass)) (scrutinee, defn.StringType)
+        else (scrutinee.select(nme.toInt), defn.IntType)
+
+      def primLiteral(lit: Tree): Tree =
+        val Literal(constant) = lit: @unchecked
+        if (constant.tag == Constants.IntTag) lit
+        else if (constant.tag == Constants.StringTag) lit
+        else cpy.Literal(lit)(Constant(constant.intValue))
+
+      val caseDefs = cases.map { (alts, ons) =>
+        val pat = alts match {
+          case alt :: Nil => primLiteral(alt)
+          case Nil => Underscore(scrutineeTpe) // default case
+          case _ => Alternative(alts.map(primLiteral))
+        }
+        CaseDef(pat, EmptyTree, emit(ons))
+      }
+
+      Match(primScrutinee, caseDefs)
+    }
+
+    /** If selfCheck is `true`, used to check whether a tree gets generated twice */
+    private val emitted = mutable.Set[Int]()
+
+    /** Translate plan to tree */
+    private def emit(plan: Plan): Tree = {
+      if (selfCheck) {
+        assert(plan.isInstanceOf[ReturnPlan] || !emitted.contains(plan.id), plan.id)
+        emitted += plan.id
+      }
+      plan match {
+        case plan: TestPlan =>
+          /** Merge nested `if`s that have the same `else` branch into a single `if`.
+           *  This optimization targets calls to label defs for case failure jumps to next case.
+           *
+           *  Plan for
+           *  ```
+           *  val x1: Int = ...
+           *  val x2: Int = ...
+           *  if (x1 == y1) {
+           *    if (x2 == y2) someCode
+           *    else ()
+           *  } else ()
+           *  ```
+           *  is emitted as
+           *  ```
+           *  val x1: Int = ...
+           *  val x2: Int = ...
+           *  if (x1 == y1 && x2 == y2) someCode
+           *  else ()
+           *  ```
+           */
+          def emitWithMashedConditions(plans: List[TestPlan]): Tree = {
+            val plan = plans.head
+            plan.onSuccess match {
+              case plan2: TestPlan =>
+                emitWithMashedConditions(plan2 :: plans)
+              case _ =>
+                def emitCondWithPos(plan: TestPlan) = emitCondition(plan).withSpan(plan.span)
+                val conditions =
+                  plans.foldRight[Tree](EmptyTree) { (otherPlan, acc) =>
+                    if (acc.isEmpty) emitCondWithPos(otherPlan)
+                    else acc.select(nme.ZAND).appliedTo(emitCondWithPos(otherPlan))
+                  }
+                If(conditions, emit(plan.onSuccess), unitLiteral)
+            }
+          }
+          emitWithMashedConditions(plan :: Nil)
+        case LetPlan(sym, body) =>
+          val valDef = ValDef(sym, initializer(sym).ensureConforms(sym.info), inferred = true).withSpan(sym.span)
+          seq(valDef :: Nil, emit(body))
+        case LabeledPlan(label, expr) =>
+          Labeled(label, emit(expr))
+        case ReturnPlan(label) =>
+          Return(Literal(Constant(())), ref(label))
+        case plan: SeqPlan =>
+          def default = seq(emit(plan.head) :: Nil, emit(plan.tail))
+          def maybeEmitSwitch(scrutinee: Tree): Tree = {
+            val switchCases = collectSwitchCases(scrutinee, plan)
+            if (hasEnoughSwitchCases(switchCases, MinSwitchCases)) // at least 3 cases + default
+              emitSwitchMatch(scrutinee, switchCases)
+            else
+              default
+          }
+          plan.head match {
+            case testPlan: TestPlan =>
+              maybeEmitSwitch(testPlan.scrutinee)
+            case LabeledPlan(_, SeqPlan(LabeledPlan(_, SeqPlan(testPlan: TestPlan, _)), _)) =>
+              maybeEmitSwitch(testPlan.scrutinee)
+            case _ =>
+              default
+          }
+        case ResultPlan(tree) =>
+          if (tree.symbol == defn.throwMethod) tree // For example MatchError
+          else Return(tree, ref(resultLabel))
+      }
+    }
+
+    /** Pretty-print plan; used for debugging */
+    def show(plan: Plan): String = {
+      val lrefCount = labelRefCount(plan)
+      val vrefCount = varRefCount(plan)
+      val sb = new StringBuilder
+      val seen = mutable.Set[Int]()
+      def showTest(test: Test) = test match {
+        case EqualTest(tree) => i"EqualTest($tree)"
+        case TypeTest(tpt, trusted) => i"TypeTest($tpt, trusted=$trusted)"
+        case _ => test.toString
+      }
+      def showPlan(plan: Plan): Unit =
+        if (!seen.contains(plan.id)) {
+          seen += plan.id
+          sb append s"\n${plan.id}: "
+          plan match {
+            case TestPlan(test, scrutinee, _, ons) =>
+              sb.append(i"$scrutinee ? ${showTest(test)}(${ons.id})")
+              showPlan(ons)
+            case LetPlan(sym, body) =>
+              sb.append(i"Let($sym = ${initializer(sym)}}, ${body.id})")
+              sb.append(s", refcount = ${vrefCount(sym)}")
+              showPlan(body)
+            case LabeledPlan(label, expr) =>
+              sb.append(i"Labeled($label: { ${expr.id} })")
+              sb.append(s", refcount = ${lrefCount(label)}")
+              showPlan(expr)
+            case ReturnPlan(label) =>
+              sb.append(s"Return($label)")
+            case SeqPlan(head, tail) =>
+              sb.append(s"Seq(${head.id}, ${tail.id})")
+              showPlan(head)
+              showPlan(tail)
+            case ResultPlan(tree) =>
+              sb.append(tree.show)
+          }
+        }
+      showPlan(plan)
+      sb.toString
+    }
+
+    /** If match is switch annotated, check that it translates to a switch
+     *  with at least as many cases as the original match.
+     */
+    private def checkSwitch(original: Match, result: Tree) = original.selector match
+      case Typed(_, tpt) if tpt.tpe.hasAnnotation(defn.SwitchAnnot) =>
+        val resultCases = result match
+          case Match(_, cases) => cases
+          case Block(_, Match(_, cases)) => cases
+          case Block((_: ValDef) :: Block(_, Match(_, cases)) :: Nil, _) => cases
+          case _ => Nil
+        val caseThreshold =
+          if ValueClasses.isDerivedValueClass(tpt.tpe.typeSymbol) then 1
+          else MinSwitchCases
+        def typesInPattern(pat: Tree): List[Type] = pat match
+          case Alternative(pats) => pats.flatMap(typesInPattern)
+          case _ => pat.tpe :: Nil
+        def typesInCases(cdefs: List[CaseDef]): List[Type] =
+          cdefs.flatMap(cdef => typesInPattern(cdef.pat))
+        def numTypes(cdefs: List[CaseDef]): Int =
+          typesInCases(cdefs).toSet.size: Int // without the type ascription, testPickling fails because of #2840.
+        val numTypesInOriginal = numTypes(original.cases)
+        if numTypesInOriginal >= caseThreshold && numTypes(resultCases) < numTypesInOriginal then
+          patmatch.println(i"switch warning for ${ctx.compilationUnit}")
+          patmatch.println(i"original types: ${typesInCases(original.cases)}%, %")
+          patmatch.println(i"switch types  : ${typesInCases(resultCases)}%, %")
+          patmatch.println(i"tree = $result")
+          report.warning(UnableToEmitSwitch(), original.srcPos)
+      case _ =>
+    end checkSwitch
+
+    val optimizations: List[(String, Plan -> Plan)] = List(
+      "mergeTests" -> mergeTests,
+      "inlineVars" -> inlineVars
+    )
+
+    /** Translate pattern match to sequence of tests. */
+    def translateMatch(tree: Match): Tree = {
+      var plan = matchPlan(tree)
+      patmatch.println(i"Plan for $tree: ${show(plan)}")
+      if (!ctx.settings.YnoPatmatOpt.value)
+        for ((title, optimization) <- optimizations) {
+          plan = optimization(plan)
+          patmatch.println(s"After $title: ${show(plan)}")
+        }
+      val result = emit(plan)
+      checkSwitch(tree, result)
+      Labeled(resultLabel, result)
+    }
+  }
+}
diff --git a/tests/pos-with-compiler-cc/dotc/transform/PickleQuotes.scala b/tests/pos-with-compiler-cc/dotc/transform/PickleQuotes.scala
new file mode 100644
index 000000000000..f3ae6a377aab
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/transform/PickleQuotes.scala
@@ -0,0 +1,383 @@
+package dotty.tools.dotc
+package transform
+
+import core._
+import Decorators._
+import Flags._
+import Types._
+import Contexts._
+import Symbols._
+import Constants._
+import ast.Trees._
+import ast.TreeTypeMap
+import SymUtils._
+import NameKinds._
+import dotty.tools.dotc.ast.tpd
+import dotty.tools.dotc.config.ScalaRelease.*
+
+import scala.collection.mutable
+import dotty.tools.dotc.core.Annotations._
+import dotty.tools.dotc.core.StdNames._
+import dotty.tools.dotc.quoted._
+import dotty.tools.dotc.transform.TreeMapWithStages._
+import dotty.tools.dotc.inlines.Inlines
+
+import scala.annotation.constructorOnly
+
+/** Translates quoted terms and types to `unpickleExprV2` or `unpickleType` method calls.
+ *
+ *  Transforms top level quote
+ *   ```
+ *   '{ ...
+ *      @TypeSplice type X0 = {{ 0 | .. | contentsTpe0 | .. }}
+ *      @TypeSplice type X2 = {{ 1 | .. | contentsTpe1 | .. }}
+ *      val x1: U1 = ???
+ *      val x2: U2 = ???
+ *      ...
+ *      {{{ 3 | x1 | contents0 | T0 }}} // hole
+ *      ...
+ *      {{{ 4 | x2 | contents1 | T1 }}} // hole
+ *      ...
+ *      {{{ 5 | x1, x2 | contents2 | T2 }}} // hole
+ *      ...
+ *    }
+ *    ```
+ *  to
+ *    ```
+ *     unpickleExprV2(
+ *       pickled = [[ // PICKLED TASTY
+ *       @TypeSplice type X0 // with bounds that do not contain captured types
+ *       @TypeSplice type X1 // with bounds that do not contain captured types
+ *         val x1 = ???
+ *         val x2 = ???
+ *         ...
+ *      {{{ 0 | x1 | | T0 }}} // hole
+ *      ...
+ *      {{{ 1 | x2 | | T1 }}} // hole
+ *      ...
+ *      {{{ 2 | x1, x2 | | T2 }}} // hole
+ *         ...
+ *       ]],
+ *       typeHole = (idx: Int, args: List[Any]) => idx match {
+ *         case 0 => contentsTpe0.apply(args(0).asInstanceOf[Type[?]]) // beta reduced
+ *         case 1 => contentsTpe1.apply(args(0).asInstanceOf[Type[?]]) // beta reduced
+ *       },
+ *       termHole = (idx: Int, args: List[Any], quotes: Quotes) => idx match {
+ *         case 3 => content0.apply(args(0).asInstanceOf[Expr[U1]]).apply(quotes) // beta reduced
+ *         case 4 => content1.apply(args(0).asInstanceOf[Expr[U2]]).apply(quotes) // beta reduced
+ *         case 5 => content2.apply(args(0).asInstanceOf[Expr[U1]], args(1).asInstanceOf[Expr[U2]]).apply(quotes) // beta reduced
+ *       },
+ *     )
+ *    ```
+ *  and then performs the same transformation on any quote contained in the `content`s.
+ *
+ */
+class PickleQuotes extends MacroTransform {
+  import PickleQuotes._
+  import tpd._
+
+  override def phaseName: String = PickleQuotes.name
+
+  override def description: String = PickleQuotes.description
+
+  override def allowsImplicitSearch: Boolean = true
+
+  override def checkPostCondition(tree: Tree)(using Context): Unit =
+    tree match
+      case tree: RefTree if !Inlines.inInlineMethod =>
+        assert(!tree.symbol.isQuote)
+        assert(!tree.symbol.isExprSplice)
+      case _ : TypeDef if !Inlines.inInlineMethod =>
+        assert(!tree.symbol.hasAnnotation(defn.QuotedRuntime_SplicedTypeAnnot),
+          s"${tree.symbol} should have been removed by PickledQuotes because it has a @quoteTypeTag")
+      case _ =>
+
+  override def run(using Context): Unit =
+    if (ctx.compilationUnit.needsStaging) super.run(using freshStagingContext)
+
+  protected def newTransformer(using Context): Transformer = new Transformer {
+    override def transform(tree: tpd.Tree)(using Context): tpd.Tree =
+      tree match
+        case Apply(Select(Apply(TypeApply(fn, List(tpt)), List(code)),nme.apply), List(quotes))
+        if fn.symbol == defn.QuotedRuntime_exprQuote =>
+          val (contents, codeWithHoles) = makeHoles(code)
+          val sourceRef = Inlines.inlineCallTrace(ctx.owner, tree.sourcePos)
+          val codeWithHoles2 = Inlined(sourceRef, Nil, codeWithHoles)
+          val pickled = PickleQuotes(quotes, codeWithHoles2, contents, tpt.tpe, false)
+          transform(pickled) // pickle quotes that are in the contents
+        case Apply(TypeApply(_, List(tpt)), List(quotes)) if tree.symbol == defn.QuotedTypeModule_of =>
+          tpt match
+            case Select(t, _) if tpt.symbol == defn.QuotedType_splice =>
+              // `Type.of[t.Underlying](quotes)`  --> `t`
+              ref(t.symbol)(using ctx.withSource(tpt.source)).withSpan(tpt.span)
+            case _ =>
+              val (contents, tptWithHoles) = makeHoles(tpt)
+              PickleQuotes(quotes, tptWithHoles, contents, tpt.tpe, true)
+        case tree: DefDef if tree.symbol.is(Macro) =>
+          // Shrink size of the tree. The methods have already been inlined.
+          // TODO move to FirstTransform to trigger even without quotes
+          cpy.DefDef(tree)(rhs = defaultValue(tree.rhs.tpe))
+        case _: DefDef if tree.symbol.isInlineMethod =>
+          tree
+        case _ =>
+          super.transform(tree)
+  }
+
+  private def makeHoles(tree: tpd.Tree)(using Context): (List[Tree], tpd.Tree) =
+
+    class HoleContentExtractor extends Transformer:
+      private val contents = List.newBuilder[Tree]
+      override def transform(tree: tpd.Tree)(using Context): tpd.Tree =
+        tree match
+          case tree @ Hole(isTerm, _, _, content, _) =>
+            if !content.isEmpty then
+              contents += content
+            val holeType =
+              if isTerm then getTermHoleType(tree.tpe) else getTypeHoleType(tree.tpe)
+            val hole = cpy.Hole(tree)(content = EmptyTree, TypeTree(holeType))
+            if isTerm then Inlined(EmptyTree, Nil, hole).withSpan(tree.span) else hole
+          case tree: DefTree =>
+            val newAnnotations = tree.symbol.annotations.mapconserve { annot =>
+              annot.derivedAnnotation(transform(annot.tree)(using ctx.withOwner(tree.symbol)))
+            }
+            tree.symbol.annotations = newAnnotations
+            super.transform(tree)
+          case _ =>
+            super.transform(tree).withType(mapAnnots(tree.tpe))
+
+      private def mapAnnots = new TypeMap { // TODO factor out duplicated logic in Splicing
+        override def apply(tp: Type): Type = {
+            tp match
+              case tp @ AnnotatedType(underlying, annot) =>
+                val underlying1 = this(underlying)
+                derivedAnnotatedType(tp, underlying1, annot.derivedAnnotation(transform(annot.tree)))
+              case _ => mapOver(tp)
+        }
+      }
+
+      /** Remove references to local types that will not be defined in this quote */
+      private def getTypeHoleType(using Context) = new TypeMap() {
+        override def apply(tp: Type): Type = tp match
+          case tp: TypeRef if tp.typeSymbol.isTypeSplice =>
+            apply(tp.dealias)
+          case tp @ TypeRef(pre, _) if pre == NoPrefix || pre.termSymbol.isLocal =>
+            val hiBound = tp.typeSymbol.info match
+              case info: ClassInfo => info.parents.reduce(_ & _)
+              case info => info.hiBound
+            apply(hiBound)
+          case tp =>
+            mapOver(tp)
+      }
+
+      /** Remove references to local types that will not be defined in this quote */
+      private def getTermHoleType(using Context) = new TypeMap() {
+        override def apply(tp: Type): Type = tp match
+          case tp @ TypeRef(NoPrefix, _) =>
+            // reference to term with a type defined in outer quote
+            getTypeHoleType(tp)
+          case tp @ TermRef(NoPrefix, _) =>
+            // widen term refs to terms defined in outer quote
+            apply(tp.widenTermRefExpr)
+          case tp =>
+            mapOver(tp)
+      }
+
+      /** Get the contents of the transformed tree */
+      def getContents() =
+        val res = contents.result
+        contents.clear()
+        res
+    end HoleContentExtractor
+
+    val holeMaker = new HoleContentExtractor
+    val newTree = holeMaker.transform(tree)
+    (holeMaker.getContents(), newTree)
+
+
+  end makeHoles
+
+}
+
+object PickleQuotes {
+  import tpd._
+
+  val name: String = "pickleQuotes"
+  val description: String = "turn quoted trees into explicit run-time data structures"
+
+  def apply(quotes: Tree, body: Tree, contents: List[Tree], originalTp: Type, isType: Boolean)(using Context) = {
+    /** Helper methods to construct trees calling methods in `Quotes.reflect` based on the current `quotes` tree */
+    object reflect extends ReifiedReflect {
+      val quotesTree = quotes
+    }
+
+    /** Encode quote using Reflection.Literal
+      *
+      *  Generate the code
+      *  ```scala
+      *    quotes => quotes.reflect.TreeMethods.asExpr(
+      *      quotes.reflect.Literal.apply(x$1.reflect.Constant.<typeName>.apply(<literalValue>))
+      *    ).asInstanceOf[scala.quoted.Expr[<body.type>]]
+      *  ```
+      *  this closure is always applied directly to the actual context and the BetaReduce phase removes it.
+      */
+    def pickleAsLiteral(lit: Literal) = {
+      val typeName = body.tpe.typeSymbol.name
+      val literalValue =
+        if lit.const.tag == Constants.NullTag || lit.const.tag == Constants.UnitTag then Nil
+        else List(body)
+      val constModule = lit.const.tag match
+        case Constants.BooleanTag => defn. Quotes_reflect_BooleanConstant
+        case Constants.ByteTag => defn. Quotes_reflect_ByteConstant
+        case Constants.ShortTag => defn. Quotes_reflect_ShortConstant
+        case Constants.IntTag => defn. Quotes_reflect_IntConstant
+        case Constants.LongTag => defn. Quotes_reflect_LongConstant
+        case Constants.FloatTag => defn. Quotes_reflect_FloatConstant
+        case Constants.DoubleTag => defn. Quotes_reflect_DoubleConstant
+        case Constants.CharTag => defn. Quotes_reflect_CharConstant
+        case Constants.StringTag => defn. Quotes_reflect_StringConstant
+        case Constants.UnitTag => defn. Quotes_reflect_UnitConstant
+        case Constants.NullTag => defn. Quotes_reflect_NullConstant
+        case Constants.ClazzTag => defn. Quotes_reflect_ClassOfConstant
+      reflect.asExpr(body.tpe) {
+        reflect.Literal {
+          reflect.self
+            .select(constModule)
+            .select(nme.apply)
+            .appliedToTermArgs(literalValue)
+        }
+      }
+    }
+
+    /** Encode quote using Reflection.Literal
+      *
+      *  Generate the code
+      *  ```scala
+      *    quotes => scala.quoted.ToExpr.{BooleanToExpr,ShortToExpr, ...}.apply(<literalValue>)(quotes)
+      *  ```
+      *  this closure is always applied directly to the actual context and the BetaReduce phase removes it.
+      */
+    def liftedValue(lit: Literal, lifter: Symbol) =
+      val exprType = defn.QuotedExprClass.typeRef.appliedTo(body.tpe)
+      ref(lifter).appliedToType(originalTp).select(nme.apply).appliedTo(lit).appliedTo(quotes)
+
+    def pickleAsValue(lit: Literal) = {
+      // TODO should all constants be pickled as Literals?
+      // Should examine the generated bytecode size to decide and performance
+      lit.const.tag match {
+        case Constants.NullTag => pickleAsLiteral(lit)
+        case Constants.UnitTag => pickleAsLiteral(lit)
+        case Constants.BooleanTag => liftedValue(lit, defn.ToExprModule_BooleanToExpr)
+        case Constants.ByteTag => liftedValue(lit, defn.ToExprModule_ByteToExpr)
+        case Constants.ShortTag => liftedValue(lit, defn.ToExprModule_ShortToExpr)
+        case Constants.IntTag => liftedValue(lit, defn.ToExprModule_IntToExpr)
+        case Constants.LongTag => liftedValue(lit, defn.ToExprModule_LongToExpr)
+        case Constants.FloatTag => liftedValue(lit, defn.ToExprModule_FloatToExpr)
+        case Constants.DoubleTag => liftedValue(lit, defn.ToExprModule_DoubleToExpr)
+        case Constants.CharTag => liftedValue(lit, defn.ToExprModule_CharToExpr)
+        case Constants.StringTag => liftedValue(lit, defn.ToExprModule_StringToExpr)
+      }
+    }
+
+    /** Encode quote using QuoteUnpickler.{unpickleExpr, unpickleType}
+      *
+      *  Generate the code
+      *  ```scala
+      *    quotes => quotes.asInstanceOf[QuoteUnpickler].<unpickleExpr|unpickleType>[<type>](
+      *      <pickledQuote>,
+      *      <typeHole>,
+      *      <termHole>,
+      *    )
+      *  ```
+      *  this closure is always applied directly to the actual context and the BetaReduce phase removes it.
+      */
+    def pickleAsTasty() = {
+      val pickleQuote = PickledQuotes.pickleQuote(body)
+      val pickledQuoteStrings = pickleQuote match
+        case x :: Nil => Literal(Constant(x))
+        case xs => tpd.mkList(xs.map(x => Literal(Constant(x))), TypeTree(defn.StringType))
+
+      // TODO split holes earlier into types and terms. This all holes in each category can have consecutive indices
+      val (typeSplices, termSplices) = contents.zipWithIndex.partition {
+        _._1.tpe.derivesFrom(defn.QuotedTypeClass)
+      }
+
+      // This and all closures in typeSplices are removed by the BetaReduce phase
+      val types =
+        if typeSplices.isEmpty then Literal(Constant(null)) // keep pickled quote without contents as small as possible
+        else SeqLiteral(typeSplices.map(_._1), TypeTree(defn.QuotedTypeClass.typeRef.appliedTo(WildcardType)))
+
+      // This and all closures in termSplices are removed by the BetaReduce phase
+      val termHoles =
+        if termSplices.isEmpty then Literal(Constant(null)) // keep pickled quote without contents as small as possible
+        else
+          Lambda(
+            MethodType(
+              List(nme.idx, nme.contents, nme.quotes).map(name => UniqueName.fresh(name).toTermName),
+              List(defn.IntType, defn.SeqType.appliedTo(defn.AnyType), defn.QuotesClass.typeRef),
+              defn.QuotedExprClass.typeRef.appliedTo(defn.AnyType)),
+            args =>
+              val cases = termSplices.map { case (splice, idx) =>
+                val defn.FunctionOf(argTypes, defn.FunctionOf(quotesType :: _, _, _, _), _, _) = splice.tpe: @unchecked
+                val rhs = {
+                  val spliceArgs = argTypes.zipWithIndex.map { (argType, i) =>
+                    args(1).select(nme.apply).appliedTo(Literal(Constant(i))).asInstance(argType)
+                  }
+                  val Block(List(ddef: DefDef), _) = splice: @unchecked
+                  // TODO: beta reduce inner closure? Or wait until BetaReduce phase?
+                  BetaReduce(ddef, spliceArgs).select(nme.apply).appliedTo(args(2).asInstance(quotesType))
+                }
+                CaseDef(Literal(Constant(idx)), EmptyTree, rhs)
+              }
+              cases match
+                case CaseDef(_, _, rhs) :: Nil => rhs
+                case _ => Match(args(0).annotated(New(ref(defn.UncheckedAnnot.typeRef))), cases)
+          )
+
+      val quoteClass = if isType then defn.QuotedTypeClass else defn.QuotedExprClass
+      val quotedType = quoteClass.typeRef.appliedTo(originalTp)
+      val lambdaTpe = MethodType(defn.QuotesClass.typeRef :: Nil, quotedType)
+      val unpickleMeth =
+        if isType then defn.QuoteUnpickler_unpickleTypeV2
+        else defn.QuoteUnpickler_unpickleExprV2
+      val unpickleArgs =
+        if isType then List(pickledQuoteStrings, types)
+        else List(pickledQuoteStrings, types, termHoles)
+      quotes
+        .asInstance(defn.QuoteUnpicklerClass.typeRef)
+        .select(unpickleMeth).appliedToType(originalTp)
+        .appliedToArgs(unpickleArgs).withSpan(body.span)
+    }
+
+    /** Encode quote using Reflection.TypeRepr.typeConstructorOf
+      *
+      *  Generate the code
+      *  ```scala
+      *    quotes.reflect.TypeReprMethods.asType(
+      *      quotes.reflect.TypeRepr.typeConstructorOf(classOf[<type>]])
+      *    ).asInstanceOf[scala.quoted.Type[<type>]]
+      *  ```
+      *  this closure is always applied directly to the actual context and the BetaReduce phase removes it.
+      */
+    def taggedType() =
+      reflect.asType(body.tpe) {
+        reflect.TypeRepr_typeConstructorOf(
+          TypeApply(ref(defn.Predef_classOf.termRef), body :: Nil)
+        )
+      }
+
+    def getLiteral(tree: tpd.Tree): Option[Literal] = tree match
+      case tree: Literal => Some(tree)
+      case Block(Nil, e) => getLiteral(e)
+      case Inlined(_, Nil, e) => getLiteral(e)
+      case _ => None
+
+    if (isType) then
+      if contents.isEmpty && body.symbol.isPrimitiveValueClass then taggedType()
+      else pickleAsTasty()
+    else
+      getLiteral(body) match
+        case Some(lit) => pickleAsValue(lit)
+        case _ => pickleAsTasty()
+  }
+
+}
diff --git a/tests/pos-with-compiler-cc/dotc/transform/Pickler.scala b/tests/pos-with-compiler-cc/dotc/transform/Pickler.scala
new file mode 100644
index 000000000000..4d9b42a36fe7
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/transform/Pickler.scala
@@ -0,0 +1,154 @@
+package dotty.tools.dotc
+package transform
+
+import core._
+import Contexts._
+import Decorators._
+import tasty._
+import config.Printers.{noPrinter, pickling}
+import java.io.PrintStream
+import Periods._
+import Phases._
+import Symbols._
+import Flags.Module
+import reporting.{ThrowingReporter, Profile}
+import collection.mutable
+import scala.concurrent.{Future, Await, ExecutionContext}
+import scala.concurrent.duration.Duration
+
+object Pickler {
+  val name: String = "pickler"
+  val description: String = "generates TASTy info"
+
+  /** If set, perform jump target compacting, position and comment pickling,
+   *  as well as final assembly in parallel with downstream phases; force
+   *  only in backend.
+   */
+  inline val ParallelPickling = true
+}
+
+/** This phase pickles trees */
+class Pickler extends Phase {
+  import ast.tpd._
+
+  override def phaseName: String = Pickler.name
+
+  override def description: String = Pickler.description
+
+  // No need to repickle trees coming from TASTY
+  override def isRunnable(using Context): Boolean =
+    super.isRunnable && !ctx.settings.fromTasty.value
+
+  private def output(name: String, msg: String) = {
+    val s = new PrintStream(name)
+    s.print(msg)
+    s.close
+  }
+
+  // Maps that keep a record if -Ytest-pickler is set.
+  private val beforePickling = new mutable.HashMap[ClassSymbol, String]
+  private val picklers = new mutable.HashMap[ClassSymbol, TastyPickler]
+
+  /** Drop any elements of this list that are linked module classes of other elements in the list */
+  private def dropCompanionModuleClasses(clss: List[ClassSymbol])(using Context): List[ClassSymbol] = {
+    val companionModuleClasses =
+      clss.filterNot(_.is(Module)).map(_.linkedClass).filterNot(_.isAbsent())
+    clss.filterNot(companionModuleClasses.contains)
+  }
+
+  override def run(using Context): Unit = {
+    val unit = ctx.compilationUnit
+    pickling.println(i"unpickling in run ${ctx.runId}")
+
+    for
+      cls <- dropCompanionModuleClasses(topLevelClasses(unit.tpdTree))
+      tree <- sliceTopLevel(unit.tpdTree, cls)
+    do
+      val pickler = new TastyPickler(cls)
+      if ctx.settings.YtestPickler.value then
+        beforePickling(cls) = tree.show
+        picklers(cls) = pickler
+      val treePkl = new TreePickler(pickler)
+      treePkl.pickle(tree :: Nil)
+      Profile.current.recordTasty(treePkl.buf.length)
+      val positionWarnings = new mutable.ListBuffer[String]()
+      val pickledF = inContext(ctx.fresh) {
+        Future {
+          treePkl.compactify()
+          if tree.span.exists then
+            val reference = ctx.settings.sourceroot.value
+            new PositionPickler(pickler, treePkl.buf.addrOfTree, treePkl.treeAnnots, reference)
+              .picklePositions(unit.source, tree :: Nil, positionWarnings)
+
+          if !ctx.settings.YdropComments.value then
+            new CommentPickler(pickler, treePkl.buf.addrOfTree, treePkl.docString)
+              .pickleComment(tree)
+
+          val pickled = pickler.assembleParts()
+
+          def rawBytes = // not needed right now, but useful to print raw format.
+            pickled.iterator.grouped(10).toList.zipWithIndex.map {
+              case (row, i) => s"${i}0: ${row.mkString(" ")}"
+            }
+
+          // println(i"rawBytes = \n$rawBytes%\n%") // DEBUG
+          if pickling ne noPrinter then
+            pickling.synchronized {
+              println(i"**** pickled info of $cls")
+              println(TastyPrinter.showContents(pickled, ctx.settings.color.value == "never"))
+            }
+          pickled
+        }(using ExecutionContext.global)
+      }
+      def force(): Array[Byte] =
+        val result = Await.result(pickledF, Duration.Inf)
+        positionWarnings.foreach(report.warning(_))
+        result
+
+      if !Pickler.ParallelPickling || ctx.settings.YtestPickler.value then force()
+
+      unit.pickled += (cls -> force)
+    end for
+  }
+
+  override def runOn(units: List[CompilationUnit])(using Context): List[CompilationUnit] = {
+    val result = super.runOn(units)
+    if ctx.settings.YtestPickler.value then
+      val ctx2 = ctx.fresh.setSetting(ctx.settings.YreadComments, true)
+      testUnpickler(
+        using ctx2
+            .setPeriod(Period(ctx.runId + 1, ctx.base.typerPhase.id))
+            .setReporter(new ThrowingReporter(ctx.reporter))
+            .addMode(Mode.ReadPositions)
+            .addMode(Mode.PrintShowExceptions))
+    result
+  }
+
+  private def testUnpickler(using Context): Unit = {
+    pickling.println(i"testing unpickler at run ${ctx.runId}")
+    ctx.initialize()
+    val unpicklers =
+      for ((cls, pickler) <- picklers) yield {
+        val unpickler = new DottyUnpickler(pickler.assembleParts())
+        unpickler.enter(roots = Set.empty)
+        cls -> unpickler
+      }
+    pickling.println("************* entered toplevel ***********")
+    for ((cls, unpickler) <- unpicklers) {
+      val unpickled = unpickler.rootTrees
+      testSame(i"$unpickled%\n%", beforePickling(cls), cls)
+    }
+  }
+
+  private def testSame(unpickled: String, previous: String, cls: ClassSymbol)(using Context) =
+    import java.nio.charset.StandardCharsets.UTF_8
+    def normal(s: String) = new String(s.getBytes(UTF_8), UTF_8)
+    val unequal = unpickled.length() != previous.length() || normal(unpickled) != normal(previous)
+    if unequal then
+      output("before-pickling.txt", previous)
+      output("after-pickling.txt", unpickled)
+      report.error(s"""pickling difference for $cls in ${cls.source}, for details:
+                   |
+                   |  diff before-pickling.txt after-pickling.txt""".stripMargin)
+  end testSame
+}
diff --git a/tests/pos-with-compiler-cc/dotc/transform/PostInlining.scala b/tests/pos-with-compiler-cc/dotc/transform/PostInlining.scala
new file mode 100644
index 000000000000..0cfd3650ad0b
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/transform/PostInlining.scala
@@ -0,0 +1,35 @@
+package dotty.tools.dotc
+package transform
+
+import core._
+import Contexts.*
+import DenotTransformers.IdentityDenotTransformer
+import SyntheticMembers.*
+import ast.tpd.*
+
+/** A phase that adds mirror support for anonymous mirrors created at inlining. */
+class PostInlining extends MacroTransform, IdentityDenotTransformer:
+  thisPhase =>
+
+  override def phaseName: String = PostInlining.name
+
+  override def description: String = PostInlining.description
+
+  override def changesMembers = true
+
+  override def run(using Context): Unit =
+    if ctx.compilationUnit.needsMirrorSupport then super.run
+
+  lazy val synthMbr: SyntheticMembers = new SyntheticMembers(thisPhase)
+
+  def newTransformer(using Context): Transformer = new Transformer:
+    override def transform(tree: Tree)(using Context): Tree =
+      super.transform(tree) match
+        case tree1: Template
+        if tree1.hasAttachment(ExtendsSingletonMirror) || tree1.hasAttachment(ExtendsSumOrProductMirror) =>
+          synthMbr.addMirrorSupport(tree1)
+        case tree1 => tree1
+
+object PostInlining:
+  val name: String = "postInlining"
+  val description: String = "add mirror support for inlined code"
diff --git a/tests/pos-with-compiler-cc/dotc/transform/PostTyper.scala b/tests/pos-with-compiler-cc/dotc/transform/PostTyper.scala
new file mode 100644
index 000000000000..0424b48751bc
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/transform/PostTyper.scala
@@ -0,0 +1,497 @@
+package dotty.tools.dotc
+package transform
+
+import dotty.tools.dotc.ast.{Trees, tpd, untpd, desugar}
+import scala.collection.mutable
+import core._
+import dotty.tools.dotc.typer.Checking
+import dotty.tools.dotc.inlines.Inlines
+import dotty.tools.dotc.typer.VarianceChecker
+import typer.ErrorReporting.errorTree
+import Types._, Contexts._, Names._, Flags._, DenotTransformers._, Phases._
+import SymDenotations._, StdNames._, Annotations._, Trees._, Scopes._
+import Decorators._
+import Symbols._, SymUtils._, NameOps._
+import ContextFunctionResults.annotateContextResults
+import config.Printers.typr
+import config.Feature
+import util.SrcPos
+import reporting._
+import NameKinds.WildcardParamName
+
+object PostTyper {
+  val name: String = "posttyper"
+  val description: String = "additional checks and cleanups after type checking"
+}
+
+/** A macro transform that runs immediately after typer and that performs the following functions:
+ *
+ *  (1) Add super accessors (@see SuperAccessors)
+ *
+ *  (2) Convert parameter fields that have the same name as a corresponding
+ *      public parameter field in a superclass to a forwarder to the superclass
+ *      field (corresponding = super class field is initialized with subclass field)
+ *      @see forwardParamAccessors.
+ *
+ *  (3) Add synthetic members (@see SyntheticMembers)
+ *
+ *  (4) Check that `New` nodes can be instantiated, and that annotations are valid
+ *
+ *  (5) Convert all trees representing types to TypeTrees.
+ *
+ *  (6) Check the bounds of AppliedTypeTrees
+ *
+ *  (7) Insert `.package` for selections of package object members
+ *
+ *  (8) Replaces self references by name with `this`
+ *
+ *  (9) Adds SourceFile annotations to all top-level classes and objects
+ *
+ *  (10) Adds Child annotations to all sealed classes
+ *
+ *  (11) Minimizes `call` fields of `Inlined` nodes to just point to the toplevel
+ *       class from which code was inlined.
+ *
+ *  The reason for making this a macro transform is that some functions (in particular
+ *  super and protected accessors and instantiation checks) are naturally top-down and
+ *  don't lend themselves to the bottom-up approach of a mini phase. The other two functions
+ *  (forwarding param accessors and synthetic methods) only apply to templates and fit
+ *  mini-phase or subfunction of a macro phase equally well. But taken by themselves
+ *  they do not warrant their own group of miniphases before pickling.
+ */
+class PostTyper extends MacroTransform with IdentityDenotTransformer { thisPhase =>
+  import tpd._
+
+  override def phaseName: String = PostTyper.name
+
+  override def description: String = PostTyper.description
+
+  override def checkPostCondition(tree: tpd.Tree)(using Context): Unit = tree match {
+    case tree: ValOrDefDef =>
+      assert(!tree.symbol.signature.isUnderDefined)
+    case _ =>
+  }
+
+  override def changesMembers: Boolean = true // the phase adds super accessors and synthetic members
+
+  override def transformPhase(using Context): Phase = thisPhase.next
+
+  def newTransformer(using Context): Transformer =
+    new PostTyperTransformer
+
+  val superAcc: SuperAccessors = new SuperAccessors(thisPhase)
+  val synthMbr: SyntheticMembers = new SyntheticMembers(thisPhase)
+  val beanProps: BeanProperties = new BeanProperties(thisPhase)
+
+  private def newPart(tree: Tree): Option[New] = methPart(tree) match {
+    case Select(nu: New, _) => Some(nu)
+    case _ => None
+  }
+
+  private def checkValidJavaAnnotation(annot: Tree)(using Context): Unit = {
+    // TODO fill in
+  }
+
+  class PostTyperTransformer extends Transformer {
+
+    private var inJavaAnnot: Boolean = false
+
+    private var noCheckNews: Set[New] = Set()
+
+    def withNoCheckNews[T](ts: List[New])(op: => T): T = {
+      val saved = noCheckNews
+      noCheckNews ++= ts
+      try op finally noCheckNews = saved
+    }
+
+    def isCheckable(t: New): Boolean = !inJavaAnnot && !noCheckNews.contains(t)
+
+    /** Mark parameter accessors that are aliases of like-named parameters
+     *  in their superclass with SuperParamAlias.
+     *  This info is used in phase ParamForwarding
+     */
+    private def forwardParamAccessors(impl: Template)(using Context): Unit = impl.parents match
+      case superCall @ Apply(fn, superArgs) :: _ if superArgs.nonEmpty =>
+        fn.tpe.widen match
+          case MethodType(superParamNames) =>
+            for case stat: ValDef <- impl.body do
+              val sym = stat.symbol
+              if sym.isAllOf(PrivateParamAccessor, butNot = Mutable)
+                 && !sym.info.isInstanceOf[ExprType] // val-parameters cannot be call-by name, so no need to try to forward to them
+              then
+                val idx = superArgs.indexWhere(_.symbol == sym)
+                if idx >= 0 && superParamNames(idx) == stat.name then
+                  // Supercall to like-named parameter.
+                  // Having it have the same name is needed to maintain correctness in presence of subclassing
+                  // if you would use parent param-name `a` to implement param-field `b`
+                  // overriding field `b` will actually override field `a`, that is wrong!
+                  typr.println(i"super alias: ${sym.showLocated}")
+                  sym.setFlagFrom(thisPhase, SuperParamAlias)
+          case _ =>
+      case _ =>
+
+    private def transformAnnot(annot: Tree)(using Context): Tree = {
+      val saved = inJavaAnnot
+      inJavaAnnot = annot.symbol.is(JavaDefined)
+      if (inJavaAnnot) checkValidJavaAnnotation(annot)
+      try transform(annot)
+      finally inJavaAnnot = saved
+    }
+
+    private def transformAnnot(annot: Annotation)(using Context): Annotation =
+      annot.derivedAnnotation(transformAnnot(annot.tree))
+
+    private def processMemberDef(tree: Tree)(using Context): tree.type = {
+      val sym = tree.symbol
+      Checking.checkValidOperator(sym)
+      sym.transformAnnotations(transformAnnot)
+      sym.defTree = tree
+      tree
+    }
+
+    private def processValOrDefDef(tree: Tree)(using Context): tree.type =
+      val sym = tree.symbol
+      tree match
+        case tree: ValOrDefDef if !sym.is(Synthetic) =>
+          checkInferredWellFormed(tree.tpt)
+          if sym.is(Method) then
+            if sym.isSetter then
+              removeUnwantedAnnotations(sym, defn.SetterMetaAnnot, NoSymbol, keepIfNoRelevantAnnot = false)
+          else
+            if sym.is(Param) then
+              removeUnwantedAnnotations(sym, defn.ParamMetaAnnot, NoSymbol, keepIfNoRelevantAnnot = true)
+            else
+              removeUnwantedAnnotations(sym, defn.GetterMetaAnnot, defn.FieldMetaAnnot, keepIfNoRelevantAnnot = !sym.is(ParamAccessor))
+          if sym.isScala2Macro && !ctx.settings.XignoreScala2Macros.value then
+            if !sym.owner.unforcedDecls.exists(p => !p.isScala2Macro && p.name == sym.name && p.signature == sym.signature)
+               // Allow scala.reflect.materializeClassTag to be able to compile scala/reflect/package.scala
+               // This should be removed on Scala 3.x
+               && sym.owner != defn.ReflectPackageClass
+            then
+              report.error("No Scala 3 implementation found for this Scala 2 macro.", tree.srcPos)
+        case _ =>
+      processMemberDef(tree)
+
+    private def checkInferredWellFormed(tree: Tree)(using Context): Unit = tree match
+      case tree: TypeTree
+      if tree.span.isZeroExtent
+          // don't check TypeTrees with non-zero extent;
+          // these are derived from explicit types
+         && !ctx.reporter.errorsReported
+          // don't check if errors were already reported; this avoids follow-on errors
+          // for inferred types if explicit types are already ill-formed
+        => Checking.checkAppliedTypesIn(tree)
+      case _ =>
+
+    private def removeUnwantedAnnotations(sym: Symbol, metaAnnotSym: Symbol,
+        metaAnnotSymBackup: Symbol, keepIfNoRelevantAnnot: Boolean)(using Context): Unit =
+      def shouldKeep(annot: Annotation): Boolean =
+        val annotSym = annot.symbol
+        annotSym.hasAnnotation(metaAnnotSym)
+          || annotSym.hasAnnotation(metaAnnotSymBackup)
+          || (keepIfNoRelevantAnnot && {
+            !annotSym.annotations.exists(metaAnnot => defn.FieldAccessorMetaAnnots.contains(metaAnnot.symbol))
+          })
+      if sym.annotations.nonEmpty then
+        sym.filterAnnotations(shouldKeep(_))
+
+    private def transformSelect(tree: Select, targs: List[Tree])(using Context): Tree = {
+      val qual = tree.qualifier
+      qual.symbol.moduleClass.denot match {
+        case pkg: PackageClassDenotation =>
+          val pobj = pkg.packageObjFor(tree.symbol)
+          if (pobj.exists)
+            return transformSelect(cpy.Select(tree)(qual.select(pobj).withSpan(qual.span), tree.name), targs)
+        case _ =>
+      }
+      val tree1 = super.transform(tree)
+      constToLiteral(tree1) match {
+        case _: Literal => tree1
+        case _ => superAcc.transformSelect(tree1, targs)
+      }
+    }
+
+    private def normalizeTypeArgs(tree: TypeApply)(using Context): TypeApply = tree.tpe match {
+      case pt: PolyType => // wait for more arguments coming
+        tree
+      case _ =>
+        def decompose(tree: TypeApply): (Tree, List[Tree]) = tree.fun match {
+          case fun: TypeApply =>
+            val (tycon, args) = decompose(fun)
+            (tycon, args ++ tree.args)
+          case _ =>
+            (tree.fun, tree.args)
+        }
+        def reorderArgs(pnames: List[Name], namedArgs: List[NamedArg], otherArgs: List[Tree]): List[Tree] = pnames match {
+          case pname :: pnames1 =>
+            namedArgs.partition(_.name == pname) match {
+              case (NamedArg(_, arg) :: _, namedArgs1) =>
+                arg :: reorderArgs(pnames1, namedArgs1, otherArgs)
+              case _ =>
+                val otherArg :: otherArgs1 = otherArgs: @unchecked
+                otherArg :: reorderArgs(pnames1, namedArgs, otherArgs1)
+            }
+          case nil =>
+            assert(namedArgs.isEmpty && otherArgs.isEmpty)
+            Nil
+        }
+        val (tycon, args) = decompose(tree)
+        tycon.tpe.widen match {
+          case tp: PolyType if args.exists(isNamedArg) =>
+            val (namedArgs, otherArgs) = args.partition(isNamedArg)
+            val args1 = reorderArgs(tp.paramNames, namedArgs.asInstanceOf[List[NamedArg]], otherArgs)
+            TypeApply(tycon, args1).withSpan(tree.span).withType(tree.tpe)
+          case _ =>
+            tree
+        }
+    }
+
+    private object dropInlines extends TreeMap {
+      override def transform(tree: Tree)(using Context): Tree = tree match {
+        case Inlined(call, _, expansion) =>
+          val newExpansion = PruneErasedDefs.trivialErasedTree(tree)
+          cpy.Inlined(tree)(call, Nil, newExpansion)
+        case _ => super.transform(tree)
+      }
+    }
+
+    def checkNoConstructorProxy(tree: Tree)(using Context): Unit =
+      if tree.symbol.is(ConstructorProxy) then
+        report.error(em"constructor proxy ${tree.symbol} cannot be used as a value", tree.srcPos)
+
+    def checkStableSelection(tree: Tree)(using Context): Unit =
+      def check(qual: Tree) =
+        if !qual.tpe.isStable then
+          report.error(em"Parameter untupling cannot be used for call-by-name parameters", tree.srcPos)
+      tree match
+        case Select(qual, _) => check(qual)    // simple select _n
+        case Apply(TypeApply(Select(qual, _), _), _) => check(qual) // generic select .apply[T](n)
+
+    def checkNotPackage(tree: Tree)(using Context): Tree =
+      if !tree.symbol.is(Package) then tree
+      else errorTree(tree, i"${tree.symbol} cannot be used as a type")
+
+    override def transform(tree: Tree)(using Context): Tree =
+      try tree match {
+        // TODO move CaseDef case lower: keep most probable trees first for performance
+        case CaseDef(pat, _, _) =>
+          val gadtCtx =
+           pat.removeAttachment(typer.Typer.InferredGadtConstraints) match
+             case Some(gadt) => ctx.fresh.setGadt(gadt)
+             case None =>
+               ctx
+          super.transform(tree)(using gadtCtx)
+        case tree: Ident =>
+          if tree.isType then
+            checkNotPackage(tree)
+          else
+            if tree.symbol.is(Inline) && !Inlines.inInlineMethod then
+              ctx.compilationUnit.needsInlining = true
+            checkNoConstructorProxy(tree)
+            tree.tpe match {
+              case tpe: ThisType => This(tpe.cls).withSpan(tree.span)
+              case _ => tree
+            }
+        case tree @ Select(qual, name) =>
+          if tree.symbol.is(Inline) then
+            ctx.compilationUnit.needsInlining = true
+          if name.isTypeName then
+            Checking.checkRealizable(qual.tpe, qual.srcPos)
+            withMode(Mode.Type)(super.transform(checkNotPackage(tree)))
+          else
+            checkNoConstructorProxy(tree)
+            transformSelect(tree, Nil)
+        case tree: Apply =>
+          val methType = tree.fun.tpe.widen
+          val app =
+            if (methType.isErasedMethod)
+              tpd.cpy.Apply(tree)(
+                tree.fun,
+                tree.args.mapConserve(arg =>
+                  if (methType.isImplicitMethod && arg.span.isSynthetic)
+                    arg match
+                      case _: RefTree | _: Apply | _: TypeApply if arg.symbol.is(Erased) =>
+                        dropInlines.transform(arg)
+                      case _ =>
+                        PruneErasedDefs.trivialErasedTree(arg)
+                  else dropInlines.transform(arg)))
+            else
+              tree
+          def app1 =
+   		    	// reverse order of transforming args and fun. This way, we get a chance to see other
+   			    // well-formedness errors before reporting errors in possible inferred type args of fun.
+            val args1 = transform(app.args)
+            cpy.Apply(app)(transform(app.fun), args1)
+          methPart(app) match
+            case Select(nu: New, nme.CONSTRUCTOR) if isCheckable(nu) =>
+              // need to check instantiability here, because the type of the New itself
+              // might be a type constructor.
+              ctx.typer.checkClassType(tree.tpe, tree.srcPos, traitReq = false, stablePrefixReq = true)
+              if !nu.tpe.isLambdaSub then
+                // Check the constructor type as well; it could be an illegal singleton type
+                // which would not be reflected as `tree.tpe`
+                ctx.typer.checkClassType(nu.tpe, tree.srcPos, traitReq = false, stablePrefixReq = false)
+              Checking.checkInstantiable(tree.tpe, nu.srcPos)
+              withNoCheckNews(nu :: Nil)(app1)
+            case _ =>
+              app1
+        case UnApply(fun, implicits, patterns) =>
+          // Reverse transform order for the same reason as in `app1` above.
+          val patterns1 = transform(patterns)
+          cpy.UnApply(tree)(transform(fun), transform(implicits), patterns1)
+        case tree: TypeApply =>
+          if tree.symbol.isQuote then
+            ctx.compilationUnit.needsStaging = true
+          if tree.symbol.is(Inline) then
+            ctx.compilationUnit.needsInlining = true
+          val tree1 @ TypeApply(fn, args) = normalizeTypeArgs(tree)
+          for arg <- args do
+            checkInferredWellFormed(arg)
+          if (fn.symbol != defn.ChildAnnot.primaryConstructor)
+            // Make an exception for ChildAnnot, which should really have AnyKind bounds
+            Checking.checkBounds(args, fn.tpe.widen.asInstanceOf[PolyType])
+          fn match {
+            case sel: Select =>
+              val args1 = transform(args)
+              val sel1 = transformSelect(sel, args1)
+              cpy.TypeApply(tree1)(sel1, args1)
+            case _ =>
+              super.transform(tree1)
+          }
+        case Inlined(call, bindings, expansion) if !call.isEmpty =>
+          val pos = call.sourcePos
+          val callTrace = Inlines.inlineCallTrace(call.symbol, pos)(using ctx.withSource(pos.source))
+          cpy.Inlined(tree)(callTrace, transformSub(bindings), transform(expansion)(using inlineContext(call)))
+        case templ: Template =>
+          withNoCheckNews(templ.parents.flatMap(newPart)) {
+            forwardParamAccessors(templ)
+            synthMbr.addSyntheticMembers(
+              beanProps.addBeanMethods(
+                superAcc.wrapTemplate(templ)(
+                  super.transform(_).asInstanceOf[Template]))
+            )
+          }
+        case tree: ValDef =>
+          checkErasedDef(tree)
+          val tree1 = cpy.ValDef(tree)(rhs = normalizeErasedRhs(tree.rhs, tree.symbol))
+          if tree1.removeAttachment(desugar.UntupledParam).isDefined then
+            checkStableSelection(tree.rhs)
+          processValOrDefDef(super.transform(tree1))
+        case tree: DefDef =>
+          checkErasedDef(tree)
+          annotateContextResults(tree)
+          val tree1 = cpy.DefDef(tree)(rhs = normalizeErasedRhs(tree.rhs, tree.symbol))
+          processValOrDefDef(superAcc.wrapDefDef(tree1)(super.transform(tree1).asInstanceOf[DefDef]))
+        case tree: TypeDef =>
+          val sym = tree.symbol
+          if (sym.isClass)
+            VarianceChecker.check(tree)
+            annotateExperimental(sym)
+            tree.rhs match
+              case impl: Template =>
+                for parent <- impl.parents do
+                  Checking.checkTraitInheritance(parent.tpe.classSymbol, sym.asClass, parent.srcPos)
+            // Add SourceFile annotation to top-level classes
+            if sym.owner.is(Package) then
+              if ctx.compilationUnit.source.exists && sym != defn.SourceFileAnnot then
+                val reference = ctx.settings.sourceroot.value
+                val relativePath = util.SourceFile.relativePath(ctx.compilationUnit.source, reference)
+                sym.addAnnotation(Annotation.makeSourceFile(relativePath))
+              if Feature.pureFunsEnabled && sym != defn.WithPureFunsAnnot then
+                sym.addAnnotation(Annotation(defn.WithPureFunsAnnot))
+          else
+            if !sym.is(Param) && !sym.owner.isOneOf(AbstractOrTrait) then
+              Checking.checkGoodBounds(tree.symbol)
+            (tree.rhs, sym.info) match
+              case (rhs: LambdaTypeTree, bounds: TypeBounds) =>
+                VarianceChecker.checkLambda(rhs, bounds)
+                if sym.isOpaqueAlias then
+                  VarianceChecker.checkLambda(rhs, TypeBounds.upper(sym.opaqueAlias))
+              case _ =>
+          processMemberDef(super.transform(tree))
+        case tree: Bind =>
+          if tree.symbol.isType && !tree.symbol.name.is(WildcardParamName) then
+            Checking.checkGoodBounds(tree.symbol)
+          super.transform(tree)
+        case tree: New if isCheckable(tree) =>
+          Checking.checkInstantiable(tree.tpe, tree.srcPos)
+          super.transform(tree)
+        case tree: Closure if !tree.tpt.isEmpty =>
+          Checking.checkRealizable(tree.tpt.tpe, tree.srcPos, "SAM type")
+          super.transform(tree)
+        case tree @ Annotated(annotated, annot) =>
+          cpy.Annotated(tree)(transform(annotated), transformAnnot(annot))
+        case tree: AppliedTypeTree =>
+          if (tree.tpt.symbol == defn.andType)
+            Checking.checkNonCyclicInherited(tree.tpe, tree.args.tpes, EmptyScope, tree.srcPos)
+              // Ideally, this should be done by Typer, but we run into cyclic references
+              // when trying to typecheck self types which are intersections.
+          else if (tree.tpt.symbol == defn.orType)
+            () // nothing to do
+          else
+            Checking.checkAppliedType(tree)
+          super.transform(tree)
+        case SingletonTypeTree(ref) =>
+          Checking.checkRealizable(ref.tpe, ref.srcPos)
+          super.transform(tree)
+        case tree: TypeTree =>
+          tree.withType(
+            tree.tpe match {
+              case AnnotatedType(tpe, annot) => AnnotatedType(tpe, transformAnnot(annot))
+              case tpe => tpe
+            }
+          )
+        case Typed(Ident(nme.WILDCARD), _) =>
+          withMode(Mode.Pattern)(super.transform(tree))
+            // The added mode signals that bounds in a pattern need not
+            // conform to selector bounds. I.e. assume
+            //     type Tree[T >: Null <: Type]
+            // One is still allowed to write
+            //     case x: Tree[?]
+            // (which translates to)
+            //     case x: (_: Tree[?])
+        case m @ MatchTypeTree(bounds, selector, cases) =>
+          // Analog to the case above for match types
+          def transformIgnoringBoundsCheck(x: CaseDef): CaseDef =
+            withMode(Mode.Pattern)(super.transform(x)).asInstanceOf[CaseDef]
+          cpy.MatchTypeTree(tree)(
+            super.transform(bounds),
+            super.transform(selector),
+            cases.mapConserve(transformIgnoringBoundsCheck)
+          )
+        case Block(_, Closure(_, _, tpt)) if ExpandSAMs.needsWrapperClass(tpt.tpe) =>
+          superAcc.withInvalidCurrentClass(super.transform(tree))
+        case tree =>
+          super.transform(tree)
+      }
+      catch {
+        case ex : AssertionError =>
+          println(i"error while transforming $tree")
+          throw ex
+      }
+
+    override def transformStats[T](trees: List[Tree], exprOwner: Symbol, wrapResult: List[Tree] => Context ?=> T)(using Context): T =
+      try super.transformStats(trees, exprOwner, wrapResult)
+      finally Checking.checkExperimentalImports(trees)
+
+    /** Transforms the rhs tree into a its default tree if it is in an `erased` val/def.
+     *  Performed to shrink the tree that is known to be erased later.
+     */
+    private def normalizeErasedRhs(rhs: Tree, sym: Symbol)(using Context) =
+      if (sym.isEffectivelyErased) dropInlines.transform(rhs) else rhs
+
+    private def checkErasedDef(tree: ValOrDefDef)(using Context): Unit =
+      if tree.symbol.is(Erased, butNot = Macro) then
+        val tpe = tree.rhs.tpe
+        if tpe.derivesFrom(defn.NothingClass) then
+          report.error("`erased` definition cannot be implemented with en expression of type Nothing", tree.srcPos)
+        else if tpe.derivesFrom(defn.NullClass) then
+          report.error("`erased` definition cannot be implemented with en expression of type Null", tree.srcPos)
+
+    private def annotateExperimental(sym: Symbol)(using Context): Unit =
+      if sym.is(Module) && sym.companionClass.hasAnnotation(defn.ExperimentalAnnot) then
+        sym.addAnnotation(defn.ExperimentalAnnot)
+        sym.companionModule.addAnnotation(defn.ExperimentalAnnot)
+
+  }
+}
diff --git a/tests/pos-with-compiler-cc/dotc/transform/PreRecheck.scala b/tests/pos-with-compiler-cc/dotc/transform/PreRecheck.scala
new file mode 100644
index 000000000000..db9e28d7aad7
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/transform/PreRecheck.scala
@@ -0,0 +1,19 @@
+package dotty.tools.dotc
+package transform
+
+import core.Phases.Phase
+import core.DenotTransformers.DenotTransformer
+import core.Contexts.{Context, ctx}
+
+/** A base class for a phase that precedes a rechecker and that allows installing
+ *  new types for local symbols.
+ */
+abstract class PreRecheck extends Phase, DenotTransformer:
+
+  def phaseName: String = "preRecheck"
+
+  override def changesBaseTypes: Boolean = true
+
+  def run(using Context): Unit = ()
+
+  override def isCheckable = false
diff --git a/tests/pos-with-compiler-cc/dotc/transform/ProtectedAccessors.scala b/tests/pos-with-compiler-cc/dotc/transform/ProtectedAccessors.scala
new file mode 100644
index 000000000000..98e835293303
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/transform/ProtectedAccessors.scala
@@ -0,0 +1,97 @@
+package dotty.tools.dotc
+package transform
+
+import core.Contexts._
+import core.NameKinds._
+import core.Symbols._
+import core.Flags._
+import core.Decorators._
+import core.Names.TermName
+import MegaPhase.MiniPhase
+import config.Printers.transforms
+import dotty.tools.dotc.util.Property
+
+/** Add accessors for all protected accesses. An accessor is needed if
+ *  according to the rules of the JVM a protected class member is not accessible
+ *  from the point of access, but is accessible if the access is from an enclosing
+ *  class. In this point a public access method is placed in that enclosing class.
+ */
+object ProtectedAccessors {
+  val name: String = "protectedAccessors"
+  val description: String = "add accessors for protected members"
+
+  /** Is the current context's owner inside the access boundary established by `sym`? */
+  def insideBoundaryOf(sym: Symbol)(using Context): Boolean =
+    if (sym.is(JavaDefined))
+      sym.is(JavaStatic) ||  // Java's static protected definitions are treated as public
+      ctx.owner.enclosingPackageClass == sym.enclosingPackageClass
+    else {
+      // For Scala-defined symbols we currently allow private and protected accesses
+      // from inner packages, and compensate by widening accessibility of such symbols to public.
+      // It would be good if we could revisit this at some point.
+      val boundary = sym.accessBoundary(sym.enclosingPackageClass)
+      ctx.owner.isContainedIn(boundary) || ctx.owner.isContainedIn(boundary.linkedClass)
+    }
+
+  /** Do we need a protected accessor if the current context's owner
+   *  is not in a subclass or subtrait of `sym`?
+   */
+  def needsAccessorIfNotInSubclass(sym: Symbol)(using Context): Boolean =
+    sym.isTerm && sym.is(Protected) &&
+    !sym.owner.is(Trait) && // trait methods need to be handled specially, are currently always public
+    !insideBoundaryOf(sym)
+
+  /** Do we need a protected accessor for accessing sym from the current context's owner? */
+  def needsAccessor(sym: Symbol)(using Context): Boolean =
+    needsAccessorIfNotInSubclass(sym) &&
+    !ctx.owner.enclosingClass.derivesFrom(sym.owner)
+}
+
+class ProtectedAccessors extends MiniPhase {
+  import ast.tpd._
+
+  override def phaseName: String = ProtectedAccessors.name
+
+  override def description: String = ProtectedAccessors.description
+
+  private val AccessorsKey = new Property.Key[Accessors]
+
+  private def accessors(using Context): Accessors =
+   ctx.property(AccessorsKey).get
+
+  override def prepareForUnit(tree: Tree)(using Context): Context =
+    ctx.fresh.setProperty(AccessorsKey, new Accessors)
+
+  private class Accessors extends AccessProxies {
+    val insert: Insert = new Insert {
+      def accessorNameOf(name: TermName, site: Symbol)(using Context): TermName = ProtectedAccessorName(name)
+      def needsAccessor(sym: Symbol)(using Context) = ProtectedAccessors.needsAccessor(sym)
+
+      override def ifNoHost(reference: RefTree)(using Context): Tree = {
+        val curCls = ctx.owner.enclosingClass
+        transforms.println(i"${curCls.ownersIterator.toList}%, %")
+        report.error(i"illegal access to protected ${reference.symbol.showLocated} from $curCls",
+          reference.srcPos)
+        reference
+      }
+    }
+  }
+
+  override def transformIdent(tree: Ident)(using Context): Tree =
+    accessors.insert.accessorIfNeeded(tree)
+
+  override def transformSelect(tree: Select)(using Context): Tree =
+    accessors.insert.accessorIfNeeded(tree)
+
+  override def transformAssign(tree: Assign)(using Context): Tree =
+    tree.lhs match {
+      case lhs: RefTree if lhs.name.is(ProtectedAccessorName) =>
+        cpy.Apply(tree)(accessors.insert.useSetter(lhs), tree.rhs :: Nil)
+      case _ =>
+        tree
+    }
+
+  override def transformTemplate(tree: Template)(using Context): Tree =
+    cpy.Template(tree)(body = accessors.addAccessorDefs(tree.symbol.owner, tree.body))
+
+}
diff --git a/tests/pos-with-compiler-cc/dotc/transform/PruneErasedDefs.scala b/tests/pos-with-compiler-cc/dotc/transform/PruneErasedDefs.scala
new file mode 100644
index 000000000000..568512207fde
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/transform/PruneErasedDefs.scala
@@ -0,0 +1,72 @@
+package dotty.tools.dotc
+package transform
+
+import core._
+import Contexts._
+import DenotTransformers.SymTransformer
+import Flags._
+import SymDenotations._
+import Symbols._
+import typer.RefChecks
+import MegaPhase.MiniPhase
+import ast.tpd
+import SymUtils._
+import config.Feature
+import Decorators.*
+
+/** This phase makes all erased term members of classes private so that they cannot
+ *  conflict with non-erased members. This is needed so that subsequent phases like
+ *  ResolveSuper that inspect class members work correctly.
+ *  The phase also replaces all expressions that appear in an erased context by
+ *  default values. This is necessary so that subsequent checking phases such
+ *  as IsInstanceOfChecker don't give false negatives.
+ */
+class PruneErasedDefs extends MiniPhase with SymTransformer { thisTransform =>
+  import tpd._
+  import PruneErasedDefs._
+
+  override def phaseName: String = PruneErasedDefs.name
+
+  override def description: String = PruneErasedDefs.description
+
+  override def changesMembers: Boolean = true   // makes erased members private
+
+  override def runsAfterGroupsOf: Set[String] = Set(RefChecks.name, ExplicitOuter.name)
+
+  override def transformSym(sym: SymDenotation)(using Context): SymDenotation =
+    if !sym.isEffectivelyErased || !sym.isTerm || sym.is(Private) || !sym.owner.isClass then sym
+    else sym.copySymDenotation(initFlags = sym.flags | Private)
+
+  override def transformApply(tree: Apply)(using Context): Tree =
+    if !tree.fun.tpe.widen.isErasedMethod then tree
+    else cpy.Apply(tree)(tree.fun, tree.args.map(trivialErasedTree))
+
+  override def transformValDef(tree: ValDef)(using Context): Tree =
+    checkErasedInExperimental(tree.symbol)
+    if !tree.symbol.isEffectivelyErased || tree.rhs.isEmpty then tree
+    else cpy.ValDef(tree)(rhs = trivialErasedTree(tree.rhs))
+
+  override def transformDefDef(tree: DefDef)(using Context): Tree =
+    checkErasedInExperimental(tree.symbol)
+    if !tree.symbol.isEffectivelyErased || tree.rhs.isEmpty then tree
+    else cpy.DefDef(tree)(rhs = trivialErasedTree(tree.rhs))
+
+  override def transformTypeDef(tree: TypeDef)(using Context): Tree =
+    checkErasedInExperimental(tree.symbol)
+    tree
+
+  def checkErasedInExperimental(sym: Symbol)(using Context): Unit =
+    // Make an exception for Scala 2 experimental macros to allow dual Scala 2/3 macros under non experimental mode
+    if sym.is(Erased, butNot = Macro) && sym != defn.Compiletime_erasedValue && !sym.isInExperimentalScope then
+      Feature.checkExperimentalFeature("erased", sym.sourcePos)
+}
+
+object PruneErasedDefs {
+  import tpd._
+
+  val name: String = "pruneErasedDefs"
+  val description: String = "drop erased definitions and simplify erased expressions"
+
+  def trivialErasedTree(tree: Tree)(using Context): Tree =
+    ref(defn.Compiletime_erasedValue).appliedToType(tree.tpe).withSpan(tree.span)
+}
diff --git a/tests/pos-with-compiler-cc/dotc/transform/PureStats.scala b/tests/pos-with-compiler-cc/dotc/transform/PureStats.scala
new file mode 100644
index 000000000000..b747d7d6b9e4
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/transform/PureStats.scala
@@ -0,0 +1,35 @@
+package dotty.tools.dotc
+package transform
+
+import ast.{Trees, tpd}
+import core._, core.Decorators._
+import MegaPhase._
+import Types._, Contexts._, Flags._, DenotTransformers._
+import Symbols._, StdNames._, Trees._
+
+object PureStats {
+  val name: String = "pureStats"
+  val description: String = "remove pure statements in blocks"
+}
+
+/** Remove pure statements in blocks */
+class PureStats extends MiniPhase {
+
+  import tpd._
+
+  override def phaseName: String = PureStats.name
+
+  override def description: String = PureStats.description
+
+  override def runsAfter: Set[String] = Set(Erasure.name)
+
+  override def transformBlock(tree: Block)(using Context): Tree =
+    val stats = tree.stats.mapConserve {
+      case Typed(Block(stats, expr), _) if isPureExpr(expr) => Thicket(stats)
+      case stat if !stat.symbol.isConstructor && isPureExpr(stat) => EmptyTree
+      case stat => stat
+    }
+    if stats eq tree.stats then tree
+    else cpy.Block(tree)(Trees.flatten(stats), tree.expr)
+
+}
diff --git a/tests/pos-with-compiler-cc/dotc/transform/Recheck.scala b/tests/pos-with-compiler-cc/dotc/transform/Recheck.scala
new file mode 100644
index 000000000000..0ac9087a08c0
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/transform/Recheck.scala
@@ -0,0 +1,568 @@
+package dotty.tools
+package dotc
+package transform
+
+import core.*
+import Symbols.*, Contexts.*, Types.*, ContextOps.*, Decorators.*, SymDenotations.*
+import Flags.*, SymUtils.*, NameKinds.*, Denotations.Denotation
+import ast.*
+import Names.Name
+import Phases.Phase
+import DenotTransformers.{DenotTransformer, IdentityDenotTransformer, SymTransformer}
+import NamerOps.{methodType, linkConstructorParams}
+import NullOpsDecorator.stripNull
+import typer.ErrorReporting.err
+import typer.ProtoTypes.*
+import typer.TypeAssigner.seqLitType
+import typer.ConstFold
+import NamerOps.methodType
+import config.Printers.recheckr
+import util.Property
+import StdNames.nme
+import reporting.trace
+import annotation.constructorOnly
+import cc.CaptureSet.IdempotentCaptRefMap
+import dotty.tools.dotc.core.Denotations.SingleDenotation
+
+object Recheck:
+  import tpd.*
+
+  /** A flag used to indicate that a ParamAccessor has been temporarily made not-private
+   *  Only used at the start of the Recheck phase, reset at its end.
+   *  The flag repurposes the Scala2ModuleVar flag. No confusion is possible since
+   *  Scala2ModuleVar cannot be also ParamAccessors.
+   */
+  val ResetPrivate = Scala2ModuleVar
+  val ResetPrivateParamAccessor = ResetPrivate | ParamAccessor
+
+  /** Attachment key for rechecked types of TypeTrees */
+  val RecheckedType = Property.Key[Type]
+
+  val addRecheckedTypes = new TreeMap:
+    override def transform(tree: Tree)(using Context): Tree =
+      val tree1 = super.transform(tree)
+      tree.getAttachment(RecheckedType) match
+        case Some(tpe) => tree1.withType(tpe)
+        case None => tree1
+
+  extension (sym: Symbol)
+
+    /** Update symbol's info to newInfo from prevPhase.next to lastPhase.
+     *  Reset to previous info for phases after lastPhase.
+     */
+    def updateInfoBetween(prevPhase: DenotTransformer, lastPhase: DenotTransformer, newInfo: Type)(using Context): Unit =
+      if sym.info ne newInfo then
+        sym.copySymDenotation(
+            initFlags =
+              if sym.flags.isAllOf(ResetPrivateParamAccessor)
+              then sym.flags &~ ResetPrivate | Private
+              else sym.flags
+          ).installAfter(lastPhase) // reset
+        sym.copySymDenotation(
+            info = newInfo,
+            initFlags =
+              if newInfo.isInstanceOf[LazyType] then sym.flags &~ Touched
+              else sym.flags
+          ).installAfter(prevPhase)
+
+    /** Does symbol have a new denotation valid from phase.next that is different
+     *  from the denotation it had before?
+     */
+    def isUpdatedAfter(phase: Phase)(using Context) =
+      val symd = sym.denot
+      symd.validFor.firstPhaseId == phase.id + 1 && (sym.originDenotation ne symd)
+
+  extension [T <: Tree](tree: T)
+
+    /** Remember `tpe` as the type of `tree`, which might be different from the
+     *  type stored in the tree itself, unless a type was already remembered for `tree`.
+     */
+    def rememberType(tpe: Type)(using Context): Unit =
+      if !tree.hasAttachment(RecheckedType) then rememberTypeAlways(tpe)
+
+    /** Remember `tpe` as the type of `tree`, which might be different from the
+     *  type stored in the tree itself
+     */
+    def rememberTypeAlways(tpe: Type)(using Context): Unit =
+      if tpe ne tree.tpe then tree.putAttachment(RecheckedType, tpe)
+
+    /** The remembered type of the tree, or if none was installed, the original type */
+    def knownType: Type =
+      tree.attachmentOrElse(RecheckedType, tree.tpe)
+
+    def hasRememberedType: Boolean = tree.hasAttachment(RecheckedType)
+
+    def withKnownType(using Context): T = tree.getAttachment(RecheckedType) match
+      case Some(tpe) => tree.withType(tpe).asInstanceOf[T]
+      case None => tree
+
+  extension (tpe: Type)
+
+    /** Map ExprType => T to () ?=> T (and analogously for pure versions).
+     *  Even though this phase runs after ElimByName, ExprTypes can still occur
+     *  as by-name arguments of applied types. See note in doc comment for
+     *  ElimByName phase. Test case is bynamefun.scala.
+     */
+    def mapExprType(using Context): Type = tpe match
+      case ExprType(rt) => defn.ByNameFunction(rt)
+      case _ => tpe
+
+
+/** A base class that runs a simplified typer pass over an already re-typed program. The pass
+ *  does not transform trees but returns instead the re-typed type of each tree as it is
+ *  traversed. The Recheck phase must be directly preceded by a phase of type PreRecheck.
+ */
+abstract class Recheck extends Phase, SymTransformer:
+  thisPhase =>
+
+  import ast.tpd.*
+  import Recheck.*
+
+  def preRecheckPhase = this.prev.asInstanceOf[PreRecheck]
+
+  override def changesBaseTypes: Boolean = true
+
+  override def isCheckable = false
+    // TODO: investigate what goes wrong we Ycheck directly after rechecking.
+    // One failing test is pos/i583a.scala
+
+  /** Change any `ResetPrivate` flags back to `Private` */
+  def transformSym(sym: SymDenotation)(using Context): SymDenotation =
+    if sym.isAllOf(Recheck.ResetPrivateParamAccessor) then
+      sym.copySymDenotation(initFlags = sym.flags &~ Recheck.ResetPrivate | Private)
+    else sym
+
+  def run(using Context): Unit =
+    val rechecker = newRechecker()
+    rechecker.checkUnit(ctx.compilationUnit)
+    rechecker.reset()
+
+  def newRechecker()(using Context): Rechecker
+
+  /** The typechecker pass */
+  class Rechecker(@constructorOnly ictx: Context):
+    private val ta = ictx.typeAssigner
+
+    /** If true, remember types of all tree nodes in attachments so that they
+     *  can be retrieved with `knownType`
+     */
+    private val keepAllTypes = inContext(ictx) {
+      ictx.settings.Xprint.value.containsPhase(thisPhase)
+    }
+
+    /** Should type of `tree` be kept in an attachment so that it can be retrieved with
+     *  `knownType`? By default true only is `keepAllTypes` hold, but can be overridden.
+     */
+    def keepType(tree: Tree): Boolean = keepAllTypes
+
+    private val prevSelDenots = util.HashMap[NamedType, Denotation]()
+
+    def reset()(using Context): Unit =
+      for (ref, mbr) <- prevSelDenots.iterator do
+        ref.withDenot(mbr)
+
+    /** Constant-folded rechecked type `tp` of tree `tree` */
+    protected def constFold(tree: Tree, tp: Type)(using Context): Type =
+      val tree1 = tree.withType(tp)
+      val tree2 = ConstFold(tree1)
+      if tree2 ne tree1 then tree2.tpe else tp
+
+    def recheckIdent(tree: Ident)(using Context): Type =
+      tree.tpe
+
+    def recheckSelect(tree: Select, pt: Type)(using Context): Type =
+      val Select(qual, name) = tree
+      val proto =
+        if tree.symbol == defn.Any_asInstanceOf then WildcardType
+        else AnySelectionProto
+      recheckSelection(tree, recheck(qual, proto).widenIfUnstable, name, pt)
+
+    /** When we select the `apply` of a function with type such as `(=> A) => B`,
+     *  we need to convert the parameter type `=> A` to `() ?=> A`. See doc comment
+     *  of `mapExprType`.
+     */
+    def normalizeByName(mbr: SingleDenotation)(using Context): SingleDenotation = mbr.info match
+      case mt: MethodType if mt.paramInfos.exists(_.isInstanceOf[ExprType]) =>
+        mbr.derivedSingleDenotation(mbr.symbol,
+          mt.derivedLambdaType(paramInfos = mt.paramInfos.map(_.mapExprType)))
+      case _ =>
+        mbr
+
+    def recheckSelection(tree: Select, qualType: Type, name: Name,
+        sharpen: Denotation => Denotation)(using Context): Type =
+      if name.is(OuterSelectName) then tree.tpe
+      else
+        //val pre = ta.maybeSkolemizePrefix(qualType, name)
+        val mbr = normalizeByName(
+          sharpen(
+            qualType.findMember(name, qualType,
+              excluded = if tree.symbol.is(Private) then EmptyFlags else Private
+          )).suchThat(tree.symbol == _))
+        val newType = tree.tpe match
+          case prevType: NamedType =>
+            val prevDenot = prevType.denot
+            val newType = qualType.select(name, mbr)
+            if (newType eq prevType) && (mbr.info ne prevDenot.info) && !prevSelDenots.contains(prevType) then
+              prevSelDenots(prevType) = prevDenot
+            newType
+          case _ =>
+            qualType.select(name, mbr)
+        constFold(tree, newType)
+          //.showing(i"recheck select $qualType . $name : ${mbr.info} = $result")
+
+
+    /** Keep the symbol of the `select` but re-infer its type */
+    def recheckSelection(tree: Select, qualType: Type, name: Name, pt: Type)(using Context): Type =
+      recheckSelection(tree, qualType, name, sharpen = identity[Denotation])
+
+    def recheckBind(tree: Bind, pt: Type)(using Context): Type = tree match
+      case Bind(name, body) =>
+        recheck(body, pt)
+        val sym = tree.symbol
+        if sym.isType then sym.typeRef else sym.info
+
+    def recheckLabeled(tree: Labeled, pt: Type)(using Context): Type = tree match
+      case Labeled(bind, expr) =>
+        val bindType = recheck(bind, pt)
+        val exprType = recheck(expr, defn.UnitType)
+        bindType
+
+    def recheckValDef(tree: ValDef, sym: Symbol)(using Context): Unit =
+      if !tree.rhs.isEmpty then recheck(tree.rhs, sym.info)
+
+    def recheckDefDef(tree: DefDef, sym: Symbol)(using Context): Unit =
+      val rhsCtx = linkConstructorParams(sym).withOwner(sym)
+      if !tree.rhs.isEmpty && !sym.isInlineMethod && !sym.isEffectivelyErased then
+        inContext(rhsCtx) { recheck(tree.rhs, recheck(tree.tpt)) }
+
+    def recheckTypeDef(tree: TypeDef, sym: Symbol)(using Context): Type =
+      recheck(tree.rhs)
+      sym.typeRef
+
+    def recheckClassDef(tree: TypeDef, impl: Template, sym: ClassSymbol)(using Context): Type =
+      recheck(impl.constr)
+      impl.parentsOrDerived.foreach(recheck(_))
+      recheck(impl.self)
+      recheckStats(impl.body)
+      sym.typeRef
+
+    /** Assuming `formals` are parameters of a Java-defined method, remap Object
+     *  to FromJavaObject since it got lost in ElimRepeated
+     */
+    private def mapJavaArgs(formals: List[Type])(using Context): List[Type] =
+      val tm = new TypeMap with IdempotentCaptRefMap:
+        def apply(t: Type) = t match
+          case t: TypeRef if t.symbol == defn.ObjectClass => defn.FromJavaObjectType
+          case _ => mapOver(t)
+      formals.mapConserve(tm)
+
+    /** Hook for method type instantiation */
+    protected def instantiate(mt: MethodType, argTypes: List[Type], sym: Symbol)(using Context): Type =
+      mt.instantiate(argTypes)
+
+    def recheckApply(tree: Apply, pt: Type)(using Context): Type =
+      val funtpe = recheck(tree.fun)
+      funtpe.widen match
+        case fntpe: MethodType =>
+          assert(fntpe.paramInfos.hasSameLengthAs(tree.args))
+          val formals =
+            if tree.symbol.is(JavaDefined) then mapJavaArgs(fntpe.paramInfos)
+            else fntpe.paramInfos
+          def recheckArgs(args: List[Tree], formals: List[Type], prefs: List[ParamRef]): List[Type] = args match
+            case arg :: args1 =>
+              val argType = recheck(arg, formals.head.mapExprType)
+              val formals1 =
+                if fntpe.isParamDependent
+                then formals.tail.map(_.substParam(prefs.head, argType))
+                else formals.tail
+              argType :: recheckArgs(args1, formals1, prefs.tail)
+            case Nil =>
+              assert(formals.isEmpty)
+              Nil
+          val argTypes = recheckArgs(tree.args, formals, fntpe.paramRefs)
+          constFold(tree, instantiate(fntpe, argTypes, tree.fun.symbol))
+            //.showing(i"typed app $tree : $fntpe with ${tree.args}%, % : $argTypes%, % = $result")
+        case tp =>
+          assert(false, i"unexpected type of ${tree.fun}: $funtpe")
+
+    def recheckTypeApply(tree: TypeApply, pt: Type)(using Context): Type =
+      recheck(tree.fun).widen match
+        case fntpe: PolyType =>
+          assert(fntpe.paramInfos.hasSameLengthAs(tree.args))
+          val argTypes = tree.args.map(recheck(_))
+          constFold(tree, fntpe.instantiate(argTypes))
+
+    def recheckTyped(tree: Typed)(using Context): Type =
+      val tptType = recheck(tree.tpt)
+      recheck(tree.expr, tptType)
+      tptType
+
+    def recheckAssign(tree: Assign)(using Context): Type =
+      val lhsType = recheck(tree.lhs)
+      recheck(tree.rhs, lhsType.widen)
+      defn.UnitType
+
+    def recheckBlock(stats: List[Tree], expr: Tree, pt: Type)(using Context): Type =
+      recheckStats(stats)
+      val exprType = recheck(expr)
+        // The expected type `pt` is not propagated. Doing so would allow variables in the
+        // expected type to contain references to local symbols of the block, so the
+        // local symbols could escape that way.
+      TypeOps.avoid(exprType, localSyms(stats).filterConserve(_.isTerm))
+
+    def recheckBlock(tree: Block, pt: Type)(using Context): Type =
+      recheckBlock(tree.stats, tree.expr, pt)
+
+    def recheckInlined(tree: Inlined, pt: Type)(using Context): Type =
+      recheckBlock(tree.bindings, tree.expansion, pt)(using inlineContext(tree.call))
+
+    def recheckIf(tree: If, pt: Type)(using Context): Type =
+      recheck(tree.cond, defn.BooleanType)
+      recheck(tree.thenp, pt) | recheck(tree.elsep, pt)
+
+    def recheckClosure(tree: Closure, pt: Type)(using Context): Type =
+      if tree.tpt.isEmpty then
+        tree.meth.tpe.widen.toFunctionType(tree.meth.symbol.is(JavaDefined))
+      else
+        recheck(tree.tpt)
+
+    def recheckMatch(tree: Match, pt: Type)(using Context): Type =
+      val selectorType = recheck(tree.selector)
+      val casesTypes = tree.cases.map(recheckCase(_, selectorType.widen, pt))
+      TypeComparer.lub(casesTypes)
+
+    def recheckCase(tree: CaseDef, selType: Type, pt: Type)(using Context): Type =
+      recheck(tree.pat, selType)
+      recheck(tree.guard, defn.BooleanType)
+      recheck(tree.body, pt)
+
+    def recheckReturn(tree: Return)(using Context): Type =
+      // Avoid local pattern defined symbols in returns from matchResult blocks
+      // that are inserted by the PatternMatcher transform.
+      // For regular symbols in the case branch, we already avoid them by the rule
+      // for blocks since a case branch is of the form `return[MatchResultN] { ... }`
+      // For source-level returns from methods, there's nothing to avoid, since the
+      // result type of a method with a return must be given explicitly.
+      def avoidMap = new TypeOps.AvoidMap:
+        def toAvoid(tp: NamedType) =
+           tp.symbol.is(Case) && tp.symbol.owner.isContainedIn(ctx.owner)
+
+      val rawType = recheck(tree.expr)
+      val ownType = avoidMap(rawType)
+
+      // The pattern matching translation, which runs before this phase
+      // sometimes instantiates return types with singleton type alternatives
+      // but the returned expression is widened. We compensate by widening the expected
+      // type as well. See also `widenSkolems` in `checkConformsExpr` which fixes
+      // a more general problem. It turns out that pattern matching returns
+      // are not checked by Ycheck, that's why these problems were allowed to slip
+      // through.
+      def widened(tp: Type): Type = tp match
+        case tp: SingletonType => tp.widen
+        case tp: AndOrType => tp.derivedAndOrType(widened(tp.tp1), widened(tp.tp2))
+        case tp @ AnnotatedType(tp1, ann) => tp.derivedAnnotatedType(widened(tp1), ann)
+        case _ => tp
+      checkConforms(ownType, widened(tree.from.symbol.returnProto), tree)
+      defn.NothingType
+    end recheckReturn
+
+    def recheckWhileDo(tree: WhileDo)(using Context): Type =
+      recheck(tree.cond, defn.BooleanType)
+      recheck(tree.body, defn.UnitType)
+      defn.UnitType
+
+    def recheckTry(tree: Try, pt: Type)(using Context): Type =
+      val bodyType = recheck(tree.expr, pt)
+      val casesTypes = tree.cases.map(recheckCase(_, defn.ThrowableType, pt))
+      val finalizerType = recheck(tree.finalizer, defn.UnitType)
+      TypeComparer.lub(bodyType :: casesTypes)
+
+    def recheckSeqLiteral(tree: SeqLiteral, pt: Type)(using Context): Type =
+      val elemProto = pt.stripNull.elemType match
+        case NoType => WildcardType
+        case bounds: TypeBounds => WildcardType(bounds)
+        case elemtp => elemtp
+      val declaredElemType = recheck(tree.elemtpt)
+      val elemTypes = tree.elems.map(recheck(_, elemProto))
+      seqLitType(tree, TypeComparer.lub(declaredElemType :: elemTypes))
+
+    def recheckTypeTree(tree: TypeTree)(using Context): Type =
+      knownType(tree) // allows to install new types at Setup
+
+    def recheckAnnotated(tree: Annotated)(using Context): Type =
+      tree.tpe match
+        case tp: AnnotatedType =>
+          val argType = recheck(tree.arg)
+          tp.derivedAnnotatedType(argType, tp.annot)
+
+    def recheckAlternative(tree: Alternative, pt: Type)(using Context): Type =
+      val altTypes = tree.trees.map(recheck(_, pt))
+      TypeComparer.lub(altTypes)
+
+    def recheckPackageDef(tree: PackageDef)(using Context): Type =
+      recheckStats(tree.stats)
+      NoType
+
+    def recheckStats(stats: List[Tree])(using Context): Unit =
+      stats.foreach(recheck(_))
+
+    def recheckDef(tree: ValOrDefDef, sym: Symbol)(using Context): Unit =
+      inContext(ctx.localContext(tree, sym)) {
+        tree match
+          case tree: ValDef => recheckValDef(tree, sym)
+          case tree: DefDef => recheckDefDef(tree, sym)
+      }
+
+    /** Recheck tree without adapting it, returning its new type.
+     *  @param tree        the original tree
+     *  @param pt          the expected result type
+     */
+    def recheckStart(tree: Tree, pt: Type = WildcardType)(using Context): Type =
+
+      def recheckNamed(tree: NameTree, pt: Type)(using Context): Type =
+        val sym = tree.symbol
+        tree match
+          case tree: Ident => recheckIdent(tree)
+          case tree: Select => recheckSelect(tree, pt)
+          case tree: Bind => recheckBind(tree, pt)
+          case tree: ValOrDefDef =>
+            if tree.isEmpty then NoType
+            else
+              if sym.isUpdatedAfter(preRecheckPhase) then
+                sym.ensureCompleted() // in this case the symbol's completer should recheck the right hand side
+              else
+                recheckDef(tree, sym)
+              sym.termRef
+          case tree: TypeDef =>
+            // TODO: Should we allow for completers as for ValDefs or DefDefs?
+            tree.rhs match
+              case impl: Template =>
+                recheckClassDef(tree, impl, sym.asClass)(using ctx.localContext(tree, sym))
+              case _ =>
+                recheckTypeDef(tree, sym)(using ctx.localContext(tree, sym))
+          case tree: Labeled => recheckLabeled(tree, pt)
+
+      def recheckUnnamed(tree: Tree, pt: Type): Type = tree match
+        case tree: Apply => recheckApply(tree, pt)
+        case tree: TypeApply => recheckTypeApply(tree, pt)
+        case _: New | _: This | _: Super | _: Literal => tree.tpe
+        case tree: Typed => recheckTyped(tree)
+        case tree: Assign => recheckAssign(tree)
+        case tree: Block => recheckBlock(tree, pt)
+        case tree: If => recheckIf(tree, pt)
+        case tree: Closure => recheckClosure(tree, pt)
+        case tree: Match => recheckMatch(tree, pt)
+        case tree: Return => recheckReturn(tree)
+        case tree: WhileDo => recheckWhileDo(tree)
+        case tree: Try => recheckTry(tree, pt)
+        case tree: SeqLiteral => recheckSeqLiteral(tree, pt)
+        case tree: Inlined => recheckInlined(tree, pt)
+        case tree: TypeTree => recheckTypeTree(tree)
+        case tree: Annotated => recheckAnnotated(tree)
+        case tree: Alternative => recheckAlternative(tree, pt)
+        case tree: PackageDef => recheckPackageDef(tree)
+        case tree: Thicket => defn.NothingType
+        case tree: Import => defn.NothingType
+
+      tree match
+        case tree: NameTree => recheckNamed(tree, pt)
+        case tree => recheckUnnamed(tree, pt)
+    end recheckStart
+
+    /** Finish rechecking a tree node: check rechecked type against expected type
+     *  and remember rechecked type in a tree attachment if required.
+     *  @param tpe   the recheched type of `tree`
+     *  @param tree  the rechecked tree
+     *  @param pt    the expected type
+     */
+    def recheckFinish(tpe: Type, tree: Tree, pt: Type)(using Context): Type =
+      checkConforms(tpe, pt, tree)
+      if keepType(tree) then tree.rememberType(tpe)
+      tpe
+
+    def recheck(tree: Tree, pt: Type = WildcardType)(using Context): Type =
+      trace(i"rechecking $tree with pt = $pt", recheckr, show = true) {
+        try recheckFinish(recheckStart(tree, pt), tree, pt)
+        catch case ex: Exception =>
+          println(i"error while rechecking $tree")
+          throw ex
+      }
+
+    /** Typing and previous transforms sometiems leaves skolem types in prefixes of
+     *  NamedTypes in `expected` that do not match the `actual` Type. -Ycheck does
+     *  not complain (need to find out why), but a full recheck does. We compensate
+     *  by de-skolemizing everywhere in `expected` except when variance is negative.
+     *  @return If `tp` contains SkolemTypes in covariant or invariant positions,
+     *          the type where these SkolemTypes are mapped to their underlying type.
+     *          Otherwise, `tp` itself
+     */
+    def widenSkolems(tp: Type)(using Context): Type =
+      object widenSkolems extends TypeMap, IdempotentCaptRefMap:
+        var didWiden: Boolean = false
+        def apply(t: Type): Type = t match
+          case t: SkolemType if variance >= 0 =>
+            didWiden = true
+            apply(t.underlying)
+          case t: LazyRef => t
+          case t @ AnnotatedType(t1, ann) => t.derivedAnnotatedType(apply(t1), ann)
+          case _ => mapOver(t)
+      val tp1 = widenSkolems(tp)
+      if widenSkolems.didWiden then tp1 else tp
+
+    /** If true, print info for some successful checkConforms operations (failing ones give
+     *  an error message in any case).
+     */
+    private val debugSuccesses = false
+
+    /** Check that widened types of `tpe` and `pt` are compatible. */
+    def checkConforms(tpe: Type, pt: Type, tree: Tree)(using Context): Unit = tree match
+      case _: DefTree | EmptyTree | _: TypeTree | _: Closure =>
+        // Don't report closure nodes, since their span is a point; wait instead
+        // for enclosing block to preduce an error
+      case _ =>
+        checkConformsExpr(tpe.widenExpr, pt.widenExpr, tree)
+
+    def checkConformsExpr(actual: Type, expected: Type, tree: Tree)(using Context): Unit =
+      //println(i"check conforms $actual <:< $expected")
+
+      def isCompatible(expected: Type): Boolean =
+        actual <:< expected
+        || expected.isRepeatedParam
+            && isCompatible(expected.translateFromRepeated(toArray = tree.tpe.isRef(defn.ArrayClass)))
+        || {
+          val widened = widenSkolems(expected)
+          (widened ne expected) && isCompatible(widened)
+        }
+      if !isCompatible(expected) then
+        recheckr.println(i"conforms failed for ${tree}: $actual vs $expected")
+        err.typeMismatch(tree.withType(actual), expected)
+      else if debugSuccesses then
+        tree match
+          case _: Ident =>
+            println(i"SUCCESS $tree:\n${TypeComparer.explained(_.isSubType(actual, expected))}")
+          case _ =>
+    end checkConformsExpr
+
+    def checkUnit(unit: CompilationUnit)(using Context): Unit =
+      recheck(unit.tpdTree)
+
+  end Rechecker
+
+  /** Show tree with rechecked types instead of the types stored in the `.tpe` field */
+  override def show(tree: untpd.Tree)(using Context): String =
+    atPhase(thisPhase) {
+      super.show(addRecheckedTypes.transform(tree.asInstanceOf[tpd.Tree]))
+    }
+end Recheck
+
+/** A class that can be used to test basic rechecking without any customaization */
+object TestRecheck:
+  class Pre extends PreRecheck, IdentityDenotTransformer:
+    override def isEnabled(using Context) = ctx.settings.YrecheckTest.value
+
+class TestRecheck extends Recheck:
+  def phaseName: String = "recheck"
+  override def isEnabled(using Context) = ctx.settings.YrecheckTest.value
+  def newRechecker()(using Context): Rechecker = Rechecker(ctx)
+
+
diff --git a/tests/pos-with-compiler-cc/dotc/transform/ReifiedReflect.scala b/tests/pos-with-compiler-cc/dotc/transform/ReifiedReflect.scala
new file mode 100644
index 000000000000..e462f82b1dad
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/transform/ReifiedReflect.scala
@@ -0,0 +1,109 @@
+package dotty.tools.dotc
+package transform
+
+import core._
+import Decorators._
+import Flags._
+import Types._
+import Contexts._
+import Symbols._
+import SymUtils._
+import NameKinds._
+import dotty.tools.dotc.ast.tpd
+import tpd._
+
+import scala.collection.mutable
+import dotty.tools.dotc.core.Annotations._
+import dotty.tools.dotc.core.Names._
+import dotty.tools.dotc.core.StdNames._
+import dotty.tools.dotc.quoted._
+import dotty.tools.dotc.transform.TreeMapWithStages._
+
+import scala.annotation.constructorOnly
+
+/** Helper methods to construct trees calling methods in `Quotes.reflect` based on the current `quotes` tree */
+trait ReifiedReflect:
+
+  /** Stable reference to the instance of `scala.quoted.Quotes` */
+  def quotesTree: Tree
+
+  def self(using Context): Tree =
+    quotesTree.select(defn.Quotes_reflect)
+
+  /** Create type for `quotes.reflect.Term` */
+  def TermTpt(using Context) =
+    self.select(defn.Quotes_reflect_TermType)
+
+  /** Create type for `quotes.reflect.TypeTree` */
+  def TypeTreeTpt(using Context) =
+    self.select(defn.Quotes_reflect_TypeTreeType)
+
+  /** Create tree for `quotes.reflect.Apply(<fn>, List(<args>*))` */
+  def Apply(fn: Tree, args: List[Tree])(using Context) =
+    val argTrees = tpd.mkList(args, TermTpt)
+    self.select(defn.Quotes_reflect_Apply)
+      .select(defn.Quotes_reflect_Apply_apply)
+      .appliedTo(fn, argTrees)
+
+  /** Create tree for `quotes.reflect.TypeApply(<fn>, List(<args>*))` */
+  def TypeApply(fn: Tree, args: List[Tree])(using Context) =
+    val argTrees = tpd.mkList(args, TypeTreeTpt)
+    self.select(defn.Quotes_reflect_TypeApply)
+      .select(defn.Quotes_reflect_TypeApply_apply)
+      .appliedTo(fn, argTrees)
+
+  /** Create tree for `quotes.reflect.Assing(<lhs>, <rhs>)` */
+  def Assign(lhs: Tree, rhs: Tree)(using Context) =
+    self.select(defn.Quotes_reflect_Assign)
+      .select(defn.Quotes_reflect_Assign_apply)
+      .appliedTo(lhs, rhs)
+
+  /** Create tree for `quotes.reflect.Inferred(<typeTree>)` */
+  def Inferred(typeTree: Tree)(using Context) =
+    self.select(defn.Quotes_reflect_Inferred)
+      .select(defn.Quotes_reflect_Inferred_apply)
+      .appliedTo(typeTree)
+
+  /** Create tree for `quotes.reflect.Literal(<constant>)` */
+  def Literal(constant: Tree)(using Context) =
+    self.select(defn.Quotes_reflect_Literal)
+      .select(defn.Quotes_reflect_Literal_apply)
+      .appliedTo(constant)
+
+  /** Create tree for `quotes.reflect.TypeRepr.of(Type.of[<tpe>](quotes))` */
+  def TypeReprOf(tpe: Type)(using Context) =
+    self.select(defn.Quotes_reflect_TypeRepr)
+      .select(defn.Quotes_reflect_TypeRepr_of)
+      .appliedToType(tpe)
+      .appliedTo(
+        ref(defn.QuotedTypeModule_of)
+          .appliedToType(tpe)
+          .appliedTo(quotesTree)
+      )
+
+  /** Create tree for `quotes.reflect.TypeRepr.typeConstructorOf(<classTree>)` */
+  def TypeRepr_typeConstructorOf(classTree: Tree)(using Context) =
+    self.select(defn.Quotes_reflect_TypeRepr)
+      .select(defn.Quotes_reflect_TypeRepr_typeConstructorOf)
+      .appliedTo(classTree)
+
+  /** Create tree for `quotes.reflect.asTerm(<expr>)` */
+  def asTerm(expr: Tree)(using Context) =
+    self.select(defn.Quotes_reflect_asTerm)
+      .appliedTo(expr)
+
+  /** Create tree for `quotes.reflect.TypeReprMethods.asType(<typeRepr>)` */
+  def asType(tpe: Type)(typeRepr: Tree)(using Context) =
+    self.select(defn.Quotes_reflect_TypeReprMethods)
+      .select(defn.Quotes_reflect_TypeReprMethods_asType)
+      .appliedTo(typeRepr)
+      .asInstance(defn.QuotedTypeClass.typeRef.appliedTo(tpe))
+
+  /** Create tree for `quotes.reflect.TreeMethods.asExpr(<term>).asInstanceOf[<tpe>]` */
+  def asExpr(tpe: Type)(term: Tree)(using Context) =
+    self.select(defn.Quotes_reflect_TreeMethods)
+      .select(defn.Quotes_reflect_TreeMethods_asExpr)
+      .appliedTo(term)
+      .asInstance(defn.QuotedExprClass.typeRef.appliedTo(tpe))
+
+end ReifiedReflect
diff --git a/tests/pos-with-compiler-cc/dotc/transform/RepeatableAnnotations.scala b/tests/pos-with-compiler-cc/dotc/transform/RepeatableAnnotations.scala
new file mode 100644
index 000000000000..e8f8a80e1a0d
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/transform/RepeatableAnnotations.scala
@@ -0,0 +1,65 @@
+package dotty.tools.dotc
+package transform
+
+import core._
+import ast.tpd._
+import Contexts._
+import MegaPhase._
+import Annotations._
+import Symbols.defn
+import Constants._
+import Types._
+import Decorators._
+
+import scala.collection.mutable
+
+class RepeatableAnnotations extends MiniPhase:
+
+  override def phaseName: String = RepeatableAnnotations.name
+
+  override def description: String = RepeatableAnnotations.description
+
+  override def transformTypeDef(tree: TypeDef)(using Context): Tree = transformDef(tree)
+  override def transformValDef(tree: ValDef)(using Context): Tree = transformDef(tree)
+  override def transformDefDef(tree: DefDef)(using Context): Tree = transformDef(tree)
+
+  private def transformDef(tree: DefTree)(using Context) =
+    val annotations = tree.symbol.annotations
+    if (!annotations.isEmpty) then
+      tree.symbol.annotations = aggregateAnnotations(tree.symbol.annotations)
+    tree
+
+  private def aggregateAnnotations(annotations: Seq[Annotation])(using Context): List[Annotation] =
+    val annsByType = stableGroupBy(annotations, _.symbol)
+    annsByType.flatMap {
+      case (_, a :: Nil) => a :: Nil
+      case (sym, anns) if sym.derivesFrom(defn.ClassfileAnnotationClass) =>
+        sym.getAnnotation(defn.JavaRepeatableAnnot).flatMap(_.argumentConstant(0)) match
+          case Some(Constant(containerTpe: Type)) =>
+            val clashingAnns = annsByType.getOrElse(containerTpe.classSymbol, Nil)
+            if clashingAnns.nonEmpty then
+              // this is the same error javac would raise in this case
+              val pos = clashingAnns.head.tree.srcPos
+              report.error("Container must not be present at the same time as the element it contains", pos)
+              Nil
+            else
+              val aggregated = JavaSeqLiteral(anns.map(_.tree).toList, TypeTree(sym.typeRef))
+              Annotation(containerTpe, NamedArg("value".toTermName, aggregated)) :: Nil
+          case _ =>
+            val pos = anns.head.tree.srcPos
+            report.error("Not repeatable annotation repeated", pos)
+            Nil
+      case (_, anns) => anns
+    }.toList
+
+  private def stableGroupBy[A, K](ins: Seq[A], f: A => K): scala.collection.MapView[K, List[A]] =
+    val out = new mutable.LinkedHashMap[K, mutable.ListBuffer[A]]()
+    for (in <- ins) {
+      val buffer = out.getOrElseUpdate(f(in), new mutable.ListBuffer)
+      buffer += in
+    }
+    out.view.mapValues(_.toList)
+
+object RepeatableAnnotations:
+  val name: String = "repeatableAnnotations"
+  val description: String = "aggregate repeatable annotations"
diff --git a/tests/pos-with-compiler-cc/dotc/transform/ResolveSuper.scala b/tests/pos-with-compiler-cc/dotc/transform/ResolveSuper.scala
new file mode 100644
index 000000000000..dd109ce153eb
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/transform/ResolveSuper.scala
@@ -0,0 +1,128 @@
+package dotty.tools.dotc
+package transform
+
+import core._
+import MegaPhase._
+import Contexts._
+import Flags._
+import SymUtils._
+import Symbols._
+import Decorators._
+import DenotTransformers._
+import Names._
+import NameOps._
+import NameKinds._
+import NullOpsDecorator._
+import ResolveSuper._
+import reporting.IllegalSuperAccessor
+
+/** This phase implements super accessors in classes that need them.
+ *
+ *  For every trait M directly implemented by the class (see SymUtils.mixin), in
+ *  reverse linearization order, add the following definitions to C:
+ *
+ *  For every superAccessor `<mods> def super$f[Ts](ps1)...(psN): U` in M:
+ *
+ *       <mods> def super$f[Ts](ps1)...(psN): U = super[S].f[Ts](ps1)...(psN)
+ *
+ *  where `S` is the superclass of `M` in the linearization of `C`.
+ *
+ *  This is the first part of what was the mixin phase. It is complemented by
+ *  Mixin, which runs after erasure.
+ */
+class ResolveSuper extends MiniPhase with IdentityDenotTransformer { thisPhase =>
+  import ast.tpd._
+
+  override def phaseName: String = ResolveSuper.name
+
+  override def description: String = ResolveSuper.description
+
+  override def runsAfter: Set[String] = Set(ElimByName.name, // verified empirically, need to figure out what the reason is.
+                               PruneErasedDefs.name) // Erased decls make `isCurrent` work incorrectly
+
+  override def changesMembers: Boolean = true // the phase adds super accessors
+
+  override def transformTemplate(impl: Template)(using Context): Template = {
+    val cls = impl.symbol.owner.asClass
+    val ops = new MixinOps(cls, thisPhase)
+    import ops._
+
+    def superAccessors(mixin: ClassSymbol): List[Tree] =
+      for superAcc <- mixin.info.decls.filter(_.isSuperAccessor)
+      yield
+        util.Stats.record("super accessors")
+        val fwd = mkForwarderSym(superAcc.asTerm)
+        DefDef(fwd, forwarderRhsFn(rebindSuper(cls, superAcc))
+          .andThen(_.etaExpandCFT(using ctx.withOwner(fwd))))
+
+    val overrides = mixins.flatMap(superAccessors)
+
+    cpy.Template(impl)(body = overrides ::: impl.body)
+  }
+
+  override def transformDefDef(ddef: DefDef)(using Context): Tree = {
+    val meth = ddef.symbol.asTerm
+    if (meth.isSuperAccessor && !meth.is(Deferred)) {
+      assert(ddef.rhs.isEmpty, ddef.symbol)
+      val cls = meth.owner.asClass
+      val ops = new MixinOps(cls, thisPhase)
+      import ops._
+      DefDef(meth, forwarderRhsFn(rebindSuper(cls, meth)))
+    }
+    else ddef
+  }
+}
+
+object ResolveSuper {
+  val name: String = "resolveSuper"
+  val description: String = "implement super accessors"
+
+  /** Returns the symbol that is accessed by a super-accessor in a mixin composition.
+   *
+   *  @param base       The class in which everything is mixed together
+   *  @param acc        The symbol statically referred to by the superaccessor in the trait
+   */
+  def rebindSuper(base: Symbol, acc: Symbol)(using Context): Symbol = {
+    var bcs = base.info.baseClasses.dropWhile(acc.owner != _).tail
+    var sym: Symbol = NoSymbol
+
+    def decomposeSuperName(superName: Name): (Name, TypeName) =
+      superName.unexpandedName match
+        case SuperAccessorName(ExpandPrefixName(name, mixName)) =>
+          (name, mixName.toTypeName)
+        case SuperAccessorName(name) =>
+          (name, EmptyTypeName)
+
+    val (memberName, mix) = decomposeSuperName(acc.name.unexpandedName)
+    val targetName =
+      if acc.name == acc.targetName then memberName
+      else decomposeSuperName(acc.targetName)._1
+
+    report.debuglog(i"starting rebindsuper from $base of ${acc.showLocated}: ${acc.info} in $bcs, name = $memberName")
+
+    while (bcs.nonEmpty && sym == NoSymbol) {
+      val other = bcs.head.info.nonPrivateDecl(memberName)
+        .filterWithPredicate(denot => mix.isEmpty || denot.symbol.owner.name == mix)
+        .matchingDenotation(base.thisType, base.thisType.memberInfo(acc), targetName)
+      report.debuglog(i"rebindsuper ${bcs.head} $other deferred = ${other.symbol.is(Deferred)}")
+      if other.exists && !other.symbol.is(Deferred) then
+        sym = other.symbol
+        // Having a matching denotation is not enough: it should also be a subtype
+        // of the superaccessor's type, see i5433.scala for an example where this matters
+        val otherTp = other.asSeenFrom(base.typeRef).info
+        val accTp = acc.asSeenFrom(base.typeRef).info
+        // Since the super class can be Java defined,
+        // we use relaxed overriding check for explicit nulls if one of the symbols is Java defined.
+        // This forces `Null` to be a subtype of non-primitive value types during override checking.
+        val relaxedOverriding = ctx.explicitNulls && (sym.is(JavaDefined) || acc.is(JavaDefined))
+        if !otherTp.overrides(accTp, relaxedOverriding, matchLoosely = true) then
+          report.error(IllegalSuperAccessor(base, memberName, targetName, acc, accTp, other.symbol, otherTp), base.srcPos)
+      bcs = bcs.tail
+    }
+    sym.orElse {
+      val originalName = acc.name.asTermName.originalOfSuperAccessorName
+      report.error(em"Member method ${originalName.debugString} of mixin ${acc.owner} is missing a concrete super implementation in $base.", base.srcPos)
+      acc
+    }
+  }
+}
diff --git a/tests/pos-with-compiler-cc/dotc/transform/RestoreScopes.scala b/tests/pos-with-compiler-cc/dotc/transform/RestoreScopes.scala
new file mode 100644
index 000000000000..d01be0419a4d
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/transform/RestoreScopes.scala
@@ -0,0 +1,56 @@
+package dotty.tools.dotc
+package transform
+
+import core._
+import DenotTransformers.IdentityDenotTransformer
+import Contexts._
+import Symbols._
+import Scopes._
+import MegaPhase.MiniPhase
+
+/** The preceding lambda lift and flatten phases move symbols to different scopes
+ *  and rename them. This miniphase cleans up afterwards and makes sure that all
+ *  class scopes contain the symbols defined in them.
+ */
+class RestoreScopes extends MiniPhase with IdentityDenotTransformer { thisPhase =>
+  import ast.tpd._
+
+  override def phaseName: String = RestoreScopes.name
+
+  override def description: String = RestoreScopes.description
+
+  override def changesMembers: Boolean = true // the phase affects scopes, applying tree transformations of previous phases
+
+  /* Note: We need to wait until we see a package definition because
+   * DropEmptyConstructors changes template members when analyzing the
+   * enclosing package definitions. So by the time RestoreScopes gets to
+   * see a typedef or template, it still might be changed by DropEmptyConstructors.
+   */
+  override def transformPackageDef(pdef: PackageDef)(using Context): PackageDef = {
+    pdef.stats.foreach(restoreScope)
+    pdef
+  }
+
+  private def restoreScope(tree: Tree)(using Context) = tree match {
+    case TypeDef(_, impl: Template) =>
+      val restoredDecls = newScope
+      for (stat <- impl.constr :: impl.body)
+        if (stat.isInstanceOf[MemberDef] && stat.symbol.exists)
+          restoredDecls.enter(stat.symbol)
+      // Enter class in enclosing package scope, in case it was an inner class before flatten.
+      // For top-level classes this does nothing.
+      val cls = tree.symbol.asClass
+      val pkg = cls.owner.asClass
+
+      pkg.enter(cls)
+      tree.symbol.copySymDenotation(
+        info =  cls.classInfo.derivedClassInfo(
+          decls = restoredDecls: Scope)).installAfter(thisPhase)
+      tree
+    case tree => tree
+  }
+}
+
+object RestoreScopes:
+  val name: String = "restoreScopes"
+  val description: String = "repair rendered invalid scopes"
diff --git a/tests/pos-with-compiler-cc/dotc/transform/SelectStatic.scala b/tests/pos-with-compiler-cc/dotc/transform/SelectStatic.scala
new file mode 100644
index 000000000000..1df9809c2f62
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/transform/SelectStatic.scala
@@ -0,0 +1,101 @@
+package dotty.tools.dotc
+package transform
+
+import dotty.tools.dotc.ast.tpd
+import dotty.tools.dotc.core.Contexts._
+import dotty.tools.dotc.core.DenotTransformers.IdentityDenotTransformer
+import dotty.tools.dotc.core.Flags._
+import dotty.tools.dotc.core.Symbols._
+import dotty.tools.dotc.core._
+import dotty.tools.dotc.transform.MegaPhase._
+import dotty.tools.dotc.transform.SymUtils._
+
+/** Removes `Select`s that would be compiled into `GetStatic`.
+ *
+ *  Otherwise, the backend needs to be aware that some qualifiers need to be
+ *  dropped.
+ *
+ *  A tranformation similar to what this phase does seems to be performed by
+ *  flatten in nsc.
+ *
+ *  The side effects of the qualifier of a dropped `Select` is normally
+ *  retained. As an exception, the qualifier is completely dropped if it is
+ *  a reference to a static owner (see `isStaticOwnerRef`). Concretely, this
+ *  means that in
+ *
+ *  {{{
+ *  object Foo {
+ *    println("side effects")
+ *
+ *    object Bar
+ *    class Baz
+ *  }
+ *
+ *  Foo.Bar
+ *  new Foo.Baz()
+ *  }}}
+ *
+ *  the `Foo` qualifiers will be dropped, since it is a static object. The
+ *  `println("side effects")` will therefore not be executed.
+ *
+ *  This intended behavior is equivalent to what scalac does.
+ *
+ *  @author Dmytro Petrashko
+ */
+class SelectStatic extends MiniPhase with IdentityDenotTransformer {
+  import ast.tpd._
+
+  override def phaseName: String = SelectStatic.name
+
+  override def description: String = SelectStatic.description
+
+  override def transformSelect(tree: tpd.Select)(using Context): tpd.Tree = {
+    val sym = tree.symbol
+    def isStaticMember =
+      (sym is Flags.Module) && sym.initial.maybeOwner.initial.isStaticOwner ||
+      (sym is Flags.JavaStatic) ||
+      sym.isScalaStatic
+    val isStaticRef = !sym.is(Package) && !sym.maybeOwner.is(Package) && isStaticMember
+    val tree1 =
+      if isStaticRef && !tree.qualifier.symbol.isAllOf(JavaModule) && !tree.qualifier.isType then
+        if isStaticOwnerRef(tree.qualifier) then ref(sym)
+        else Block(List(tree.qualifier), ref(sym))
+      else tree
+
+    normalize(tree1)
+  }
+
+  private def isStaticOwnerRef(tree: Tree)(using Context): Boolean = tree match {
+    case Ident(_) =>
+      tree.symbol.is(Module) && tree.symbol.moduleClass.isStaticOwner
+    case Select(qual, _) =>
+      isStaticOwnerRef(qual) && tree.symbol.is(Module) && tree.symbol.moduleClass.isStaticOwner
+    case _ =>
+      false
+  }
+
+  private def normalize(t: Tree)(using Context) = t match {
+    case Select(Block(stats, qual), nm) =>
+      Block(stats, cpy.Select(t)(qual, nm))
+    case Apply(Block(stats, qual), nm) =>
+      Block(stats, Apply(qual, nm))
+    case TypeApply(Block(stats, qual), nm) =>
+      Block(stats, TypeApply(qual, nm))
+    case Closure(env, Block(stats, qual), tpt) =>
+      Block(stats, Closure(env, qual, tpt))
+    case _ => t
+  }
+
+  override def transformApply(tree: tpd.Apply)(using Context): tpd.Tree =
+    normalize(tree)
+
+  override def transformTypeApply(tree: tpd.TypeApply)(using Context): tpd.Tree =
+    normalize(tree)
+
+  override def transformClosure(tree: tpd.Closure)(using Context): tpd.Tree =
+    normalize(tree)
+}
+
+object SelectStatic:
+  val name: String = "selectStatic"
+  val description: String = "get rid of selects that would be compiled into GetStatic"
diff --git a/tests/pos-with-compiler-cc/dotc/transform/SeqLiterals.scala b/tests/pos-with-compiler-cc/dotc/transform/SeqLiterals.scala
new file mode 100644
index 000000000000..2f586104c4e3
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/transform/SeqLiterals.scala
@@ -0,0 +1,44 @@
+package dotty.tools.dotc
+package transform
+
+import core._
+import dotty.tools.dotc.transform.MegaPhase._
+import Contexts._
+
+/** A transformer that eliminates SeqLiteral's, transforming `SeqLiteral(elems)` to an operation
+ *  equivalent to
+ *
+ *      JavaSeqLiteral(elems).toSeq
+ *
+ *  Instead of `toSeq`, which takes an implicit, the appropriate "wrapArray" method
+ *  is called directly. The reason for this step is that JavaSeqLiterals, being arrays
+ *  keep a precise type after erasure, whereas SeqLiterals only get the erased type `Seq`,
+ */
+class SeqLiterals extends MiniPhase {
+  import ast.tpd._
+
+  override def phaseName: String = SeqLiterals.name
+
+  override def description: String = SeqLiterals.description
+
+  override def runsAfter: Set[String] = Set(PatternMatcher.name)
+
+  override def checkPostCondition(tree: Tree)(using Context): Unit = tree match {
+    case tpd: SeqLiteral => assert(tpd.isInstanceOf[JavaSeqLiteral])
+    case _ =>
+  }
+
+  override def transformSeqLiteral(tree: SeqLiteral)(using Context): Tree = tree match {
+    case tree: JavaSeqLiteral => tree
+    case _ =>
+      val arr = JavaSeqLiteral(tree.elems, tree.elemtpt)
+      //println(i"trans seq $tree, arr = $arr: ${arr.tpe} ${arr.tpe.elemType}")
+      val elemtp = tree.elemtpt.tpe
+      wrapArray(arr, elemtp).withSpan(tree.span).ensureConforms(tree.tpe)
+  }
+}
+
+object SeqLiterals:
+  val name: String = "seqLiterals"
+  val description: String = "express vararg arguments as arrays"
+
diff --git a/tests/pos-with-compiler-cc/dotc/transform/SetRootTree.scala b/tests/pos-with-compiler-cc/dotc/transform/SetRootTree.scala
new file mode 100644
index 000000000000..d17dbbecc555
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/transform/SetRootTree.scala
@@ -0,0 +1,49 @@
+package dotty.tools.dotc.transform
+
+import dotty.tools.dotc.ast.tpd
+import dotty.tools.dotc.core.Contexts._
+import dotty.tools.dotc.core.Phases.Phase
+
+/** Set the `rootTreeOrProvider` property of class symbols. */
+class SetRootTree extends Phase {
+
+  override val phaseName: String = SetRootTree.name
+
+  override val description: String = SetRootTree.description
+
+  override def isRunnable(using Context) =
+    super.isRunnable && ctx.settings.YretainTrees.value
+
+  // Check no needed. Does not transform trees
+  override def isCheckable: Boolean = false
+
+  override def run(using Context): Unit = {
+    val tree = ctx.compilationUnit.tpdTree
+    traverser.traverse(tree)
+  }
+
+  private def traverser = new tpd.TreeTraverser {
+    override def traverse(tree: tpd.Tree)(using Context): Unit =
+      tree match {
+        case pkg: tpd.PackageDef =>
+          traverseChildren(pkg)
+        case td: tpd.TypeDef =>
+          if (td.symbol.isClass) {
+            val sym = td.symbol.asClass
+            tpd.sliceTopLevel(ctx.compilationUnit.tpdTree, sym) match {
+              case (pkg: tpd.PackageDef) :: Nil =>
+                sym.rootTreeOrProvider = pkg
+              case _ =>
+                sym.rootTreeOrProvider = td
+            }
+          }
+        case _ =>
+          ()
+      }
+  }
+}
+
+object SetRootTree {
+  val name: String = "SetRootTree"
+  val description: String = "set the rootTreeOrProvider on class symbols"
+}
diff --git a/tests/pos-with-compiler-cc/dotc/transform/SpecializeApplyMethods.scala b/tests/pos-with-compiler-cc/dotc/transform/SpecializeApplyMethods.scala
new file mode 100644
index 000000000000..6ffa05075201
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/transform/SpecializeApplyMethods.scala
@@ -0,0 +1,124 @@
+package dotty.tools.dotc
+package transform
+
+import ast.Trees._, ast.tpd, core._
+import Contexts._, Types._, Decorators._, Symbols._, DenotTransformers._
+import SymDenotations._, Scopes._, StdNames._, NameOps._, Names._
+import MegaPhase.MiniPhase
+
+import scala.collection.mutable
+
+
+/** This phase synthesizes specialized methods for FunctionN, this is done
+ *  since there are no scala signatures in the bytecode for the specialized
+ *  methods.
+ *
+ *  We know which specializations exist for the different arities, therefore we
+ *  can hardcode them. This should, however be removed once we're using a
+ *  different standard library.
+ */
+class SpecializeApplyMethods extends MiniPhase with InfoTransformer {
+  import ast.tpd._
+
+  override def phaseName: String = SpecializeApplyMethods.name
+
+  override def description: String = SpecializeApplyMethods.description
+
+  override def isEnabled(using Context): Boolean =
+    !ctx.settings.scalajs.value
+
+  private def specApplySymbol(sym: Symbol, args: List[Type], ret: Type)(using Context): Symbol = {
+    val name = nme.apply.specializedFunction(ret, args)
+    // Create the symbol at the next phase, so that it is a valid member of the
+    // corresponding function for all valid periods of its SymDenotations.
+    // Otherwise, the valid period will offset by 1, which causes a stale symbol
+    // in compiling stdlib.
+    atNextPhase(newSymbol(sym, name, Flags.Method, MethodType(args, ret)))
+  }
+
+  private inline def specFun0(inline op: Type => Unit)(using Context): Unit = {
+    for (r <- defn.Function0SpecializedReturnTypes) do
+      op(r)
+  }
+
+  private inline def specFun1(inline op: (Type, Type) => Unit)(using Context): Unit = {
+    for
+      r  <- defn.Function1SpecializedReturnTypes
+      t1 <- defn.Function1SpecializedParamTypes
+    do
+      op(t1, r)
+  }
+
+  private inline def specFun2(inline op: (Type, Type, Type) => Unit)(using Context): Unit = {
+    for
+      r  <- defn.Function2SpecializedReturnTypes
+      t1 <- defn.Function2SpecializedParamTypes
+      t2 <- defn.Function2SpecializedParamTypes
+    do
+      op(t1, t2, r)
+  }
+
+  override def infoMayChange(sym: Symbol)(using Context) =
+    sym == defn.Function0
+    || sym == defn.Function1
+    || sym == defn.Function2
+
+  /** Add symbols for specialized methods to FunctionN */
+  override def transformInfo(tp: Type, sym: Symbol)(using Context) = tp match {
+    case tp: ClassInfo =>
+      if sym == defn.Function0 then
+        val scope = tp.decls.cloneScope
+        specFun0 { r => scope.enter(specApplySymbol(sym, Nil, r)) }
+        tp.derivedClassInfo(decls = scope)
+
+      else if sym == defn.Function1 then
+        val scope = tp.decls.cloneScope
+        specFun1 { (t1, r) => scope.enter(specApplySymbol(sym, t1 :: Nil, r)) }
+        tp.derivedClassInfo(decls = scope)
+
+      else if sym == defn.Function2 then
+        val scope = tp.decls.cloneScope
+        specFun2 { (t1, t2, r) => scope.enter(specApplySymbol(sym, t1 :: t2 :: Nil, r)) }
+        tp.derivedClassInfo(decls = scope)
+
+      else tp
+
+    case _ => tp
+  }
+
+  /** Create bridge methods for FunctionN with specialized applys */
+  override def transformTemplate(tree: Template)(using Context) = {
+    val cls = tree.symbol.owner.asClass
+
+    def synthesizeApply(names: collection.Set[TermName]): Tree = {
+      val applyBuf = new mutable.ListBuffer[DefDef]
+      names.foreach { name =>
+        val applySym = cls.info.decls.lookup(name)
+        val ddef = DefDef(
+          applySym.asTerm,
+          { vparamss =>
+              This(cls)
+                .select(nme.apply)
+                .appliedToArgss(vparamss)
+                .ensureConforms(applySym.info.finalResultType)
+          }
+        )
+        applyBuf += ddef
+      }
+      cpy.Template(tree)(body = tree.body ++ applyBuf)
+    }
+
+    if cls == defn.Function0 then
+      synthesizeApply(defn.Function0SpecializedApplyNames)
+    else if cls == defn.Function1 then
+      synthesizeApply(defn.Function1SpecializedApplyNames)
+    else if cls == defn.Function2 then
+      synthesizeApply(defn.Function2SpecializedApplyNames)
+    else
+      tree
+  }
+}
+
+object SpecializeApplyMethods:
+  val name: String = "specializeApplyMethods"
+  val description: String = "adds specialized methods to FunctionN"
diff --git a/tests/pos-with-compiler-cc/dotc/transform/SpecializeFunctions.scala b/tests/pos-with-compiler-cc/dotc/transform/SpecializeFunctions.scala
new file mode 100644
index 000000000000..c1f891d6293a
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/transform/SpecializeFunctions.scala
@@ -0,0 +1,114 @@
+package dotty.tools.dotc
+package transform
+
+import ast.Trees._, ast.tpd, core._
+import Contexts._, Types._, Decorators._, Symbols._, DenotTransformers._
+import SymDenotations._, Scopes._, StdNames._, NameOps._, Names._
+import MegaPhase.MiniPhase
+
+
+/** Specializes classes that inherit from `FunctionN` where there exists a
+ *  specialized form.
+ */
+class SpecializeFunctions extends MiniPhase {
+  import ast.tpd._
+
+  override def phaseName: String = SpecializeFunctions.name
+
+  override def description: String = SpecializeFunctions.description
+
+  override def runsAfter = Set(ElimByName.name)
+
+  override def isEnabled(using Context): Boolean =
+    !ctx.settings.scalajs.value
+
+  /** Create forwarders from the generic applys to the specialized ones.
+   */
+  override def transformDefDef(ddef: DefDef)(using Context) = {
+    if ddef.name != nme.apply
+       || ddef.termParamss.length != 1
+       || ddef.termParamss.head.length > 2
+       || !ctx.owner.isClass
+    then
+      return ddef
+
+    val sym = ddef.symbol
+    val cls = ctx.owner.asClass
+
+    var specName: Name | Null = null
+
+    def isSpecializable = {
+      val paramTypes = ddef.termParamss.head.map(_.symbol.info)
+      val retType = sym.info.finalResultType
+      specName = nme.apply.specializedFunction(retType, paramTypes)
+      defn.isSpecializableFunction(cls, paramTypes, retType)
+    }
+
+    if (sym.is(Flags.Deferred) || !isSpecializable) return ddef
+
+    val specializedApply = newSymbol(
+        cls,
+        specName.nn,
+        sym.flags | Flags.Synthetic,
+        sym.info
+      ).entered
+
+    val specializedDecl =
+      DefDef(specializedApply.asTerm, vparamss => {
+        ddef.rhs
+          .changeOwner(ddef.symbol, specializedApply)
+          .subst(ddef.termParamss.head.map(_.symbol), vparamss.head.map(_.symbol))
+      })
+
+    // create a forwarding to the specialized apply
+    val args = ddef.termParamss.head.map(vparam => ref(vparam.symbol))
+    val rhs = This(cls).select(specializedApply).appliedToTermArgs(args)
+    val ddef1 = cpy.DefDef(ddef)(rhs = rhs)
+    Thicket(ddef1, specializedDecl)
+  }
+
+  /** Dispatch to specialized `apply`s in user code when available */
+  override def transformApply(tree: Apply)(using Context) =
+    tree match {
+      case Apply(fun: NameTree, args) if fun.name == nme.apply && args.size <= 3 && fun.symbol.owner.isType =>
+        val argTypes = fun.tpe.widen.firstParamTypes.map(_.widenSingleton.dealias)
+        val retType  = tree.tpe.widenSingleton.dealias
+        val isSpecializable =
+          defn.isSpecializableFunction(
+            fun.symbol.owner.asClass,
+            argTypes,
+            retType
+          )
+        if isSpecializable then
+          val specializedApply = nme.apply.specializedFunction(retType, argTypes)
+          val newSel = fun match
+            case Select(qual, _) =>
+              val qual1 = qual.tpe.widen match
+                case defn.ByNameFunction(res) =>
+                  // Need to cast to regular function, since specialied apply methods
+                  // are not members of ContextFunction0. The cast will be eliminated in
+                  // erasure.
+                  qual.cast(defn.FunctionOf(Nil, res))
+                case _ =>
+                  qual
+              qual1.select(specializedApply)
+            case _ =>
+              (fun.tpe: @unchecked) match
+                case TermRef(prefix: ThisType, name) =>
+                  tpd.This(prefix.cls).select(specializedApply)
+                case TermRef(prefix: NamedType, name) =>
+                  tpd.ref(prefix).select(specializedApply)
+          newSel.appliedToTermArgs(args)
+        else tree
+      case _ => tree
+    }
+
+  private def derivesFromFn012(cls: ClassSymbol)(using Context): Boolean =
+    cls.baseClasses.exists { p =>
+      p == defn.Function0 || p == defn.Function1 || p == defn.Function2
+    }
+}
+
+object SpecializeFunctions:
+  val name: String = "specializeFunctions"
+  val description: String = "specialize Function{0,1,2} by replacing super with specialized super"
diff --git a/tests/pos-with-compiler-cc/dotc/transform/SpecializeTuples.scala b/tests/pos-with-compiler-cc/dotc/transform/SpecializeTuples.scala
new file mode 100644
index 000000000000..5237ecbcef8a
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/transform/SpecializeTuples.scala
@@ -0,0 +1,53 @@
+package dotty.tools
+package dotc
+package transform
+
+import ast.Trees.*, ast.tpd, core.*
+import Contexts.*, Types.*, Decorators.*, Symbols.*, DenotTransformers.*
+import SymDenotations.*, Scopes.*, StdNames.*, NameOps.*, Names.*
+import MegaPhase.MiniPhase
+import inlines.Inliner.isElideableExpr
+
+/** Specializes Tuples by replacing tuple construction and selection trees.
+ *
+ * Specifically:
+ * 1. Replaces `(1, 1)` (which is `Tuple2.apply[Int, Int](1, 1)`) and
+ *    `new Tuple2[Int, Int](1, 1)` with `new Tuple2$mcII$sp(1, 1)`.
+ * 2. Replaces `(_: Tuple2[Int, Int])._1` with `(_: Tuple2[Int, Int])._1$mcI$sp`
+ */
+class SpecializeTuples extends MiniPhase:
+  import tpd.*
+
+  override def phaseName: String                 = SpecializeTuples.name
+  override def description: String               = SpecializeTuples.description
+  override def isEnabled(using Context): Boolean = !ctx.settings.scalajs.value
+
+  override def transformApply(tree: Apply)(using Context): Tree = tree match
+    case Apply(TypeApply(fun: NameTree, targs), args)
+        if fun.symbol.name == nme.apply && fun.symbol.exists && defn.isSpecializableTuple(fun.symbol.owner.companionClass, targs.map(_.tpe))
+        && isElideableExpr(tree)
+    =>
+      cpy.Apply(tree)(Select(New(defn.SpecializedTuple(fun.symbol.owner.companionClass, targs.map(_.tpe)).typeRef), nme.CONSTRUCTOR), args).withType(tree.tpe)
+    case Apply(TypeApply(fun: NameTree, targs), args)
+        if fun.symbol.name == nme.CONSTRUCTOR && fun.symbol.exists && defn.isSpecializableTuple(fun.symbol.owner, targs.map(_.tpe))
+        && isElideableExpr(tree)
+    =>
+      cpy.Apply(tree)(Select(New(defn.SpecializedTuple(fun.symbol.owner, targs.map(_.tpe)).typeRef), nme.CONSTRUCTOR), args).withType(tree.tpe)
+    case _ => tree
+  end transformApply
+
+  override def transformSelect(tree: Select)(using Context): Tree = tree match
+    case Select(qual, nme._1) if isAppliedSpecializableTuple(qual.tpe.widen) =>
+      Select(qual, nme._1.specializedName(qual.tpe.widen.argInfos.slice(0, 1)))
+    case Select(qual, nme._2) if isAppliedSpecializableTuple(qual.tpe.widen) =>
+      Select(qual, nme._2.specializedName(qual.tpe.widen.argInfos.slice(1, 2)))
+    case _ => tree
+
+  private def isAppliedSpecializableTuple(tp: Type)(using Context) = tp match
+    case AppliedType(tycon, args) => defn.isSpecializableTuple(tycon.classSymbol, args)
+    case _                        => false
+end SpecializeTuples
+
+object SpecializeTuples:
+  val name: String = "specializeTuples"
+  val description: String = "replaces tuple construction and selection trees"
diff --git a/tests/pos-with-compiler-cc/dotc/transform/Splicer.scala b/tests/pos-with-compiler-cc/dotc/transform/Splicer.scala
new file mode 100644
index 000000000000..5d031d100e53
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/transform/Splicer.scala
@@ -0,0 +1,572 @@
+package dotty.tools.dotc
+package transform
+
+import scala.language.unsafeNulls
+
+import java.io.{PrintWriter, StringWriter}
+import java.lang.reflect.{InvocationTargetException, Method => JLRMethod}
+
+import dotty.tools.dotc.ast.tpd
+import dotty.tools.dotc.core.Contexts._
+import dotty.tools.dotc.core.Decorators._
+import dotty.tools.dotc.core.Flags._
+import dotty.tools.dotc.core.NameKinds.FlatName
+import dotty.tools.dotc.core.Names.Name
+import dotty.tools.dotc.core.StdNames._
+import dotty.tools.dotc.core.Types._
+import dotty.tools.dotc.core.Symbols._
+import dotty.tools.dotc.core.Denotations.staticRef
+import dotty.tools.dotc.core.TypeErasure
+import dotty.tools.dotc.core.Constants.Constant
+
+import scala.util.control.NonFatal
+import dotty.tools.dotc.util.SrcPos
+import dotty.tools.repl.AbstractFileClassLoader
+
+import scala.reflect.ClassTag
+
+import dotty.tools.dotc.quoted.{PickledQuotes, QuoteUtils}
+
+import scala.quoted.Quotes
+import scala.quoted.runtime.impl._
+import language.experimental.pureFunctions
+
+/** Utility class to splice quoted expressions */
+object Splicer {
+  import tpd._
+
+  /** Splice the Tree for a Quoted expression. `${'{xyz}}` becomes `xyz`
+   *  and for `$xyz` the tree of `xyz` is interpreted for which the
+   *  resulting expression is returned as a `Tree`
+   *
+   *  See: `Staging`
+   */
+  def splice(tree: Tree, splicePos: SrcPos, spliceExpansionPos: SrcPos, classLoader: ClassLoader)(using Context): Tree = tree match {
+    case Quoted(quotedTree) => quotedTree
+    case _ =>
+      val macroOwner = newSymbol(ctx.owner, nme.MACROkw, Macro | Synthetic, defn.AnyType, coord = tree.span)
+      try
+        val sliceContext = SpliceScope.contextWithNewSpliceScope(splicePos.sourcePos).withOwner(macroOwner)
+        inContext(sliceContext) {
+          val oldContextClassLoader = Thread.currentThread().getContextClassLoader
+          Thread.currentThread().setContextClassLoader(classLoader)
+          try {
+            val interpreter = new Interpreter(splicePos, classLoader)
+
+            // Some parts of the macro are evaluated during the unpickling performed in quotedExprToTree
+            val interpretedExpr: Option[Quotes -> scala.quoted.Expr[Any]] = // !cc! explicit type ascription needed here
+              interpreter.interpret(tree)
+            val interpretedTree: Tree = interpretedExpr match
+              case Some(macroClosure) => PickledQuotes.quotedExprToTree(macroClosure(QuotesImpl()))
+              case None => tree
+
+            checkEscapedVariables(interpretedTree, macroOwner)
+          } finally {
+            Thread.currentThread().setContextClassLoader(oldContextClassLoader)
+          }
+        }.changeOwner(macroOwner, ctx.owner)
+      catch {
+        case ex: CompilationUnit.SuspendException =>
+          throw ex
+        case ex: scala.quoted.runtime.StopMacroExpansion =>
+          if !ctx.reporter.hasErrors then
+            report.error("Macro expansion was aborted by the macro without any errors reported. Macros should issue errors to end-users to facilitate debugging when aborting a macro expansion.", splicePos)
+          // errors have been emitted
+          EmptyTree
+        case ex: StopInterpretation =>
+          report.error(ex.msg, ex.pos)
+          ref(defn.Predef_undefined).withType(ErrorType(ex.msg))
+        case NonFatal(ex) =>
+          val msg =
+            s"""Failed to evaluate macro.
+               |  Caused by ${ex.getClass}: ${if (ex.getMessage == null) "" else ex.getMessage}
+               |    ${ex.getStackTrace.takeWhile(_.getClassName != "dotty.tools.dotc.transform.Splicer$").drop(1).mkString("\n    ")}
+             """.stripMargin
+          report.error(msg, spliceExpansionPos)
+          ref(defn.Predef_undefined).withType(ErrorType(msg))
+      }
+  }
+
+  /** Checks that no symbol that whas generated within the macro expansion has an out of scope reference */
+  def checkEscapedVariables(tree: Tree, expansionOwner: Symbol)(using Context): tree.type =
+    new TreeTraverser {
+      private[this] var locals = Set.empty[Symbol]
+      private def markSymbol(sym: Symbol)(using Context): Unit =
+          locals = locals + sym
+      private def markDef(tree: Tree)(using Context): Unit = tree match {
+        case tree: DefTree => markSymbol(tree.symbol)
+        case _ =>
+      }
+      def traverse(tree: Tree)(using Context): Unit =
+        def traverseOver(lastEntered: Set[Symbol]) =
+          try traverseChildren(tree)
+          finally locals = lastEntered
+        tree match
+          case tree: Ident if isEscapedVariable(tree.symbol) =>
+            val sym = tree.symbol
+            report.error(em"While expanding a macro, a reference to $sym was used outside the scope where it was defined", tree.srcPos)
+          case Block(stats, _) =>
+            val last = locals
+            stats.foreach(markDef)
+            traverseOver(last)
+          case CaseDef(pat, guard, body) =>
+            val last = locals
+            tpd.patVars(pat).foreach(markSymbol)
+            traverseOver(last)
+          case _ =>
+            markDef(tree)
+            traverseChildren(tree)
+      private def isEscapedVariable(sym: Symbol)(using Context): Boolean =
+        sym.exists && !sym.is(Package)
+        && sym.owner.ownersIterator.exists(x =>
+          x == expansionOwner || // symbol was generated within this macro expansion
+          x.is(Macro, butNot = Method) && x.name == nme.MACROkw // symbol was generated within another macro expansion
+        )
+        && !locals.contains(sym) // symbol is not in current scope
+    }.traverse(tree)
+    tree
+
+
+  /** Check that the Tree can be spliced. `${'{xyz}}` becomes `xyz`
+    *  and for `$xyz` the tree of `xyz` is interpreted for which the
+    *  resulting expression is returned as a `Tree`
+    *
+    *  See: `Staging`
+    */
+  def checkValidMacroBody(tree: Tree)(using Context): Unit = tree match {
+    case Quoted(_) => // ok
+    case _ =>
+      type Env = Set[Symbol]
+
+      def checkValidStat(tree: Tree)(using Env): Env = tree match {
+        case tree: ValDef if tree.symbol.is(Synthetic) =>
+          // Check val from `foo(j = x, i = y)` which it is expanded to
+          // `val j$1 = x; val i$1 = y; foo(i = i$1, j = j$1)`
+          checkIfValidArgument(tree.rhs)
+          summon[Env] + tree.symbol
+        case _ =>
+          report.error("Macro should not have statements", tree.srcPos)
+          summon[Env]
+      }
+
+      def checkIfValidArgument(tree: Tree)(using Env): Unit = tree match {
+        case Block(Nil, expr) => checkIfValidArgument(expr)
+        case Typed(expr, _) => checkIfValidArgument(expr)
+
+        case Apply(Select(Apply(fn, quoted :: Nil), nme.apply), _) if fn.symbol == defn.QuotedRuntime_exprQuote =>
+          val noSpliceChecker = new TreeTraverser {
+            def traverse(tree: Tree)(using Context): Unit = tree match
+              case Spliced(_) =>
+                report.error("Quoted argument of macros may not have splices", tree.srcPos)
+              case _ =>
+                traverseChildren(tree)
+          }
+          noSpliceChecker.traverse(quoted)
+
+        case Apply(TypeApply(fn, List(quoted)), _)if fn.symbol == defn.QuotedTypeModule_of =>
+          // OK
+
+        case Literal(Constant(value)) =>
+          // OK
+
+        case NamedArg(_, arg) =>
+          checkIfValidArgument(arg)
+
+        case SeqLiteral(elems, _) =>
+          elems.foreach(checkIfValidArgument)
+
+        case tree: Ident if summon[Env].contains(tree.symbol) || tree.symbol.is(Inline, butNot = Method) =>
+          // OK
+
+        case _ =>
+          val extra = if tree.span.isZeroExtent then ": " + tree.show else ""
+          report.error(
+            s"""Malformed macro parameter$extra
+              |
+              |Parameters may only be:
+              | * Quoted parameters or fields
+              | * Literal values of primitive types
+              | * References to `inline val`s
+              |""".stripMargin, tree.srcPos)
+      }
+
+      def checkIfValidStaticCall(tree: Tree)(using Env): Unit = tree match {
+        case closureDef(ddef @ DefDef(_, ValDefs(ev :: Nil) :: Nil, _, _)) if ddef.symbol.info.isContextualMethod =>
+          checkIfValidStaticCall(ddef.rhs)(using summon[Env] + ev.symbol)
+
+        case Block(stats, expr) =>
+          val newEnv = stats.foldLeft(summon[Env])((env, stat) => checkValidStat(stat)(using env))
+          checkIfValidStaticCall(expr)(using newEnv)
+
+        case Typed(expr, _) =>
+          checkIfValidStaticCall(expr)
+
+        case Apply(Select(Apply(fn, quoted :: Nil), nme.apply), _) if fn.symbol == defn.QuotedRuntime_exprQuote =>
+          // OK, canceled and warning emitted
+
+        case Call(fn, args)
+            if (fn.symbol.isConstructor && fn.symbol.owner.owner.is(Package)) ||
+               fn.symbol.is(Module) || fn.symbol.isStatic ||
+               (fn.qualifier.symbol.is(Module) && fn.qualifier.symbol.isStatic) =>
+          if (fn.symbol.flags.is(Inline))
+            report.error("Macro cannot be implemented with an `inline` method", fn.srcPos)
+          args.flatten.foreach(checkIfValidArgument)
+
+        case _ =>
+          report.error(
+            """Malformed macro.
+              |
+              |Expected the splice ${...} to contain a single call to a static method.
+              |""".stripMargin, tree.srcPos)
+      }
+
+      checkIfValidStaticCall(tree)(using Set.empty)
+  }
+
+  /** Tree interpreter that evaluates the tree */
+  private class Interpreter(pos: SrcPos, classLoader: ClassLoader)(using Context) {
+
+    type Env = Map[Symbol, Object]
+
+    /** Returns the interpreted result of interpreting the code a call to the symbol with default arguments.
+     *  Return Some of the result or None if some error happen during the interpretation.
+     */
+    def interpret[T](tree: Tree)(implicit ct: ClassTag[T]): Option[T] =
+      interpretTree(tree)(Map.empty) match {
+        case obj: T => Some(obj)
+        case obj =>
+          // TODO upgrade to a full type tag check or something similar
+          report.error(s"Interpreted tree returned a result of an unexpected type. Expected ${ct.runtimeClass} but was ${obj.getClass}", pos)
+          None
+      }
+
+    def interpretTree(tree: Tree)(implicit env: Env): Object = tree match {
+      case Apply(Select(Apply(TypeApply(fn, _), quoted :: Nil), nme.apply), _) if fn.symbol == defn.QuotedRuntime_exprQuote =>
+        val quoted1 = quoted match {
+          case quoted: Ident if quoted.symbol.isAllOf(InlineByNameProxy) =>
+            // inline proxy for by-name parameter
+            quoted.symbol.defTree.asInstanceOf[DefDef].rhs
+          case Inlined(EmptyTree, _, quoted) => quoted
+          case _ => quoted
+        }
+        interpretQuote(quoted1)
+
+      case Apply(TypeApply(fn, quoted :: Nil), _) if fn.symbol == defn.QuotedTypeModule_of =>
+        interpretTypeQuote(quoted)
+
+      case Literal(Constant(value)) =>
+        interpretLiteral(value)
+
+      case tree: Ident if tree.symbol.is(Inline, butNot = Method) =>
+        tree.tpe.widenTermRefExpr match
+          case ConstantType(c) => c.value.asInstanceOf[Object]
+          case _ => throw new StopInterpretation(em"${tree.symbol} could not be inlined", tree.srcPos)
+
+      // TODO disallow interpreted method calls as arguments
+      case Call(fn, args) =>
+        if (fn.symbol.isConstructor && fn.symbol.owner.owner.is(Package))
+          interpretNew(fn.symbol, args.flatten.map(interpretTree))
+        else if (fn.symbol.is(Module))
+          interpretModuleAccess(fn.symbol)
+        else if (fn.symbol.is(Method) && fn.symbol.isStatic) {
+          val staticMethodCall = interpretedStaticMethodCall(fn.symbol.owner, fn.symbol)
+          staticMethodCall(interpretArgs(args, fn.symbol.info))
+        }
+        else if fn.symbol.isStatic then
+          assert(args.isEmpty)
+          interpretedStaticFieldAccess(fn.symbol)
+        else if (fn.qualifier.symbol.is(Module) && fn.qualifier.symbol.isStatic)
+          if (fn.name == nme.asInstanceOfPM)
+            interpretModuleAccess(fn.qualifier.symbol)
+          else {
+            val staticMethodCall = interpretedStaticMethodCall(fn.qualifier.symbol.moduleClass, fn.symbol)
+            staticMethodCall(interpretArgs(args, fn.symbol.info))
+          }
+        else if (env.contains(fn.symbol))
+          env(fn.symbol)
+        else if (tree.symbol.is(InlineProxy))
+          interpretTree(tree.symbol.defTree.asInstanceOf[ValOrDefDef].rhs)
+        else
+          unexpectedTree(tree)
+
+      case closureDef((ddef @ DefDef(_, ValDefs(arg :: Nil) :: Nil, _, _))) =>
+        (obj: AnyRef) => interpretTree(ddef.rhs)(using env.updated(arg.symbol, obj))
+
+      // Interpret `foo(j = x, i = y)` which it is expanded to
+      // `val j$1 = x; val i$1 = y; foo(i = i$1, j = j$1)`
+      case Block(stats, expr) => interpretBlock(stats, expr)
+      case NamedArg(_, arg) => interpretTree(arg)
+
+      case Inlined(_, bindings, expansion) => interpretBlock(bindings, expansion)
+
+      case Typed(expr, _) =>
+        interpretTree(expr)
+
+      case SeqLiteral(elems, _) =>
+        interpretVarargs(elems.map(e => interpretTree(e)))
+
+      case _ =>
+        unexpectedTree(tree)
+    }
+
+    private def interpretArgs(argss: List[List[Tree]], fnType: Type)(using Env): List[Object] = {
+      def interpretArgsGroup(args: List[Tree], argTypes: List[Type]): List[Object] =
+        assert(args.size == argTypes.size)
+        val view =
+          for (arg, info) <- args.lazyZip(argTypes) yield
+            info match
+              case _: ExprType => () => interpretTree(arg) // by-name argument
+              case _ => interpretTree(arg) // by-value argument
+        view.toList
+
+      fnType.dealias match
+        case fnType: MethodType if fnType.isErasedMethod => interpretArgs(argss, fnType.resType)
+        case fnType: MethodType =>
+          val argTypes = fnType.paramInfos
+          assert(argss.head.size == argTypes.size)
+          interpretArgsGroup(argss.head, argTypes) ::: interpretArgs(argss.tail, fnType.resType)
+        case fnType: AppliedType if defn.isContextFunctionType(fnType) =>
+          val argTypes :+ resType = fnType.args: @unchecked
+          interpretArgsGroup(argss.head, argTypes) ::: interpretArgs(argss.tail, resType)
+        case fnType: PolyType => interpretArgs(argss, fnType.resType)
+        case fnType: ExprType => interpretArgs(argss, fnType.resType)
+        case _ =>
+          assert(argss.isEmpty)
+          Nil
+    }
+
+    private def interpretBlock(stats: List[Tree], expr: Tree)(implicit env: Env) = {
+      var unexpected: Option[Object] = None
+      val newEnv = stats.foldLeft(env)((accEnv, stat) => stat match {
+        case stat: ValDef =>
+          accEnv.updated(stat.symbol, interpretTree(stat.rhs)(accEnv))
+        case stat =>
+          if (unexpected.isEmpty)
+            unexpected = Some(unexpectedTree(stat))
+          accEnv
+      })
+      unexpected.getOrElse(interpretTree(expr)(newEnv))
+    }
+
+    private def interpretQuote(tree: Tree)(implicit env: Env): Object =
+      new ExprImpl(Inlined(EmptyTree, Nil, QuoteUtils.changeOwnerOfTree(tree, ctx.owner)).withSpan(tree.span), SpliceScope.getCurrent)
+
+    private def interpretTypeQuote(tree: Tree)(implicit env: Env): Object =
+      new TypeImpl(QuoteUtils.changeOwnerOfTree(tree, ctx.owner), SpliceScope.getCurrent)
+
+    private def interpretLiteral(value: Any)(implicit env: Env): Object =
+      value.asInstanceOf[Object]
+
+    private def interpretVarargs(args: List[Object])(implicit env: Env): Object =
+      args.toSeq
+
+    private def interpretedStaticMethodCall(moduleClass: Symbol, fn: Symbol)(implicit env: Env): List[Object] => Object = {
+      val (inst, clazz) =
+        try
+          if (moduleClass.name.startsWith(str.REPL_SESSION_LINE))
+            (null, loadReplLineClass(moduleClass))
+          else {
+            val inst = loadModule(moduleClass)
+            (inst, inst.getClass)
+          }
+        catch
+          case MissingClassDefinedInCurrentRun(sym)  if ctx.compilationUnit.isSuspendable =>
+            if (ctx.settings.XprintSuspension.value)
+              report.echo(i"suspension triggered by a dependency on $sym", pos)
+            ctx.compilationUnit.suspend() // this throws a SuspendException
+
+      val name = fn.name.asTermName
+      val method = getMethod(clazz, name, paramsSig(fn))
+      (args: List[Object]) => stopIfRuntimeException(method.invoke(inst, args: _*), method)
+    }
+
+    private def interpretedStaticFieldAccess(sym: Symbol)(implicit env: Env): Object = {
+      val clazz = loadClass(sym.owner.fullName.toString)
+      val field = clazz.getField(sym.name.toString)
+      field.get(null)
+    }
+
+    private def interpretModuleAccess(fn: Symbol)(implicit env: Env): Object =
+      loadModule(fn.moduleClass)
+
+    private def interpretNew(fn: Symbol, args: => List[Object])(implicit env: Env): Object = {
+      val clazz = loadClass(fn.owner.fullName.toString)
+      val constr = clazz.getConstructor(paramsSig(fn): _*)
+      constr.newInstance(args: _*).asInstanceOf[Object]
+    }
+
+    private def unexpectedTree(tree: Tree)(implicit env: Env): Object =
+      throw new StopInterpretation("Unexpected tree could not be interpreted: " + tree, tree.srcPos)
+
+    private def loadModule(sym: Symbol): Object =
+      if (sym.owner.is(Package)) {
+        // is top level object
+        val moduleClass = loadClass(sym.fullName.toString)
+        moduleClass.getField(str.MODULE_INSTANCE_FIELD).get(null)
+      }
+      else {
+        // nested object in an object
+        val className = {
+          val pack = sym.topLevelClass.owner
+          if (pack == defn.RootPackage || pack == defn.EmptyPackageClass) sym.flatName.toString
+          else pack.showFullName + "." + sym.flatName
+        }
+        val clazz = loadClass(className)
+        clazz.getConstructor().newInstance().asInstanceOf[Object]
+      }
+
+    private def loadReplLineClass(moduleClass: Symbol)(implicit env: Env): Class[?] = {
+      val lineClassloader = new AbstractFileClassLoader(ctx.settings.outputDir.value, classLoader)
+      lineClassloader.loadClass(moduleClass.name.firstPart.toString)
+    }
+
+    private def loadClass(name: String): Class[?] =
+      try classLoader.loadClass(name)
+      catch {
+        case _: ClassNotFoundException =>
+          val msg = s"Could not find class $name in classpath"
+          throw new StopInterpretation(msg, pos)
+      }
+
+    private def getMethod(clazz: Class[?], name: Name, paramClasses: List[Class[?]]): JLRMethod =
+      try clazz.getMethod(name.toString, paramClasses: _*)
+      catch {
+        case _: NoSuchMethodException =>
+          val msg = em"Could not find method ${clazz.getCanonicalName}.$name with parameters ($paramClasses%, %)"
+          throw new StopInterpretation(msg, pos)
+        case MissingClassDefinedInCurrentRun(sym) if ctx.compilationUnit.isSuspendable =>
+            if (ctx.settings.XprintSuspension.value)
+              report.echo(i"suspension triggered by a dependency on $sym", pos)
+            ctx.compilationUnit.suspend() // this throws a SuspendException
+      }
+
+    private def stopIfRuntimeException[T](thunk: => T, method: JLRMethod): T =
+      try thunk
+      catch {
+        case ex: RuntimeException =>
+          val sw = new StringWriter()
+          sw.write("A runtime exception occurred while executing macro expansion\n")
+          sw.write(ex.getMessage)
+          sw.write("\n")
+          ex.printStackTrace(new PrintWriter(sw))
+          sw.write("\n")
+          throw new StopInterpretation(sw.toString, pos)
+        case ex: InvocationTargetException =>
+          ex.getTargetException match {
+            case ex: scala.quoted.runtime.StopMacroExpansion =>
+              throw ex
+            case MissingClassDefinedInCurrentRun(sym) if ctx.compilationUnit.isSuspendable =>
+              if (ctx.settings.XprintSuspension.value)
+                report.echo(i"suspension triggered by a dependency on $sym", pos)
+              ctx.compilationUnit.suspend() // this throws a SuspendException
+            case targetException =>
+              val sw = new StringWriter()
+              sw.write("Exception occurred while executing macro expansion.\n")
+              if (!ctx.settings.Ydebug.value) {
+                val end = targetException.getStackTrace.lastIndexWhere { x =>
+                  x.getClassName == method.getDeclaringClass.getCanonicalName && x.getMethodName == method.getName
+                }
+                val shortStackTrace = targetException.getStackTrace.take(end + 1)
+                targetException.setStackTrace(shortStackTrace)
+              }
+              targetException.printStackTrace(new PrintWriter(sw))
+              sw.write("\n")
+              throw new StopInterpretation(sw.toString, pos)
+          }
+      }
+
+    private object MissingClassDefinedInCurrentRun {
+      def unapply(targetException: NoClassDefFoundError)(using Context): Option[Symbol] = {
+        val className = targetException.getMessage
+        if (className == null) None
+        else {
+          val sym = staticRef(className.toTypeName).symbol
+          if (sym.isDefinedInCurrentRun) Some(sym) else None
+        }
+      }
+    }
+
+    /** List of classes of the parameters of the signature of `sym` */
+    private def paramsSig(sym: Symbol): List[Class[?]] = {
+      def paramClass(param: Type): Class[?] = {
+        def arrayDepth(tpe: Type, depth: Int): (Type, Int) = tpe match {
+          case JavaArrayType(elemType) => arrayDepth(elemType, depth + 1)
+          case _ => (tpe, depth)
+        }
+        def javaArraySig(tpe: Type): String = {
+          val (elemType, depth) = arrayDepth(tpe, 0)
+          val sym = elemType.classSymbol
+          val suffix =
+            if (sym == defn.BooleanClass) "Z"
+            else if (sym == defn.ByteClass) "B"
+            else if (sym == defn.ShortClass) "S"
+            else if (sym == defn.IntClass) "I"
+            else if (sym == defn.LongClass) "J"
+            else if (sym == defn.FloatClass) "F"
+            else if (sym == defn.DoubleClass) "D"
+            else if (sym == defn.CharClass) "C"
+            else "L" + javaSig(elemType) + ";"
+          ("[" * depth) + suffix
+        }
+        def javaSig(tpe: Type): String = tpe match {
+          case tpe: JavaArrayType => javaArraySig(tpe)
+          case _ =>
+            // Take the flatten name of the class and the full package name
+            val pack = tpe.classSymbol.topLevelClass.owner
+            val packageName = if (pack == defn.EmptyPackageClass) "" else s"${pack.fullName}."
+            packageName + tpe.classSymbol.fullNameSeparated(FlatName).toString
+        }
+
+        val sym = param.classSymbol
+        if (sym == defn.BooleanClass) classOf[Boolean]
+        else if (sym == defn.ByteClass) classOf[Byte]
+        else if (sym == defn.CharClass) classOf[Char]
+        else if (sym == defn.ShortClass) classOf[Short]
+        else if (sym == defn.IntClass) classOf[Int]
+        else if (sym == defn.LongClass) classOf[Long]
+        else if (sym == defn.FloatClass) classOf[Float]
+        else if (sym == defn.DoubleClass) classOf[Double]
+        else java.lang.Class.forName(javaSig(param), false, classLoader)
+      }
+      def getExtraParams(tp: Type): List[Type] = tp.widenDealias match {
+        case tp: AppliedType if defn.isContextFunctionType(tp) =>
+          // Call context function type direct method
+          tp.args.init.map(arg => TypeErasure.erasure(arg)) ::: getExtraParams(tp.args.last)
+        case _ => Nil
+      }
+      val extraParams = getExtraParams(sym.info.finalResultType)
+      val allParams = TypeErasure.erasure(sym.info) match {
+        case meth: MethodType => meth.paramInfos ::: extraParams
+        case _ => extraParams
+      }
+      allParams.map(paramClass)
+    }
+  }
+
+
+
+  /** Exception that stops interpretation if some issue is found */
+  private class StopInterpretation(val msg: String, val pos: SrcPos) extends Exception
+
+  object Call {
+    /** Matches an expression that is either a field access or an application
+     *  It retruns a TermRef containing field accessed or a method reference and the arguments passed to it.
+     */
+    def unapply(arg: Tree)(using Context): Option[(RefTree, List[List[Tree]])] =
+      Call0.unapply(arg).map((fn, args) => (fn, args.reverse))
+
+    private object Call0 {
+      def unapply(arg: Tree)(using Context): Option[(RefTree, List[List[Tree]])] = arg match {
+        case Select(Call0(fn, args), nme.apply) if defn.isContextFunctionType(fn.tpe.widenDealias.finalResultType) =>
+          Some((fn, args))
+        case fn: Ident => Some((tpd.desugarIdent(fn).withSpan(fn.span), Nil))
+        case fn: Select => Some((fn, Nil))
+        case Apply(f @ Call0(fn, args1), args2) =>
+          if (f.tpe.widenDealias.isErasedMethod) Some((fn, args1))
+          else Some((fn, args2 :: args1))
+        case TypeApply(Call0(fn, args), _) => Some((fn, args))
+        case _ => None
+      }
+    }
+  }
+}
diff --git a/tests/pos-with-compiler-cc/dotc/transform/Splicing.scala b/tests/pos-with-compiler-cc/dotc/transform/Splicing.scala
new file mode 100644
index 000000000000..df6128d249d2
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/transform/Splicing.scala
@@ -0,0 +1,392 @@
+package dotty.tools.dotc
+package transform
+
+import core._
+import Decorators._
+import Flags._
+import Types._
+import Contexts._
+import Symbols._
+import Constants._
+import ast.Trees._
+import ast.{TreeTypeMap, untpd}
+import util.Spans._
+import SymUtils._
+import NameKinds._
+import dotty.tools.dotc.ast.tpd
+import StagingContext._
+
+import scala.collection.mutable
+import dotty.tools.dotc.core.Annotations._
+import dotty.tools.dotc.core.Names._
+import dotty.tools.dotc.core.StdNames._
+import dotty.tools.dotc.quoted._
+import dotty.tools.dotc.transform.TreeMapWithStages._
+import dotty.tools.dotc.config.ScalaRelease.*
+
+import scala.annotation.constructorOnly
+import language.experimental.pureFunctions
+
+object Splicing:
+  val name: String = "splicing"
+
+/** Transforms level 1 splices into holes. To do so it transforms the contents of the splice into
+ *  a lambda that receives all cross-quote references.
+ *
+ *  Cross-quote reference is a reference to a definition that is not defined in the current quote.
+ *  Those references appear in quotes that are nested in a splice.
+ *
+ *  After this phase we have the invariant where all splices have the following shape
+ *  ```
+ *  {{{ <holeIdx> | <holeType> | <captures>* | (<capturedTerms>*) => <spliceContent> }}}
+ *  ```
+ *  where `<spliceContent>` does not contain any free references to quoted definitions and `<captures>*`
+ *  contains the quotes with references to all cross-quote references. There are some special rules
+ *  for references in the LHS of assignments and cross-quote method references.
+ *
+ *  In the following code example `x1` and `x2` are cross-quote references.
+ *  ```
+ *  '{ ...
+ *    val x1: T1 = ???
+ *    val x2: T2 = ???
+ *    ${ (q: Quotes) ?=> f('{ g(x1, x2) }) }: T3
+ *  }
+ *  ```
+ *
+ *  This phase identifies cross-quote references such as `x1` and replaces it with an `${x1$}`.
+ *  All cross-quote arguments are directly applied in the lambda.
+ *
+ *  ```
+ *  '{ ...
+ *     val x1: T1 = ???
+ *     val x2: T2 = ???
+ *     {{{ 0 | T3 | x1, x2 |
+ *       (x1$: Expr[T1], x2$: Expr[T2]) => // body of this lambda does not contain references to x1 or x2
+ *         (q: Quotes) ?=> f('{ g(${x1$}, ${x2$}) })
+ *
+ *     }}}
+ *   }
+ *   ```
+ *
+ *  and then performs the same transformation on `'{ g(${x1$}, ${x2$}) }`.
+ *
+ */
+class Splicing extends MacroTransform:
+  import tpd._
+
+  override def phaseName: String = Splicing.name
+
+  override def run(using Context): Unit =
+    if ctx.compilationUnit.needsStaging then
+      super.run(using freshStagingContext)
+
+  protected def newTransformer(using Context): Transformer = Level0QuoteTransformer
+
+  /** Transforms all quotes at level 0 using the `QuoteTransformer` */
+  private object Level0QuoteTransformer extends Transformer:
+    override def transform(tree: tpd.Tree)(using Context): tpd.Tree =
+      assert(level == 0)
+      tree match
+        case Apply(Select(Apply(TypeApply(fn,_), List(code)),nme.apply),List(quotes))
+        if fn.symbol == defn.QuotedRuntime_exprQuote =>
+          QuoteTransformer().transform(tree)
+        case TypeApply(_, _) if tree.symbol == defn.QuotedTypeModule_of =>
+          QuoteTransformer().transform(tree)
+        case tree: DefDef if tree.symbol.is(Inline) =>
+          // Quotes in inlined methods are only pickled after they are inlined.
+          tree
+        case _ =>
+          super.transform(tree)
+  end Level0QuoteTransformer
+
+
+  /** Transforms all direct splices in the current quote and replace them with holes. */
+  private class QuoteTransformer() extends Transformer:
+    /** Set of definitions in the current quote */
+    private val quotedDefs = mutable.Set.empty[Symbol]
+
+    /** Number of holes created in this quote. Used for indexing holes. */
+    private var numHoles = 0
+
+    /** Mapping from the term symbol of a `Type[T]` to it's hole. Used to deduplicate type holes. */
+    private val typeHoles = mutable.Map.empty[Symbol, Hole]
+
+    override def transform(tree: tpd.Tree)(using Context): tpd.Tree =
+      tree match
+        case Apply(fn, List(splicedCode)) if fn.symbol == defn.QuotedRuntime_exprNestedSplice =>
+          if level > 1 then
+            val splicedCode1 = super.transform(splicedCode)(using spliceContext)
+            cpy.Apply(tree)(fn, List(splicedCode1))
+          else
+            val holeIdx = numHoles
+            numHoles += 1
+            val splicer = SpliceTransformer(ctx.owner, quotedDefs.contains)
+            val newSplicedCode1 = splicer.transformSplice(splicedCode, tree.tpe, holeIdx)(using spliceContext)
+            val newSplicedCode2 = Level0QuoteTransformer.transform(newSplicedCode1)(using spliceContext)
+            newSplicedCode2
+        case tree: TypeDef if tree.symbol.hasAnnotation(defn.QuotedRuntime_SplicedTypeAnnot) =>
+          val tp @ TypeRef(qual: TermRef, _) = tree.rhs.tpe.hiBound: @unchecked
+          quotedDefs += tree.symbol
+          val hole = typeHoles.get(qual.symbol) match
+            case Some (hole) => cpy.Hole(hole)(content = EmptyTree)
+            case None =>
+              val holeIdx = numHoles
+              numHoles += 1
+              val hole = tpd.Hole(false, holeIdx, Nil, ref(qual), TypeTree(tp))
+              typeHoles.put(qual.symbol, hole)
+              hole
+          cpy.TypeDef(tree)(rhs = hole)
+        case Apply(Select(Apply(TypeApply(fn,_), List(code)),nme.apply),List(quotes))
+        if fn.symbol == defn.QuotedRuntime_exprQuote =>
+          super.transform(tree)(using quoteContext)
+        case _: Template =>
+          for sym <- tree.symbol.owner.info.decls do
+            quotedDefs += sym
+          super.transform(tree)
+        case tree: DefTree =>
+          quotedDefs += tree.symbol
+          transformAnnotations(tree)
+          super.transform(tree)
+        case _: TypeTree =>
+          super.transform(tree).withType(transformAnnotTrees(tree.tpe))
+        case _ =>
+          super.transform(tree)
+
+    private def transformAnnotations(tree: DefTree)(using Context): Unit =
+      tree.symbol.annotations = tree.symbol.annotations.mapconserve { annot =>
+        val newAnnotTree = transform(annot.tree)(using ctx.withOwner(tree.symbol))
+        if (annot.tree == newAnnotTree) annot
+        else ConcreteAnnotation(newAnnotTree)
+      }
+
+    /** Transform trees within annotations */
+    private def transformAnnotTrees(using Context) = new TypeMap {
+      override def apply(tp: Type): Type = {
+          tp match
+            case tp @ AnnotatedType(underlying, annot) =>
+              val underlying1 = this(underlying)
+              derivedAnnotatedType(tp, underlying1, annot.derivedAnnotation(transform(annot.tree)))
+            case _ => mapOver(tp)
+      }
+    }
+
+  end QuoteTransformer
+
+  /** Transforms a splice at level 1 into a hole
+   *
+   *  Finds all terms and types that are defined in the current quote and used within this splice.
+   *  The resulting hole will contain all of these terms and types as arguments.
+   *  Note that these captured variables are stage correct.
+   *
+   *  For a `x` of type `T1` and a type `X` defined in the current quote
+   *  ```scala
+   *  ${  (using Quotes) ?=> {... x ... X ...} }: T2
+   *  ```
+   *  is transformed into
+   * ```scala
+   *  {{{ <holeIdx++> | T2 | x, X | (x$1: Expr[T1], X$1: Type[X]) => (using Quotes) ?=> {... ${x$1} ...  X$1.Underlying ...}  }}}
+   *  ```
+   */
+  private class SpliceTransformer(spliceOwner: Symbol, isCaptured: Symbol -> Boolean) extends Transformer:
+    private var refBindingMap = mutable.Map.empty[Symbol, (Tree, Symbol)]
+    /** Reference to the `Quotes` instance of the current level 1 splice */
+    private var quotes: Tree | Null = null // TODO: add to the context
+    private var healedTypes: PCPCheckAndHeal.QuoteTypeTags | Null = null // TODO: add to the context
+
+    def transformSplice(tree: tpd.Tree, tpe: Type, holeIdx: Int)(using Context): tpd.Tree =
+      assert(level == 0)
+      val newTree = transform(tree)
+      val (refs, bindings) = refBindingMap.values.toList.unzip
+      val bindingsTypes = bindings.map(_.termRef.widenTermRefExpr)
+      val methType = MethodType(bindingsTypes, newTree.tpe)
+      val meth = newSymbol(spliceOwner, nme.ANON_FUN, Synthetic | Method, methType)
+      val ddef = DefDef(meth, List(bindings), newTree.tpe, newTree.changeOwner(ctx.owner, meth))
+      val fnType = defn.FunctionType(bindings.size, isContextual = false).appliedTo(bindingsTypes :+ newTree.tpe)
+      val closure = Block(ddef :: Nil, Closure(Nil, ref(meth), TypeTree(fnType)))
+      tpd.Hole(true, holeIdx, refs, closure, TypeTree(tpe))
+
+    override def transform(tree: tpd.Tree)(using Context): tpd.Tree =
+      tree match
+        case tree: RefTree =>
+          if tree.isTerm then
+            if isCaptured(tree.symbol) then
+              val tpe = tree.tpe.widenTermRefExpr match {
+                case tpw: MethodicType => tpw.toFunctionType(isJava = false)
+                case tpw => tpw
+              }
+              spliced(tpe)(capturedTerm(tree))
+            else super.transform(tree)
+          else // tree.isType then
+            if containsCapturedType(tree.tpe) then
+              if level >= 1 then getTagRefFor(tree)
+              else
+                // Dealias references to captured types
+                TypeTree(tree.tpe.dealias)
+            else super.transform(tree)
+        case tree: TypeTree =>
+          if containsCapturedType(tree.tpe) && level >= 1 then getTagRefFor(tree)
+          else tree
+        case tree @ Assign(lhs: RefTree, rhs) =>
+          if isCaptured(lhs.symbol) then transformSplicedAssign(tree)
+          else super.transform(tree)
+        case Apply(fn, args) if fn.symbol == defn.QuotedRuntime_exprNestedSplice =>
+          val newArgs = args.mapConserve(arg => transform(arg)(using spliceContext))
+          cpy.Apply(tree)(fn, newArgs)
+        case Apply(sel @ Select(app @ Apply(fn, args),nme.apply), quotesArgs)
+        if fn.symbol == defn.QuotedRuntime_exprQuote =>
+          args match
+            case List(tree: RefTree) if isCaptured(tree.symbol) =>
+              capturedTerm(tree)
+            case _ =>
+              val newArgs = withCurrentQuote(quotesArgs.head) {
+                if level > 1 then args.mapConserve(arg => transform(arg)(using quoteContext))
+                else args.mapConserve(arg => transformLevel0QuoteContent(arg)(using quoteContext))
+              }
+              cpy.Apply(tree)(cpy.Select(sel)(cpy.Apply(app)(fn, newArgs), nme.apply), quotesArgs)
+        case Apply(TypeApply(_, List(tpt)), List(quotes))
+        if tree.symbol == defn.QuotedTypeModule_of && containsCapturedType(tpt.tpe) =>
+          ref(capturedType(tpt))(using ctx.withSource(tree.source)).withSpan(tree.span)
+        case CapturedApplication(fn, argss) =>
+          transformCapturedApplication(tree, fn, argss)
+        case _ =>
+          super.transform(tree)
+
+    private def transformLevel0QuoteContent(tree: Tree)(using Context): Tree =
+      // transform and collect new healed types
+      val old = healedTypes
+      healedTypes = new PCPCheckAndHeal.QuoteTypeTags(tree.span)
+      val tree1 = transform(tree)
+      val newHealedTypes = healedTypes.nn.getTypeTags
+      healedTypes = old
+      // add new healed types to the current, merge with existing healed types if necessary
+      if newHealedTypes.isEmpty then tree1
+      else tree1 match
+        case Block(stats @ (x :: _), expr) if x.symbol.hasAnnotation(defn.QuotedRuntime_SplicedTypeAnnot) =>
+          Block(newHealedTypes ::: stats, expr)
+        case _ =>
+          Block(newHealedTypes, tree1)
+
+    class ArgsClause(val args: List[Tree]):
+      def isTerm: Boolean = args.isEmpty || args.head.isTerm
+
+    private object CapturedApplication {
+
+      /** Matches and application `f(...)` (possibly with several argument clauses) where `f` is captured */
+      def unapply(tree: Tree)(using Context): Option[(RefTree, List[ArgsClause])] = tree match
+        case GenericApply(fn: RefTree, args) if isCaptured(fn.symbol) =>
+          Some((fn, ArgsClause(args) :: Nil))
+        case GenericApply(CapturedApplication(fn, argss), args) =>
+          Some((fn, argss :+ ArgsClause(args)))
+        case _ =>
+          None
+    }
+
+    private def containsCapturedType(tpe: Type)(using Context): Boolean =
+      tpe.existsPart(t => isCaptured(t.typeSymbol) || isCaptured(t.termSymbol), StopAt.Static)
+
+    /** Transform an assignment `x = e` with a captured `x` to
+     * `${ Assign(x$1.asTerm, '{e}.asTerm).asExpr.asInstanceOf[Expr[T]] }`
+     *
+     *  Registers `x` as a captured variable in the hole and creates an `x$1` `Expr` reference to it.
+     */
+    private def transformSplicedAssign(tree: Assign)(using Context): Tree =
+      spliced(tree.tpe) {
+        reflect.asExpr(tree.tpe)(
+          reflect.Assign(
+            reflect.asTerm(capturedTerm(tree.lhs)),
+            reflect.asTerm(quoted(transform(tree.rhs)))
+          )
+        )
+      }
+
+    /** Transform an application `f(a1, a2, ...)` with a captured `f` to
+     * `${ Apply(f$1.asTerm, List('{a1$}.asTerm, '{a2$}.asTerm, ...)).asExpr.asInstanceOf[Expr[T]] }`
+     *
+     *  Registers `f` as a captured variable in the hole and creates an `f$1` `Expr` reference to it.
+     *
+     *  It also handles cases with multiple argument clauses using nested `Apply`/`TypeApply`.
+     */
+    private def transformCapturedApplication(tree: Tree, fn: RefTree, argss: List[ArgsClause])(using Context): Tree =
+      spliced(tree.tpe) {
+        def TermList(args: List[Tree]): List[Tree] =
+          args.map(arg => reflect.asTerm(quoted(transform(arg)(using spliceContext))))
+        def TypeTreeList(args: List[Tree]): List[Tree] =
+          args.map(arg => reflect.Inferred(reflect.TypeReprOf(transform(arg)(using spliceContext).tpe)))
+        reflect.asExpr(tree.tpe) {
+          argss.foldLeft[Tree](reflect.asTerm(capturedTerm(fn, defn.AnyType))) { (acc, clause) =>
+            if clause.isTerm then reflect.Apply(acc, TermList(clause.args))
+            else reflect.TypeApply(acc, TypeTreeList(clause.args))
+          }
+        }
+      }
+
+    private def capturedTerm(tree: Tree)(using Context): Tree =
+      val tpe = tree.tpe.widenTermRefExpr match
+        case tpw: MethodicType => tpw.toFunctionType(isJava = false)
+        case tpw => tpw
+      capturedTerm(tree, tpe)
+
+    private def capturedTerm(tree: Tree, tpe: Type)(using Context): Tree =
+      def newBinding = newSymbol(
+        spliceOwner,
+        UniqueName.fresh(tree.symbol.name.toTermName).toTermName,
+        Param,
+        defn.QuotedExprClass.typeRef.appliedTo(tpe),
+      )
+      val bindingSym = refBindingMap.getOrElseUpdate(tree.symbol, (tree, newBinding))._2
+      ref(bindingSym)
+
+    private def capturedType(tree: Tree)(using Context): Symbol =
+      val tpe = tree.tpe.widenTermRefExpr
+      def newBinding = newSymbol(
+        spliceOwner,
+        UniqueName.fresh(nme.Type).toTermName,
+        Param,
+        defn.QuotedTypeClass.typeRef.appliedTo(tpe),
+      )
+      val bindingSym = refBindingMap.getOrElseUpdate(tree.symbol, (TypeTree(tree.tpe), newBinding))._2
+      bindingSym
+
+    private def getTagRefFor(tree: Tree)(using Context): Tree =
+      val capturedTypeSym = capturedType(tree)
+      TypeTree(healedTypes.nn.getTagRef(capturedTypeSym.termRef))
+
+    private def withCurrentQuote[T](newQuotes: Tree)(body: => T)(using Context): T =
+      if level == 0 then
+        val savedQuotes = quotes
+        quotes = newQuotes
+        try body
+        finally quotes = savedQuotes
+      else body
+
+    private def spliced(tpe: Type)(body: Context ?=> Tree)(using Context): Tree =
+      val exprTpe = defn.QuotedExprClass.typeRef.appliedTo(tpe)
+      val closure =
+        val methTpe = ContextualMethodType(List(defn.QuotesClass.typeRef), exprTpe)
+        val meth = newSymbol(ctx.owner, nme.ANON_FUN, Synthetic | Method, methTpe)
+        Closure(meth, argss => {
+          withCurrentQuote(argss.head.head) {
+            body(using ctx.withOwner(meth)).changeOwner(ctx.owner, meth)
+          }
+        })
+      ref(defn.QuotedRuntime_exprNestedSplice)
+        .appliedToType(tpe)
+        .appliedTo(Literal(Constant(null))) // Dropped when creating the Hole that contains it
+        .appliedTo(closure)
+
+    private def quoted(expr: Tree)(using Context): Tree =
+      val tpe = expr.tpe.widenTermRefExpr
+      ref(defn.QuotedRuntime_exprQuote)
+        .appliedToType(tpe)
+        .appliedTo(expr)
+        .select(nme.apply)
+        .appliedTo(quotes.nn)
+
+    /** Helper methods to construct trees calling methods in `Quotes.reflect` based on the current `quotes` tree */
+    private object reflect extends ReifiedReflect {
+      def quotesTree = quotes.nn
+    }
+
+  end SpliceTransformer
+
+end Splicing
diff --git a/tests/pos-with-compiler-cc/dotc/transform/Staging.scala b/tests/pos-with-compiler-cc/dotc/transform/Staging.scala
new file mode 100644
index 000000000000..1de050a9a6c1
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/transform/Staging.scala
@@ -0,0 +1,81 @@
+package dotty.tools.dotc
+package transform
+
+import dotty.tools.dotc.ast.tpd
+import dotty.tools.dotc.core.Contexts._
+import dotty.tools.dotc.core.Phases._
+import dotty.tools.dotc.core.Decorators._
+import dotty.tools.dotc.core.Flags._
+import dotty.tools.dotc.core.StagingContext._
+import dotty.tools.dotc.core.Symbols._
+import dotty.tools.dotc.core.Types._
+import dotty.tools.dotc.util.SrcPos
+import dotty.tools.dotc.transform.SymUtils._
+import dotty.tools.dotc.transform.TreeMapWithStages._
+
+
+
+/** Checks that the Phase Consistency Principle (PCP) holds and heals types.
+ *
+ *  Type healing consists in transforming a phase inconsistent type `T` into `${ implicitly[Type[T]] }`.
+ */
+class Staging extends MacroTransform {
+  import tpd._
+
+  override def phaseName: String = Staging.name
+
+  override def description: String = Staging.description
+
+  override def runsAfter: Set[String] = Set(Inlining.name)
+
+  override def allowsImplicitSearch: Boolean = true
+
+  override def checkPostCondition(tree: Tree)(using Context): Unit =
+    if (ctx.phase <= splicingPhase) {
+      // Recheck that PCP holds but do not heal any inconsistent types as they should already have been heald
+      tree match {
+        case PackageDef(pid, _) if tree.symbol.owner == defn.RootClass =>
+          val checker = new PCPCheckAndHeal(freshStagingContext) {
+            override protected def tryHeal(sym: Symbol, tp: TypeRef, pos: SrcPos)(using Context): TypeRef = {
+              def symStr =
+                if (sym.is(ModuleClass)) sym.sourceModule.show
+                else i"${sym.name}.this"
+              val errMsg = s"\nin ${ctx.owner.fullName}"
+              assert(
+                ctx.owner.hasAnnotation(defn.QuotedRuntime_SplicedTypeAnnot) ||
+                (sym.isType && levelOf(sym) > 0),
+                em"""access to $symStr from wrong staging level:
+                    | - the definition is at level ${levelOf(sym)},
+                    | - but the access is at level $level.$errMsg""")
+
+              tp
+            }
+          }
+          checker.transform(tree)
+        case _ =>
+      }
+
+      tree.tpe match {
+        case tpe @ TypeRef(prefix, _) if tpe.typeSymbol.isTypeSplice =>
+          // Type splices must have a know term ref, usually to an implicit argument
+          // This is mostly intended to catch `quoted.Type[T]#splice` types which should just be `T`
+          assert(prefix.isInstanceOf[TermRef] || prefix.isInstanceOf[ThisType], prefix)
+        case _ =>
+          // OK
+      }
+    }
+
+  override def run(using Context): Unit =
+    if (ctx.compilationUnit.needsStaging) super.run(using freshStagingContext)
+
+  protected def newTransformer(using Context): Transformer = new Transformer {
+    override def transform(tree: tpd.Tree)(using Context): tpd.Tree =
+      new PCPCheckAndHeal(ctx).transform(tree)
+  }
+}
+
+
+object Staging {
+  val name: String = "staging"
+  val description: String = "check staging levels and heal staged types"
+}
diff --git a/tests/pos-with-compiler-cc/dotc/transform/SuperAccessors.scala b/tests/pos-with-compiler-cc/dotc/transform/SuperAccessors.scala
new file mode 100644
index 000000000000..b0c8605e7dd1
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/transform/SuperAccessors.scala
@@ -0,0 +1,224 @@
+package dotty.tools
+package dotc
+package transform
+
+import dotty.tools.dotc.ast.{Trees, tpd}
+import scala.collection.mutable
+import ValueClasses.isMethodWithExtension
+import core._
+import Contexts._, Flags._, Symbols._, Names._, StdNames._, NameOps._, Trees._
+import TypeUtils._, SymUtils._
+import DenotTransformers.DenotTransformer
+import Symbols._
+import util.Spans._
+import Decorators._
+import NameKinds.{ SuperAccessorName, ExpandPrefixName }
+
+/** This class adds super accessors for all super calls that either
+ *  appear in a trait or have as a target a member of some outer class.
+ *
+ *  It also checks that:
+ *
+ *  (1) Symbols accessed from super are not abstract, or are overridden by
+ *  an abstract override.
+ *
+ *  (2) If a symbol accessed from super is defined in a real class (not a trait),
+ *  there are no abstract members which override this member in Java's rules
+ *  (see SI-4989; such an access would lead to illegal bytecode)
+ *
+ *  (3) Super calls do not go to some synthetic members of Any (see isDisallowed)
+ *
+ *  (4) Super calls do not go to synthetic field accessors
+ */
+class SuperAccessors(thisPhase: DenotTransformer) {
+
+  import tpd._
+
+  /** Some parts of trees will get a new owner in subsequent phases.
+    *  These are value class methods, which will become extension methods.
+    *  (By-name arguments used to be included also, but these
+    *  don't get a new class anymore, they are just wrapped in a new method).
+    *
+    *  These regions will have to be treated specially for the purpose
+    *  of adding accessors. For instance, super calls from these regions
+    *  always have to go through an accessor.
+    *
+    *  The `invalidEnclClass` field, if different from NoSymbol,
+    *  contains the symbol that is not a valid owner.
+    */
+  private var invalidEnclClass: Symbol = NoSymbol
+
+  def withInvalidCurrentClass[A](trans: => A)(using Context): A = {
+    val saved = invalidEnclClass
+    invalidEnclClass = ctx.owner.enclosingClass
+    try trans
+    finally invalidEnclClass = saved
+  }
+
+  private def validCurrentClass(using Context): Boolean =
+    ctx.owner.enclosingClass != invalidEnclClass
+
+  /** List buffers for new accessor definitions, indexed by class */
+  private val accDefs = MutableSymbolMap[mutable.ListBuffer[Tree]]()
+
+  /** A super accessor call corresponding to `sel` */
+  private def superAccessorCall(sel: Select, mixName: Name = nme.EMPTY)(using Context) = {
+    val Select(qual, name) = sel
+    val sym = sel.symbol
+    val clazz = qual.symbol.asClass
+
+    def superAccessorName(original: Name) =
+      val unexpanded = SuperAccessorName(
+        if mixName.isEmpty then original.toTermName
+        else ExpandPrefixName(original.toTermName, mixName.toTermName))
+      if clazz.is(Trait) then unexpanded.expandedName(clazz) else unexpanded
+
+    val superName = superAccessorName(name)
+    val superInfo = sel.tpe.widenSingleton.ensureMethodic
+    val accRange = sel.span.focus
+    val superAcc = clazz.info.decl(superName)
+      .suchThat(_.signature == superInfo.signature).symbol
+      .orElse {
+        report.debuglog(s"add super acc ${sym.showLocated} to $clazz")
+        val maybeDeferred = if (clazz.is(Trait)) Deferred else EmptyFlags
+        val acc = newSymbol(
+            clazz, superName, Artifact | Method | maybeDeferred,
+            superInfo, coord = accRange).enteredAfter(thisPhase)
+        acc.deriveTargetNameAnnotation(sym, superAccessorName)
+        // Diagnostic for SI-7091
+        if (!accDefs.contains(clazz))
+          report.error(
+            s"Internal error: unable to store accessor definition in ${clazz}. clazz.hasPackageFlag=${clazz.is(Package)}. Accessor required for ${sel} (${sel.show})",
+            sel.srcPos)
+        else accDefs(clazz) += DefDef(acc, EmptyTree).withSpan(accRange)
+        acc
+    }
+
+    This(clazz).select(superAcc).withSpan(sel.span)
+  }
+
+  /** Check selection `super.f` for conforming to rules. If necessary,
+    *  replace by a super accessor call.
+    */
+  private def transformSuperSelect(sel: Select)(using Context): Tree = {
+    val Select(sup @ Super(_, mix), name) = sel: @unchecked
+    val sym   = sel.symbol
+    assert(sup.symbol.exists, s"missing symbol in $sel: ${sup.tpe}")
+    val clazz = sup.symbol
+    val currentClass = ctx.owner.enclosingClass
+
+    if (sym.isTerm && !sym.is(Method, butNot = Accessor) && !ctx.owner.isAllOf(ParamForwarder))
+      // ParamForwaders as installed ParamForwarding.scala do use super calls to vals
+      report.error(s"super may be not be used on ${sym.underlyingSymbol}", sel.srcPos)
+    else if (isDisallowed(sym))
+      report.error(s"super not allowed here: use this.${sel.name} instead", sel.srcPos)
+    else if (sym.is(Deferred)) {
+      val member = sym.overridingSymbol(clazz.asClass)
+      if (!mix.name.isEmpty ||
+          !member.exists ||
+          !(member.is(AbsOverride) && member.isIncompleteIn(clazz)))
+        report.error(
+            i"${sym.showLocated} is accessed from super. It may not be abstract unless it is overridden by a member declared `abstract' and `override'",
+            sel.srcPos)
+      else report.log(i"ok super $sel ${sym.showLocated} $member $clazz ${member.isIncompleteIn(clazz)}")
+    }
+    else {
+      val owner = sym.owner
+      if (!owner.is(Trait))
+        if (mix.name.isEmpty)
+          // scala/bug#4989 Check if an intermediate class between `clazz` and `sym.owner` redeclares the method as abstract.
+          for (intermediateClass <- clazz.info.baseClasses.tail.takeWhile(_ != sym.owner)) {
+            val overriding = sym.overridingSymbol(intermediateClass)
+            if (overriding.is(Deferred, butNot = AbsOverride) && !overriding.owner.is(Trait))
+              report.error(
+                s"${sym.showLocated} cannot be directly accessed from ${clazz} because ${overriding.owner} redeclares it as abstract",
+                sel.srcPos)
+          }
+        else {
+          // scala/scala-dev#143:
+          //   a call `super[T].m` that resolves to `A.m` cannot be translated to correct bytecode if
+          //   `A` is a class (not a trait / interface), but not the direct superclass. Invokespecial
+          //   would select an overriding method in the direct superclass, rather than `A.m`.
+          //   We allow this if there are statically no intervening overrides.
+          def hasClassOverride(member: Symbol, subCls: ClassSymbol): Boolean =
+            if (subCls == defn.ObjectClass || subCls == member.owner) false
+            else if (member.overridingSymbol(subCls).exists) true
+            else hasClassOverride(member, subCls.superClass.asClass)
+          val superCls = clazz.asClass.superClass.asClass
+          if (owner != superCls && hasClassOverride(sym, superCls))
+            report.error(
+              em"""Super call cannot be emitted: the selected $sym is declared in $owner, which is not the direct superclass of $clazz.
+              |An unqualified super call (super.${sym.name}) would be allowed.""",
+              sel.srcPos)
+        }
+    }
+
+    val needAccessor = name.isTermName && (
+      clazz != currentClass || !validCurrentClass || mix.name.isEmpty && clazz.is(Trait))
+
+    if (needAccessor) atPhase(thisPhase.next)(superAccessorCall(sel, mix.name))
+    else sel
+  }
+
+  /** Disallow some super.XX calls targeting Any methods which would
+    *  otherwise lead to either a compiler crash or runtime failure.
+    */
+  private def isDisallowed(sym: Symbol)(using Context) =
+    sym.isTypeTestOrCast ||
+    (sym eq defn.Any_==) ||
+    (sym eq defn.Any_!=) ||
+    (sym eq defn.Any_##)
+
+  /** Transform select node, adding super and protected accessors as needed */
+  def transformSelect(tree: Tree, targs: List[Tree])(using Context): Tree = {
+    val sel @ Select(qual, name) = tree: @unchecked
+    val sym = sel.symbol
+
+    /** If an accesses to protected member of a class comes from a trait,
+      *  or would need a protected accessor placed in a trait, we cannot
+      *  perform the access to the protected member directly since jvm access
+      *  restrictions require the call site to be in an actual subclass and
+      *  traits don't count as subclasses in this respect. In this case
+      *  we generate a super accessor instead. See SI-2296.
+      */
+    def needsSuperAccessor =
+      ProtectedAccessors.needsAccessorIfNotInSubclass(sym) &&
+      AccessProxies.hostForAccessorOf(sym).is(Trait)
+    qual match {
+      case _: This if needsSuperAccessor =>
+        /*
+          * A trait which extends a class and accesses a protected member
+          *  of that class cannot implement the necessary accessor method
+          *  because jvm access restrictions require the call site to be in
+          *  an actual subclass and traits don't count as subclasses in this
+          *  respect. We generate a super accessor itself, which will be fixed
+          *  by the implementing class.  See SI-2296.
+          */
+        superAccessorCall(sel)
+      case Super(_, mix) =>
+        transformSuperSelect(sel)
+      case _ =>
+        sel
+    }
+  }
+
+  /** Wrap template to template transform `op` with needed initialization and finalization */
+  def wrapTemplate(tree: Template)(op: Template => Template)(using Context): Template = {
+    accDefs(currentClass) = new mutable.ListBuffer[Tree]
+    val impl = op(tree)
+    val accessors = accDefs.remove(currentClass).nn
+    if (accessors.isEmpty) impl
+    else {
+      val (params, rest) = impl.body span {
+        case td: TypeDef => !td.isClassDef
+        case vd: ValOrDefDef => vd.symbol.flags.is(ParamAccessor)
+        case _ => false
+      }
+      cpy.Template(impl)(body = params ++ accessors ++ rest)
+    }
+  }
+
+  /** Wrap `DefDef` producing operation `op`, potentially setting `invalidClass` info */
+  def wrapDefDef(ddef: DefDef)(op: => DefDef)(using Context): DefDef =
+    if (isMethodWithExtension(ddef.symbol)) withInvalidCurrentClass(op) else op
+}
diff --git a/tests/pos-with-compiler-cc/dotc/transform/SymUtils.scala b/tests/pos-with-compiler-cc/dotc/transform/SymUtils.scala
new file mode 100644
index 000000000000..6010fe2a2a44
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/transform/SymUtils.scala
@@ -0,0 +1,434 @@
+package dotty.tools.dotc
+package transform
+
+import core._
+import Types._
+import Contexts._
+import Symbols._
+import SymDenotations._
+import Names._
+import NameOps._
+import StdNames._
+import NameKinds._
+import Flags._
+import ValueClasses.isDerivedValueClass
+import Decorators._
+import Constants.Constant
+import Annotations.Annotation
+import Phases._
+import ast.tpd.Literal
+
+import scala.annotation.tailrec
+
+object SymUtils:
+
+  extension (self: Symbol)
+
+    /** All traits implemented by a class or trait except for those inherited
+    *  through the superclass. Traits are given in the order they appear in the
+    *  parents clause (which is the reverse of their order in baseClasses)
+    */
+    def directlyInheritedTraits(using Context): List[ClassSymbol] = {
+      val superCls = self.asClass.superClass
+      val baseClasses = self.asClass.baseClasses
+      if (baseClasses.isEmpty) Nil
+      else
+        def recur(bcs: List[ClassSymbol], acc: List[ClassSymbol]): List[ClassSymbol] = bcs match
+          case bc :: bcs1 => if bc eq superCls then acc else recur(bcs1, bc :: acc)
+          case nil => acc
+        recur(baseClasses.tail, Nil)
+    }
+
+    /** All traits implemented by a class, except for those inherited through the superclass.
+    *  The empty list if `self` is a trait.
+    */
+    def mixins(using Context): List[ClassSymbol] =
+      if (self.is(Trait)) Nil
+      else directlyInheritedTraits
+
+    def isTypeTest(using Context): Boolean =
+      self == defn.Any_isInstanceOf || self == defn.Any_typeTest
+
+    def isTypeCast(using Context): Boolean =
+      self == defn.Any_asInstanceOf || self == defn.Any_typeCast
+
+    def isTypeTestOrCast(using Context): Boolean =
+      isTypeCast || isTypeTest
+
+    def isThreadUnsafe(using Context): Boolean = self.hasAnnotation(defn.ThreadUnsafeAnnot)
+
+    def isVolatile(using Context): Boolean = self.hasAnnotation(defn.VolatileAnnot)
+
+    def isAnyOverride(using Context): Boolean = self.is(Override) || self.is(AbsOverride)
+      // careful: AbsOverride is a term only flag. combining with Override would catch only terms.
+
+    def isSuperAccessor(using Context): Boolean = self.name.is(SuperAccessorName)
+
+    def isNoValue(using Context): Boolean = self.is(Package) || self.isAllOf(JavaModule)
+
+    def isUniversalTrait(using Context): Boolean =
+      self.is(Trait) && self.asClass.parentSyms.head == defn.AnyClass
+
+    /** Is this a type or term parameter or a term parameter accessor? */
+    def isParamOrAccessor(using Context): Boolean =
+      self.is(Param) || self.is(ParamAccessor)
+
+    def derivesFromJavaEnum(using Context) =
+      self.is(Enum, butNot = Case) &&
+      self.info.parents.exists(p => p.typeSymbol == defn.JavaEnumClass)
+
+    /** Is this a case class for which a product mirror is generated?
+    *  Excluded are value classes, abstract classes and case classes with more than one
+    *  parameter section.
+    */
+    def whyNotGenericProduct(using Context): String =
+      /** for a case class, if it will have an anonymous mirror,
+       *  check that its constructor can be accessed
+       *  from the calling scope.
+       */
+      def canAccessCtor: Boolean =
+        def isAccessible(sym: Symbol): Boolean = ctx.owner.isContainedIn(sym)
+        def isSub(sym: Symbol): Boolean = ctx.owner.ownersIterator.exists(_.derivesFrom(sym))
+        val ctor = self.primaryConstructor
+        (!ctor.isOneOf(Private | Protected) || isSub(self)) // we cant access the ctor because we do not extend cls
+        && (!ctor.privateWithin.exists || isAccessible(ctor.privateWithin)) // check scope is compatible
+
+
+      def companionMirror = self.useCompanionAsProductMirror
+      if (!self.is(CaseClass)) "it is not a case class"
+      else if (self.is(Abstract)) "it is an abstract class"
+      else if (self.primaryConstructor.info.paramInfoss.length != 1) "it takes more than one parameter list"
+      else if (isDerivedValueClass(self)) "it is a value class"
+      else if (!(companionMirror || canAccessCtor)) s"the constructor of $self is innaccessible from the calling scope."
+      else ""
+    end whyNotGenericProduct
+
+    def isGenericProduct(using Context): Boolean = whyNotGenericProduct.isEmpty
+
+    /** Is this an old style implicit conversion?
+     *  @param directOnly            only consider explicitly written methods
+     *  @param forImplicitClassOnly  only consider methods generated from implicit classes
+     */
+    def isOldStyleImplicitConversion(directOnly: Boolean = false, forImplicitClassOnly: Boolean = false)(using Context): Boolean =
+      self.is(Implicit) && self.info.stripPoly.match
+        case mt @ MethodType(_ :: Nil) if !mt.isImplicitMethod =>
+          if self.isCoDefinedGiven(mt.finalResultType.typeSymbol)
+          then !directOnly
+          else !forImplicitClassOnly
+        case _ =>
+          false
+
+    /** Is this the method that summons a structural given instance? */
+    def isGivenInstanceSummoner(using Context): Boolean =
+      def isCodefined(info: Type): Boolean = info.stripPoly match
+        case mt: MethodType =>
+          // given summoner can only have contextual params
+          mt.isImplicitMethod && isCodefined(mt.resultType)
+        case mt: ExprType =>
+          isCodefined(mt.resultType)
+        case res =>
+          self.isCoDefinedGiven(res.typeSymbol)
+      self.isAllOf(GivenMethod) && isCodefined(self.info)
+
+    // TODO Scala 3.x: only check for inline vals (no final ones)
+    def isInlineVal(using Context) =
+      self.isOneOf(FinalOrInline, butNot = Mutable)
+      && (!self.is(Method) || self.is(Accessor))
+
+    def useCompanionAsProductMirror(using Context): Boolean =
+      self.linkedClass.exists && !self.is(Scala2x) && !self.linkedClass.is(Case)
+
+    def useCompanionAsSumMirror(using Context): Boolean =
+      def companionExtendsSum(using Context): Boolean =
+        self.linkedClass.isSubClass(defn.Mirror_SumClass)
+      !self.is(Scala2x)
+        && self.linkedClass.exists
+        && !self.linkedClass.is(Case)
+        && (
+          // If the sum type is compiled from source, and `self` is a "generic sum"
+          // then its companion object will become a sum mirror in `posttyper`. (This method
+          // can be called from `typer` when summoning a Mirror.)
+          // However if `self` is from a binary file, then we should check that its companion
+          // subclasses `Mirror.Sum`. e.g. before Scala 3.1, hierarchical sum types were not
+          // considered "generic sums", so their companion would not cache the mirror.
+          // Companions from TASTy will already be typed as `Mirror.Sum`.
+          self.isDefinedInSource || companionExtendsSum
+        )
+
+    /** Is this a sealed class or trait for which a sum mirror is generated?
+    *  It must satisfy the following conditions:
+    *   - it has at least one child class or object
+    *   - none of its children are anonymous classes
+    *   - all of its children are addressable through a path from the parent class
+    *     and also the location of the generated mirror.
+    *   - all of its children are generic products, singletons, or generic sums themselves.
+    */
+    def whyNotGenericSum(pre: Type)(using Context): String =
+      if (!self.is(Sealed))
+        s"it is not a sealed ${self.kindString}"
+      else if (!self.isOneOf(AbstractOrTrait))
+        "it is not an abstract class"
+      else {
+        val children = self.children
+        val companionMirror = self.useCompanionAsSumMirror
+        val ownerScope = if pre.isInstanceOf[SingletonType] then pre.classSymbol else NoSymbol
+        def problem(child: Symbol) = {
+
+          def accessibleMessage(sym: Symbol): String =
+            def inherits(sym: Symbol, scope: Symbol): Boolean =
+              !scope.is(Package) && (scope.derivesFrom(sym) || inherits(sym, scope.owner))
+            def isVisibleToParent(sym: Symbol): Boolean =
+              self.isContainedIn(sym) || sym.is(Module) && isVisibleToParent(sym.owner)
+            def isVisibleToScope(sym: Symbol): Boolean =
+              def isReachable: Boolean = ctx.owner.isContainedIn(sym)
+              def isMemberOfPrefix: Boolean =
+                ownerScope.exists && inherits(sym, ownerScope)
+              isReachable || isMemberOfPrefix || sym.is(Module) && isVisibleToScope(sym.owner)
+            if !isVisibleToParent(sym) then i"to its parent $self"
+            else if !companionMirror && !isVisibleToScope(sym) then i"to call site ${ctx.owner}"
+            else ""
+          end accessibleMessage
+
+          val childAccessible = accessibleMessage(child.owner)
+
+          if (child == self) "it has anonymous or inaccessible subclasses"
+          else if (!childAccessible.isEmpty) i"its child $child is not accessible $childAccessible"
+          else if (!child.isClass) "" // its a singleton enum value
+          else {
+            val s = child.whyNotGenericProduct
+            if s.isEmpty then s
+            else if child.is(Sealed) then
+              val s = child.whyNotGenericSum(pre)
+              if s.isEmpty then s
+              else i"its child $child is not a generic sum because $s"
+            else
+              i"its child $child is not a generic product because $s"
+          }
+        }
+        if (children.isEmpty) "it does not have subclasses"
+        else children.map(problem).find(!_.isEmpty).getOrElse("")
+      }
+
+    def isGenericSum(pre: Type)(using Context): Boolean = whyNotGenericSum(pre).isEmpty
+
+    /** If this is a constructor, its owner: otherwise this. */
+    final def skipConstructor(using Context): Symbol =
+      if (self.isConstructor) self.owner else self
+
+    /** The closest properly enclosing method or class of this symbol. */
+    final def enclosure(using Context): Symbol =
+      self.owner.enclosingMethodOrClass
+
+    /** The closest enclosing method or class of this symbol */
+    @tailrec final def enclosingMethodOrClass(using Context): Symbol =
+      if (self.is(Method) || self.isClass) self
+      else if (self.exists) self.owner.enclosingMethodOrClass
+      else NoSymbol
+
+    /** Apply symbol/symbol substitution to this symbol */
+    def subst(from: List[Symbol], to: List[Symbol]): Symbol = {
+      @tailrec def loop(from: List[Symbol], to: List[Symbol]): Symbol =
+        if (from.isEmpty) self
+        else if (self eq from.head) to.head
+        else loop(from.tail, to.tail)
+      loop(from, to)
+    }
+
+    def accessorNamed(name: TermName)(using Context): Symbol =
+      self.owner.info.decl(name).suchThat(_.is(Accessor)).symbol
+
+    def caseAccessors(using Context): List[Symbol] =
+      self.info.decls.filter(_.is(CaseAccessor))
+
+    def getter(using Context): Symbol =
+      if (self.isGetter) self else accessorNamed(self.asTerm.name.getterName)
+
+    def setter(using Context): Symbol =
+      if (self.isSetter) self
+      else accessorNamed(self.asTerm.name.setterName)
+
+    def traitSetter(using Context): Symbol =
+      if (self.name.is(TraitSetterName)) self
+      else accessorNamed(Mixin.traitSetterName(self.asTerm))
+
+    def field(using Context): Symbol = {
+      val thisName = self.name.asTermName
+      val fieldName =
+        if (self.hasAnnotation(defn.ScalaStaticAnnot)) thisName.getterName
+        else thisName.fieldName
+      self.owner.info.decl(fieldName).suchThat(!_.is(Method)).symbol
+    }
+
+    def isConstExprFinalVal(using Context): Boolean =
+      atPhaseNoLater(erasurePhase) {
+        self.is(Final) && self.info.resultType.isInstanceOf[ConstantType]
+      }
+
+    def isField(using Context): Boolean =
+      self.isTerm && !self.is(Method)
+
+    def isEnumCase(using Context): Boolean =
+      self.isAllOf(EnumCase, butNot = JavaDefined)
+
+    def annotationsCarrying(meta: ClassSymbol)(using Context): List[Annotation] =
+      self.annotations.filter(_.symbol.hasAnnotation(meta))
+
+    def withAnnotationsCarrying(from: Symbol, meta: ClassSymbol)(using Context): self.type = {
+      self.addAnnotations(from.annotationsCarrying(meta))
+      self
+    }
+
+    def isEnum(using Context): Boolean = self.is(Enum, butNot = JavaDefined)
+    def isEnumClass(using Context): Boolean = isEnum && !self.is(Case)
+
+    /** Does this symbol refer to anonymous classes synthesized by enum desugaring? */
+    def isEnumAnonymClass(using Context): Boolean =
+      self.isAnonymousClass && (self.owner.name.eq(nme.DOLLAR_NEW) || self.owner.is(CaseVal))
+
+    /** Is this symbol defined locally (i.e. at some level owned by a term) so that
+    *  it cannot be seen from parent class `cls`?
+    */
+    def isInaccessibleChildOf(cls: Symbol)(using Context): Boolean =
+      def isAccessible(sym: Symbol, cls: Symbol): Boolean =
+        if cls.isType && !cls.is(Package) then
+          isAccessible(sym, cls.owner)
+        else
+          sym == cls
+          || sym.is(Package)
+          || sym.isType && isAccessible(sym.owner, cls)
+      !isAccessible(self.owner, cls)
+
+    def hasAnonymousChild(using Context): Boolean =
+      self.children.exists(_ `eq` self)
+
+    /** Is this symbol directly owner by a term symbol, i.e., is it local to a block? */
+    def isLocalToBlock(using Context): Boolean =
+      self.owner.isTerm
+
+    /** Is symbol directly or indirectly owned by a term symbol? */
+    @tailrec final def isLocal(using Context): Boolean = {
+      val owner = self.maybeOwner
+      if (!owner.exists) false
+      else if (isLocalToBlock) true
+      else if (owner.is(Package)) false
+      else owner.isLocal
+    }
+
+    /** The reachable typeRef with wildcard arguments for each type parameter */
+    def reachableRawTypeRef(using Context) =
+      self.reachableTypeRef.appliedTo(self.typeParams.map(_ => TypeBounds.emptyPolyKind))
+
+    /** Is symbol a quote operation? */
+    def isQuote(using Context): Boolean =
+      self == defn.QuotedRuntime_exprQuote || self == defn.QuotedTypeModule_of
+
+    /** Is symbol a term splice operation? */
+    def isExprSplice(using Context): Boolean =
+      self == defn.QuotedRuntime_exprSplice || self == defn.QuotedRuntime_exprNestedSplice
+
+    /** Is symbol a type splice operation? */
+    def isTypeSplice(using Context): Boolean =
+      self == defn.QuotedType_splice
+
+    def isScalaStatic(using Context): Boolean =
+      self.hasAnnotation(defn.ScalaStaticAnnot)
+
+    def isDeprecated(using Context): Boolean =
+      self.hasAnnotation(defn.DeprecatedAnnot)
+
+    /** Is symbol assumed or declared as an infix symbol? */
+    def isDeclaredInfix(using Context): Boolean =
+      self.is(Infix)
+      || defn.isInfix(self)
+      || self.name.isUnapplyName
+        && self.owner.is(Module)
+        && self.owner.linkedClass.is(Case)
+        && self.owner.linkedClass.isDeclaredInfix
+
+    /** Is symbol declared or inherits @experimental? */
+    def isExperimental(using Context): Boolean =
+      self.hasAnnotation(defn.ExperimentalAnnot)
+      || (self.maybeOwner.isClass && self.owner.hasAnnotation(defn.ExperimentalAnnot))
+
+    def isInExperimentalScope(using Context): Boolean =
+      def isDefaultArgumentOfExperimentalMethod =
+        self.name.is(DefaultGetterName)
+        && self.owner.isClass
+        && {
+          val overloads = self.owner.asClass.membersNamed(self.name.firstPart)
+          overloads.filterWithFlags(HasDefaultParams, EmptyFlags) match
+            case denot: SymDenotation => denot.symbol.isExperimental
+            case _ => false
+        }
+      self.hasAnnotation(defn.ExperimentalAnnot)
+      || isDefaultArgumentOfExperimentalMethod
+      || (!self.is(Package) && self.owner.isInExperimentalScope)
+      || self.topLevelClass.ownersIterator.exists(p =>
+          p.is(Package) && p.owner.isRoot && p.name == tpnme.dotty)
+
+    /** The declared self type of this class, as seen from `site`, stripping
+    *  all refinements for opaque types.
+    */
+    def declaredSelfTypeAsSeenFrom(site: Type)(using Context): Type =
+      extension (tp: Type) def stripOpaques: Type = tp match
+        case RefinedType(parent, name, _) if self.info.decl(name).symbol.isOpaqueAlias =>
+          parent.stripOpaques
+        case _ =>
+          tp
+      self.asClass.givenSelfType.stripOpaques.asSeenFrom(site, self)
+
+    /** If `original` has a target name annotation, add one to this symbol as well
+    *  such that the new target name is `original`'s target name transformed by `nameFn`.
+    */
+    def deriveTargetNameAnnotation(original: Symbol, nameFn: Name => Name)(using Context): Unit =
+      if original.hasAnnotation(defn.TargetNameAnnot) then
+        self.addAnnotation(
+          Annotation(defn.TargetNameAnnot,
+            Literal(Constant(nameFn(original.targetName).toString)).withSpan(original.span)))
+
+    /** The return type as seen from the body of this definition. It is
+     *  computed from the symbol's type by replacing param refs by param symbols.
+     */
+    def localReturnType(using Context): Type =
+      if self.isConstructor then defn.UnitType
+      else
+        def instantiateRT(info: Type, psymss: List[List[Symbol]]): Type = info match
+          case info: PolyType =>
+            instantiateRT(info.instantiate(psymss.head.map(_.typeRef)), psymss.tail)
+          case info: MethodType =>
+            instantiateRT(info.instantiate(psymss.head.map(_.termRef)), psymss.tail)
+          case info =>
+            info.widenExpr
+        instantiateRT(self.info, self.paramSymss)
+
+    /** The expected type of a return to `self` at the place indicated by the context.
+     *  This is the local return type instantiated by the symbols of any context function
+     *  closures that enclose the site of the return
+     */
+    def returnProto(using Context): Type =
+
+      /** If `pt` is a context function type, its return type. If the CFT
+       * is dependent, instantiate with the parameters of the associated
+       * anonymous function.
+       * @param  paramss  the parameters of the anonymous functions
+       *                  enclosing the return expression
+       */
+      def instantiateCFT(pt: Type, paramss: => List[List[Symbol]]): Type =
+        val ift = defn.asContextFunctionType(pt)
+        if ift.exists then
+          ift.nonPrivateMember(nme.apply).info match
+            case appType: MethodType =>
+              instantiateCFT(appType.instantiate(paramss.head.map(_.termRef)), paramss.tail)
+        else pt
+
+      def iftParamss = ctx.owner.ownersIterator
+          .filter(_.is(Method, butNot = Accessor))
+          .takeWhile(_.isAnonymousFunction)
+          .toList
+          .reverse
+          .map(_.paramSymss.head)
+
+      instantiateCFT(self.localReturnType, iftParamss)
+    end returnProto
+  end extension
+end SymUtils
diff --git a/tests/pos-with-compiler-cc/dotc/transform/SyntheticMembers.scala b/tests/pos-with-compiler-cc/dotc/transform/SyntheticMembers.scala
new file mode 100644
index 000000000000..0a9a7a83948c
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/transform/SyntheticMembers.scala
@@ -0,0 +1,651 @@
+package dotty.tools.dotc
+package transform
+
+import core._
+import Symbols._, Types._, Contexts._, Names._, StdNames._, Constants._, SymUtils._
+import Flags._
+import DenotTransformers._
+import Decorators._
+import NameOps._
+import Annotations.Annotation
+import typer.ProtoTypes.constrained
+import ast.untpd
+import ValueClasses.isDerivedValueClass
+import SymUtils._
+import util.Property
+import config.Printers.derive
+import NullOpsDecorator._
+
+object SyntheticMembers {
+
+  enum MirrorImpl:
+    case OfProduct(pre: Type)
+    case OfSum(childPres: List[Type])
+
+  /** Attachment marking an anonymous class as a singleton case that will extend from Mirror.Singleton */
+  val ExtendsSingletonMirror: Property.StickyKey[Unit] = new Property.StickyKey
+
+  /** Attachment recording that an anonymous class should extend Mirror.Product */
+  val ExtendsSumOrProductMirror: Property.StickyKey[MirrorImpl] = new Property.StickyKey
+}
+
+/** Synthetic method implementations for case classes, case objects,
+ *  and value classes.
+ *
+ *  Selectively added to case classes/objects, unless a non-default
+ *  implementation already exists:
+ *    def equals(other: Any): Boolean
+ *    def hashCode(): Int
+ *    def canEqual(other: Any): Boolean
+ *    def toString(): String
+ *    def productElement(i: Int): Any
+ *    def productArity: Int
+ *    def productPrefix: String
+ *
+ *  Add to serializable static objects, unless an implementation
+ *  already exists:
+ *    private def writeReplace(): AnyRef
+ *
+ *  Selectively added to value classes, unless a non-default
+ *  implementation already exists:
+ *    def equals(other: Any): Boolean
+ *    def hashCode(): Int
+ */
+class SyntheticMembers(thisPhase: DenotTransformer) {
+  import SyntheticMembers._
+  import ast.tpd._
+
+  private var myValueSymbols: List[Symbol] = Nil
+  private var myCaseSymbols: List[Symbol] = Nil
+  private var myCaseModuleSymbols: List[Symbol] = Nil
+  private var myEnumValueSymbols: List[Symbol] = Nil
+  private var myNonJavaEnumValueSymbols: List[Symbol] = Nil
+
+  private def initSymbols(using Context) =
+    if (myValueSymbols.isEmpty) {
+      myValueSymbols = List(defn.Any_hashCode, defn.Any_equals)
+      myCaseSymbols = defn.caseClassSynthesized
+      myCaseModuleSymbols = myCaseSymbols.filter(_ ne defn.Any_equals)
+      myEnumValueSymbols = List(defn.Product_productPrefix)
+      myNonJavaEnumValueSymbols = myEnumValueSymbols :+ defn.Any_toString :+ defn.Enum_ordinal
+    }
+
+  def valueSymbols(using Context): List[Symbol] = { initSymbols; myValueSymbols }
+  def caseSymbols(using Context): List[Symbol] = { initSymbols; myCaseSymbols }
+  def caseModuleSymbols(using Context): List[Symbol] = { initSymbols; myCaseModuleSymbols }
+  def enumValueSymbols(using Context): List[Symbol] = { initSymbols; myEnumValueSymbols }
+  def nonJavaEnumValueSymbols(using Context): List[Symbol] = { initSymbols; myNonJavaEnumValueSymbols }
+
+  private def existingDef(sym: Symbol, clazz: ClassSymbol)(using Context): Symbol =
+    val existing = sym.matchingMember(clazz.thisType)
+    if existing != sym && !existing.is(Deferred) then existing else NoSymbol
+
+  private def synthesizeDef(sym: TermSymbol, rhsFn: List[List[Tree]] => Context ?=> Tree)(using Context): Tree =
+    DefDef(sym, rhsFn(_)(using ctx.withOwner(sym))).withSpan(ctx.owner.span.focus)
+
+  /** If this is a case or value class, return the appropriate additional methods,
+   *  otherwise return nothing.
+   */
+  def caseAndValueMethods(clazz: ClassSymbol)(using Context): List[Tree] = {
+    val clazzType = clazz.appliedRef
+    lazy val accessors =
+      if (isDerivedValueClass(clazz)) clazz.paramAccessors.take(1) // Tail parameters can only be `erased`
+      else clazz.caseAccessors
+    val isEnumValue = clazz.isAnonymousClass && clazz.info.parents.head.classSymbol.is(Enum)
+    val isSimpleEnumValue = isEnumValue && !clazz.owner.isAllOf(EnumCase)
+    val isJavaEnumValue = isEnumValue && clazz.derivesFrom(defn.JavaEnumClass)
+    val isNonJavaEnumValue = isEnumValue && !isJavaEnumValue
+
+    val symbolsToSynthesize: List[Symbol] =
+      if (clazz.is(Case))
+        if (clazz.is(Module)) caseModuleSymbols
+        else caseSymbols
+      else if (isNonJavaEnumValue) nonJavaEnumValueSymbols
+      else if (isEnumValue) enumValueSymbols
+      else if (isDerivedValueClass(clazz)) valueSymbols
+      else Nil
+
+    def syntheticDefIfMissing(sym: Symbol): List[Tree] =
+      if (existingDef(sym, clazz).exists) Nil else syntheticDef(sym) :: Nil
+
+    def syntheticDef(sym: Symbol): Tree = {
+      val synthetic = sym.copy(
+        owner = clazz,
+        flags = sym.flags &~ Deferred | Synthetic | Override,
+        info = clazz.thisType.memberInfo(sym),
+        coord = clazz.coord).enteredAfter(thisPhase).asTerm
+
+      def forwardToRuntime(vrefs: List[Tree]): Tree =
+        ref(defn.runtimeMethodRef("_" + sym.name.toString)).appliedToTermArgs(This(clazz) :: vrefs)
+
+      def ownName: Tree =
+        Literal(Constant(clazz.name.stripModuleClassSuffix.toString))
+
+      def nameRef: Tree =
+        if isJavaEnumValue then
+          val name = Select(This(clazz), nme.name).ensureApplied
+          if ctx.explicitNulls then name.cast(defn.StringType) else name
+        else
+          identifierRef
+
+      def identifierRef: Tree =
+        if isSimpleEnumValue then // owner is `def $new(_$ordinal: Int, $name: String) = new MyEnum { ... }`
+          ref(clazz.owner.paramSymss.head.find(_.name == nme.nameDollar).get)
+        else // assume owner is `val Foo = new MyEnum { def ordinal = 0 }`
+          Literal(Constant(clazz.owner.name.toString))
+
+      def ordinalRef: Tree =
+        if isSimpleEnumValue then // owner is `def $new(_$ordinal: Int, $name: String) = new MyEnum { ... }`
+          ref(clazz.owner.paramSymss.head.find(_.name == nme.ordinalDollar_).get)
+        else // val CaseN = new MyEnum { ... def ordinal: Int = n }
+          val vdef = clazz.owner
+          val parentEnum = vdef.owner.companionClass
+          val children = parentEnum.children.zipWithIndex
+          val candidate: Option[Int] = children.collectFirst { case (child, idx) if child == vdef => idx }
+          assert(candidate.isDefined, i"could not find child for $vdef in ${parentEnum.children}%, % of $parentEnum")
+          Literal(Constant(candidate.get))
+
+      def toStringBody(vrefss: List[List[Tree]]): Tree =
+        if (clazz.is(ModuleClass)) ownName
+        else if (isNonJavaEnumValue) identifierRef
+        else forwardToRuntime(vrefss.head)
+
+      def syntheticRHS(vrefss: List[List[Tree]])(using Context): Tree = synthetic.name match {
+        case nme.hashCode_ if isDerivedValueClass(clazz) => valueHashCodeBody
+        case nme.hashCode_ => chooseHashcode
+        case nme.toString_ => toStringBody(vrefss)
+        case nme.equals_ => equalsBody(vrefss.head.head)
+        case nme.canEqual_ => canEqualBody(vrefss.head.head)
+        case nme.ordinal => ordinalRef
+        case nme.productArity => Literal(Constant(accessors.length))
+        case nme.productPrefix if isEnumValue => nameRef
+        case nme.productPrefix => ownName
+        case nme.productElement => productElementBody(accessors.length, vrefss.head.head)
+        case nme.productElementName => productElementNameBody(accessors.length, vrefss.head.head)
+      }
+      report.log(s"adding $synthetic to $clazz at ${ctx.phase}")
+      synthesizeDef(synthetic, syntheticRHS)
+    }
+
+    /** The class
+     *
+     *  ```
+     *  case class C(x: T, y: T)
+     *  ```
+     *
+     *  gets the `productElement` method:
+     *
+     *  ```
+     *  def productElement(index: Int): Any = index match {
+     *    case 0 => this._1
+     *    case 1 => this._2
+     *    case _ => throw new IndexOutOfBoundsException(index.toString)
+     *  }
+     *  ```
+     */
+    def productElementBody(arity: Int, index: Tree)(using Context): Tree = {
+      // case N => _${N + 1}
+      val cases = 0.until(arity).map { i =>
+        val sel = This(clazz).select(nme.selectorName(i), _.info.isParameterless)
+        CaseDef(Literal(Constant(i)), EmptyTree, sel)
+      }
+
+      Match(index, (cases :+ generateIOBECase(index)).toList)
+    }
+
+    /** The class
+     *
+     *  ```
+     *  case class C(x: T, y: T)
+     *  ```
+     *
+     *  gets the `productElementName` method:
+     *
+     *  ```
+     *  def productElementName(index: Int): String = index match {
+     *    case 0 => "x"
+     *    case 1 => "y"
+     *    case _ => throw new IndexOutOfBoundsException(index.toString)
+     *  }
+     *  ```
+     */
+    def productElementNameBody(arity: Int, index: Tree)(using Context): Tree = {
+      // case N => // name for case arg N
+      val cases = 0.until(arity).map { i =>
+        CaseDef(Literal(Constant(i)), EmptyTree, Literal(Constant(accessors(i).name.toString)))
+      }
+
+      Match(index, (cases :+ generateIOBECase(index)).toList)
+    }
+
+    def generateIOBECase(index: Tree): CaseDef = {
+      val ioob = defn.IndexOutOfBoundsException.typeRef
+      // Second constructor of ioob that takes a String argument
+      def filterStringConstructor(s: Symbol): Boolean = s.info match {
+        case m: MethodType if s.isConstructor && m.paramInfos.size == 1 =>
+          m.paramInfos.head.stripNull == defn.StringType
+        case _ => false
+      }
+      val constructor = ioob.typeSymbol.info.decls.find(filterStringConstructor _).asTerm
+      val stringIndex = Apply(Select(index, nme.toString_), Nil)
+      val error = Throw(New(ioob, constructor, List(stringIndex)))
+
+      // case _ => throw new IndexOutOfBoundsException(i.toString)
+      CaseDef(Underscore(defn.IntType), EmptyTree, error)
+    }
+
+    /** The class
+     *
+     *  ```
+     *  case class C(x: T, y: U)
+     *  ```
+     *
+     *  gets the `equals` method:
+     *
+     *  ```
+     *  def equals(that: Any): Boolean =
+     *    (this eq that) || {
+     *      that match {
+     *        case x$0 @ (_: C @unchecked) => this.x == this$0.x && this.y == x$0.y && that.canEqual(this)
+     *        case _ => false
+     *     }
+     *  ```
+     *
+     *  If `C` is a value class, the initial `eq` test is omitted.
+     *  The `canEqual` test can be omitted if it is known that `canEqual` return always true.
+     *
+     *  `@unchecked` is needed for parametric case classes.
+     *
+     */
+    def equalsBody(that: Tree)(using Context): Tree = {
+      val thatAsClazz = newSymbol(ctx.owner, nme.x_0, SyntheticCase, clazzType, coord = ctx.owner.span) // x$0
+      def wildcardAscription(tp: Type) = Typed(Underscore(tp), TypeTree(tp))
+      val pattern = Bind(thatAsClazz, wildcardAscription(AnnotatedType(clazzType, Annotation(defn.UncheckedAnnot)))) // x$0 @ (_: C @unchecked)
+      // compare primitive fields first, slow equality checks of non-primitive fields can be skipped when primitives differ
+      val sortedAccessors = accessors.sortBy(accessor => if (accessor.info.typeSymbol.isPrimitiveValueClass) 0 else 1)
+      val comparisons = sortedAccessors.map { accessor =>
+        This(clazz).withSpan(ctx.owner.span.focus).select(accessor).equal(ref(thatAsClazz).select(accessor)) }
+      var rhs = // this.x == this$0.x && this.y == x$0.y && that.canEqual(this)
+        if comparisons.isEmpty then Literal(Constant(true)) else comparisons.reduceLeft(_ and _)
+      val canEqualMeth = existingDef(defn.Product_canEqual, clazz)
+      if !clazz.is(Final) || canEqualMeth.exists && !canEqualMeth.is(Synthetic) then
+        rhs = rhs.and(
+            ref(thatAsClazz)
+            .select(canEqualMeth.orElse(defn.Product_canEqual))
+            .appliedTo(This(clazz)))
+      val matchingCase = CaseDef(pattern, EmptyTree, rhs) // case x$0 @ (_: C) => this.x == this$0.x && this.y == x$0.y
+      val defaultCase = CaseDef(Underscore(defn.AnyType), EmptyTree, Literal(Constant(false))) // case _ => false
+      val matchExpr = Match(that, List(matchingCase, defaultCase))
+      if (isDerivedValueClass(clazz)) matchExpr
+      else {
+        val eqCompare = This(clazz).select(defn.Object_eq).appliedTo(that.cast(defn.ObjectType))
+        eqCompare or matchExpr
+      }
+    }
+
+    /** The class
+     *
+     *  ```
+     *  class C(x: T) extends AnyVal
+     *  ```
+     *
+     *  gets the `hashCode` method:
+     *
+     *  ```
+     *  def hashCode: Int = x.hashCode()
+     *  ```
+     */
+    def valueHashCodeBody(using Context): Tree = {
+      assert(accessors.nonEmpty)
+      ref(accessors.head).select(nme.hashCode_).ensureApplied
+    }
+
+    /** The class
+     *
+     *  ```
+     *  case object C
+     *  ```
+     *
+     *  gets the `hashCode` method:
+     *
+     *  ```
+     *  def hashCode: Int = "C".hashCode // constant folded
+     *  ```
+     *
+     *  The class
+     *
+     *  ```
+     *  case class C(x: T, y: U)
+     *  ```
+     *
+     *  if none of `T` or `U` are primitive types, gets the `hashCode` method:
+     *
+     *  ```
+     *  def hashCode: Int = ScalaRunTime._hashCode(this)
+     *  ```
+     *
+     *  else if either `T` or `U` are primitive, gets the `hashCode` method implemented by [[caseHashCodeBody]]
+     */
+    def chooseHashcode(using Context) =
+      if (clazz.is(ModuleClass))
+        Literal(Constant(clazz.name.stripModuleClassSuffix.toString.hashCode))
+      else if (accessors.exists(_.info.finalResultType.classSymbol.isPrimitiveValueClass))
+        caseHashCodeBody
+      else
+        ref(defn.ScalaRuntime__hashCode).appliedTo(This(clazz))
+
+    /** The class
+     *
+     *  ```
+     *  case class C(x: Int, y: T)
+     *  ```
+     *
+     *  gets the `hashCode` method:
+     *
+     *  ```
+     *  def hashCode: Int = {
+     *    <synthetic> var acc: Int = 0xcafebabe
+     *    acc = Statics.mix(acc, this.productPrefix.hashCode());
+     *    acc = Statics.mix(acc, x);
+     *    acc = Statics.mix(acc, Statics.this.anyHash(y));
+     *    Statics.finalizeHash(acc, 2)
+     *  }
+     *  ```
+     */
+    def caseHashCodeBody(using Context): Tree = {
+      val acc = newSymbol(ctx.owner, nme.acc, Mutable | Synthetic, defn.IntType, coord = ctx.owner.span)
+      val accDef = ValDef(acc, Literal(Constant(0xcafebabe)))
+      val mixPrefix = Assign(ref(acc),
+        ref(defn.staticsMethod("mix")).appliedTo(ref(acc), This(clazz).select(defn.Product_productPrefix).select(defn.Any_hashCode).appliedToNone))
+      val mixes = for (accessor <- accessors) yield
+        Assign(ref(acc), ref(defn.staticsMethod("mix")).appliedTo(ref(acc), hashImpl(accessor)))
+      val finish = ref(defn.staticsMethod("finalizeHash")).appliedTo(ref(acc), Literal(Constant(accessors.size)))
+      Block(accDef :: mixPrefix :: mixes, finish)
+    }
+
+    /** The `hashCode` implementation for given symbol `sym`. */
+    def hashImpl(sym: Symbol)(using Context): Tree =
+      defn.scalaClassName(sym.info.finalResultType) match {
+        case tpnme.Unit | tpnme.Null               => Literal(Constant(0))
+        case tpnme.Boolean                         => If(ref(sym), Literal(Constant(1231)), Literal(Constant(1237)))
+        case tpnme.Int                             => ref(sym)
+        case tpnme.Short | tpnme.Byte | tpnme.Char => ref(sym).select(nme.toInt)
+        case tpnme.Long                            => ref(defn.staticsMethod("longHash")).appliedTo(ref(sym))
+        case tpnme.Double                          => ref(defn.staticsMethod("doubleHash")).appliedTo(ref(sym))
+        case tpnme.Float                           => ref(defn.staticsMethod("floatHash")).appliedTo(ref(sym))
+        case _                                     => ref(defn.staticsMethod("anyHash")).appliedTo(ref(sym))
+      }
+
+    /** The class
+     *
+     *  ```
+     *  case class C(...)
+     *  ```
+     *
+     *  gets the `canEqual` method
+     *
+     *  ```
+     *  def canEqual(that: Any) = that.isInstanceOf[C @unchecked]
+     *  ```
+     *
+     *  `@unchecked` is needed for parametric case classes.
+     */
+    def canEqualBody(that: Tree): Tree = that.isInstance(AnnotatedType(clazzType, Annotation(defn.UncheckedAnnot)))
+
+    symbolsToSynthesize.flatMap(syntheticDefIfMissing)
+  }
+
+  private def hasWriteReplace(clazz: ClassSymbol)(using Context): Boolean =
+    clazz.membersNamed(nme.writeReplace)
+      .filterWithPredicate(s => s.signature == Signature(defn.AnyRefType, sourceLanguage = SourceLanguage.Scala3))
+      .exists
+
+  private def hasReadResolve(clazz: ClassSymbol)(using Context): Boolean =
+    clazz.membersNamed(nme.readResolve)
+      .filterWithPredicate(s => s.signature == Signature(defn.AnyRefType, sourceLanguage = SourceLanguage.Scala3))
+      .exists
+
+  private def writeReplaceDef(clazz: ClassSymbol)(using Context): TermSymbol =
+    newSymbol(clazz, nme.writeReplace, PrivateMethod | Synthetic,
+        MethodType(Nil, defn.AnyRefType), coord = clazz.coord).entered.asTerm
+
+  private def readResolveDef(clazz: ClassSymbol)(using Context): TermSymbol =
+    newSymbol(clazz, nme.readResolve, PrivateMethod | Synthetic,
+        MethodType(Nil, defn.AnyRefType), coord = clazz.coord).entered.asTerm
+
+  /** If this is a static object `Foo`, add the method:
+   *
+   *      private def writeReplace(): AnyRef =
+   *        new scala.runtime.ModuleSerializationProxy(classOf[Foo.type])
+   *
+   *  unless an implementation already exists, otherwise do nothing.
+   *
+   *  All static objects receive the `Serializable` flag in the back-end, so
+   *  we do that even for objects that are not serializable at this phase.
+   */
+  def serializableObjectMethod(clazz: ClassSymbol)(using Context): List[Tree] =
+    if clazz.is(Module)
+      && clazz.isStatic
+      && !hasWriteReplace(clazz)
+      && ctx.platform.shouldReceiveJavaSerializationMethods(clazz)
+    then
+      List(
+        DefDef(writeReplaceDef(clazz),
+          _ => New(defn.ModuleSerializationProxyClass.typeRef,
+                   defn.ModuleSerializationProxyConstructor,
+                   List(Literal(Constant(clazz.sourceModule.termRef)))))
+          .withSpan(ctx.owner.span.focus))
+    else
+      Nil
+
+  /** Is this an anonymous class deriving from an enum definition? */
+  extension (cls: ClassSymbol) private def isEnumValueImplementation(using Context): Boolean =
+    cls.isAnonymousClass && cls.info.parents.head.typeSymbol.is(Enum) // asserted in Typer
+
+  /** If this is the class backing a serializable singleton enum value with base class `MyEnum`,
+   *  and not deriving from `java.lang.Enum` add the method:
+   *
+   *      private def readResolve(): AnyRef =
+   *        MyEnum.fromOrdinal(this.ordinal)
+   *
+   *  unless an implementation already exists, otherwise do nothing.
+   */
+   def serializableEnumValueMethod(clazz: ClassSymbol)(using Context): List[Tree] =
+    if clazz.isEnumValueImplementation
+      && !clazz.derivesFrom(defn.JavaEnumClass)
+      && clazz.isSerializable
+      && !hasReadResolve(clazz)
+      && ctx.platform.shouldReceiveJavaSerializationMethods(clazz)
+    then
+      List(
+        DefDef(readResolveDef(clazz),
+          _ => ref(clazz.owner.owner.sourceModule)
+                .select(nme.fromOrdinal)
+                .appliedTo(This(clazz).select(nme.ordinal).ensureApplied))
+          .withSpan(ctx.owner.span.focus))
+    else
+      Nil
+
+  /** The class
+   *
+   *  ```
+   *  case class C[T <: U](x: T, y: String*)
+   *  ```
+   *
+   *  gets the `fromProduct` method:
+   *
+   *  ```
+   *  def fromProduct(x$0: Product): MirroredMonoType =
+   *    new C[U](
+   *      x$0.productElement(0).asInstanceOf[U],
+   *      x$0.productElement(1).asInstanceOf[Seq[String]]: _*)
+   *  ```
+   *  where
+   *  ```
+   *  type MirroredMonoType = C[?]
+   *  ```
+   */
+  def fromProductBody(caseClass: Symbol, param: Tree, optInfo: Option[MirrorImpl.OfProduct])(using Context): Tree =
+    def extractParams(tpe: Type): List[Type] =
+      tpe.asInstanceOf[MethodType].paramInfos
+
+    def computeFromCaseClass: (Type, List[Type]) =
+      val (baseRef, baseInfo) =
+        val rawRef = caseClass.typeRef
+        val rawInfo = caseClass.primaryConstructor.info
+        optInfo match
+          case Some(info) =>
+            (rawRef.asSeenFrom(info.pre, caseClass.owner), rawInfo.asSeenFrom(info.pre, caseClass.owner))
+          case _ =>
+            (rawRef, rawInfo)
+      baseInfo match
+        case tl: PolyType =>
+          val (tl1, tpts) = constrained(tl, untpd.EmptyTree, alwaysAddTypeVars = true)
+          val targs =
+            for (tpt <- tpts) yield
+              tpt.tpe match {
+                case tvar: TypeVar => tvar.instantiate(fromBelow = false)
+              }
+          (baseRef.appliedTo(targs), extractParams(tl.instantiate(targs)))
+        case methTpe =>
+          (baseRef, extractParams(methTpe))
+    end computeFromCaseClass
+
+    val (classRefApplied, paramInfos) = computeFromCaseClass
+    val elems =
+      for ((formal, idx) <- paramInfos.zipWithIndex) yield
+        val elem =
+          param.select(defn.Product_productElement).appliedTo(Literal(Constant(idx)))
+            .ensureConforms(formal.translateFromRepeated(toArray = false))
+        if (formal.isRepeatedParam) ctx.typer.seqToRepeated(elem) else elem
+    New(classRefApplied, elems)
+  end fromProductBody
+
+  /** For an enum T:
+   *
+   *     def ordinal(x: MirroredMonoType) = x.ordinal
+   *
+   *  For  sealed trait with children of normalized types C_1, ..., C_n:
+   *
+   *     def ordinal(x: MirroredMonoType) = x match {
+   *        case _: C_1 => 0
+   *        ...
+   *        case _: C_n => n - 1
+   *     }
+   *
+   *  Here, the normalized type of a class C is C[?, ...., ?] with
+   *  a wildcard for each type parameter. The normalized type of an object
+   *  O is O.type.
+   */
+  def ordinalBody(cls: Symbol, param: Tree, optInfo: Option[MirrorImpl.OfSum])(using Context): Tree =
+    if cls.is(Enum) then
+      param.select(nme.ordinal).ensureApplied
+    else
+      def computeChildTypes: List[Type] =
+        def rawRef(child: Symbol): Type =
+          if (child.isTerm) child.reachableTermRef else child.reachableRawTypeRef
+        optInfo match
+          case Some(info) => info
+            .childPres
+            .lazyZip(cls.children)
+            .map((pre, child) => rawRef(child).asSeenFrom(pre, child.owner))
+          case _ =>
+            cls.children.map(rawRef)
+      end computeChildTypes
+      val childTypes = computeChildTypes
+      val cases =
+        for (patType, idx) <- childTypes.zipWithIndex yield
+          val pat = Typed(untpd.Ident(nme.WILDCARD).withType(patType), TypeTree(patType))
+          CaseDef(pat, EmptyTree, Literal(Constant(idx)))
+
+      Match(param.annotated(New(defn.UncheckedAnnot.typeRef, Nil)), cases)
+  end ordinalBody
+
+  /** - If `impl` is the companion of a generic sum, add `deriving.Mirror.Sum` parent
+   *    and `MirroredMonoType` and `ordinal` members.
+   *  - If `impl` is the companion of a generic product, add `deriving.Mirror.Product` parent
+   *    and `MirroredMonoType` and `fromProduct` members.
+   *  - If `impl` is marked with one of the attachments ExtendsSingletonMirror or ExtendsSumOfProductMirror,
+   *    remove the attachment and generate the corresponding mirror support,
+   *    On this case the represented class or object is referred to in a pre-existing `MirroredMonoType`
+   *    member of the template.
+   */
+  def addMirrorSupport(impl: Template)(using Context): Template = {
+    val clazz = ctx.owner.asClass
+
+    var newBody = impl.body
+    var newParents = impl.parents
+    def addParent(parent: Type): Unit = {
+      newParents = newParents :+ TypeTree(parent)
+      val oldClassInfo = clazz.classInfo
+      val newClassInfo = oldClassInfo.derivedClassInfo(
+        declaredParents = oldClassInfo.declaredParents :+ parent)
+      clazz.copySymDenotation(info = newClassInfo).installAfter(thisPhase)
+    }
+    def addMethod(name: TermName, info: Type, cls: Symbol, body: (Symbol, Tree) => Context ?=> Tree): Unit = {
+      val meth = newSymbol(clazz, name, Synthetic | Method, info, coord = clazz.coord)
+      if (!existingDef(meth, clazz).exists) {
+        meth.enteredAfter(thisPhase)
+        newBody = newBody :+
+          synthesizeDef(meth, vrefss => body(cls, vrefss.head.head))
+      }
+    }
+    val linked = clazz.linkedClass
+    lazy val monoType = {
+      val existing = clazz.info.member(tpnme.MirroredMonoType).symbol
+      if (existing.exists && !existing.is(Deferred)) existing
+      else {
+        val monoType =
+          newSymbol(clazz, tpnme.MirroredMonoType, Synthetic, TypeAlias(linked.reachableRawTypeRef), coord = clazz.coord)
+        newBody = newBody :+ TypeDef(monoType).withSpan(ctx.owner.span.focus)
+        monoType.enteredAfter(thisPhase)
+      }
+    }
+    def makeSingletonMirror() =
+      addParent(defn.Mirror_SingletonClass.typeRef)
+    def makeProductMirror(cls: Symbol, optInfo: Option[MirrorImpl.OfProduct]) = {
+      addParent(defn.Mirror_ProductClass.typeRef)
+      addMethod(nme.fromProduct, MethodType(defn.ProductClass.typeRef :: Nil, monoType.typeRef), cls,
+        fromProductBody(_, _, optInfo).ensureConforms(monoType.typeRef))  // t4758.scala or i3381.scala are examples where a cast is needed
+    }
+    def makeSumMirror(cls: Symbol, optInfo: Option[MirrorImpl.OfSum]) = {
+      addParent(defn.Mirror_SumClass.typeRef)
+      addMethod(nme.ordinal, MethodType(monoType.typeRef :: Nil, defn.IntType), cls,
+        ordinalBody(_, _, optInfo))
+    }
+
+    if (clazz.is(Module)) {
+      if (clazz.is(Case)) makeSingletonMirror()
+      else if (linked.isGenericProduct) makeProductMirror(linked, None)
+      else if (linked.isGenericSum(NoType)) makeSumMirror(linked, None)
+      else if (linked.is(Sealed))
+        derive.println(i"$linked is not a sum because ${linked.whyNotGenericSum(NoType)}")
+    }
+    else if (impl.removeAttachment(ExtendsSingletonMirror).isDefined)
+      makeSingletonMirror()
+    else
+      impl.removeAttachment(ExtendsSumOrProductMirror).match
+        case Some(prodImpl: MirrorImpl.OfProduct) =>
+          makeProductMirror(monoType.typeRef.dealias.classSymbol, Some(prodImpl))
+        case Some(sumImpl: MirrorImpl.OfSum) =>
+          makeSumMirror(monoType.typeRef.dealias.classSymbol, Some(sumImpl))
+        case _ =>
+
+    cpy.Template(impl)(parents = newParents, body = newBody)
+  }
+
+  def addSyntheticMembers(impl: Template)(using Context): Template = {
+    val clazz = ctx.owner.asClass
+    val syntheticMembers = serializableObjectMethod(clazz) ::: serializableEnumValueMethod(clazz) ::: caseAndValueMethods(clazz)
+    checkInlining(syntheticMembers)
+    addMirrorSupport(
+      cpy.Template(impl)(body = syntheticMembers ::: impl.body))
+  }
+
+  private def checkInlining(syntheticMembers: List[Tree])(using Context): Unit =
+    if syntheticMembers.exists(_.existsSubTree {
+      case tree: GenericApply => tree.symbol.isAllOf(InlineMethod)
+      case tree: Select => tree.symbol.isAllOf(InlineMethod)
+      case _ => false
+    }) then ctx.compilationUnit.needsInlining = true
+}
diff --git a/tests/pos-with-compiler-cc/dotc/transform/TailRec.scala b/tests/pos-with-compiler-cc/dotc/transform/TailRec.scala
new file mode 100644
index 000000000000..71b66c3d0da6
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/transform/TailRec.scala
@@ -0,0 +1,460 @@
+package dotty.tools.dotc
+package transform
+
+import ast.{TreeTypeMap, tpd}
+import config.Printers.tailrec
+import core.*
+import Contexts.*, Flags.*, Symbols.*
+import Constants.Constant
+import NameKinds.{TailLabelName, TailLocalName, TailTempName}
+import StdNames.nme
+import reporting.*
+import transform.MegaPhase.MiniPhase
+import util.LinearSet
+import dotty.tools.uncheckedNN
+
+/** A Tail Rec Transformer.
+ *
+ *  What it does:
+ *
+ *  Finds method calls in tail-position and replaces them with jumps.
+ *  A call is in a tail-position if it is the last instruction to be
+ *  executed in the body of a method. This includes being in
+ *  tail-position of a `return` from a `Labeled` block which is itself
+ *  in tail-position (which is critical for tail-recursive calls in the
+ *  cases of a `match`). To identify tail positions, we recurse over
+ *  the trees that may contain calls in tail-position (trees that can't
+ *  contain such calls are not transformed).
+ *
+ *  When a method contains at least one tail-recursive call, its rhs
+ *  is wrapped in the following structure:
+ *
+ *  ```
+ *  var localForParam1: T1 = param1
+ *  ...
+ *  while (<empty>) {
+ *    tailResult[ResultType]: {
+ *      return {
+ *        // original rhs with tail recursive calls transformed (see below)
+ *      }
+ *    }
+ *  }
+ *  ```
+ *
+ *  Self-recursive calls in tail-position are then replaced by (a)
+ *  reassigning the local `var`s substituting formal parameters and
+ *  (b) a `return` from the `tailResult` labeled block, which has the
+ *  net effect of looping back to the beginning of the method.
+ *  If the receiver is modifed in a recursive call, an additional `var`
+ *  is used to replace `this`.
+ *
+ *  As a complete example of the transformation, the classical `fact`
+ *  function, defined as:
+ *
+ *  ```
+ *  def fact(n: Int, acc: Int): Int =
+ *    if (n == 0) acc
+ *    else fact(n - 1, acc * n)
+ *  ```
+ *
+ *  is rewritten as:
+ *
+ *  ```
+ *  def fact(n: Int, acc: Int): Int = {
+ *    var acc$tailLocal1: Int = acc
+ *    var n$tailLocal1: Int = n
+ *    while (<empty>) {
+ *      tailLabel1[Unit]: {
+ *        return {
+ *          if (n$tailLocal1 == 0)
+ *            acc$tailLocal1
+ *          else {
+ *            val n$tailLocal1$tmp1: Int = n$tailLocal1 - 1
+ *            val acc$tailLocal1$tmp1: Int = acc$tailLocal1 * n$tailLocal1
+ *            n$tailLocal1 = n$tailLocal1$tmp1
+ *            acc$tailLocal1 = acc$tailLocal1$tmp1
+ *            (return[tailLabel1] ()): Int
+ *          }
+ *        }
+ *      }
+ *    }
+ *  }
+ *  ```
+ *
+ *  As the JVM provides no way to jump from a method to another one,
+ *  non-recursive calls in tail-position are not optimized.
+ *
+ *  A method call is self-recursive if it calls the current method and
+ *  the method is final (otherwise, it could be a call to an overridden
+ *  method in a subclass). Recursive calls on a different instance are
+ *  optimized.
+ *
+ *  This phase has been moved after erasure to allow the use of vars
+ *  for the parameters combined with a `WhileDo`. This is also
+ *  beneficial to support polymorphic tail-recursive calls.
+ *
+ *  In scalac, if the method had type parameters, the call must contain
+ *  the same parameters as type arguments. This is no longer the case in
+ *  dotc thanks to being located after erasure.
+ *  In scalac, this is named tailCall but it does only provide optimization for
+ *  self recursive functions, that's why it's renamed to tailrec
+ *
+ *  @author
+ *    Erik Stenman, Iulian Dragos,
+ *    ported and heavily modified for dotty by Dmitry Petrashko
+ *    moved after erasure and adapted to emit `Labeled` blocks by Sébastien Doeraene
+ */
+class TailRec extends MiniPhase {
+  import tpd._
+
+  override def phaseName: String = TailRec.name
+
+  override def description: String = TailRec.description
+
+  override def runsAfter: Set[String] = Set(Erasure.name) // tailrec assumes erased types
+
+  override def transformDefDef(tree: DefDef)(using Context): Tree = {
+    val method = tree.symbol
+    val mandatory = method.hasAnnotation(defn.TailrecAnnot)
+    def noTailTransform(failureReported: Boolean) = {
+      // FIXME: want to report this error on `tree.nameSpan`, but
+      // because of extension method getting a weird position, it is
+      // better to report on method symbol so there's no overlap.
+      // We don't report a new error if failures were reported
+      // during the transformation.
+      if (mandatory && !failureReported)
+        report.error(TailrecNotApplicable(method), method.srcPos)
+
+      tree
+    }
+
+    val isCandidate = method.isEffectivelyFinal &&
+      !(method.is(Accessor) || tree.rhs.eq(EmptyTree))
+
+    if (isCandidate) {
+      val enclosingClass = method.enclosingClass.asClass
+
+      // Note: this can be split in two separate transforms(in different groups),
+      // than first one will collect info about which transformations and rewritings should be applied
+      // and second one will actually apply,
+      // now this speculatively transforms tree and throws away result in many cases
+      val transformer = new TailRecElimination(method, enclosingClass, tree.termParamss.head.map(_.symbol), mandatory)
+      val rhsSemiTransformed = transformer.transform(tree.rhs)
+
+      if (transformer.rewrote) {
+        val varForRewrittenThis = transformer.varForRewrittenThis
+        val rewrittenParamSyms = transformer.rewrittenParamSyms
+        val varsForRewrittenParamSyms = transformer.varsForRewrittenParamSyms
+
+        val initialVarDefs = {
+          val initialParamVarDefs = rewrittenParamSyms.lazyZip(varsForRewrittenParamSyms).map {
+            (param, local) => ValDef(local.asTerm, ref(param))
+          }
+          varForRewrittenThis match {
+            case Some(local) => ValDef(local.asTerm, This(enclosingClass)) :: initialParamVarDefs
+            case none => initialParamVarDefs
+          }
+        }
+
+        val rhsFullyTransformed = varForRewrittenThis match {
+          case Some(localThisSym) =>
+            val thisRef = localThisSym.termRef
+            val substitute = new TreeTypeMap(
+              typeMap = _.substThisUnlessStatic(enclosingClass, thisRef)
+                .subst(rewrittenParamSyms, varsForRewrittenParamSyms.map(_.termRef)),
+              treeMap = {
+                case tree: This if tree.symbol == enclosingClass => Ident(thisRef)
+                case tree => tree
+              }
+            )
+            // The previous map will map `This` references to `Ident`s even under `Super`.
+            // This violates super's contract. We fix this by cleaning up `Ident`s under
+            // super, mapping them back to the original `This` reference. This is not
+            // very elegant, but I did not manage to find a cleaner way to handle this.
+            // See pos/tailrec-super.scala for a test case.
+            val cleanup = new TreeMap:
+              override def transform(t: Tree)(using Context) = t match
+                case Super(qual: Ident, mix) if !qual.tpe.isInstanceOf[Types.ThisType] =>
+                  cpy.Super(t)(This(enclosingClass), mix)
+                case _ =>
+                  super.transform(t)
+            cleanup.transform(substitute.transform(rhsSemiTransformed))
+          case none =>
+            new TreeTypeMap(
+              typeMap = _.subst(rewrittenParamSyms, varsForRewrittenParamSyms.map(_.termRef))
+            ).transform(rhsSemiTransformed)
+        }
+
+        /** Is the RHS a direct recursive tailcall, possibly with swapped arguments or modified pure arguments.
+         *  ```
+         *  def f(<params>): T = f(<args>)
+         *  ```
+         *  where `<args>` are pure arguments or references to parameters in `<params>`.
+         */
+        def isInfiniteRecCall(tree: Tree): Boolean = {
+          def tailArgOrPureExpr(stat: Tree): Boolean = stat match {
+            case stat: ValDef if stat.name.is(TailTempName) || !stat.symbol.is(Mutable) => tailArgOrPureExpr(stat.rhs)
+            case Assign(lhs: Ident, rhs) if lhs.symbol.name.is(TailLocalName) => tailArgOrPureExpr(rhs)
+            case Assign(lhs: Ident, rhs: Ident) => lhs.symbol == rhs.symbol
+            case stat: Ident if stat.symbol.name.is(TailLocalName) => true
+            case _ => tpd.isPureExpr(stat)
+          }
+          tree match {
+            case Typed(expr, _) => isInfiniteRecCall(expr)
+            case Return(Literal(Constant(())), label) => label.symbol == transformer.continueLabel
+            case Block(stats, expr) => stats.forall(tailArgOrPureExpr) && isInfiniteRecCall(expr)
+            case _ => false
+          }
+        }
+
+        if isInfiniteRecCall(rhsFullyTransformed) then
+          report.warning("Infinite recursive call", tree.srcPos)
+
+        cpy.DefDef(tree)(rhs =
+          Block(
+            initialVarDefs,
+            WhileDo(EmptyTree, {
+              Labeled(transformer.continueLabel.asTerm, {
+                Return(rhsFullyTransformed, method)
+              })
+            })
+          )
+        )
+      }
+      else noTailTransform(failureReported = transformer.failureReported)
+    }
+    else noTailTransform(failureReported = false)
+  }
+
+  class TailRecElimination(method: Symbol, enclosingClass: ClassSymbol, paramSyms: List[Symbol], isMandatory: Boolean) extends TreeMap {
+
+    var rewrote: Boolean = false
+    var failureReported: Boolean = false
+
+    /** The `tailLabelN` label symbol, used to encode a `continue` from the infinite `while` loop. */
+    private var myContinueLabel: Symbol | Null = _
+    def continueLabel(using Context): Symbol = {
+      if (myContinueLabel == null)
+        myContinueLabel = newSymbol(method, TailLabelName.fresh(), Label, defn.UnitType)
+      myContinueLabel.uncheckedNN
+    }
+
+    /** The local `var` that replaces `this`, if it is modified in at least one recursive call. */
+    var varForRewrittenThis: Option[Symbol] = None
+    /** The subset of `paramSyms` that are modified in at least one recursive call, and which therefore need a replacement `var`. */
+    var rewrittenParamSyms: List[Symbol] = Nil
+    /** The replacement `var`s for the params in `rewrittenParamSyms`. */
+    var varsForRewrittenParamSyms: List[Symbol] = Nil
+
+    private def getVarForRewrittenThis()(using Context): Symbol =
+      varForRewrittenThis match {
+        case Some(sym) => sym
+        case none =>
+          val tpe =
+            if (enclosingClass.is(Module)) enclosingClass.thisType
+            else enclosingClass.classInfo.selfType
+          val sym = newSymbol(method, TailLocalName.fresh(nme.SELF), Synthetic | Mutable, tpe)
+          varForRewrittenThis = Some(sym)
+          sym
+      }
+
+    private def getVarForRewrittenParam(param: Symbol)(using Context): Symbol =
+      rewrittenParamSyms.indexOf(param) match {
+        case -1 =>
+          val sym = newSymbol(method, TailLocalName.fresh(param.name.toTermName), Synthetic | Mutable, param.info)
+          rewrittenParamSyms ::= param
+          varsForRewrittenParamSyms ::= sym
+          sym
+        case index => varsForRewrittenParamSyms(index)
+      }
+
+    /** Symbols of Labeled blocks that are in tail position. */
+    private var tailPositionLabeledSyms = LinearSet.empty[Symbol]
+
+    private var inTailPosition = true
+
+    /** Rewrite this tree to contain no tail recursive calls */
+    def transform(tree: Tree, tailPosition: Boolean)(using Context): Tree =
+      if (inTailPosition == tailPosition) transform(tree)
+      else {
+        val saved = inTailPosition
+        inTailPosition = tailPosition
+        try transform(tree)
+        finally inTailPosition = saved
+      }
+
+    def yesTailTransform(tree: Tree)(using Context): Tree =
+      transform(tree, tailPosition = true)
+
+    def noTailTransform(tree: Tree)(using Context): Tree =
+      transform(tree, tailPosition = false)
+
+    def noTailTransforms[Tr <: Tree](trees: List[Tr])(using Context): List[Tr] =
+      trees.mapConserve(noTailTransform).asInstanceOf[List[Tr]]
+
+    override def transform(tree: Tree)(using Context): Tree = {
+      /* Rewrite an Apply to be considered for tail call transformation. */
+      def rewriteApply(tree: Apply): Tree = {
+        val arguments = noTailTransforms(tree.args)
+
+        def continue =
+          cpy.Apply(tree)(noTailTransform(tree.fun), arguments)
+
+        def fail(reason: String) = {
+          if (isMandatory) {
+            failureReported = true
+            report.error(s"Cannot rewrite recursive call: $reason", tree.srcPos)
+          }
+          else
+            tailrec.println("Cannot rewrite recursive call at: " + tree.span + " because: " + reason)
+          continue
+        }
+
+        val calledMethod = tree.fun.symbol
+        val prefix = tree.fun match {
+          case Select(qual, _) => qual
+          case x: Ident if x.symbol eq method => EmptyTree
+          case x => x
+        }
+
+        val isRecursiveCall = calledMethod eq method
+        def isRecursiveSuperCall = (method.name eq calledMethod.name) &&
+          method.matches(calledMethod) &&
+          enclosingClass.appliedRef.widen <:< prefix.tpe.widenDealias
+
+        if (isRecursiveCall)
+          if (inTailPosition) {
+            tailrec.println("Rewriting tail recursive call:  " + tree.span)
+            rewrote = true
+
+            val assignParamPairs = for {
+              (param, arg) <- paramSyms.zip(arguments)
+              if (arg match {
+                case arg: Ident => arg.symbol != param
+                case _ => true
+              })
+            }
+            yield
+              (getVarForRewrittenParam(param), arg)
+
+            val assignThisAndParamPairs = prefix match
+              case EmptyTree =>
+                assignParamPairs
+              case prefix: This if prefix.symbol == enclosingClass =>
+                // Avoid assigning `this = this`
+                assignParamPairs
+              case _ =>
+                (getVarForRewrittenThis(), noTailTransform(prefix)) :: assignParamPairs
+
+            val assignments = assignThisAndParamPairs match {
+              case (lhs, rhs) :: Nil =>
+                Assign(ref(lhs), rhs) :: Nil
+              case _ :: _ =>
+                val (tempValDefs, assigns) = (for ((lhs, rhs) <- assignThisAndParamPairs) yield {
+                  val temp = newSymbol(method, TailTempName.fresh(lhs.name.toTermName), Synthetic, lhs.info)
+                  (ValDef(temp, rhs), Assign(ref(lhs), ref(temp)).withSpan(tree.span))
+                }).unzip
+                tempValDefs ::: assigns
+              case nil =>
+                Nil
+            }
+
+            /* The `Typed` node is necessary to perfectly preserve the type of the node.
+             * Without it, lubbing in enclosing if/else or match can infer a different type,
+             * which can cause Ycheck errors.
+             */
+            val tpt = TypeTree(method.info.resultType)
+            seq(assignments, Typed(Return(unitLiteral.withSpan(tree.span), continueLabel), tpt))
+          }
+          else fail("it is not in tail position")
+        else if (isRecursiveSuperCall)
+          fail("it targets a supertype")
+        else
+          continue
+      }
+
+      tree match {
+        case tree @ Apply(fun, args) =>
+          val meth = fun.symbol
+          if (meth == defn.Boolean_|| || meth == defn.Boolean_&&)
+            cpy.Apply(tree)(noTailTransform(fun), transform(args))
+          else
+            rewriteApply(tree)
+
+        case tree @ Select(qual, name) =>
+          cpy.Select(tree)(noTailTransform(qual), name)
+
+        case tree @ Block(stats, expr) =>
+          cpy.Block(tree)(
+            noTailTransforms(stats),
+            transform(expr)
+          )
+
+        case tree @ If(cond, thenp, elsep) =>
+          cpy.If(tree)(
+            noTailTransform(cond),
+            transform(thenp),
+            transform(elsep)
+          )
+
+        case tree: CaseDef =>
+          cpy.CaseDef(tree)(body = transform(tree.body))
+
+        case tree @ Match(selector, cases) =>
+          cpy.Match(tree)(
+            noTailTransform(selector),
+            transformSub(cases)
+          )
+
+        case tree: Try =>
+          val expr = noTailTransform(tree.expr)
+          if (tree.finalizer eq EmptyTree)
+            // SI-1672 Catches are in tail position when there is no finalizer
+            cpy.Try(tree)(expr, transformSub(tree.cases), EmptyTree)
+          else cpy.Try(tree)(
+            expr,
+            noTailTransforms(tree.cases),
+            noTailTransform(tree.finalizer)
+          )
+
+        case tree @ WhileDo(cond, body) =>
+          cpy.WhileDo(tree)(
+            noTailTransform(cond),
+            noTailTransform(body)
+          )
+
+        case _: Alternative | _: Bind =>
+          assert(false, "We should never have gotten inside a pattern")
+          tree
+
+        case tree: ValOrDefDef =>
+          if (isMandatory) noTailTransform(tree.rhs)
+          tree
+
+        case _: Super | _: This | _: Literal | _: TypeTree | _: TypeDef | EmptyTree =>
+          tree
+
+        case Labeled(bind, expr) =>
+          if (inTailPosition)
+            tailPositionLabeledSyms += bind.symbol
+          try cpy.Labeled(tree)(bind, transform(expr))
+          finally
+            if (inTailPosition)
+              tailPositionLabeledSyms -= bind.symbol
+
+        case Return(expr, from) =>
+          val fromSym = from.symbol
+          val inTailPosition = !fromSym.is(Label) || tailPositionLabeledSyms.contains(fromSym)
+          cpy.Return(tree)(transform(expr, inTailPosition), from)
+
+        case _ =>
+          super.transform(tree)
+      }
+    }
+  }
+}
+
+object TailRec {
+  val name: String = "tailrec"
+  val description: String = "rewrite tail recursion to loops"
+}
diff --git a/tests/pos-with-compiler-cc/dotc/transform/TransformWildcards.scala b/tests/pos-with-compiler-cc/dotc/transform/TransformWildcards.scala
new file mode 100644
index 000000000000..ffed65f7676e
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/transform/TransformWildcards.scala
@@ -0,0 +1,34 @@
+package dotty.tools.dotc
+package transform
+
+import MegaPhase._
+import core.DenotTransformers._
+import core.Contexts._
+import ast.tpd
+
+/** This phase transforms wildcards in valdefs with their default value.
+  *  In particular for every valdef that is declared:
+  *    `val x : T = _` to `val x : T = <zero of T>`
+  *
+  */
+class TransformWildcards extends MiniPhase with IdentityDenotTransformer {
+  import tpd._
+
+  override def phaseName: String = TransformWildcards.name
+
+  override def description: String = TransformWildcards.description
+
+  override def checkPostCondition(tree: Tree)(using Context): Unit =
+    tree match {
+      case vDef: ValDef => assert(!tpd.isWildcardArg(vDef.rhs))
+      case _ =>
+    }
+
+  override def transformValDef(tree: ValDef)(using Context): Tree =
+    if (ctx.owner.isClass) tree
+    else cpy.ValDef(tree)(rhs = tree.rhs.wildcardToDefault)
+}
+
+object TransformWildcards:
+  val name: String = "transformWildcards"
+  val description: String = "replace wildcards with default values"
diff --git a/tests/pos-with-compiler-cc/dotc/transform/TreeChecker.scala b/tests/pos-with-compiler-cc/dotc/transform/TreeChecker.scala
new file mode 100644
index 000000000000..6b4b0bc4545a
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/transform/TreeChecker.scala
@@ -0,0 +1,725 @@
+package dotty.tools.dotc
+package transform
+
+import core.Names.Name
+import core.DenotTransformers._
+import core.SymDenotations._
+import core.Contexts._
+import core.Symbols._
+import core.Types._
+import core.Flags._
+import core.StdNames._
+import core.NameKinds.{DocArtifactName, OuterSelectName}
+import core.Decorators._
+import core.Phases._
+import core.Mode
+import typer._
+import reporting._
+import ast.Trees._
+import ast.{tpd, untpd}
+import util.Chars._
+import collection.mutable
+import ProtoTypes._
+
+import dotty.tools.backend.jvm.DottyBackendInterface.symExtensions
+
+import scala.util.control.NonFatal
+
+/** Run by -Ycheck option after a given phase, this class retypes all syntax trees
+ *  and verifies that the type of each tree node so obtained conforms to the type found in the tree node.
+ *  It also performs the following checks:
+ *
+ *   - The owner of each definition is the same as the owner of the current typing context.
+ *   - Ident nodes do not refer to a denotation that would need a select to be accessible
+ *     (see tpd.needsSelect).
+ *   - After typer, identifiers and select nodes refer to terms only (all types should be
+ *     represented as TypeTrees then).
+ */
+class TreeChecker extends Phase with SymTransformer {
+  import ast.tpd._
+  import TreeChecker._
+
+  private val seenClasses = collection.mutable.HashMap[String, Symbol]()
+  private val seenModuleVals = collection.mutable.HashMap[String, Symbol]()
+
+  def isValidJVMName(name: Name): Boolean = name.toString.forall(isValidJVMChar)
+
+  def isValidJVMMethodName(name: Name): Boolean = name.toString.forall(isValidJVMMethodChar)
+
+  val NoSuperClassFlags: FlagSet = Trait | Package
+
+  def testDuplicate(sym: Symbol, registry: mutable.Map[String, Symbol], typ: String)(using Context): Unit = {
+    val name = sym.javaClassName
+    val isDuplicate = this.flatClasses && registry.contains(name)
+    assert(!isDuplicate, s"$typ defined twice $sym ${sym.id} ${registry(name).id}")
+    registry(name) = sym
+  }
+
+  def checkCompanion(symd: SymDenotation)(using Context): Unit = {
+    val cur = symd.linkedClass
+    val prev = atPhase(ctx.phase.prev) {
+      symd.symbol.linkedClass
+    }
+
+    if (prev.exists)
+      assert(cur.exists || prev.is(ConstructorProxy), i"companion disappeared from $symd")
+  }
+
+  def transformSym(symd: SymDenotation)(using Context): SymDenotation = {
+    val sym = symd.symbol
+
+    if (sym.isClass && !sym.isAbsent()) {
+      val validSuperclass = sym.isPrimitiveValueClass || defn.syntheticCoreClasses.contains(sym) ||
+        (sym eq defn.ObjectClass) || sym.isOneOf(NoSuperClassFlags) || (sym.asClass.superClass.exists) ||
+        sym.isRefinementClass
+
+      assert(validSuperclass, i"$sym has no superclass set")
+      testDuplicate(sym, seenClasses, "class")
+    }
+
+    val badDeferredAndPrivate =
+      sym.is(Method) && sym.is(Deferred) && sym.is(Private)
+      && !sym.hasAnnotation(defn.NativeAnnot)
+      && !sym.isEffectivelyErased
+
+    assert(!badDeferredAndPrivate, i"$sym is both Deferred and Private")
+
+    checkCompanion(symd)
+
+    // Signatures are used to disambiguate overloads and need to stay stable
+    // until erasure, see the comment above `Compiler#phases`.
+    if (ctx.phaseId <= erasurePhase.id) {
+      val initial = symd.initial
+      assert(symd == initial || symd.signature == initial.signature,
+        i"""Signature of ${sym} in ${sym.ownersIterator.toList}%, % changed at phase ${ctx.phase.prevMega}
+           |Initial info: ${initial.info}
+           |Initial sig : ${initial.signature}
+           |Current info: ${symd.info}
+           |Current sig : ${symd.signature}""")
+    }
+
+    symd
+  }
+
+  def phaseName: String = "Ycheck"
+
+  def run(using Context): Unit =
+    if (ctx.settings.YtestPickler.value && ctx.phase.prev.isInstanceOf[Pickler])
+      report.echo("Skipping Ycheck after pickling with -Ytest-pickler, the returned tree contains stale symbols")
+    else if (ctx.phase.prev.isCheckable)
+      check(ctx.base.allPhases.toIndexedSeq, ctx)
+
+  private def previousPhases(phases: List[Phase])(using Context): List[Phase] = phases match {
+    case (phase: MegaPhase) :: phases1 =>
+      val subPhases = phase.miniPhases
+      val previousSubPhases = previousPhases(subPhases.toList)
+      if (previousSubPhases.length == subPhases.length) previousSubPhases ::: previousPhases(phases1)
+      else previousSubPhases
+    case phase :: phases1 if phase ne ctx.phase =>
+      phase :: previousPhases(phases1)
+    case _ =>
+      Nil
+  }
+
+  def check(phasesToRun: Seq[Phase], ctx: Context): Tree = {
+    val fusedPhase = ctx.phase.prevMega(using ctx)
+    report.echo(s"checking ${ctx.compilationUnit} after phase ${fusedPhase}")(using ctx)
+
+    inContext(ctx) {
+      assert(ctx.typerState.constraint.domainLambdas.isEmpty,
+        i"non-empty constraint at end of $fusedPhase: ${ctx.typerState.constraint}, ownedVars = ${ctx.typerState.ownedVars.toList}%, %")
+      assertSelectWrapsNew(ctx.compilationUnit.tpdTree)
+      TreeNodeChecker.traverse(ctx.compilationUnit.tpdTree)
+    }
+
+    val checkingCtx = ctx
+        .fresh
+        .addMode(Mode.ImplicitsEnabled)
+        .setReporter(new ThrowingReporter(ctx.reporter))
+
+    val checker = inContext(ctx) {
+      new Checker(previousPhases(phasesToRun.toList))
+    }
+    try checker.typedExpr(ctx.compilationUnit.tpdTree)(using checkingCtx)
+    catch {
+      case NonFatal(ex) =>     //TODO CHECK. Check that we are bootstrapped
+        inContext(checkingCtx) {
+          println(i"*** error while checking ${ctx.compilationUnit} after phase ${ctx.phase.prevMega(using ctx)} ***")
+        }
+        throw ex
+    }
+  }
+
+  class Checker(phasesToCheck: Seq[Phase]) extends ReTyper with Checking {
+
+    private val nowDefinedSyms = util.HashSet[Symbol]()
+    private val patBoundSyms = util.HashSet[Symbol]()
+    private val everDefinedSyms = MutableSymbolMap[untpd.Tree]()
+
+    // don't check value classes after typer, as the constraint about constructors doesn't hold after transform
+    override def checkDerivedValueClass(clazz: Symbol, stats: List[Tree])(using Context): Unit = ()
+
+    def withDefinedSyms[T](trees: List[untpd.Tree])(op: => T)(using Context): T = {
+      var locally = List.empty[Symbol]
+      for (tree <- trees) {
+        val sym = tree.symbol
+        tree match {
+          case tree: untpd.DefTree =>
+            assert(isValidJVMName(sym.name.encode), s"${sym.name.debugString} name is invalid on jvm")
+            everDefinedSyms.get(sym) match {
+              case Some(t)  =>
+                if (t ne tree)
+                  report.warning(i"symbol ${sym.fullName} is defined at least twice in different parts of AST")
+              // should become an error
+              case None =>
+                everDefinedSyms(sym) = tree
+            }
+            assert(!nowDefinedSyms.contains(sym), i"doubly defined symbol: ${sym.fullName} in $tree")
+
+            if (ctx.settings.YcheckMods.value)
+              tree match {
+                case t: untpd.MemberDef =>
+                  if (t.name ne sym.name) report.warning(s"symbol ${sym.fullName} name doesn't correspond to AST: ${t}")
+                // todo: compare trees inside annotations
+                case _ =>
+              }
+            locally = sym :: locally
+            nowDefinedSyms += sym
+          case _ =>
+        }
+      }
+      val res = op
+      nowDefinedSyms --= locally
+      res
+    }
+
+    /** The following invariant holds:
+     *
+     *  patBoundSyms.contains(sym) <=> sym.isPatternBound
+     */
+    def withPatSyms[T](syms: List[Symbol])(op: => T)(using Context): T = {
+      syms.foreach { sym =>
+        assert(
+          sym.isPatternBound,
+          "patBoundSyms.contains(sym) => sym.isPatternBound is broken." +
+          i" Pattern bound symbol $sym has incorrect flags: " + sym.flagsString + ", line " + sym.srcPos.line
+        )
+      }
+      patBoundSyms ++= syms
+      val res = op
+      patBoundSyms --= syms
+      res
+    }
+
+    // used to check invariant of lambda encoding
+    var nestingBlock: untpd.Block | Null = null
+    private def withBlock[T](block: untpd.Block)(op: => T): T = {
+      val outerBlock = nestingBlock
+      nestingBlock = block
+      val res = op
+      nestingBlock = outerBlock
+      res
+    }
+
+    def assertDefined(tree: untpd.Tree)(using Context): Unit =
+      if (tree.symbol.maybeOwner.isTerm) {
+        val sym = tree.symbol
+        assert(
+          nowDefinedSyms.contains(sym) || patBoundSyms.contains(sym),
+          i"undefined symbol ${sym} at line " + tree.srcPos.line
+        )
+
+        if (!ctx.phase.patternTranslated)
+          assert(
+            !sym.isPatternBound || patBoundSyms.contains(sym),
+            i"sym.isPatternBound => patBoundSyms.contains(sym) is broken, sym = $sym, line " + tree.srcPos.line
+          )
+      }
+
+    /** assert Java classes are not used as objects */
+    def assertIdentNotJavaClass(tree: Tree)(using Context): Unit = tree match {
+      case _ : untpd.Ident =>
+        assert(!tree.symbol.isAllOf(JavaModule), "Java class can't be used as value: " + tree)
+      case _ =>
+    }
+
+    /** check Java classes are not used as objects */
+    def checkIdentNotJavaClass(tree: Tree)(using Context): Unit = tree match {
+      // case tree: untpd.Ident =>
+      // case tree: untpd.Select =>
+      // case tree: untpd.Bind =>
+      case vd : ValDef =>
+        assertIdentNotJavaClass(vd.forceIfLazy)
+      case dd : DefDef =>
+        assertIdentNotJavaClass(dd.forceIfLazy)
+      // case tree: untpd.TypeDef =>
+      case Apply(fun, args) =>
+        assertIdentNotJavaClass(fun)
+        args.foreach(assertIdentNotJavaClass _)
+      // case tree: untpd.This =>
+      // case tree: untpd.Literal =>
+      // case tree: untpd.New =>
+      case Typed(expr, _) =>
+        assertIdentNotJavaClass(expr)
+      case NamedArg(_, arg) =>
+        assertIdentNotJavaClass(arg)
+      case Assign(_, rhs) =>
+        assertIdentNotJavaClass(rhs)
+      case Block(stats, expr) =>
+        stats.foreach(assertIdentNotJavaClass _)
+        assertIdentNotJavaClass(expr)
+      case If(_, thenp, elsep) =>
+        assertIdentNotJavaClass(thenp)
+        assertIdentNotJavaClass(elsep)
+      // case tree: untpd.Closure =>
+      case Match(selector, cases) =>
+        assertIdentNotJavaClass(selector)
+        cases.foreach(caseDef => assertIdentNotJavaClass(caseDef.body))
+      case Return(expr, _) =>
+        assertIdentNotJavaClass(expr)
+      case Try(expr, cases, finalizer) =>
+        assertIdentNotJavaClass(expr)
+        cases.foreach(caseDef => assertIdentNotJavaClass(caseDef.body))
+        assertIdentNotJavaClass(finalizer)
+      // case tree: TypeApply =>
+      // case tree: Super =>
+      case SeqLiteral(elems, _) =>
+        elems.foreach(assertIdentNotJavaClass)
+      // case tree: TypeTree =>
+      // case tree: SingletonTypeTree =>
+      // case tree: RefinedTypeTree =>
+      // case tree: AppliedTypeTree =>
+      // case tree: ByNameTypeTree =>
+      // case tree: TypeBoundsTree =>
+      // case tree: Alternative =>
+      // case tree: PackageDef =>
+      case Annotated(arg, _) =>
+        assertIdentNotJavaClass(arg)
+      case _ =>
+    }
+
+    /** Exclude from double definition checks any erased symbols that were
+     *  made `private` in phase `UnlinkErasedDecls`. These symbols will be removed
+     *  completely in phase `Erasure` if they are defined in a currently compiled unit.
+     */
+    override def excludeFromDoubleDeclCheck(sym: Symbol)(using Context): Boolean =
+      sym.isEffectivelyErased && sym.is(Private) && !sym.initial.is(Private)
+
+    /** Check that all invariants related to Super and SuperType are met */
+    def checkSuper(tree: Tree)(implicit ctx: Context): Unit = tree match
+      case Super(qual, mix) =>
+        tree.tpe match
+          case tp @ SuperType(thistpe, supertpe) =>
+            if (!mix.isEmpty)
+              assert(supertpe.isInstanceOf[TypeRef],
+                s"Precondition of pickling violated: the supertpe in $tp is not a TypeRef even though $tree has a non-empty mix")
+          case tp =>
+            assert(false, s"The type of a Super tree must be a SuperType, but $tree has type $tp")
+      case _ =>
+        tree.tpe match
+          case tp: SuperType =>
+            assert(false, s"The type of a non-Super tree must not be a SuperType, but $tree has type $tp")
+          case _ =>
+
+    override def typed(tree: untpd.Tree, pt: Type = WildcardType)(using Context): Tree = {
+      val tpdTree = super.typed(tree, pt)
+      Typer.assertPositioned(tree)
+      checkSuper(tpdTree)
+      if (ctx.erasedTypes)
+        // Can't be checked in earlier phases since `checkValue` is only run in
+        // Erasure (because running it in Typer would force too much)
+        checkIdentNotJavaClass(tpdTree)
+      tpdTree
+    }
+
+    override def typedUnadapted(tree: untpd.Tree, pt: Type, locked: TypeVars)(using Context): Tree = {
+      val res = tree match {
+        case _: untpd.TypedSplice | _: untpd.Thicket | _: EmptyValDef[?] =>
+          super.typedUnadapted(tree, pt, locked)
+        case _ if tree.isType =>
+          promote(tree)
+        case _ =>
+          val tree1 = super.typedUnadapted(tree, pt, locked)
+          def isSubType(tp1: Type, tp2: Type) =
+            (tp1 eq tp2) || // accept NoType / NoType
+            (tp1 <:< tp2)
+          def divergenceMsg(tp1: Type, tp2: Type) =
+            s"""Types differ
+               |Original type : ${tree.typeOpt.show}
+               |After checking: ${tree1.tpe.show}
+               |Original tree : ${tree.show}
+               |After checking: ${tree1.show}
+               |Why different :
+             """.stripMargin + core.TypeComparer.explained(_.isSubType(tp1, tp2))
+          if (tree.hasType) // it might not be typed because Typer sometimes constructs new untyped trees and resubmits them to typedUnadapted
+            assert(isSubType(tree1.tpe, tree.typeOpt), divergenceMsg(tree1.tpe, tree.typeOpt))
+          tree1
+      }
+      checkNoOrphans(res.tpe)
+      phasesToCheck.foreach(_.checkPostCondition(res))
+      res
+    }
+
+    def checkNotRepeated(tree: Tree)(using Context): tree.type = {
+      def allowedRepeated = tree.tpe.widen.isRepeatedParam
+
+      assert(!tree.tpe.widen.isRepeatedParam || allowedRepeated, i"repeated parameter type not allowed here: $tree")
+      tree
+    }
+
+    /** Check that all methods have MethodicType */
+    def isMethodType(pt: Type)(using Context): Boolean = pt match {
+      case at: AnnotatedType => isMethodType(at.parent)
+      case _: MethodicType => true  // MethodType, ExprType, PolyType
+      case _ => false
+    }
+
+    override def typedIdent(tree: untpd.Ident, pt: Type)(using Context): Tree = {
+      assert(tree.isTerm || !ctx.isAfterTyper, tree.show + " at " + ctx.phase)
+      assert(tree.isType || ctx.mode.is(Mode.Pattern) && untpd.isWildcardArg(tree) || !needsSelect(tree.tpe), i"bad type ${tree.tpe} for $tree # ${tree.uniqueId}")
+      assertDefined(tree)
+
+      checkNotRepeated(super.typedIdent(tree, pt))
+    }
+
+    /** Makes sure the symbol in the tree can be approximately reconstructed by
+     *  calling `member` on the qualifier type.
+     *  Approximately means: The two symbols might be different but one still overrides the other.
+     */
+    override def typedSelect(tree: untpd.Select, pt: Type)(using Context): Tree = {
+      assert(tree.isTerm || !ctx.isAfterTyper, tree.show + " at " + ctx.phase)
+      val tpe = tree.typeOpt
+
+      // Polymorphic apply methods stay structural until Erasure
+      val isPolyFunctionApply = (tree.name eq nme.apply) && tree.qualifier.typeOpt.derivesFrom(defn.PolyFunctionClass)
+      // Outer selects are pickled specially so don't require a symbol
+      val isOuterSelect = tree.name.is(OuterSelectName)
+      val isPrimitiveArrayOp = ctx.erasedTypes && nme.isPrimitiveName(tree.name)
+      if !(tree.isType || isPolyFunctionApply || isOuterSelect || isPrimitiveArrayOp) then
+        val denot = tree.denot
+        assert(denot.exists, i"Selection $tree with type $tpe does not have a denotation")
+        assert(denot.symbol.exists, i"Denotation $denot of selection $tree with type $tpe does not have a symbol, qualifier type = ${tree.qualifier.typeOpt}")
+
+      val sym = tree.symbol
+      val symIsFixed = tpe match {
+        case tpe: TermRef => ctx.erasedTypes || !tpe.isPrefixDependentMemberRef
+        case _ => false
+      }
+      if (sym.exists && !sym.is(Private) &&
+          !symIsFixed &&
+          !isOuterSelect) { // outer selects have effectively fixed symbols
+        val qualTpe = tree.qualifier.typeOpt
+        val member =
+          if (sym.is(Private)) qualTpe.member(tree.name)
+          else qualTpe.nonPrivateMember(tree.name)
+        val memberSyms = member.alternatives.map(_.symbol)
+        assert(memberSyms.exists(mbr =>
+                 sym == mbr ||
+                 sym.overriddenSymbol(mbr.owner.asClass) == mbr ||
+                 mbr.overriddenSymbol(sym.owner.asClass) == sym),
+               ex"""symbols differ for $tree
+                   |was                 : $sym
+                   |alternatives by type: $memberSyms%, % of types ${memberSyms.map(_.info)}%, %
+                   |qualifier type      : ${qualTpe}
+                   |tree type           : ${tree.typeOpt} of class ${tree.typeOpt.getClass}""")
+      }
+
+      checkNotRepeated(super.typedSelect(tree, pt))
+    }
+
+    override def typedThis(tree: untpd.This)(using Context): Tree = {
+      val res = super.typedThis(tree)
+      val cls = res.symbol
+      assert(cls.isStaticOwner || ctx.owner.isContainedIn(cls), i"error while typing $tree, ${ctx.owner} is not contained in $cls")
+      res
+    }
+
+    override def typedSuper(tree: untpd.Super, pt: Type)(using Context): Tree =
+      assert(tree.qual.typeOpt.isInstanceOf[ThisType], i"expect prefix of Super to be This, actual = ${tree.qual}")
+      super.typedSuper(tree, pt)
+
+    override def typedApply(tree: untpd.Apply, pt: Type)(using Context): Tree = tree match
+      case Apply(Select(qual, nme.CONSTRUCTOR), _)
+          if !ctx.phase.erasedTypes
+            && defn.isSpecializedTuple(qual.typeOpt.typeSymbol) =>
+        promote(tree) // e.g. `new Tuple2$mcII$sp(7, 8)` should keep its `(7, 8)` type instead of `Tuple2$mcII$sp`
+      case _ => super.typedApply(tree, pt)
+
+    override def typedTyped(tree: untpd.Typed, pt: Type)(using Context): Tree =
+      val tpt1 = checkSimpleKinded(typedType(tree.tpt))
+      val expr1 = tree.expr match
+        case id: untpd.Ident if (ctx.mode is Mode.Pattern) && untpd.isVarPattern(id) && (id.name == nme.WILDCARD || id.name == nme.WILDCARD_STAR) =>
+          tree.expr.withType(tpt1.tpe)
+        case _ =>
+          var pt1 = tpt1.tpe
+          if pt1.isRepeatedParam then
+            pt1 = pt1.translateFromRepeated(toArray = tree.expr.typeOpt.derivesFrom(defn.ArrayClass))
+          val isAfterInlining =
+            val inliningPhase = ctx.base.inliningPhase
+            inliningPhase.exists && ctx.phase.id > inliningPhase.id
+          if isAfterInlining then
+            // The staging phase destroys in PCPCheckAndHeal the property that
+            // tree.expr.tpe <:< pt1. A test case where this arises is run-macros/enum-nat-macro.
+            // We should follow up why this happens. If the problem is fixed, we can
+            // drop the isAfterInlining special case. To reproduce the problem, just
+            // change the condition from `isAfterInlining` to `false`.
+            typed(tree.expr)
+          else
+            //println(i"typing $tree, ${tree.expr.typeOpt}, $pt1, ${ctx.mode is Mode.Pattern}")
+            typed(tree.expr, pt1)
+      untpd.cpy.Typed(tree)(expr1, tpt1).withType(tree.typeOpt)
+
+    private def checkOwner(tree: untpd.Tree)(using Context): Unit = {
+      def ownerMatches(symOwner: Symbol, ctxOwner: Symbol): Boolean =
+        symOwner == ctxOwner ||
+        ctxOwner.isWeakOwner && ownerMatches(symOwner, ctxOwner.owner)
+      assert(ownerMatches(tree.symbol.owner, ctx.owner),
+        i"bad owner; ${tree.symbol} has owner ${tree.symbol.owner}, expected was ${ctx.owner}\n" +
+        i"owner chain = ${tree.symbol.ownersIterator.toList}%, %, ctxOwners = ${ctx.outersIterator.map(_.owner).toList}%, %")
+    }
+
+    override def typedClassDef(cdef: untpd.TypeDef, cls: ClassSymbol)(using Context): Tree = {
+      val TypeDef(_, impl @ Template(constr, _, _, _)) = cdef: @unchecked
+      assert(cdef.symbol == cls)
+      assert(impl.symbol.owner == cls)
+      assert(constr.symbol.owner == cls)
+      assert(cls.primaryConstructor == constr.symbol, i"mismatch, primary constructor ${cls.primaryConstructor}, in tree = ${constr.symbol}")
+      checkOwner(impl)
+      checkOwner(impl.constr)
+
+      def isNonMagicalMember(x: Symbol) =
+        !x.isValueClassConvertMethod &&
+        !x.name.is(DocArtifactName) &&
+        !(ctx.phase.id >= genBCodePhase.id && x.name == str.MODULE_INSTANCE_FIELD.toTermName)
+
+      val decls   = cls.classInfo.decls.toList.toSet.filter(isNonMagicalMember)
+      val defined = impl.body.map(_.symbol)
+
+      def isAllowed(sym: Symbol): Boolean = sym.is(ConstructorProxy)
+
+      val symbolsNotDefined = (decls -- defined - constr.symbol).filterNot(isAllowed)
+
+      assert(symbolsNotDefined.isEmpty,
+        i" $cls tree does not define members: ${symbolsNotDefined.toList}%, %\n" +
+        i"expected: ${decls.toList}%, %\n" +
+        i"defined: ${defined}%, %")
+
+      super.typedClassDef(cdef, cls)
+    }
+
+    override def typedDefDef(ddef: untpd.DefDef, sym: Symbol)(using Context): Tree =
+      def defParamss = ddef.paramss.filter(!_.isEmpty).nestedMap(_.symbol)
+      def layout(symss: List[List[Symbol]]): String =
+        symss.map(syms => i"($syms%, %)").mkString
+      assert(ctx.erasedTypes || sym.rawParamss == defParamss,
+        i"""param mismatch for ${sym.showLocated}:
+           |defined in tree  = ${layout(defParamss)}
+           |stored in symbol = ${layout(sym.rawParamss)}""")
+      withDefinedSyms(ddef.paramss.flatten) {
+        if (!sym.isClassConstructor && !(sym.name eq nme.STATIC_CONSTRUCTOR))
+          assert(isValidJVMMethodName(sym.name.encode), s"${sym.name.debugString} name is invalid on jvm")
+
+        ddef.termParamss.foreach(_.foreach { vparam =>
+          assert(vparam.symbol.is(Param),
+            s"Parameter ${vparam.symbol} of ${sym.fullName} does not have flag `Param` set")
+          assert(!vparam.symbol.isOneOf(AccessFlags),
+            s"Parameter ${vparam.symbol} of ${sym.fullName} has invalid flag(s): ${(vparam.symbol.flags & AccessFlags).flagsString}")
+        })
+
+        val tpdTree = super.typedDefDef(ddef, sym)
+        assert(isMethodType(sym.info), i"wrong type, expect a method type for ${sym.fullName}, but found: ${sym.info}")
+        tpdTree
+      }
+
+    override def typedCase(tree: untpd.CaseDef, sel: Tree, selType: Type, pt: Type)(using Context): CaseDef =
+      withPatSyms(tpd.patVars(tree.pat.asInstanceOf[tpd.Tree])) {
+        super.typedCase(tree, sel, selType, pt)
+      }
+
+    override def typedClosure(tree: untpd.Closure, pt: Type)(using Context): Tree = {
+      if (!ctx.phase.lambdaLifted) nestingBlock match {
+        case block @ Block((meth : untpd.DefDef) :: Nil, closure: untpd.Closure) =>
+          assert(meth.symbol == closure.meth.symbol, "closure.meth symbol not equal to method symbol. Block: " + block.show)
+
+        case block: untpd.Block =>
+          assert(false, "function literal are not properly formed as a block of DefDef and Closure. Found: " + tree.show + " Nesting block: " + block.show)
+
+        case null =>
+          assert(false, "function literal are not properly formed as a block of DefDef and Closure. Found: " + tree.show + " Nesting block: null")
+      }
+      super.typedClosure(tree, pt)
+    }
+
+    override def typedBlock(tree: untpd.Block, pt: Type)(using Context): Tree =
+      withBlock(tree) { withDefinedSyms(tree.stats) { super.typedBlock(tree, pt) } }
+
+    override def typedInlined(tree: untpd.Inlined, pt: Type)(using Context): Tree =
+      withDefinedSyms(tree.bindings) { super.typedInlined(tree, pt) }
+
+    /** Check that all defined symbols have legal owners.
+     *  An owner is legal if it is either the same as the context's owner
+     *  or there's an owner chain of valdefs starting at the context's owner and
+     *  reaching up to the symbol's owner. The reason for this relaxed matching
+     *  is that we should be able to pull out an expression as an initializer
+     *  of a helper value without having to do a change owner traversal of the expression.
+     */
+    override def typedStats(trees: List[untpd.Tree], exprOwner: Symbol)(using Context): (List[Tree], Context) = {
+      for (tree <- trees) tree match {
+        case tree: untpd.DefTree => checkOwner(tree)
+        case _: untpd.Thicket => assert(false, i"unexpanded thicket $tree in statement sequence $trees%\n%")
+        case _ =>
+      }
+      super.typedStats(trees, exprOwner)
+    }
+
+    override def typedLabeled(tree: untpd.Labeled)(using Context): Labeled = {
+      checkOwner(tree.bind)
+      withDefinedSyms(tree.bind :: Nil) { super.typedLabeled(tree) }
+    }
+
+    override def typedReturn(tree: untpd.Return)(using Context): Return = {
+      val tree1 = super.typedReturn(tree)
+      val from = tree1.from
+      val fromSym = from.symbol
+      if (fromSym.is(Label))
+        assertDefined(from)
+      tree1
+    }
+
+    override def typedWhileDo(tree: untpd.WhileDo)(using Context): Tree = {
+      assert((tree.cond ne EmptyTree) || ctx.phase.refChecked, i"invalid empty condition in while at $tree")
+      super.typedWhileDo(tree)
+    }
+
+    override def typedPackageDef(tree: untpd.PackageDef)(using Context): Tree =
+      if tree.symbol == defn.StdLibPatchesPackage then
+        promote(tree) // don't check stdlib patches, since their symbols were highjacked by stdlib classes
+      else
+        super.typedPackageDef(tree)
+
+    override def typedHole(tree: untpd.Hole, pt: Type)(using Context): Tree = {
+      val tree1 @ Hole(isTermHole, _, args, content, tpt) = super.typedHole(tree, pt): @unchecked
+
+      // Check result type of the hole
+      if isTermHole then assert(tpt.typeOpt <:< pt)
+      else assert(tpt.typeOpt =:= pt)
+
+      // Check that the types of the args conform to the types of the contents of the hole
+      val argQuotedTypes = args.map { arg =>
+        if arg.isTerm then
+          val tpe = arg.typeOpt.widenTermRefExpr match
+            case _: MethodicType =>
+              // Special erasure for captured function references
+              // See `SpliceTransformer.transformCapturedApplication`
+              defn.AnyType
+            case tpe => tpe
+          defn.QuotedExprClass.typeRef.appliedTo(tpe)
+        else defn.QuotedTypeClass.typeRef.appliedTo(arg.typeOpt)
+      }
+      val expectedResultType =
+        if isTermHole then defn.QuotedExprClass.typeRef.appliedTo(tpt.typeOpt)
+        else defn.QuotedTypeClass.typeRef.appliedTo(tpt.typeOpt)
+      val contextualResult =
+        defn.FunctionOf(List(defn.QuotesClass.typeRef), expectedResultType, isContextual = true)
+      val expectedContentType =
+        defn.FunctionOf(argQuotedTypes, contextualResult)
+      assert(content.typeOpt =:= expectedContentType)
+
+      tree1
+    }
+
+    override def ensureNoLocalRefs(tree: Tree, pt: Type, localSyms: => List[Symbol])(using Context): Tree =
+      tree
+
+    override def adapt(tree: Tree, pt: Type, locked: TypeVars)(using Context): Tree = {
+      def isPrimaryConstructorReturn =
+        ctx.owner.isPrimaryConstructor && pt.isRef(ctx.owner.owner) && tree.tpe.isRef(defn.UnitClass)
+      def infoStr(tp: Type) = tp match {
+        case tp: TypeRef =>
+          val sym = tp.symbol
+          i"${sym.showLocated} with ${tp.designator}, flags = ${sym.flagsString}, underlying = ${tp.underlyingIterator.toList}%, %"
+        case _ =>
+          "??"
+      }
+      if (ctx.mode.isExpr &&
+          !tree.isEmpty &&
+          !isPrimaryConstructorReturn &&
+          !pt.isInstanceOf[FunOrPolyProto])
+        assert(tree.tpe <:< pt, {
+          val mismatch = TypeMismatch(tree.tpe, pt, Some(tree))
+          i"""|${mismatch.msg}
+              |found: ${infoStr(tree.tpe)}
+              |expected: ${infoStr(pt)}
+              |tree = $tree""".stripMargin
+        })
+      tree
+    }
+
+    override def simplify(tree: Tree, pt: Type, locked: TypeVars)(using Context): tree.type = tree
+  }
+
+  /**
+    * Checks that `New` nodes are always wrapped inside `Select` nodes.
+    */
+  def assertSelectWrapsNew(tree: Tree)(using Context): Unit =
+    (new TreeAccumulator[tpd.Tree] {
+      override def apply(parent: Tree, tree: Tree)(using Context): Tree = {
+        tree match {
+          case tree: New if !parent.isInstanceOf[tpd.Select] =>
+            assert(assertion = false, i"`New` node must be wrapped in a `Select`:\n  parent = ${parent.show}\n  child = ${tree.show}")
+          case _: Annotated =>
+            // Don't check inside annotations, since they're allowed to contain
+            // somewhat invalid trees.
+          case _ =>
+            foldOver(tree, tree) // replace the parent when folding over the children
+        }
+        parent // return the old parent so that my siblings see it
+      }
+    })(tpd.EmptyTree, tree)
+}
+
+object TreeChecker {
+  /** - Check that TypeParamRefs and MethodParams refer to an enclosing type.
+   *  - Check that all type variables are instantiated.
+   */
+  def checkNoOrphans(tp0: Type, tree: untpd.Tree = untpd.EmptyTree)(using Context): Type = new TypeMap() {
+    val definedBinders = new java.util.IdentityHashMap[Type, Any]
+    def apply(tp: Type): Type = {
+      tp match {
+        case tp: BindingType =>
+          definedBinders.put(tp, tp)
+          mapOver(tp)
+          definedBinders.remove(tp)
+        case tp: ParamRef =>
+          assert(definedBinders.get(tp.binder) != null, s"orphan param: ${tp.show}, hash of binder = ${System.identityHashCode(tp.binder)}, tree = ${tree.show}, type = $tp0")
+        case tp: TypeVar =>
+          assert(tp.isInstantiated, s"Uninstantiated type variable: ${tp.show}, tree = ${tree.show}")
+          apply(tp.underlying)
+        case _ =>
+          mapOver(tp)
+      }
+      tp
+    }
+  }.apply(tp0)
+
+  /** Run some additional checks on the nodes of the trees.  Specifically:
+   *
+   *    - TypeTree can only appear in TypeApply args, New, Typed tpt, Closure
+   *      tpt, SeqLiteral elemtpt, ValDef tpt, DefDef tpt, and TypeDef rhs.
+   */
+  object TreeNodeChecker extends untpd.TreeTraverser:
+    import untpd._
+    def traverse(tree: Tree)(using Context) = tree match
+      case t: TypeTree                             => assert(assertion = false, i"TypeTree not expected: $t")
+      case t @ TypeApply(fun, _targs)              => traverse(fun)
+      case t @ New(_tpt)                           =>
+      case t @ Typed(expr, _tpt)                   => traverse(expr)
+      case t @ Closure(env, meth, _tpt)            => traverse(env); traverse(meth)
+      case t @ SeqLiteral(elems, _elemtpt)         => traverse(elems)
+      case t @ ValDef(_, _tpt, _)                  => traverse(t.rhs)
+      case t @ DefDef(_, paramss, _tpt, _)         => for params <- paramss do traverse(params); traverse(t.rhs)
+      case t @ TypeDef(_, _rhs)                    =>
+      case t @ Template(constr, parents, self, _)  => traverse(constr); traverse(parents); traverse(self); traverse(t.body)
+      case t                                       => traverseChildren(t)
+    end traverse
+}
diff --git a/tests/pos-with-compiler-cc/dotc/transform/TreeExtractors.scala b/tests/pos-with-compiler-cc/dotc/transform/TreeExtractors.scala
new file mode 100644
index 000000000000..aec44d5987bf
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/transform/TreeExtractors.scala
@@ -0,0 +1,52 @@
+package dotty.tools.dotc
+package transform
+
+import ast.{Trees, tpd}
+import core._
+import Contexts._, Trees._, Types._, StdNames._, Symbols._
+import ValueClasses._
+
+object TreeExtractors {
+  import tpd._
+
+  /** Match arg1.op(arg2) and extract (arg1, op.symbol, arg2) */
+  object BinaryOp {
+    def unapply(t: Tree)(using Context): Option[(Tree, Symbol, Tree)] = t match {
+      case Apply(sel @ Select(arg1, _), List(arg2)) =>
+        Some((arg1, sel.symbol, arg2))
+      case _ =>
+        None
+    }
+  }
+
+ /** Match new C(args) and extract (C, args).
+  *  Also admit new C(args): T and {new C(args)}.
+  */
+  object NewWithArgs {
+    def unapply(t: Tree)(using Context): Option[(Type, List[Tree])] = t match {
+      case Apply(Select(New(_), nme.CONSTRUCTOR), args) =>
+        Some((t.tpe, args))
+      case Typed(expr, _) => unapply(expr)
+      case Block(Nil, expr) => unapply(expr)
+      case _ =>
+        None
+    }
+  }
+
+  /** For an instance v of a value class like:
+   *    class V(val underlying: X) extends AnyVal
+   *  Match v.underlying() and extract v
+   */
+  object ValueClassUnbox {
+    def unapply(t: Tree)(using Context): Option[Tree] = t match {
+      case Apply(sel @ Select(ref, _), Nil) =>
+        val sym = ref.tpe.widenDealias.typeSymbol
+        if (isDerivedValueClass(sym) && (sel.symbol eq valueClassUnbox(sym.asClass)))
+          Some(ref)
+        else
+          None
+      case _ =>
+        None
+    }
+  }
+}
diff --git a/tests/pos-with-compiler-cc/dotc/transform/TreeMapWithStages.scala b/tests/pos-with-compiler-cc/dotc/transform/TreeMapWithStages.scala
new file mode 100644
index 000000000000..b514b8a7bf11
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/transform/TreeMapWithStages.scala
@@ -0,0 +1,164 @@
+package dotty.tools.dotc
+package transform
+
+import dotty.tools.dotc.ast.{TreeMapWithImplicits, tpd}
+import dotty.tools.dotc.config.Printers.staging
+import dotty.tools.dotc.core.Decorators._
+import dotty.tools.dotc.core.Contexts._
+import dotty.tools.dotc.core.StagingContext._
+import dotty.tools.dotc.core.Symbols._
+import dotty.tools.dotc.util.Property
+
+import scala.collection.mutable
+import scala.annotation.constructorOnly
+
+/** The main transformer class
+ *  @param  level      the current level, where quotes add one and splices subtract one level.
+ *                     The initial level is 0, a level `l` where `l > 0` implies code has been quoted `l` times
+ *                     and `l == -1` is code inside a top level splice (in an inline method).
+ *  @param  levels     a stacked map from symbols to the levels in which they were defined
+ */
+abstract class TreeMapWithStages(@constructorOnly ictx: Context) extends TreeMapWithImplicits {
+
+  import tpd._
+  import TreeMapWithStages._
+
+  /** A map from locally defined symbols to their definition quotation level */
+  private[this] val levelOfMap: mutable.HashMap[Symbol, Int] = ictx.property(LevelOfKey).get
+
+  /** A stack of entered symbols, to be unwound after scope exit */
+  private[this] var enteredSyms: List[Symbol] = Nil
+
+  /** If we are inside a quote or a splice */
+  private[this] var inQuoteOrSplice = false
+
+  /** The quotation level of the definition of the locally defined symbol */
+  protected def levelOf(sym: Symbol): Int = levelOfMap.getOrElse(sym, 0)
+
+  /** Locally defined symbols seen so far by `StagingTransformer.transform` */
+  protected def localSymbols: List[Symbol] = enteredSyms
+
+  /** If we are inside a quote or a splice */
+  protected def isInQuoteOrSplice: Boolean = inQuoteOrSplice
+
+  /** Enter staging level of symbol defined by `tree` */
+  private def markSymbol(sym: Symbol)(using Context): Unit =
+    if level != 0 && !levelOfMap.contains(sym) then
+      levelOfMap(sym) = level
+      enteredSyms = sym :: enteredSyms
+
+  /** Enter staging level of symbol defined by `tree`, if applicable. */
+  private def markDef(tree: Tree)(using Context): Unit = tree match {
+    case tree: DefTree => markSymbol(tree.symbol)
+    case _ =>
+  }
+
+  /** Transform the quote `quote` which contains the quoted `body`.
+   *
+   *  - `quoted.runtime.Expr.quote[T](<body0>)`  --> `quoted.runtime.Expr.quote[T](<body>)`
+   *  - `quoted.Type.of[<body0>](quotes)`  --> `quoted.Type.of[<body>](quotes)`
+   */
+  protected def transformQuotation(body: Tree, quote: Apply)(using Context): Tree =
+    if body.isTerm then
+      cpy.Apply(quote)(quote.fun, body :: Nil)
+    else
+      val TypeApply(fun, _) = quote.fun: @unchecked
+      cpy.Apply(quote)(cpy.TypeApply(quote.fun)(fun, body :: Nil), quote.args)
+
+  /** Transform the expression splice `splice` which contains the spliced `body`. */
+  protected def transformSplice(body: Tree, splice: Apply)(using Context): Tree
+
+  /** Transform the type splice `splice` which contains the spliced `body`. */
+  protected def transformSpliceType(body: Tree, splice: Select)(using Context): Tree
+
+  override def transform(tree: Tree)(using Context): Tree =
+    if (tree.source != ctx.source && tree.source.exists)
+      transform(tree)(using ctx.withSource(tree.source))
+    else reporting.trace(i"StagingTransformer.transform $tree at $level", staging, show = true) {
+      def mapOverTree(lastEntered: List[Symbol]) =
+        try super.transform(tree)
+        finally
+          while (enteredSyms ne lastEntered) {
+            levelOfMap -= enteredSyms.head
+            enteredSyms = enteredSyms.tail
+          }
+
+      def dropEmptyBlocks(tree: Tree): Tree = tree match {
+        case Block(Nil, expr) => dropEmptyBlocks(expr)
+        case _ => tree
+      }
+
+      tree match {
+        case Apply(Select(Quoted(quotedTree), _), _) if quotedTree.isType =>
+          dropEmptyBlocks(quotedTree) match
+            case SplicedType(t) =>
+              // Optimization: `quoted.Type.of[x.Underlying]` --> `x`
+              transform(t)
+            case _ =>
+              super.transform(tree)
+
+        case tree @ Quoted(quotedTree) =>
+          val old = inQuoteOrSplice
+          inQuoteOrSplice = true
+          try dropEmptyBlocks(quotedTree) match {
+            case Spliced(t) =>
+              // Optimization: `'{ $x }` --> `x`
+              // and adapt the refinement of `Quotes { type reflect: ... } ?=> Expr[T]`
+              transform(t).asInstance(tree.tpe)
+            case _ => transformQuotation(quotedTree, tree)
+          }
+          finally inQuoteOrSplice = old
+
+        case tree @ Spliced(splicedTree) =>
+          val old = inQuoteOrSplice
+          inQuoteOrSplice = true
+          try dropEmptyBlocks(splicedTree) match {
+            case Quoted(t) =>
+              // Optimization: `${ 'x }` --> `x`
+              transform(t)
+            case _ => transformSplice(splicedTree, tree)
+          }
+          finally inQuoteOrSplice = old
+
+        case tree @ SplicedType(splicedTree) =>
+          val old = inQuoteOrSplice
+          inQuoteOrSplice = true
+          try transformSpliceType(splicedTree, tree)
+          finally inQuoteOrSplice = old
+
+        case Block(stats, _) =>
+          val last = enteredSyms
+          stats.foreach(markDef)
+          mapOverTree(last)
+
+        case CaseDef(pat, guard, body) =>
+          val last = enteredSyms
+          tpd.patVars(pat).foreach(markSymbol)
+          mapOverTree(last)
+
+        case (_:Import | _:Export) =>
+          tree
+
+        case _: Template =>
+          val last = enteredSyms
+          tree.symbol.owner.info.decls.foreach(markSymbol)
+          mapOverTree(last)
+
+        case _ =>
+          markDef(tree)
+          mapOverTree(enteredSyms)
+      }
+    }
+}
+
+
+object TreeMapWithStages {
+
+  /** A key to be used in a context property that caches the `levelOf` mapping */
+  private val LevelOfKey = new Property.Key[mutable.HashMap[Symbol, Int]]
+
+  /** Initial context for a StagingTransformer transformation. */
+  def freshStagingContext(using Context): Context =
+    ctx.fresh.setProperty(LevelOfKey, new mutable.HashMap[Symbol, Int])
+
+}
diff --git a/tests/pos-with-compiler-cc/dotc/transform/TryCatchPatterns.scala b/tests/pos-with-compiler-cc/dotc/transform/TryCatchPatterns.scala
new file mode 100644
index 000000000000..f9779cbbfee4
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/transform/TryCatchPatterns.scala
@@ -0,0 +1,104 @@
+package dotty.tools.dotc
+package transform
+
+import core.Symbols._
+import core.StdNames._
+import core.Types._
+import core.NameKinds.ExceptionBinderName
+import dotty.tools.dotc.core.Flags
+import dotty.tools.dotc.core.Contexts._
+import dotty.tools.dotc.transform.MegaPhase.MiniPhase
+import dotty.tools.dotc.util.Spans.Span
+
+/** Compiles the cases that can not be handled by primitive catch cases as a common pattern match.
+ *
+ *  The following code:
+ *    ```
+ *    try { <code> }
+ *    catch {
+ *      <tryCases> // Cases that can be handled by catch
+ *      <patternMatchCases> // Cases starting with first one that can't be handled by catch
+ *    }
+ *    ```
+ *  will become:
+ *    ```
+ *    try { <code> }
+ *    catch {
+ *      <tryCases>
+ *      case e => e match {
+ *        <patternMatchCases>
+ *      }
+ *    }
+ *    ```
+ *
+ *  Cases that are not supported include:
+ *   - Applies and unapplies
+ *   - Idents
+ *   - Alternatives
+ *   - `case _: T =>` where `T` is not `Throwable`
+ *
+ */
+class TryCatchPatterns extends MiniPhase {
+  import dotty.tools.dotc.ast.tpd._
+
+  override def phaseName: String = TryCatchPatterns.name
+
+  override def description: String = TryCatchPatterns.description
+
+  override def runsAfter: Set[String] = Set(ElimRepeated.name)
+
+  override def checkPostCondition(tree: Tree)(using Context): Unit = tree match {
+    case Try(_, cases, _) =>
+      cases.foreach { (t: CaseDef) => t match // !cc! explicity typed scrutinee is needed
+        case CaseDef(Typed(_, _), guard, _) => assert(guard.isEmpty, "Try case should not contain a guard.")
+        case CaseDef(Bind(_, _), guard, _) => assert(guard.isEmpty, "Try case should not contain a guard.")
+        case c =>
+          assert(isDefaultCase(c), "Pattern in Try should be Bind, Typed or default case.")
+      }
+    case _ =>
+  }
+
+  override def transformTry(tree: Try)(using Context): Tree = {
+    val (tryCases, patternMatchCases) = tree.cases.span(isCatchCase)
+    val fallbackCase = mkFallbackPatterMatchCase(patternMatchCases, tree.span)
+    cpy.Try(tree)(cases = tryCases ++ fallbackCase)
+  }
+
+  /** Is this pattern node a catch-all or type-test pattern? */
+  private def isCatchCase(cdef: CaseDef)(using Context): Boolean = cdef match {
+    case CaseDef(Typed(Ident(nme.WILDCARD), tpt), EmptyTree, _)          => isSimpleThrowable(tpt.tpe)
+    case CaseDef(Bind(_, Typed(Ident(nme.WILDCARD), tpt)), EmptyTree, _) => isSimpleThrowable(tpt.tpe)
+    case _                                                               => isDefaultCase(cdef)
+  }
+
+  private def isSimpleThrowable(tp: Type)(using Context): Boolean = tp.stripped match {
+    case tp @ TypeRef(pre, _) =>
+      (pre == NoPrefix || pre.typeSymbol.isStatic) && // Does not require outer class check
+      !tp.symbol.is(Flags.Trait) && // Traits not supported by JVM
+      tp.derivesFrom(defn.ThrowableClass)
+    case tp: AppliedType =>
+      isSimpleThrowable(tp.tycon)
+    case _ =>
+      false
+  }
+
+  private def mkFallbackPatterMatchCase(patternMatchCases: List[CaseDef], span: Span)(
+      implicit ctx: Context): Option[CaseDef] =
+    if (patternMatchCases.isEmpty) None
+    else {
+      val exName = ExceptionBinderName.fresh()
+      val fallbackSelector =
+        newSymbol(ctx.owner, exName, Flags.Synthetic | Flags.Case, defn.ThrowableType, coord = span)
+      val sel = Ident(fallbackSelector.termRef).withSpan(span)
+      val rethrow = CaseDef(EmptyTree, EmptyTree, Throw(ref(fallbackSelector)))
+      Some(CaseDef(
+          Bind(fallbackSelector, Underscore(fallbackSelector.info).withSpan(span)),
+          EmptyTree,
+          transformFollowing(Match(sel, patternMatchCases ::: rethrow :: Nil)))
+      )
+    }
+}
+
+object TryCatchPatterns:
+  val name: String = "tryCatchPatterns"
+  val description: String = "compile cases in try/catch"
diff --git a/tests/pos-with-compiler-cc/dotc/transform/TupleOptimizations.scala b/tests/pos-with-compiler-cc/dotc/transform/TupleOptimizations.scala
new file mode 100644
index 000000000000..6bc2f438eb37
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/transform/TupleOptimizations.scala
@@ -0,0 +1,221 @@
+package dotty.tools.dotc
+package transform
+
+import core._
+import Contexts._
+import Decorators._
+import Definitions._
+import DenotTransformers._
+import StdNames._
+import Symbols._
+import MegaPhase._
+import Types._
+import dotty.tools.dotc.ast.tpd
+
+
+/** Optimize generic operations on tuples */
+class TupleOptimizations extends MiniPhase with IdentityDenotTransformer {
+  import tpd._
+
+  override def phaseName: String = TupleOptimizations.name
+
+  override def description: String = TupleOptimizations.description
+
+  override def transformApply(tree: tpd.Apply)(using Context): tpd.Tree =
+    if (!tree.symbol.exists || tree.symbol.owner != defn.RuntimeTuplesModuleClass) tree
+    else if (tree.symbol == defn.RuntimeTuples_cons) transformTupleCons(tree)
+    else if (tree.symbol == defn.RuntimeTuples_tail) transformTupleTail(tree)
+    else if (tree.symbol == defn.RuntimeTuples_size) transformTupleSize(tree)
+    else if (tree.symbol == defn.RuntimeTuples_concat) transformTupleConcat(tree)
+    else if (tree.symbol == defn.RuntimeTuples_apply) transformTupleApply(tree)
+    else if (tree.symbol == defn.RuntimeTuples_toArray) transformTupleToArray(tree)
+    else tree
+
+  private def transformTupleCons(tree: tpd.Apply)(using Context): Tree = {
+    val head :: tail :: Nil = tree.args: @unchecked
+    defn.tupleTypes(tree.tpe.widenTermRefExpr.dealias) match {
+      case Some(tpes) =>
+        // Generate a the tuple directly with TupleN+1.apply
+        val size = tpes.size
+        if (size <= 5)
+          // val t = tail
+          // TupleN+1(head, t._1, ..., t._n)
+          evalOnce(Typed(tail, TypeTree(defn.tupleType(tpes.tail)))) { tup =>
+            val elements = head :: tupleSelectors(tup, size - 1)
+            knownTupleFromElements(tpes, elements)
+          }
+        else {
+          // val it = Iterator.single(head) ++ tail.asInstanceOf[Product].productIterator
+          // TupleN+1(it.next(), ..., it.next())
+          val fullIterator = ref(defn.RuntimeTuples_consIterator).appliedToTermArgs(head :: tail :: Nil)
+          evalOnce(fullIterator) { it =>
+            knownTupleFromIterator(tpes.length, it).asInstance(tree.tpe)
+          }
+        }
+      case _ =>
+        // No optimization, keep:
+        // scala.runtime.Tuples.cons(tail, head)
+        tree
+    }
+  }
+
+  private def transformTupleTail(tree: tpd.Apply)(using Context): Tree = {
+    val Apply(_, tup :: Nil) = tree: @unchecked
+    defn.tupleTypes(tup.tpe.widenTermRefExpr.dealias, MaxTupleArity + 1) match {
+      case Some(tpes) =>
+        // Generate a the tuple directly with TupleN-1.apply
+        val size = tpes.size
+        assert(size > 0)
+        if (size == 1)
+          // scala.EmptyTuple
+          ref(defn.EmptyTupleModule.termRef)
+        else if (size <= 5)
+          // val t = tup.asInstanceOf[TupleN[...]]
+          // TupleN-1(t._2, ..., t._n)
+          evalOnce(Typed(tup, TypeTree(defn.tupleType(tpes)))) { tup =>
+            val elements = tupleSelectors(tup, size).tail
+            knownTupleFromElements(tpes.tail, elements)
+          }
+        else if (size <= MaxTupleArity + 1)
+          // val it = this.asInstanceOf[Product].productIterator
+          // it.next()
+          // TupleN-1(it.next(), ..., it.next())
+          evalOnce(tup.asInstance(defn.ProductClass.typeRef).select(nme.productIterator)) { it =>
+            Block(
+              it.select(nme.next).ensureApplied :: Nil,
+              knownTupleFromIterator(size - 1, it).asInstance(tree.tpe)
+            )
+          }
+        else
+          // tup.asInstanceOf[TupleXXL].tailXXL
+          tup.asInstance(defn.TupleXXLClass.typeRef).select("tailXXL".toTermName)
+      case None =>
+        // No optimization, keep:
+        // scala.runtime.Tuples.tail(tup)
+        tree
+    }
+  }
+
+  private def transformTupleSize(tree: tpd.Apply)(using Context): Tree =
+    tree.tpe.tryNormalize match {
+      case tp: ConstantType => Literal(tp.value)
+      case _ => tree
+    }
+
+  private def transformTupleConcat(tree: tpd.Apply)(using Context): Tree = {
+    val Apply(_, self :: that :: Nil) = tree: @unchecked
+    (defn.tupleTypes(self.tpe.widenTermRefExpr.dealias), defn.tupleTypes(that.tpe.widenTermRefExpr.dealias)) match {
+      case (Some(tpes1), Some(tpes2)) =>
+        // Generate a the tuple directly with TupleN+M.apply
+        val n = tpes1.size
+        val m = tpes2.size
+        if (n == 0) that
+        else if (m == 0) self
+        else if (n + m < 5)
+          // val t = self
+          // val u = that
+          // TupleN+M(t._1,..., t._N, u._1, ..., u._M)
+          evalOnce(Typed(self, TypeTree(defn.tupleType(tpes1)))) { self =>
+            evalOnce(Typed(that, TypeTree(defn.tupleType(tpes2)))) { that =>
+              val types = tpes1 ::: tpes2
+              val elements = tupleSelectors(self, n) ::: tupleSelectors(that, m)
+              knownTupleFromElements(types, elements)
+            }
+          }
+        else {
+          // val it = self.asInstanceOf[Product].productIterator ++ that.asInstanceOf[Product].productIterator
+          // TupleN+M(it.next(), ..., it.next())
+          val fullIterator = ref(defn.RuntimeTuples_concatIterator).appliedToTermArgs(tree.args)
+          evalOnce(fullIterator) { it =>
+            knownTupleFromIterator(n + m, it).asInstance(tree.tpe)
+          }
+        }
+      case _ =>
+        // No optimization, keep:
+        // scala.runtime.Tuples.cons(self, that)
+        tree
+    }
+  }
+
+  private def transformTupleApply(tree: tpd.Apply)(using Context): Tree = {
+    val Apply(_, tup :: nTree :: Nil) = tree: @unchecked
+    (defn.tupleTypes(tup.tpe.widenTermRefExpr.dealias), nTree.tpe) match {
+      case (Some(tpes), nTpe: ConstantType) =>
+        // Get the element directly with TupleM._n+1 or TupleXXL.productElement(n)
+        val size = tpes.size
+        val n = nTpe.value.intValue
+        if (n < 0 || n >= size) {
+          report.error("index out of bounds: " + n, nTree.underlyingArgument.srcPos)
+          tree
+        }
+        else if (size <= MaxTupleArity)
+          // tup._n
+          Typed(tup, TypeTree(defn.tupleType(tpes))).select(nme.selectorName(n))
+        else
+          // tup.asInstanceOf[TupleXXL].productElement(n)
+          tup.asInstance(defn.TupleXXLClass.typeRef).select(nme.productElement).appliedTo(Literal(nTpe.value))
+      case (None, nTpe: ConstantType) if nTpe.value.intValue < 0 =>
+        report.error("index out of bounds: " + nTpe.value.intValue, nTree.srcPos)
+        tree
+      case _ =>
+        // No optimization, keep:
+        // scala.runtime.Tuples.apply(tup, n)
+        tree
+    }
+  }
+
+  private def transformTupleToArray(tree: tpd.Apply)(using Context): Tree = {
+    val Apply(_, tup :: Nil) = tree: @unchecked
+    defn.tupleTypes(tup.tpe.widen, MaxTupleArity) match {
+      case Some(tpes) =>
+        val size = tpes.size
+        if (size == 0)
+          // Array.emptyObjectArray
+          ref(defn.ArrayModule).select("emptyObjectArray".toTermName).ensureApplied.withSpan(tree.span)
+        else if (size <= MaxTupleArity)
+          // scala.runtime.Tuples.productToArray(tup.asInstanceOf[Product])
+          ref(defn.RuntimeTuples_productToArray).appliedTo(tup.asInstance(defn.ProductClass.typeRef))
+        else
+          // tup.asInstanceOf[TupleXXL].elems.clone()
+          tup.asInstance(defn.TupleXXLClass.typeRef).select(nme.toArray)
+      case None =>
+        // No optimization, keep:
+        // scala.runtime.Tuples.toArray(tup)
+        tree
+    }
+  }
+
+  /** Create a TupleN (1 <= N < 23) from the elements */
+  private def knownTupleFromElements(tpes: List[Type], elements: List[Tree])(using Context) = {
+    val size = elements.size
+    assert(0 < size && size <= MaxTupleArity)
+    val tupleModule = defn.TupleType(size).nn.classSymbol.companionModule
+    ref(tupleModule).select(nme.apply).appliedToTypes(tpes).appliedToTermArgs(elements)
+  }
+
+  private def knownTupleFromIterator(size: Int, it: Tree)(using Context): Tree =
+    if (size == 0)
+      // EmptyTuple for empty tuple
+      ref(defn.EmptyTupleModule.termRef) // TODO should this code be here? Or assert(size > specializedSize)
+    else if (size <= MaxTupleArity) {
+      // TupleN(it.next(), ..., it.next())
+
+      // TODO outline this code for the 22 alternatives (or less, may not need the smallest ones)?
+      // This would yield smaller bytecode at the cost of an extra (easily JIT inlinable) call.
+      // def tupleN(it: Iterator[Any]): TupleN[Any, ..., Any] = Tuple(it.next(), ..., it.next())
+      val tpes = List.fill(size)(defn.AnyType)
+      val elements = (0 until size).map(_ => it.select(nme.next)).toList
+      knownTupleFromElements(tpes, elements)
+    }
+    else
+      // No optimization, keep:
+      // TupleXXL.fromIterator(it)
+      ref(defn.TupleXXL_fromIterator).appliedTo(it)
+
+  private def tupleSelectors(tup: Tree, size: Int)(using Context): List[Tree] =
+    (0 until size).map(i => tup.select(nme.selectorName(i))).toList
+}
+
+object TupleOptimizations:
+  val name: String = "genericTuples"
+  val description: String = "optimize generic operations on tuples"
diff --git a/tests/pos-with-compiler-cc/dotc/transform/TypeTestsCasts.scala b/tests/pos-with-compiler-cc/dotc/transform/TypeTestsCasts.scala
new file mode 100644
index 000000000000..7db89300e710
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/transform/TypeTestsCasts.scala
@@ -0,0 +1,393 @@
+package dotty.tools
+package dotc
+package transform
+
+import scala.language.unsafeNulls as _
+
+import core._
+import Contexts._, Symbols._, Types._, Constants._, StdNames._, Decorators._
+import ast.untpd
+import Erasure.Boxing._
+import TypeErasure._
+import ValueClasses._
+import SymUtils._
+import core.Flags._
+import util.Spans._
+import reporting._
+import config.Printers.{ transforms => debug }
+import language.experimental.pureFunctions
+
+/** This transform normalizes type tests and type casts,
+ *  also replacing type tests with singleton argument type with reference equality check
+ *  Any remaining type tests
+ *   - use the object methods $isInstanceOf and $asInstanceOf
+ *   - have a reference type as receiver
+ *   - can be translated directly to machine instructions
+ *
+ * Unfortunately this phase ended up being not Y-checkable unless types are erased. A cast to an ConstantType(3) or x.type
+ * cannot be rewritten before erasure. That's why TypeTestsCasts is called from Erasure.
+ */
+object TypeTestsCasts {
+  import ast.tpd._
+  import typer.Inferencing.maximizeType
+  import typer.ProtoTypes.constrained
+
+  /** Tests whether `(x: X).isInstanceOf[P]` is uncheckable at runtime, returning the reason,
+   *  or the empty string if it is checkable.
+   *
+   *  First do the following substitution:
+   *  (a) replace `T @unchecked` and pattern binder types (e.g., `_$1`) in P with WildcardType
+   *
+   *  Then check:
+   *
+   *  1. if `X <:< P`, ""
+   *  2. if `P` is a singleton type, ""
+   *  3. if `P` refers to an abstract type member or type parameter, "it refers to an abstract type member or type parameter"
+   *  4. if `P = Array[T]`, checkable(E, T) where `E` is the element type of `X`, defaults to `Any`.
+   *  5. if `P` is `pre.F[Ts]` and `pre.F` refers to a class which is not `Array`:
+   *     (a) replace `Ts` with fresh type variables `Xs`
+   *     (b) constrain `Xs` with `pre.F[Xs] <:< X`
+   *     (c) maximize `pre.F[Xs]`
+   *     (d) if !`pre.F[Xs] <:< P`, "its type arguments can't be determined from $X"
+   *  6. if `P = T1 | T2` or `P = T1 & T2`, checkable(X, T1) && checkable(X, T2).
+   *  7. if `P` is a refinement type, "it's a refinement type"
+   *  8. if `P` is a local class which is not statically reachable from the scope where `X` is defined, "it's a local class"
+   *  9. otherwise, ""
+   */
+  def whyUncheckable(X: Type, P: Type, span: Span)(using Context): String = atPhase(Phases.refchecksPhase.next) {
+    extension (inline s1: String) inline def &&(inline s2: String): String = if s1 == "" then s2 else s1
+    extension (inline b: Boolean) inline def |||(inline s: String): String = if b then "" else s
+
+    // Run just before ElimOpaque transform (which follows RefChecks)
+    def isAbstract(P: Type) = !P.dealias.typeSymbol.isClass
+
+    def replaceP(tp: Type)(using Context) = new TypeMap {
+      def apply(tp: Type) = tp match {
+        case tref: TypeRef if tref.typeSymbol.isPatternBound =>
+          WildcardType
+        case AnnotatedType(_, annot) if annot.symbol == defn.UncheckedAnnot =>
+          WildcardType
+        case _ => mapOver(tp)
+      }
+    }.apply(tp)
+
+    /** Returns true if the type arguments of `P` can be determined from `X` */
+    def typeArgsTrivial(X: Type, P: AppliedType)(using Context) = inContext(ctx.fresh.setExploreTyperState().setFreshGADTBounds) {
+      val AppliedType(tycon, _) = P
+
+      def underlyingLambda(tp: Type): TypeLambda = tp.ensureLambdaSub match {
+        case tp: TypeLambda => tp
+        case tp: TypeProxy => underlyingLambda(tp.superType)
+      }
+      val typeLambda = underlyingLambda(tycon)
+      val tvars = constrained(typeLambda, untpd.EmptyTree, alwaysAddTypeVars = true)._2.map(_.tpe)
+      val P1 = tycon.appliedTo(tvars)
+
+      debug.println("before " + ctx.typerState.constraint.show)
+      debug.println("P : " + P.show)
+      debug.println("P1 : " + P1.show)
+      debug.println("X : " + X.show)
+
+      // It does not matter whether P1 is a subtype of X or not.
+      // It just tries to infer type arguments of P1 from X if the value x
+      // conforms to the type skeleton pre.F[_]. Then it goes on to check
+      // if P1 <: P, which means the type arguments in P are trivial,
+      // thus no runtime checks are needed for them.
+      withMode(Mode.GadtConstraintInference) {
+        // Why not widen type arguments here? Given the following program
+        //
+        //    trait Tree[-T] class Ident[-T] extends Tree[T]
+        //
+        //    def foo1(tree: Tree[Int]) = tree.isInstanceOf[Ident[Int]]
+        //
+        // In checking whether the test tree.isInstanceOf[Ident[Int]]
+        // is realizable, we want to constrain Ident[X] <: Tree[Int],
+        // such that we can infer X = Int and Ident[X] <:< Ident[Int].
+        //
+        // If we perform widening, we will get X = Nothing, and we don't have
+        // Ident[X] <:< Ident[Int] any more.
+        TypeComparer.constrainPatternType(P1, X, forceInvariantRefinement = true)
+        debug.println(
+          TypeComparer.explained(_.constrainPatternType(P1, X, forceInvariantRefinement = true))
+        )
+      }
+
+      // Maximization of the type means we try to cover all possible values
+      // which conform to the skeleton pre.F[_] and X. Then we have to make
+      // sure all of them are actually of the type P, which implies that the
+      // type arguments in P are trivial (no runtime check needed).
+      maximizeType(P1, span)
+
+      debug.println("after " + ctx.typerState.constraint.show)
+
+      val res = P1 <:< P
+
+      debug.println(TypeComparer.explained(_.isSubType(P1, P)))
+      debug.println("P1 : " + P1.show)
+      debug.println("P1 <:< P = " + res)
+
+      res
+
+    }
+
+    def recur(X: Type, P: Type): String = (X <:< P) ||| (P.dealias match {
+      case _: SingletonType     => ""
+      case _: TypeProxy
+      if isAbstract(P)          => i"it refers to an abstract type member or type parameter"
+      case defn.ArrayOf(tpT)    =>
+        X match {
+          case defn.ArrayOf(tpE)   => recur(tpE, tpT)
+          case _                   => recur(defn.AnyType, tpT)
+        }
+      case tpe: AppliedType     =>
+        X.widenDealias match {
+          case OrType(tp1, tp2) =>
+            // This case is required to retrofit type inference,
+            // which cut constraints in the following two cases:
+            //   - T1 <:< T2 | T3
+            //   - T1 & T2 <:< T3
+            // See TypeComparer#either
+            recur(tp1, P) && recur(tp2, P)
+          case _ =>
+            // always false test warnings are emitted elsewhere
+            X.classSymbol.exists && P.classSymbol.exists &&
+              !X.classSymbol.asClass.mayHaveCommonChild(P.classSymbol.asClass)
+            || typeArgsTrivial(X, tpe)
+            ||| i"its type arguments can't be determined from $X"
+        }
+      case AndType(tp1, tp2)    => recur(X, tp1) && recur(X, tp2)
+      case OrType(tp1, tp2)     => recur(X, tp1) && recur(X, tp2)
+      case AnnotatedType(t, _)  => recur(X, t)
+      case tp2: RefinedType     => recur(X, tp2.parent)
+        && (TypeComparer.hasMatchingMember(tp2.refinedName, X, tp2) ||| i"it's a refinement type")
+      case tp2: RecType         => recur(X, tp2.parent)
+      case _
+      if P.classSymbol.isLocal && foundClasses(X).exists(P.classSymbol.isInaccessibleChildOf) => // 8
+        i"it's a local class"
+      case _                    => ""
+    })
+
+    val res = recur(X.widen, replaceP(P))
+
+    debug.println(i"checking  $X isInstanceOf $P = $res")
+
+    res
+  }
+
+  def interceptTypeApply(tree: TypeApply)(using Context): Tree = trace(s"transforming ${tree.show}", show = true) {
+    /** Intercept `expr.xyz[XYZ]` */
+    def interceptWith(expr: Tree): Tree =
+      if (expr.isEmpty) tree
+      else {
+        val sym = tree.symbol
+
+        def isPrimitive(tp: Type) = tp.classSymbol.isPrimitiveValueClass
+
+        def derivedTree(expr1: Tree, sym: Symbol, tp: Type) =
+          cpy.TypeApply(tree)(expr1.select(sym).withSpan(expr.span), List(TypeTree(tp)))
+
+        def inMatch =
+          tree.fun.symbol == defn.Any_typeTest ||  // new scheme
+          expr.symbol.is(Case)                // old scheme
+
+        def transformIsInstanceOf(
+            expr: Tree, testType: Type,
+            unboxedTestType: Type, flagUnrelated: Boolean): Tree = {
+          def testCls = effectiveClass(testType.widen)
+          def unboxedTestCls = effectiveClass(unboxedTestType.widen)
+
+          def unreachable(why: -> String)(using Context): Boolean = {
+            if (flagUnrelated)
+              if (inMatch) report.error(em"this case is unreachable since $why", expr.srcPos)
+              else report.warning(em"this will always yield false since $why", expr.srcPos)
+            false
+          }
+
+          /** Are `foundCls` and `testCls` classes that allow checks
+           *  whether a test would be always false?
+           */
+          def isCheckable(foundCls: Symbol) =
+            foundCls.isClass && testCls.isClass &&
+            !(testCls.isPrimitiveValueClass && !foundCls.isPrimitiveValueClass) &&
+               // if `test` is primitive but `found` is not, we might have a case like
+               // found = java.lang.Integer, test = Int, which could be true
+               // (not sure why that is so, but scalac behaves the same way)
+            !(!testCls.isPrimitiveValueClass && foundCls.isPrimitiveValueClass) &&
+               // foundCls can be `Boolean`, while testCls is `Integer`
+               // it can happen in `(3: Boolean | Int).isInstanceOf[Int]`
+            !isDerivedValueClass(foundCls) && !isDerivedValueClass(testCls)
+               // we don't have the logic to handle derived value classes
+
+          /** Check whether a runtime test that a value of `foundCls` can be a `testCls`
+           *  can be true in some cases. Issues a warning or an error otherwise.
+           */
+          def checkSensical(foundClasses: List[Symbol])(using Context): Boolean =
+            def exprType = i"type ${expr.tpe.widen.stripped}"
+            def check(foundCls: Symbol): Boolean =
+              if (!isCheckable(foundCls)) true
+              else if (!foundCls.derivesFrom(testCls)) {
+                val unrelated =
+                  !testCls.derivesFrom(foundCls)
+                  && !unboxedTestCls.derivesFrom(foundCls)
+                  && (testCls.is(Final) || !testCls.is(Trait) && !foundCls.is(Trait))
+                if (foundCls.is(Final))
+                  unreachable(i"$exprType is not a subclass of $testCls")
+                else if (unrelated)
+                  unreachable(i"$exprType and $testCls are unrelated")
+                else true
+              }
+              else true
+            end check
+
+            val foundEffectiveClass = effectiveClass(expr.tpe.widen)
+
+            if foundEffectiveClass.isPrimitiveValueClass && !testCls.isPrimitiveValueClass then
+              report.error(i"cannot test if value of $exprType is a reference of $testCls", tree.srcPos)
+              false
+            else foundClasses.exists(check)
+          end checkSensical
+
+          if (expr.tpe <:< testType) && inMatch then
+            if expr.tpe.isNotNull then constant(expr, Literal(Constant(true)))
+            else expr.testNotNull
+          else {
+            if expr.tpe.isBottomType then
+              report.warning(TypeTestAlwaysDiverges(expr.tpe, testType), tree.srcPos)
+            val nestedCtx = ctx.fresh.setNewTyperState()
+            val foundClsSyms = foundClasses(expr.tpe.widen)
+            val sensical = checkSensical(foundClsSyms)(using nestedCtx)
+            if (!sensical) {
+              nestedCtx.typerState.commit()
+              constant(expr, Literal(Constant(false)))
+            }
+            else if (testCls.isPrimitiveValueClass)
+              foundClsSyms match
+                case List(cls) if cls.isPrimitiveValueClass =>
+                  constant(expr, Literal(Constant(foundClsSyms.head == testCls)))
+                case _ =>
+                  transformIsInstanceOf(
+                    expr, defn.boxedType(testCls.typeRef), testCls.typeRef, flagUnrelated)
+            else
+              derivedTree(expr, defn.Any_isInstanceOf, testType)
+          }
+        }
+
+        def transformAsInstanceOf(testType: Type): Tree = {
+          def testCls = effectiveClass(testType.widen)
+          def foundClsSymPrimitive = {
+            val foundClsSyms = foundClasses(expr.tpe.widen)
+            foundClsSyms.size == 1 && foundClsSyms.head.isPrimitiveValueClass
+          }
+          if (erasure(expr.tpe) <:< testType)
+            Typed(expr, tree.args.head) // Replace cast by type ascription (which does not generate any bytecode)
+          else if (testCls eq defn.BoxedUnitClass)
+            // as a special case, casting to Unit always successfully returns Unit
+            Block(expr :: Nil, Literal(Constant(()))).withSpan(expr.span)
+          else if (foundClsSymPrimitive)
+            if (testCls.isPrimitiveValueClass) primitiveConversion(expr, testCls)
+            else derivedTree(box(expr), defn.Any_asInstanceOf, testType)
+          else if (testCls.isPrimitiveValueClass)
+            unbox(expr.ensureConforms(defn.ObjectType), testType)
+          else if (isDerivedValueClass(testCls))
+            expr // adaptToType in Erasure will do the necessary type adaptation
+          else if (testCls eq defn.NothingClass) {
+            // In the JVM `x.asInstanceOf[Nothing]` would throw a class cast exception except when `x eq null`.
+            // To avoid this loophole we execute `x` and then regardless of the result throw a `ClassCastException`
+            val throwCCE = Throw(New(defn.ClassCastExceptionClass.typeRef, defn.ClassCastExceptionClass_stringConstructor,
+                Literal(Constant("Cannot cast to scala.Nothing")) :: Nil))
+            Block(expr :: Nil, throwCCE).withSpan(expr.span)
+          }
+          else
+            derivedTree(expr, defn.Any_asInstanceOf, testType)
+        }
+
+        /** Transform isInstanceOf
+         *
+         *    expr.isInstanceOf[A | B]  ~~>  expr.isInstanceOf[A] | expr.isInstanceOf[B]
+         *    expr.isInstanceOf[A & B]  ~~>  expr.isInstanceOf[A] & expr.isInstanceOf[B]
+         *    expr.isInstanceOf[Tuple]          ~~>  scala.runtime.Tuples.isInstanceOfTuple(expr)
+         *    expr.isInstanceOf[EmptyTuple]     ~~>  scala.runtime.Tuples.isInstanceOfEmptyTuple(expr)
+         *    expr.isInstanceOf[NonEmptyTuple]  ~~>  scala.runtime.Tuples.isInstanceOfNonEmptyTuple(expr)
+         *    expr.isInstanceOf[*:[_, _]]       ~~>  scala.runtime.Tuples.isInstanceOfNonEmptyTuple(expr)
+         *
+         *  The transform happens before erasure of `testType`, thus cannot be merged
+         *  with `transformIsInstanceOf`, which depends on erased type of `testType`.
+         */
+        def transformTypeTest(expr: Tree, testType: Type, flagUnrelated: Boolean): Tree = testType.dealias match {
+          case tref: TermRef if tref.symbol == defn.EmptyTupleModule =>
+            ref(defn.RuntimeTuples_isInstanceOfEmptyTuple).appliedTo(expr)
+          case _: SingletonType =>
+            expr.isInstance(testType).withSpan(tree.span)
+          case OrType(tp1, tp2) =>
+            evalOnce(expr) { e =>
+              transformTypeTest(e, tp1, flagUnrelated = false)
+                .or(transformTypeTest(e, tp2, flagUnrelated = false))
+            }
+          case AndType(tp1, tp2) =>
+            evalOnce(expr) { e =>
+              transformTypeTest(e, tp1, flagUnrelated)
+                .and(transformTypeTest(e, tp2, flagUnrelated))
+            }
+          case defn.MultiArrayOf(elem, ndims) if isGenericArrayElement(elem, isScala2 = false) =>
+            def isArrayTest(arg: Tree) =
+              ref(defn.runtimeMethodRef(nme.isArray)).appliedTo(arg, Literal(Constant(ndims)))
+            if (ndims == 1) isArrayTest(expr)
+            else evalOnce(expr) { e =>
+              derivedTree(e, defn.Any_isInstanceOf, e.tpe)
+                .and(isArrayTest(e))
+            }
+          case tref: TypeRef if tref.symbol == defn.TupleClass =>
+            ref(defn.RuntimeTuples_isInstanceOfTuple).appliedTo(expr)
+          case tref: TypeRef if tref.symbol == defn.NonEmptyTupleClass =>
+            ref(defn.RuntimeTuples_isInstanceOfNonEmptyTuple).appliedTo(expr)
+          case AppliedType(tref: TypeRef, _) if tref.symbol == defn.PairClass =>
+            ref(defn.RuntimeTuples_isInstanceOfNonEmptyTuple).appliedTo(expr)
+          case _ =>
+            val testWidened = testType.widen
+            defn.untestableClasses.find(testWidened.isRef(_)) match
+              case Some(untestable) =>
+                report.error(i"$untestable cannot be used in runtime type tests", tree.srcPos)
+                constant(expr, Literal(Constant(false)))
+              case _ =>
+                val erasedTestType = erasure(testType)
+                transformIsInstanceOf(expr, erasedTestType, erasedTestType, flagUnrelated)
+        }
+
+        if (sym.isTypeTest) {
+          val argType = tree.args.head.tpe
+          val isTrusted = tree.hasAttachment(PatternMatcher.TrustedTypeTestKey)
+          val isUnchecked = expr.tpe.widenTermRefExpr.hasAnnotation(defn.UncheckedAnnot)
+          if !isTrusted && !isUnchecked then
+            val whyNot = whyUncheckable(expr.tpe, argType, tree.span)
+            if whyNot.nonEmpty then
+              report.uncheckedWarning(i"the type test for $argType cannot be checked at runtime because $whyNot", expr.srcPos)
+          transformTypeTest(expr, argType,
+            flagUnrelated = enclosingInlineds.isEmpty) // if test comes from inlined code, dont't flag it even if it always false
+        }
+        else if (sym.isTypeCast)
+          transformAsInstanceOf(erasure(tree.args.head.tpe))
+        else tree
+      }
+    val expr = tree.fun match {
+      case Select(expr, _) => expr
+      case i: Ident =>
+        val expr = desugarIdentPrefix(i)
+        if (expr.isEmpty) expr
+        else expr.withSpan(i.span)
+      case _ => EmptyTree
+    }
+    interceptWith(expr)
+  }
+
+  private def effectiveClass(tp: Type)(using Context): Symbol =
+    if tp.isRef(defn.PairClass) then effectiveClass(erasure(tp))
+    else if tp.isRef(defn.AnyValClass) then defn.AnyClass
+    else tp.classSymbol
+
+  private[transform] def foundClasses(tp: Type)(using Context): List[Symbol] =
+    def go(tp: Type, acc: List[Type])(using Context): List[Type] = tp.dealias match
+      case  OrType(tp1, tp2) => go(tp2, go(tp1, acc))
+      case AndType(tp1, tp2) => (for t1 <- go(tp1, Nil); t2 <- go(tp2, Nil) yield AndType(t1, t2)) ::: acc
+      case _                 => tp :: acc
+    go(tp, Nil).map(effectiveClass)
+}
diff --git a/tests/pos-with-compiler-cc/dotc/transform/TypeUtils.scala b/tests/pos-with-compiler-cc/dotc/transform/TypeUtils.scala
new file mode 100644
index 000000000000..5b6e36343379
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/transform/TypeUtils.scala
@@ -0,0 +1,120 @@
+package dotty.tools
+package dotc
+package transform
+
+import core._
+import TypeErasure.ErasedValueType
+import Types._
+import Contexts._
+import Symbols._
+import Names.Name
+
+import dotty.tools.dotc.core.Decorators.*
+
+object TypeUtils {
+  /** A decorator that provides methods on types
+   *  that are needed in the transformer pipeline.
+   */
+  extension (self: Type) {
+
+    def isErasedValueType(using Context): Boolean =
+      self.isInstanceOf[ErasedValueType]
+
+    def isPrimitiveValueType(using Context): Boolean =
+      self.classSymbol.isPrimitiveValueClass
+
+    def isErasedClass(using Context): Boolean =
+      self.underlyingClassRef(refinementOK = true).typeSymbol.is(Flags.Erased)
+
+    /** Is this type a checked exception? This is the case if the type
+     *  derives from Exception but not from RuntimeException. According to
+     *  that definition Throwable is unchecked. That makes sense since you should
+     *  neither throw nor catch `Throwable` anyway, so we should not define
+     *  a capability to do so.
+     */
+    def isCheckedException(using Context): Boolean =
+      self.derivesFrom(defn.ExceptionClass)
+      && !self.derivesFrom(defn.RuntimeExceptionClass)
+
+    def isByName: Boolean =
+      self.isInstanceOf[ExprType]
+
+    def ensureMethodic(using Context): Type = self match {
+      case self: MethodicType => self
+      case _ => if (ctx.erasedTypes) MethodType(Nil, self) else ExprType(self)
+    }
+
+    def widenToParents(using Context): Type = self.parents match {
+      case Nil => self
+      case ps => ps.reduceLeft(AndType(_, _))
+    }
+
+    /** The arity of this tuple type, which can be made up of EmptyTuple, TupleX and `*:` pairs,
+     *  or -1 if this is not a tuple type.
+     */
+    def tupleArity(using Context): Int = self/*.dealias*/ match { // TODO: why does dealias cause a failure in tests/run-deep-subtype/Tuple-toArray.scala
+      case AppliedType(tycon, _ :: tl :: Nil) if tycon.isRef(defn.PairClass) =>
+        val arity = tl.tupleArity
+        if (arity < 0) arity else arity + 1
+      case self: SingletonType =>
+        if self.termSymbol == defn.EmptyTupleModule then 0 else -1
+      case self: AndOrType =>
+        val arity1 = self.tp1.tupleArity
+        val arity2 = self.tp2.tupleArity
+        if arity1 == arity2 then arity1 else -1
+      case _ =>
+        if defn.isTupleNType(self) then self.dealias.argInfos.length
+        else -1
+    }
+
+    /** The element types of this tuple type, which can be made up of EmptyTuple, TupleX and `*:` pairs */
+    def tupleElementTypes(using Context): Option[List[Type]] = self.dealias match {
+      case AppliedType(tycon, hd :: tl :: Nil) if tycon.isRef(defn.PairClass) =>
+        tl.tupleElementTypes.map(hd :: _)
+      case self: SingletonType =>
+        if self.termSymbol == defn.EmptyTupleModule then Some(Nil) else None
+      case AndType(tp1, tp2) =>
+        // We assume that we have the following property:
+        // (T1, T2, ..., Tn) & (U1, U2, ..., Un) = (T1 & U1, T2 & U2, ..., Tn & Un)
+        tp1.tupleElementTypes.zip(tp2.tupleElementTypes).map { case (t1, t2) => t1 & t2 }
+      case OrType(tp1, tp2) =>
+        None // We can't combine the type of two tuples
+      case _ =>
+        if defn.isTupleClass(self.typeSymbol) then Some(self.dealias.argInfos)
+        else None
+    }
+
+    /** The `*:` equivalent of an instance of a Tuple class */
+    def toNestedPairs(using Context): Type =
+      tupleElementTypes match
+        case Some(types) => TypeOps.nestedPairs(types)
+        case None => throw new AssertionError("not a tuple")
+
+    def refinedWith(name: Name, info: Type)(using Context) = RefinedType(self, name, info)
+
+    /** The TermRef referring to the companion of the underlying class reference
+     *  of this type, while keeping the same prefix.
+     */
+    def mirrorCompanionRef(using Context): TermRef = self match {
+      case AndType(tp1, tp2) =>
+        val c1 = tp1.classSymbol
+        val c2 = tp2.classSymbol
+        if c1.isSubClass(c2) then tp1.mirrorCompanionRef
+        else tp2.mirrorCompanionRef // precondition: the parts of the AndType have already been checked to be non-overlapping
+      case self @ TypeRef(prefix, _) if self.symbol.isClass =>
+        prefix.select(self.symbol.companionModule).asInstanceOf[TermRef]
+      case self: TypeProxy =>
+        self.superType.mirrorCompanionRef
+    }
+
+    /** Is this type a methodic type that takes at least one parameter? */
+    def takesParams(using Context): Boolean = self.stripPoly match
+      case mt: MethodType => mt.paramNames.nonEmpty || mt.resType.takesParams
+      case _ => false
+
+    /** Is this type a methodic type that takes implicit parameters (both old and new) at some point? */
+    def takesImplicitParams(using Context): Boolean = self.stripPoly match
+      case mt: MethodType => mt.isImplicitMethod || mt.resType.takesImplicitParams
+      case _ => false
+  }
+}
diff --git a/tests/pos-with-compiler-cc/dotc/transform/UncacheGivenAliases.scala b/tests/pos-with-compiler-cc/dotc/transform/UncacheGivenAliases.scala
new file mode 100644
index 000000000000..95d40102c5a7
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/transform/UncacheGivenAliases.scala
@@ -0,0 +1,65 @@
+package dotty.tools.dotc
+package transform
+
+import MegaPhase._
+import core.DenotTransformers.{IdentityDenotTransformer}
+import core.Symbols._
+import core.Contexts._
+import core.Types._
+import core.Flags._
+import ast.tpd
+
+object UncacheGivenAliases:
+  val name: String = "uncacheGivenAliases"
+  val description: String = "avoid caching RHS of simple parameterless given aliases"
+
+/** This phase optimizes alias givens represented as lazy vals to be uncached
+ *  if that does not change runtime behavior. A definition does not need to be
+ *  cached if its right hand side has a stable type and is of one of them forms
+ *
+ *    this
+ *    this.y
+ *    y
+ */
+class UncacheGivenAliases extends MiniPhase with IdentityDenotTransformer:
+  thisPhase =>
+  import tpd._
+
+  override def phaseName: String = UncacheGivenAliases.name
+
+  override def description: String = UncacheGivenAliases.description
+
+  private def needsCache(sym: Symbol, rhs: Tree)(using Context): Boolean = rhs.tpe match
+    case rhsTpe @ TermRef(NoPrefix, _)
+    if rhsTpe.isStable => false
+    case rhsTpe @ TermRef(pre: ThisType, _)
+    if rhsTpe.isStable && pre.cls == sym.owner.enclosingClass => false
+    case rhsTpe: ThisType => false
+    case _ => true
+
+  /** Transform
+   *
+   *    lazy given val x = rhs
+   *
+   *  to
+   *
+   *    def x = rhs
+   *
+   *  provided `rhs` has a stable type and is of one of them forms
+   *
+   *    this
+   *    this.y
+   *    y
+   */
+  override def transformValDef(tree: ValDef)(using Context): Tree =
+    val sym = tree.symbol
+    if sym.isAllOf(LazyGiven) && !needsCache(sym, tree.rhs) then
+      sym.copySymDenotation(
+        initFlags = sym.flags &~ Lazy | Method,
+        info = ExprType(sym.info))
+      .installAfter(thisPhase)
+      cpy.DefDef(tree)(tree.name, Nil, tree.tpt, tree.rhs)
+    else tree
+end UncacheGivenAliases
+
+
diff --git a/tests/pos-with-compiler-cc/dotc/transform/UninitializedDefs.scala b/tests/pos-with-compiler-cc/dotc/transform/UninitializedDefs.scala
new file mode 100644
index 000000000000..a7ccaa19d90a
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/transform/UninitializedDefs.scala
@@ -0,0 +1,48 @@
+package dotty.tools.dotc
+package transform
+
+import core._
+import Contexts._
+import Flags._
+import Symbols._
+import MegaPhase.MiniPhase
+import StdNames.nme
+import ast.tpd
+
+/** This phase replaces `compiletime.uninitialized` on the right hand side of a mutable field definition by `_`.
+ *  This avoids a
+ *  ```scala
+ *  "@compileTimeOnly("`uninitialized` can only be used as the right hand side of a mutable field definition")`
+ *  ```
+ *  error in Erasure and communicates to Constructors that the variable does not have an initializer.
+ *
+ *  @syntax markdown
+ */
+class UninitializedDefs extends MiniPhase:
+  import tpd._
+
+  override def phaseName: String = UninitializedDefs.name
+
+  override def description: String = UninitializedDefs.description
+
+  override def transformValDef(tree: ValDef)(using Context): Tree =
+    if !hasUninitializedRHS(tree) then tree
+    else cpy.ValDef(tree)(rhs = cpy.Ident(tree.rhs)(nme.WILDCARD).withType(tree.tpt.tpe))
+
+  private def hasUninitializedRHS(tree: ValOrDefDef)(using Context): Boolean =
+    def recur(rhs: Tree): Boolean = rhs match
+      case rhs: RefTree =>
+        rhs.symbol == defn.Compiletime_uninitialized
+        && tree.symbol.is(Mutable) && tree.symbol.owner.isClass
+      case closureDef(ddef) if defn.isContextFunctionType(tree.tpt.tpe.dealias) =>
+        recur(ddef.rhs)
+      case _ =>
+        false
+    recur(tree.rhs)
+
+end UninitializedDefs
+
+object UninitializedDefs:
+  val name: String = "uninitialized"
+  val description: String = "eliminates `compiletime.uninitialized`"
+end UninitializedDefs
diff --git a/tests/pos-with-compiler-cc/dotc/transform/VCElideAllocations.scala b/tests/pos-with-compiler-cc/dotc/transform/VCElideAllocations.scala
new file mode 100644
index 000000000000..879a885d626e
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/transform/VCElideAllocations.scala
@@ -0,0 +1,55 @@
+package dotty.tools.dotc
+package transform
+
+import ast.tpd
+import core._
+import Contexts._, Symbols._, Types._, Flags._, Phases._
+import DenotTransformers._, MegaPhase._
+import TreeExtractors._, ValueClasses._
+
+/** This phase elides unnecessary value class allocations
+ *
+ *  For a value class V defined as:
+ *    class V(val underlying: U) extends AnyVal
+ *  we avoid unnecessary allocations:
+ *     new V(u1) == new V(u2) => u1 == u2   provided V does not redefine `equals`
+ *    (new V(u)).underlying() => u
+ */
+class VCElideAllocations extends MiniPhase with IdentityDenotTransformer {
+  import tpd._
+
+  override def phaseName: String = VCElideAllocations.name
+
+  override def description: String = VCElideAllocations.description
+
+  override def runsAfter: Set[String] = Set(ElimErasedValueType.name)
+
+  override def transformApply(tree: Apply)(using Context): Tree =
+    def hasUserDefinedEquals(tp: Type): Boolean =
+      val eql = atPhase(erasurePhase) {
+        defn.Any_equals.matchingMember(tp.typeSymbol.thisType)
+      }
+      eql.owner != defn.AnyClass && !eql.is(Synthetic)
+
+    tree match {
+      // new V(u1) == new V(u2) => u1 == u2, unless V defines its own equals.
+      // (We don't handle != because it has been eliminated by InterceptedMethods)
+      case BinaryOp(NewWithArgs(tp1, List(u1)), op, NewWithArgs(tp2, List(u2)))
+      if (tp1 eq tp2) && (op eq defn.Any_==)
+         && isDerivedValueClass(tp1.typeSymbol)
+         && !hasUserDefinedEquals(tp1) =>
+        // == is overloaded in primitive classes
+        u1.equal(u2)
+
+      // (new V(u)).underlying() => u
+      case ValueClassUnbox(NewWithArgs(_, List(u))) =>
+        u
+
+      case _ =>
+        tree
+    }
+}
+
+object VCElideAllocations:
+  val name: String = "vcElideAllocations"
+  val description: String = "peep-hole optimization to eliminate unnecessary value class allocations"
diff --git a/tests/pos-with-compiler-cc/dotc/transform/VCInlineMethods.scala b/tests/pos-with-compiler-cc/dotc/transform/VCInlineMethods.scala
new file mode 100644
index 000000000000..219945d4ebb1
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/transform/VCInlineMethods.scala
@@ -0,0 +1,113 @@
+package dotty.tools
+package dotc
+package transform
+
+import ast.{Trees, tpd}
+import core._
+import Contexts._, Trees._, Types._
+import DenotTransformers._, MegaPhase._
+import ExtensionMethods._, ValueClasses._
+
+
+/** This phase inlines calls to methods of value classes.
+ *
+ *  A value class V after [[ExtensionMethods]] will look like:
+ *    class V[A, B, ...](val underlying: U) extends AnyVal {
+ *      def foo[T, S, ...](arg1: A1, arg2: A2, ...) =
+ *        V.foo$extension[T, S, ..., A, B, ...](this)(arg1, arg2, ...)
+ *
+ *       ...
+ *    }
+ *
+ *  Let e have type V, if e is a stable prefix or if V does not have any class
+ *  type parameter, then we can rewrite:
+ *    e.foo[X, Y, ...](args)
+ *  as:
+ *    V.foo$extension[X, Y, ..., A', B', ...](e)(args)
+ *    where A', B', ... are the class type parameters A, B, ... as seen from `e`.
+ *  Otherwise, we need to evaluate e first:
+ *    {
+ *      val ev = e
+ *      V.foo$extension[X, Y, ..., A', B', ...](ev)(args)
+ *    }
+ *
+ *  This phase needs to be placed after phases which may introduce calls to
+ *  value class methods (like [[PatternMatcher]]). This phase uses name mangling
+ *  to find the correct extension method corresponding to a value class method
+ *  (see [[ExtensionMethods.extensionMethod]]), therefore we choose to place it
+ *  before phases which may perform their own name mangling on value class
+ *  methods (like [[TypeSpecializer]]), this way [[VCInlineMethods]] does not
+ *  need to have any knowledge of the name mangling done by other phases.
+ */
+class VCInlineMethods extends MiniPhase with IdentityDenotTransformer {
+  import tpd._
+
+  override def phaseName: String = VCInlineMethods.name
+
+  override def description: String = VCInlineMethods.description
+
+  override def runsAfter: Set[String] =
+    Set(ExtensionMethods.name, PatternMatcher.name)
+
+  /** Replace a value class method call by a call to the corresponding extension method.
+   *
+   *  @param tree   The tree corresponding to the method call
+   *  @param mtArgs Type arguments for the method call not present in `tree`
+   *  @param mArgss Arguments for the method call not present in `tree`
+   *  @return       A tree for the extension method call
+   */
+  private def rewire(tree: Tree, mtArgs: List[Tree] = Nil, mArgss: List[List[Tree]] = Nil)
+    (using Context): Tree =
+    tree match {
+      case Apply(qual, mArgs) =>
+        rewire(qual, mtArgs, mArgs :: mArgss)
+      case TypeApply(qual, mtArgs2) =>
+        assert(mtArgs == Nil)
+        rewire(qual, mtArgs2, mArgss)
+      case sel @ Select(qual, _) =>
+        val origMeth = sel.symbol
+        val origCls = origMeth.enclosingClass
+        val ctParams = origCls.typeParams
+        val extensionMeth = extensionMethod(origMeth)
+
+        if (!ctParams.isEmpty)
+          evalOnce(qual) { ev =>
+            val ctArgs = ctParams.map(tparam =>
+              TypeTree(tparam.typeRef.asSeenFrom(ev.tpe, origCls)))
+            transformFollowing(
+              ref(extensionMeth)
+              .appliedToTypeTrees(mtArgs ++ ctArgs)
+              .appliedTo(ev)
+              .appliedToArgss(mArgss))
+          }
+        else
+          ref(extensionMeth)
+            .appliedToTypeTrees(mtArgs)
+            .appliedTo(qual)
+            .appliedToArgss(mArgss)
+    }
+
+  /** If this tree corresponds to a fully-applied value class method call, replace it
+   *  by a call to the corresponding extension method, otherwise return it as is.
+   */
+  private def rewireIfNeeded(tree: Tree)(using Context) = tree.tpe.widen match {
+    case tp: LambdaType =>
+      tree // The rewiring will be handled by a fully-applied parent node
+    case _ =>
+      if (isMethodWithExtension(tree.symbol))
+        rewire(tree).ensureConforms(tree.tpe).withSpan(tree.span)
+      else
+        tree
+  }
+
+  override def transformSelect(tree: Select)(using Context): Tree =
+    rewireIfNeeded(tree)
+  override def transformTypeApply(tree: TypeApply)(using Context): Tree =
+    rewireIfNeeded(tree)
+  override def transformApply(tree: Apply)(using Context): Tree =
+    rewireIfNeeded(tree)
+}
+
+object VCInlineMethods:
+  val name: String = "vcInlineMethods"
+  val description: String = "inlines calls to value class methods"
diff --git a/tests/pos-with-compiler-cc/dotc/transform/ValueClasses.scala b/tests/pos-with-compiler-cc/dotc/transform/ValueClasses.scala
new file mode 100644
index 000000000000..a86bf2c48fb5
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/transform/ValueClasses.scala
@@ -0,0 +1,57 @@
+package dotty.tools.dotc
+package transform
+
+import core._
+import Types._
+import Symbols._
+import Contexts._
+import Phases._
+import Flags._
+import StdNames._
+import SymUtils._
+
+/** Methods that apply to user-defined value classes */
+object ValueClasses {
+
+  def isDerivedValueClass(sym: Symbol)(using Context): Boolean = sym.isClass && {
+    val d = sym.denot
+    !d.isRefinementClass &&
+    d.isValueClass &&
+    (d.initial.symbol ne defn.AnyValClass) && // Compare the initial symbol because AnyVal does not exist after erasure
+    !d.isPrimitiveValueClass
+  }
+
+  def isMethodWithExtension(sym: Symbol)(using Context): Boolean =
+    atPhaseNoLater(extensionMethodsPhase) {
+      val d = sym.denot
+      d.validFor.containsPhaseId(ctx.phaseId) &&
+      d.isRealMethod &&
+      isDerivedValueClass(d.owner) &&
+      !d.isConstructor &&
+      !d.symbol.isSuperAccessor &&
+      !d.is(Macro)
+    }
+
+  /** The member of a derived value class that unboxes it. */
+  def valueClassUnbox(cls: ClassSymbol)(using Context): Symbol =
+    // (info.decl(nme.unbox)).orElse(...)      uncomment once we accept unbox methods
+    cls.classInfo.decls.find(_.is(ParamAccessor))
+
+  /** For a value class `d`, this returns the synthetic cast from the underlying type to
+   *  ErasedValueType defined in the companion module. This method is added to the module
+   *  and further described in [[ExtensionMethods]].
+   */
+  def u2evt(cls: ClassSymbol)(using Context): Symbol =
+    cls.linkedClass.info.decl(nme.U2EVT).symbol
+
+  /** For a value class `d`, this returns the synthetic cast from ErasedValueType to the
+   *  underlying type defined in the companion module. This method is added to the module
+   *  and further described in [[ExtensionMethods]].
+   */
+  def evt2u(cls: ClassSymbol)(using Context): Symbol =
+    cls.linkedClass.info.decl(nme.EVT2U).symbol
+
+  /** The unboxed type that underlies a derived value class */
+  def underlyingOfValueClass(sym: ClassSymbol)(using Context): Type =
+    valueClassUnbox(sym).info.resultType
+}
diff --git a/tests/pos-with-compiler-cc/dotc/transform/YCheckPositions.scala b/tests/pos-with-compiler-cc/dotc/transform/YCheckPositions.scala
new file mode 100644
index 000000000000..ba42d826fe82
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/transform/YCheckPositions.scala
@@ -0,0 +1,72 @@
+package dotty.tools.dotc
+package transform
+
+import dotty.tools.dotc.ast.{tpd, untpd}
+import dotty.tools.dotc.core.Contexts._
+import dotty.tools.dotc.core.Decorators._
+import dotty.tools.dotc.core.Flags._
+import dotty.tools.dotc.core.Phases.{Phase, postTyperPhase}
+import dotty.tools.dotc.core.Symbols._
+import dotty.tools.dotc.util.SourceFile
+
+/** Ycheck inlined positions */
+class YCheckPositions extends Phase {
+  import tpd._
+
+  override def phaseName: String = YCheckPositions.name
+
+  override def description: String = YCheckPositions.description
+
+  override def run(using Context): Unit = () // YCheck only
+
+  override def checkPostCondition(tree: Tree)(using Context): Unit =
+    tree match {
+      case PackageDef(pid, _) if tree.symbol.owner == defn.RootClass =>
+        val checker = new TreeTraverser {
+          private var sources: List[SourceFile] = ctx.source :: Nil
+          def traverse(tree: tpd.Tree)(using Context): Unit = {
+
+            // Check current context is correct
+            assert(ctx.source == sources.head)
+            if (!tree.isEmpty && !tree.isInstanceOf[untpd.TypedSplice] && !tree.isInstanceOf[Inlined] && ctx.typerState.isGlobalCommittable)
+              if !tree.isType // TODO also check types, currently we do not add Inlined(EmptyTree, _, _) for types. We should.
+                && !tree.symbol.is(InlineProxy) // TODO check inline proxies (see tests/tun/lst)
+              then
+                val currentSource = sources.head
+                assert(tree.source == currentSource, i"wrong source set for $tree # ${tree.uniqueId} of ${tree.getClass}, set to ${tree.source} but context had $currentSource\n ${tree.symbol.flagsString}")
+
+            // Recursivlely check children while keeping track of current source
+            reporting.trace(i"check pos ${tree.getClass} ${tree.source} ${sources.head} $tree") {
+              tree match {
+                case Inlined(EmptyTree, bindings, expansion) =>
+                  assert(bindings.isEmpty)
+                  val old = sources
+                  sources = old.tail
+                  traverse(expansion)(using inlineContext(EmptyTree).withSource(sources.head))
+                  sources = old
+                case Inlined(call, bindings, expansion) =>
+                  // bindings.foreach(traverse(_)) // TODO check inline proxies (see tests/tun/lst)
+                  sources = call.symbol.topLevelClass.source :: sources
+                  if (!isMacro(call)) // FIXME macro implementations can drop Inlined nodes. We should reinsert them after macro expansion based on the positions of the trees
+                    traverse(expansion)(using inlineContext(call).withSource(sources.head))
+                  sources = sources.tail
+                case _ => traverseChildren(tree)
+              }
+            }
+          }
+        }
+        checker.traverse(tree)
+      case _ =>
+    }
+
+  private def isMacro(call: Tree)(using Context) =
+    call.symbol.is(Macro) ||
+    // The call of a macro after typer is encoded as a Select while other inlines are Ident
+    // TODO remove this distinction once Inline nodes of expanded macros can be trusted (also in Inliner.inlineCallTrace)
+    (!(ctx.phase <= postTyperPhase) && call.isInstanceOf[Select])
+
+}
+
+object YCheckPositions:
+  val name: String = "inlinedPositions"
+  val description: String = "check inlined positions"
diff --git a/tests/pos-with-compiler-cc/dotc/transform/init/Checker.scala b/tests/pos-with-compiler-cc/dotc/transform/init/Checker.scala
new file mode 100644
index 000000000000..1efb3c88149e
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/transform/init/Checker.scala
@@ -0,0 +1,72 @@
+package dotty.tools.dotc
+package transform
+package init
+
+import dotty.tools.dotc._
+import ast.tpd
+import tpd._
+
+import dotty.tools.dotc.core._
+import Contexts._
+import Types._
+import Symbols._
+import StdNames._
+
+import dotty.tools.dotc.transform._
+import Phases._
+
+import scala.collection.mutable
+
+import Semantic._
+
+class Checker extends Phase:
+
+  override def phaseName: String = Checker.name
+
+  override def description: String = Checker.description
+
+  override val runsAfter = Set(Pickler.name)
+
+  override def isEnabled(using Context): Boolean =
+    super.isEnabled && ctx.settings.YcheckInit.value
+
+  override def runOn(units: List[CompilationUnit])(using Context): List[CompilationUnit] =
+    val checkCtx = ctx.fresh.setPhase(this.start)
+    val traverser = new InitTreeTraverser()
+    units.foreach { unit => traverser.traverse(unit.tpdTree) }
+    val classes = traverser.getClasses()
+
+    Semantic.checkClasses(classes)(using checkCtx)
+
+    units
+
+  def run(using Context): Unit =
+    // ignore, we already called `Semantic.check()` in `runOn`
+    ()
+
+  class InitTreeTraverser extends TreeTraverser:
+    private val classes: mutable.ArrayBuffer[ClassSymbol] = new mutable.ArrayBuffer
+
+    def getClasses(): List[ClassSymbol] = classes.toList
+
+    override def traverse(tree: Tree)(using Context): Unit =
+      traverseChildren(tree)
+      tree match {
+        case mdef: MemberDef =>
+          // self-type annotation ValDef has no symbol
+          if mdef.name != nme.WILDCARD then
+            mdef.symbol.defTree = tree
+
+          mdef match
+          case tdef: TypeDef if tdef.isClassDef =>
+            val cls = tdef.symbol.asClass
+            classes.append(cls)
+          case _ =>
+
+        case _ =>
+      }
+  end InitTreeTraverser
+
+object Checker:
+  val name: String = "initChecker"
+  val description: String = "check initialization of objects"
diff --git a/tests/pos-with-compiler-cc/dotc/transform/init/Errors.scala b/tests/pos-with-compiler-cc/dotc/transform/init/Errors.scala
new file mode 100644
index 000000000000..7d92d2b2a921
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/transform/init/Errors.scala
@@ -0,0 +1,145 @@
+package dotty.tools
+package dotc
+package transform
+package init
+
+import ast.tpd._
+import core._
+import util.SourcePosition
+import util.Property
+import Decorators._, printing.SyntaxHighlighting
+import Types._, Symbols._, Contexts._
+
+import scala.collection.mutable
+
+object Errors:
+  private val IsFromPromotion = new Property.Key[Boolean]
+
+  sealed trait Error:
+    def trace: Seq[Tree]
+    def show(using Context): String
+
+    def pos(using Context): SourcePosition = trace.last.sourcePos
+
+    def stacktrace(using Context): String =
+      val preamble: String =
+        if ctx.property(IsFromPromotion).nonEmpty
+        then " Promotion trace:\n"
+        else " Calling trace:\n"
+      buildStacktrace(trace, preamble)
+
+    def issue(using Context): Unit =
+      report.warning(show, this.pos)
+  end Error
+
+  def buildStacktrace(trace: Seq[Tree], preamble: String)(using Context): String = if trace.isEmpty then "" else preamble + {
+    var lastLineNum = -1
+    var lines: mutable.ArrayBuffer[String] = new mutable.ArrayBuffer
+    trace.foreach { tree =>
+      val pos = tree.sourcePos
+      val prefix = "-> "
+      val line =
+        if pos.source.exists then
+          val loc = "[ " + pos.source.file.name + ":" + (pos.line + 1) + " ]"
+          val code = SyntaxHighlighting.highlight(pos.lineContent.trim.nn)
+          i"$code\t$loc"
+        else
+          tree.show
+      val positionMarkerLine =
+        if pos.exists && pos.source.exists then
+          positionMarker(pos)
+        else ""
+
+      // always use the more precise trace location
+      if lastLineNum == pos.line then
+        lines.dropRightInPlace(1)
+
+      lines += (prefix + line + "\n" + positionMarkerLine)
+
+      lastLineNum = pos.line
+    }
+    val sb = new StringBuilder
+    for line <- lines do sb.append(line)
+    sb.toString
+  }
+
+  /** Used to underline source positions in the stack trace
+   *  pos.source must exist
+   */
+  private def positionMarker(pos: SourcePosition): String =
+    val trimmed = pos.lineContent.takeWhile(c => c.isWhitespace).length
+    val padding = pos.startColumnPadding.substring(trimmed).nn + "   "
+    val carets =
+      if (pos.startLine == pos.endLine)
+        "^" * math.max(1, pos.endColumn - pos.startColumn)
+      else "^"
+
+    s"$padding$carets\n"
+
+  override def toString() = this.getClass.getName.nn
+
+  /** Access non-initialized field */
+  case class AccessNonInit(field: Symbol)(val trace: Seq[Tree]) extends Error:
+    def source: Tree = trace.last
+    def show(using Context): String =
+      "Access non-initialized " + field.show + "." + stacktrace
+
+    override def pos(using Context): SourcePosition = field.sourcePos
+
+  /** Promote a value under initialization to fully-initialized */
+  case class PromoteError(msg: String)(val trace: Seq[Tree]) extends Error:
+    def show(using Context): String = msg + stacktrace
+
+  case class AccessCold(field: Symbol)(val trace: Seq[Tree]) extends Error:
+    def show(using Context): String =
+      "Access field " + field.show +  " on a cold object." + stacktrace
+
+  case class CallCold(meth: Symbol)(val trace: Seq[Tree]) extends Error:
+    def show(using Context): String =
+      "Call method " + meth.show + " on a cold object." + stacktrace
+
+  case class CallUnknown(meth: Symbol)(val trace: Seq[Tree]) extends Error:
+    def show(using Context): String =
+      val prefix = if meth.is(Flags.Method) then "Calling the external method " else "Accessing the external field"
+      prefix + meth.show + " may cause initialization errors." + stacktrace
+
+  /** Promote a value under initialization to fully-initialized */
+  case class UnsafePromotion(msg: String, error: Error)(val trace: Seq[Tree]) extends Error:
+    def show(using Context): String =
+      msg + stacktrace + "\n" +
+        "Promoting the value to hot (transitively initialized) failed due to the following problem:\n" + {
+          val ctx2 = ctx.withProperty(IsFromPromotion, Some(true))
+          error.show(using ctx2)
+        }
+
+  /** Unsafe leaking a non-hot value as constructor arguments
+   *
+   *  Invariant: argsIndices.nonEmpty
+   */
+  case class UnsafeLeaking(error: Error, nonHotOuterClass: Symbol, argsIndices: List[Int])(val trace: Seq[Tree]) extends Error:
+    def show(using Context): String =
+      "Problematic object instantiation: " + argumentInfo() + stacktrace + "\n" +
+        "It leads to the following error during object initialization:\n" +
+        error.show
+
+    private def punctuation(i: Int): String =
+      if i == argsIndices.size - 2 then " and "
+      else if i == argsIndices.size - 1 then ""
+      else ", "
+
+    private def argumentInfo()(using Context): String =
+      val multiple = argsIndices.size > 1 || nonHotOuterClass.exists
+      val init =
+        if nonHotOuterClass.exists
+        then  "the outer " + nonHotOuterClass.name.show + ".this" + punctuation(-1)
+        else ""
+
+      val subject =
+        argsIndices.zipWithIndex.foldLeft(init) { case (acc, (pos, i)) =>
+          val text1 = "arg " + pos.toString
+          val text2 = text1 + punctuation(i)
+          acc + text2
+        }
+      val verb = if multiple then " are " else " is "
+      val adjective = "not hot (transitively initialized)."
+      subject + verb + adjective
diff --git a/tests/pos-with-compiler-cc/dotc/transform/init/Semantic.scala b/tests/pos-with-compiler-cc/dotc/transform/init/Semantic.scala
new file mode 100644
index 000000000000..541cf50c43e1
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/transform/init/Semantic.scala
@@ -0,0 +1,1807 @@
+package dotty.tools.dotc
+package transform
+package init
+
+import core.*
+import Contexts.*
+import Symbols.*
+import Types.*
+import StdNames.*
+import NameKinds.OuterSelectName
+import NameKinds.SuperAccessorName
+
+import ast.tpd.*
+import config.Printers.init as printer
+import reporting.trace as log
+
+import Errors.*
+
+import scala.collection.mutable
+import scala.annotation.tailrec
+import caps.unsafe.unsafeBoxFunArg
+
+object Semantic:
+
+// ----- Domain definitions --------------------------------
+
+  /** Abstract values
+   *
+   *  Value = Hot | Cold | Warm | ThisRef | Fun | RefSet
+   *
+   *                 Cold
+   *        ┌──────►  ▲  ◄────┐  ◄────┐
+   *        │         │       │       │
+   *        │         │       │       │
+   *        |         │       │       │
+   *        |         │       │       │
+   *     ThisRef     Warm   Fun    RefSet
+   *        │         ▲       ▲       ▲
+   *        │         │       │       │
+   *        |         │       │       │
+   *        ▲         │       │       │
+   *        │         │       │       │
+   *        └─────────┴───────┴───────┘
+   *                  Hot
+   *
+   *   The diagram above does not reflect relationship between `RefSet`
+   *   and other values. `RefSet` represents a set of values which could
+   *   be `ThisRef`, `Warm` or `Fun`. The following ordering applies for
+   *   RefSet:
+   *
+   *         R_a ⊑ R_b if R_a ⊆ R_b
+   *
+   *         V ⊑ R if V ∈ R
+   *
+   */
+  sealed abstract class Value:
+    def show(using Context): String = this match
+      case ThisRef(klass) =>
+        "ThisRef[" + klass.show + "]"
+      case Warm(klass, outer, ctor, args) =>
+        val argsText = if args.nonEmpty then ", args = " + args.map(_.show).mkString("(", ", ", ")") else ""
+        "Warm[" + klass.show + "] { outer = " + outer.show + argsText + " }"
+      case Fun(expr, thisV, klass) =>
+        "Fun { this = " + thisV.show + ", owner = " + klass.show + " }"
+      case RefSet(values) =>
+        values.map(_.show).mkString("Set { ", ", ", " }")
+      case _ =>
+        this.toString()
+
+    def isHot = this == Hot
+    def isCold = this == Cold
+    def isWarm = this.isInstanceOf[Warm]
+    def isThisRef = this.isInstanceOf[ThisRef]
+
+  /** A transitively initialized object */
+  case object Hot extends Value
+
+  /** An object with unknown initialization status */
+  case object Cold extends Value
+
+  sealed abstract class Ref extends Value:
+    def klass: ClassSymbol
+    def outer: Value
+
+  /** A reference to the object under initialization pointed by `this` */
+  case class ThisRef(klass: ClassSymbol) extends Ref:
+    val outer = Hot
+
+  /** An object with all fields initialized but reaches objects under initialization
+   *
+   *  We need to restrict nesting levels of `outer` to finitize the domain.
+   */
+  case class Warm(klass: ClassSymbol, outer: Value, ctor: Symbol, args: List[Value]) extends Ref:
+
+    /** If a warm value is in the process of populating parameters, class bodies are not executed. */
+    private var populatingParams: Boolean = false
+
+    def isPopulatingParams = populatingParams
+
+    /** Ensure that outers and class parameters are initialized.
+     *
+     *  Fields in class body are not initialized.
+     *
+     *  We need to populate class parameters and outers for warm values for the
+     *  following cases:
+     *
+     *  - Widen an already checked warm value to another warm value without
+     *    corresponding object
+     *
+     *  - Using a warm value from the cache, whose corresponding object from
+     *    the last iteration have been remove due to heap reversion
+     *    {@see Cache.prepareForNextIteration}
+     *
+     *  After populating class parameters and outers, it is possible to lazily
+     *  compute the field values in class bodies when they are accessed.
+     */
+    private def populateParams(): Contextual[this.type] = log("populating parameters", printer, (_: Warm).objekt.toString) {
+      assert(!populatingParams, "the object is already populating parameters")
+      populatingParams = true
+      val tpl = klass.defTree.asInstanceOf[TypeDef].rhs.asInstanceOf[Template]
+      extendTrace(klass.defTree) { this.callConstructor(ctor, args.map(arg => ArgInfo(arg, trace))) }
+      populatingParams = false
+      this
+    }
+
+    def ensureObjectExistsAndPopulated(): Contextual[this.type] =
+      if cache.containsObject(this) then this
+      else this.ensureFresh().populateParams()
+
+  end Warm
+
+  /** A function value */
+  case class Fun(expr: Tree, thisV: Ref, klass: ClassSymbol) extends Value
+
+  /** A value which represents a set of addresses
+   *
+   * It comes from `if` expressions.
+   */
+  case class RefSet(refs: List[Fun | Ref]) extends Value
+
+  // end of value definition
+
+  /** The abstract object which stores value about its fields and immediate outers.
+   *
+   *  Semantically it suffices to store the outer for `klass`. We cache other outers
+   *  for performance reasons.
+   *
+   *  Note: Object is NOT a value.
+   */
+  case class Objekt(val klass: ClassSymbol, val fields: Map[Symbol, Value], val outers: Map[ClassSymbol, Value]):
+    def field(f: Symbol): Value = fields(f)
+
+    def outer(klass: ClassSymbol) = outers(klass)
+
+    def hasOuter(klass: ClassSymbol) = outers.contains(klass)
+
+    def hasField(f: Symbol) = fields.contains(f)
+
+  object Promoted:
+    class PromotionInfo(val entryClass: ClassSymbol):
+      var isCurrentObjectPromoted: Boolean = false
+      val values = mutable.Set.empty[Value]
+      override def toString(): String = values.toString()
+
+    /** Values that have been safely promoted */
+    opaque type Promoted = PromotionInfo
+
+    /** Note: don't use `val` to avoid incorrect sharing */
+    def empty(entryClass: ClassSymbol): Promoted = new PromotionInfo(entryClass)
+
+    extension (promoted: Promoted)
+      def isCurrentObjectPromoted: Boolean = promoted.isCurrentObjectPromoted
+      def promoteCurrent(thisRef: ThisRef): Unit = promoted.isCurrentObjectPromoted = true
+      def contains(value: Value): Boolean = promoted.values.contains(value)
+      def add(value: Value): Unit = promoted.values += value
+      def remove(value: Value): Unit = promoted.values -= value
+      def entryClass: ClassSymbol = promoted.entryClass
+    end extension
+  end Promoted
+  type Promoted = Promoted.Promoted
+
+  import Promoted.*
+  inline def promoted(using p: Promoted): Promoted = p
+
+  /** Cache used in fixed point computation
+   *
+   *  The analysis computes the least fixed point for the cache (see doc for
+   *   `ExprValueCache`).
+   *
+   *  For the fixed point computation to terminate, we need to make sure that
+   *  the domain of the cache, i.e. the key pair (Ref, Tree) is finite. As the
+   *  code is finite, we only need to carefully design the abstract domain to
+   *  be finitary.
+   *
+   *  We also need to make sure that the computing function (i.e. the abstract
+   *  interpreter) is monotone. Error handling breaks monotonicity of the
+   *  abstract interpreter, because when an error happens, we always return
+   *  the bottom value `Hot` for an expression. It is not a threat for
+   *  termination because when an error happens, we stop the fixed point
+   *  computation at the end of the iteration where the error happens. Care
+   *  must be paid to tests of errors, monotonicity will be broken if we simply
+   *  ignore the test errors (See `TryReporter`).
+   *
+   *  Note: It's tempting to use location of trees as key. That should
+   *  be avoided as a template may have the same location as its single
+   *  statement body. Macros may also create incorrect locations.
+   */
+  object Cache:
+    /** Cache for expressions
+     *
+     *  Ref -> Tree -> Value
+     *
+     *  The first key is the value of `this` for the expression.
+     *
+     *  We do not need the heap in the key, because the value of an expression
+     *  is only determined by the value of `this`. The heap is immutable: the
+     *  abstract values for object fields never change within one iteration.
+     *  The initial abstraction of a field is always a safe over-approximation
+     *  thanks to monotonicity of initialization states.
+     *
+     *  If the heap is unstable in an iteration, the cache should also be
+     *  unstable. This is because all values stored in the heap are also present
+     *  in the cache. Therefore, we only need to track whether the cache is
+     *  stable between two iterations.
+     *
+     *  The heap is not part of the fixed point computation -- we throw the
+     *  unstable heap from last iteration away. In contrast, we use the unstable
+     *  output cache from the last iteration as input for the next iteration.
+     *  This is safe because the heap is determined by the cache -- it is a
+     *  "local" data to the computing function, conceptually. Local data is
+     *  always safe be discarded.
+     *
+     *  Now, if a fixed point is reached, the local data contains stable data
+     *  that could be reused to check other classes. We employ this trick to
+     *  improve performance of the analysis.
+     */
+    private type ExprValueCache = Map[Value, Map[TreeWrapper, Value]]
+
+    /** The heap for abstract objects
+     *
+     *  The heap objects are immutable.
+     */
+    private type Heap = Map[Ref, Objekt]
+
+    /** A wrapper for trees for storage in maps based on referential equality of trees. */
+    private abstract class TreeWrapper:
+      def tree: Tree
+
+      override final def equals(other: Any): Boolean =
+        other match
+        case that: TreeWrapper => this.tree eq that.tree
+        case _ => false
+
+      override final def hashCode = tree.hashCode
+
+    /** The immutable wrapper is intended to be stored as key in the heap. */
+    private class ImmutableTreeWrapper(val tree: Tree) extends TreeWrapper
+
+    /** For queries on the heap, reuse the same wrapper to avoid unnecessary allocation.
+     *
+     *  A `MutableTreeWrapper` is only ever used temporarily for querying a map,
+     *  and is never inserted to the map.
+     */
+    private class MutableTreeWrapper extends TreeWrapper:
+      var queryTree: Tree | Null = null
+      def tree: Tree = queryTree match
+        case tree: Tree => tree
+        case null => ???
+
+    class Cache:
+      /** The cache for expression values from last iteration */
+      private var last: ExprValueCache =  Map.empty
+
+      /** The output cache for expression values
+       *
+       *  The output cache is computed based on the cache values `last` from the
+       *  last iteration.
+       *
+       *  Both `last` and `current` are required to make sure an encountered
+       *  expression is evaluated once in each iteration.
+       */
+      private var current: ExprValueCache = Map.empty
+
+      /** Global cached values for expressions
+       *
+       *  The values are only added when a fixed point is reached.
+       *
+       *  It is intended to improve performance for computation related to warm values.
+       */
+      private var stable: ExprValueCache = Map.empty
+
+      /** Whether the current heap is different from the last heap?
+       *
+       *  `changed == false` implies that the fixed point has been reached.
+       */
+      private var changed: Boolean = false
+
+      /** Abstract heap stores abstract objects
+       *
+       *  The heap serves as cache of summaries for warm objects and is shared for checking all classes.
+       *
+       *  The fact that objects of `ThisRef` are stored in heap is just an engineering convenience.
+       *  Technically, we can also store the object directly in `ThisRef`.
+       *
+       *  The heap contains objects of two conceptually distinct kinds.
+       *
+       *  - Objects that are also in `heapStable` are flow-insensitive views of already initialized objects that are
+       *    cached for reuse in analysis of later classes. These objects and their fields should never change; this is
+       *    enforced using assertions.
+       *
+       *  - Objects that are not (yet) in `heapStable` are the flow-sensitive abstract state of objects being analyzed
+       *    in the current iteration of the analysis of the current class. Their fields do change flow-sensitively: more
+       *    fields are added as fields become initialized. These objects are valid only within the current iteration and
+       *    are removed when moving to a new iteration of analyzing the current class. When the analysis of a class
+       *    reaches a fixed point, these now stable flow-sensitive views of the object at the end of the constructor
+       *    of the analyzed class now become the flow-insensitive views of already initialized objects and can therefore
+       *    be added to `heapStable`.
+       */
+      private var heap: Heap = Map.empty
+
+      /** Used to revert heap to last stable heap. */
+      private var heapStable: Heap = Map.empty
+
+      /** Used to avoid allocation, its state does not matter */
+      private given MutableTreeWrapper = new MutableTreeWrapper
+
+      def hasChanged = changed
+
+      def get(value: Value, expr: Tree): Option[Value] =
+        current.get(value, expr) match
+        case None => stable.get(value, expr)
+        case res => res
+
+      /** Backup the state of the cache
+       *
+       *  All the shared data structures must be immutable.
+       */
+      def backup(): Cache =
+        val cache = new Cache
+        cache.last = this.last
+        cache.current = this.current
+        cache.stable = this.stable
+        cache.heap = this.heap
+        cache.heapStable = this.heapStable
+        cache.changed = this.changed
+        cache
+
+      /** Restore state from a backup */
+      def restore(cache: Cache) =
+        this.last = cache.last
+        this.current = cache.current
+        this.stable = cache.stable
+        this.heap = cache.heap
+        this.heapStable = cache.heapStable
+        this.changed = cache.changed
+
+      /** Copy the value of `(value, expr)` from the last cache to the current cache
+       *
+       *  It assumes the value is `Hot` if it doesn't exist in the last cache.
+       *
+       *  It updates the current caches if the values change.
+       *
+       *  The two caches are required because we want to make sure in a new iteration, an expression is evaluated once.
+       */
+      def assume(value: Value, expr: Tree, cacheResult: Boolean)(fun: => Value): Contextual[Value] =
+        val assumeValue: Value =
+          last.get(value, expr) match
+          case Some(value) => value
+          case None =>
+            this.last = last.updatedNested(value, expr, Hot)
+            Hot
+
+        this.current = current.updatedNested(value, expr, assumeValue)
+
+        val actual = fun
+        if actual != assumeValue then
+          this.changed = true
+          this.current = this.current.updatedNested(value, expr, actual)
+        else
+          // It's tempting to cache the value in stable, but it's unsound.
+          // The reason is that the current value may depend on other values
+          // which might change.
+          //
+          // stable.put(value, expr, actual)
+          ()
+        end if
+
+        actual
+      end assume
+
+      /** Commit current cache to stable cache. */
+      private def commitToStableCache() =
+        for
+          (v, m) <- current
+          if v.isWarm          // It's useless to cache value for ThisRef.
+          (wrapper, res) <- m
+        do
+          this.stable = stable.updatedNestedWrapper(v, wrapper.asInstanceOf[ImmutableTreeWrapper], res)
+
+      /** Prepare cache for the next iteration
+       *
+       *  1. Reset changed flag.
+       *
+       *  2. Use current cache as last cache and set current cache to be empty.
+       *
+       *  3. Revert heap to stable.
+       */
+      def prepareForNextIteration()(using Context) =
+        this.changed = false
+        this.last = this.current
+        this.current = Map.empty
+        this.heap = this.heapStable
+
+      /** Prepare for checking next class
+       *
+       *  1. Reset changed flag.
+       *
+       *  2. Commit current cache to stable cache if not changed.
+       *
+       *  3. Update stable heap if not changed.
+       *
+       *  4. Reset last cache.
+       */
+      def prepareForNextClass()(using Context) =
+        if this.changed then
+          this.changed = false
+          this.heap = this.heapStable
+        else
+          this.commitToStableCache()
+          this.heapStable = this.heap
+
+        this.last = Map.empty
+        this.current = Map.empty
+
+      def updateObject(ref: Ref, obj: Objekt) =
+        assert(!this.heapStable.contains(ref))
+        this.heap = this.heap.updated(ref, obj)
+
+      def containsObject(ref: Ref) = heap.contains(ref)
+
+      def getObject(ref: Ref) = heap(ref)
+    end Cache
+
+    extension (cache: ExprValueCache)
+      private def get(value: Value, expr: Tree)(using queryWrapper: MutableTreeWrapper): Option[Value] =
+        queryWrapper.queryTree = expr
+        cache.get(value).flatMap(_.get(queryWrapper))
+
+      private def removed(value: Value, expr: Tree)(using queryWrapper: MutableTreeWrapper) =
+        queryWrapper.queryTree = expr
+        val innerMap2 = cache(value).removed(queryWrapper)
+        cache.updated(value, innerMap2)
+
+      private def updatedNested(value: Value, expr: Tree, result: Value): ExprValueCache =
+        val wrapper = new ImmutableTreeWrapper(expr)
+        updatedNestedWrapper(value, wrapper, result)
+
+      private def updatedNestedWrapper(value: Value, wrapper: ImmutableTreeWrapper, result: Value): ExprValueCache =
+        val innerMap = cache.getOrElse(value, Map.empty[TreeWrapper, Value])
+        val innerMap2 = innerMap.updated(wrapper, result)
+        cache.updated(value, innerMap2)
+    end extension
+  end Cache
+
+  import Cache.*
+
+  inline def cache(using c: Cache): Cache = c
+
+// ----- Checker State -----------------------------------
+
+  /** The state that threads through the interpreter */
+  type Contextual[T] = (Context, Trace, Promoted, Cache, Reporter) ?=> T
+
+// ----- Error Handling -----------------------------------
+
+  object Trace:
+    opaque type Trace = Vector[Tree]
+
+    val empty: Trace = Vector.empty
+
+    extension (trace: Trace)
+      def add(node: Tree): Trace = trace :+ node
+      def toVector: Vector[Tree] = trace
+
+    def show(using trace: Trace, ctx: Context): String = buildStacktrace(trace, "\n")
+
+    def position(using trace: Trace): Tree = trace.last
+  type Trace = Trace.Trace
+
+  import Trace.*
+  def trace(using t: Trace): Trace = t
+  inline def withTrace[T](t: Trace)(op: Trace ?=> T): T = op(using t)
+  inline def extendTrace[T](node: Tree)(using t: Trace)(op: Trace ?=> T): T = op(using t.add(node))
+
+  /** Error reporting */
+  trait Reporter:
+    def report(err: Error): Unit
+    def reportAll(errs: Seq[Error]): Unit = for err <- errs do report(err)
+
+  /** A TryReporter cannot be simply thrown away
+   *
+   *  Either `abort` should be called or the errors be reported.
+   *
+   *  If errors are ignored and `abort` is not called, the monotonicity of the
+   *  computation function is not guaranteed, thus termination of fixed-point
+   *  computation becomes a problem.
+   */
+  trait TryReporter extends Reporter:
+    /**
+     * Revert the cache to previous state.
+     */
+    def abort()(using Cache): Unit
+    def errors: List[Error]
+
+  object Reporter:
+    class BufferedReporter extends Reporter:
+      private val buf = new mutable.ArrayBuffer[Error]
+      def errors = buf.toList
+      def report(err: Error) = buf += err
+
+    class TryBufferedReporter(backup: Cache) extends BufferedReporter with TryReporter:
+      def abort()(using Cache): Unit = cache.restore(backup)
+
+    class ErrorFound(val error: Error) extends Exception
+    class StopEarlyReporter extends Reporter:
+      def report(err: Error) = throw new ErrorFound(err)
+
+    /** Capture all errors with a TryReporter
+     *
+     *  The TryReporter cannot be thrown away: either `abort` must be called or
+     *  the errors must be reported.
+     */
+    def errorsIn(fn: Reporter ?=> Unit)(using Cache): TryReporter =
+      val reporter = new TryBufferedReporter(cache.backup())
+      fn(using reporter)
+      reporter
+
+    /** Stop on first error */
+    def stopEarly(fn: Reporter ?=> Unit): List[Error] =
+      val reporter: Reporter = new StopEarlyReporter
+
+      try
+        fn(using reporter)
+        Nil
+      catch case ex: ErrorFound =>
+        ex.error :: Nil
+
+    def hasErrors(fn: Reporter ?=> Unit)(using Cache): Boolean =
+      val backup = cache.backup()
+      val errors = stopEarly(fn)
+      cache.restore(backup)
+      errors.nonEmpty
+
+  inline def reporter(using r: Reporter): Reporter = r
+
+// ----- Operations on domains -----------------------------
+  extension (a: Value)
+    def join(b: Value): Value =
+      (a, b) match
+      case (Hot, _)  => b
+      case (_, Hot)  => a
+
+      case (Cold, _) => Cold
+      case (_, Cold) => Cold
+
+      case (a: (Fun | Warm | ThisRef), b: (Fun | Warm | ThisRef)) =>
+        if a == b then a else RefSet(a :: b :: Nil)
+
+      case (a: (Fun | Warm | ThisRef), RefSet(refs)) =>
+        if refs.exists(_ == a) then b: Value // fix pickling test
+        else RefSet(a :: refs)
+
+      case (RefSet(refs), b: (Fun | Warm | ThisRef)) =>
+        if refs.exists(_ == b) then a: Value // fix pickling test
+        else RefSet(b :: refs)
+
+      case (RefSet(refs1), RefSet(refs2)) =>
+        val diff = refs2.filter(ref => refs1.forall(_ != ref))
+        RefSet(refs1 ++ diff)
+
+    /** Conservatively approximate the value with `Cold` or `Hot` */
+    def widenArg: Contextual[Value] =
+      a match
+      case _: Ref | _: Fun =>
+        val hasError = Reporter.hasErrors { a.promote("Argument cannot be promoted to hot") }
+        if hasError then Cold else Hot
+
+      case RefSet(refs) =>
+        refs.map(_.widenArg).join
+
+      case _ => a
+
+
+  extension (values: Seq[Value])
+    def join: Value =
+      if values.isEmpty then Hot
+      else values.reduce { (v1, v2) => v1.join(v2) }
+
+    def widenArgs: Contextual[List[Value]] = values.map(_.widenArg).toList
+
+
+  extension (ref: Ref)
+    def objekt: Contextual[Objekt] =
+      // TODO: improve performance
+      ref match
+        case warm: Warm => warm.ensureObjectExistsAndPopulated()
+        case _ =>
+      cache.getObject(ref)
+
+    def ensureObjectExists()(using Cache): ref.type =
+      if cache.containsObject(ref) then
+        printer.println("object " + ref + " already exists")
+        ref
+      else
+        ensureFresh()
+
+    def ensureFresh()(using Cache): ref.type =
+      val obj = Objekt(ref.klass, fields = Map.empty, outers = Map(ref.klass -> ref.outer))
+      printer.println("reset object " + ref)
+      cache.updateObject(ref, obj)
+      ref
+
+    /** Update field value of the abstract object
+     *
+     *  Invariant: fields are immutable and only set once
+     */
+    def updateField(field: Symbol, value: Value): Contextual[Unit] = log("set field " + field + " of " + ref + " to " + value) {
+      val obj = objekt
+      // We may reset the outers or params of a populated warm object.
+      // This is the case if we need access the field of a warm object, which
+      // requires population of parameters and outers; and later create an
+      // instance of the exact warm object, whose initialization will reset
+      // the outer and constructor parameters.
+      //
+      // See tests/init/neg/unsound1.scala
+      val changed = !obj.hasField(field) || obj.field(field) != value
+      def isParamUpdate = field.isOneOf(Flags.ParamAccessor | Flags.Param) && obj.field(field) == value
+      assert(!obj.hasField(field) || isParamUpdate, field.show + " already init, new = " + value + ", old = " + obj.field(field) + ", ref = " + ref)
+      val obj2 = obj.copy(fields = obj.fields.updated(field, value))
+      if changed then cache.updateObject(ref, obj2)
+    }
+
+    /** Update the immediate outer of the given `klass` of the abstract object
+     *
+     *  Invariant: outers are immutable and only set once
+     */
+    def updateOuter(klass: ClassSymbol, value: Value): Contextual[Unit] = log("set outer " + klass + " of " + ref + " to " + value) {
+      val obj = objekt
+      // See the comment in `updateField` for setting the value twice.
+      assert(!obj.hasOuter(klass) || obj.outer(klass) == value, klass.show + " already has outer, new = " + value + ", old = " + obj.outer(klass) + ", ref = " + ref)
+      val obj2 = obj.copy(outers = obj.outers.updated(klass, value))
+      cache.updateObject(ref, obj2)
+    }
+  end extension
+
+  extension (value: Value)
+    def ensureHot(msg: String): Contextual[Value] =
+      value.promote(msg)
+      value
+
+    def select(field: Symbol, receiver: Type, needResolve: Boolean = true): Contextual[Value] = log("select " + field.show + ", this = " + value, printer, (_: Value).show) {
+      if promoted.isCurrentObjectPromoted then Hot
+      else value match
+        case Hot  =>
+          Hot
+
+        case Cold =>
+          val error = AccessCold(field)(trace.toVector)
+          reporter.report(error)
+          Hot
+
+        case ref: Ref =>
+          val target = if needResolve then resolve(ref.klass, field) else field
+          if target.is(Flags.Lazy) then
+            val rhs = target.defTree.asInstanceOf[ValDef].rhs
+            eval(rhs, ref, target.owner.asClass, cacheResult = true)
+          else if target.exists then
+            val obj = ref.objekt
+            if obj.hasField(target) then
+              obj.field(target)
+            else if ref.isInstanceOf[Warm] then
+              assert(obj.klass.isSubClass(target.owner))
+              if target.is(Flags.ParamAccessor) then
+                // possible for trait parameters
+                // see tests/init/neg/trait2.scala
+                //
+                // return `Hot` here, errors are reported in checking `ThisRef`
+                Hot
+              else if target.hasSource then
+                val rhs = target.defTree.asInstanceOf[ValOrDefDef].rhs
+                eval(rhs, ref, target.owner.asClass, cacheResult = true)
+              else
+                val error = CallUnknown(field)(trace.toVector)
+                reporter.report(error)
+                Hot
+            else
+              val error = AccessNonInit(target)(trace.toVector)
+              reporter.report(error)
+              Hot
+          else
+            if ref.klass.isSubClass(receiver.widenSingleton.classSymbol) then
+              report.error("[Internal error] Unexpected resolution failure: ref.klass = " + ref.klass.show + ", field = " + field.show + Trace.show, Trace.position)
+              Hot
+            else
+              // This is possible due to incorrect type cast.
+              // See tests/init/pos/Type.scala
+              Hot
+
+        case fun: Fun =>
+          report.error("[Internal error] unexpected tree in selecting a function, fun = " + fun.expr.show + Trace.show, fun.expr)
+          Hot
+
+        case RefSet(refs) =>
+          refs.map(_.select(field, receiver)).join
+    }
+
+    def call(meth: Symbol, args: List[ArgInfo], receiver: Type, superType: Type, needResolve: Boolean = true): Contextual[Value] = log("call " + meth.show + ", args = " + args.map(_.value.show), printer, (_: Value).show) {
+      def promoteArgs(): Contextual[Unit] = args.foreach(_.promote)
+
+      def isSyntheticApply(meth: Symbol) =
+        meth.is(Flags.Synthetic)
+        && meth.name == nme.apply
+        && meth.owner.is(Flags.Module)
+        && meth.owner.companionClass.is(Flags.Case)
+
+      def isAlwaysSafe(meth: Symbol) =
+        (meth eq defn.Object_eq)
+        || (meth eq defn.Object_ne)
+        || (meth eq defn.Any_isInstanceOf)
+
+      def checkArgsWithParametricity() =
+        val methodType = atPhaseBeforeTransforms { meth.info.stripPoly }
+        var allArgsHot = true
+        val allParamTypes = methodType.paramInfoss.flatten.map(_.repeatedToSingle)
+        val errors = allParamTypes.zip(args).flatMap { (info, arg) =>
+          val tryReporter = Reporter.errorsIn { arg.promote }
+          allArgsHot = allArgsHot && tryReporter.errors.isEmpty
+          if tryReporter.errors.isEmpty then tryReporter.errors
+          else
+            info match
+            case typeParamRef: TypeParamRef =>
+              val bounds = typeParamRef.underlying.bounds
+              val isWithinBounds = bounds.lo <:< defn.NothingType && defn.AnyType <:< bounds.hi
+              def otherParamContains = allParamTypes.exists { param => param != typeParamRef && param.typeSymbol != defn.ClassTagClass && typeParamRef.occursIn(param) }
+              // A non-hot method argument is allowed if the corresponding parameter type is a
+              // type parameter T with Any as its upper bound and Nothing as its lower bound.
+              // the other arguments should either correspond to a parameter type that is T
+              // or that does not contain T as a component.
+              if isWithinBounds && !otherParamContains then
+                tryReporter.abort()
+                Nil
+              else
+                tryReporter.errors
+            case _ => tryReporter.errors
+        }
+        (errors, allArgsHot)
+
+      // fast track if the current object is already initialized
+      if promoted.isCurrentObjectPromoted then Hot
+      else if isAlwaysSafe(meth) then Hot
+      else if meth eq defn.Any_asInstanceOf then value
+      else value match {
+        case Hot  =>
+          if isSyntheticApply(meth) && meth.hasSource then
+            val klass = meth.owner.companionClass.asClass
+            instantiate(klass, klass.primaryConstructor, args)
+          else
+            if receiver.typeSymbol.isStaticOwner then
+              val (errors, allArgsHot) = checkArgsWithParametricity()
+              if allArgsHot then
+                Hot: Value
+              else if errors.nonEmpty then
+                reporter.reportAll(errors)
+                Hot: Value
+              else
+                Cold: Value
+            else
+              promoteArgs()
+              Hot
+
+        case Cold =>
+          promoteArgs()
+          val error = CallCold(meth)(trace.toVector)
+          reporter.report(error)
+          Hot
+
+        case ref: Ref =>
+          val isLocal = !meth.owner.isClass
+          val target =
+            if !needResolve then
+              meth
+            else if superType.exists then
+              meth
+            else if meth.name.is(SuperAccessorName) then
+              ResolveSuper.rebindSuper(ref.klass, meth)
+            else
+              resolve(ref.klass, meth)
+
+          if target.isOneOf(Flags.Method) then
+            if target.hasSource then
+              val cls = target.owner.enclosingClass.asClass
+              val ddef = target.defTree.asInstanceOf[DefDef]
+              val tryReporter = Reporter.errorsIn { promoteArgs() }
+              // normal method call
+              if tryReporter.errors.nonEmpty && isSyntheticApply(meth) then
+                tryReporter.abort()
+                val klass = meth.owner.companionClass.asClass
+                val targetCls = klass.owner.lexicallyEnclosingClass.asClass
+                val outer = resolveThis(targetCls, ref, meth.owner.asClass)
+                outer.instantiate(klass, klass.primaryConstructor, args)
+              else
+                reporter.reportAll(tryReporter.errors)
+                extendTrace(ddef) {
+                  eval(ddef.rhs, ref, cls, cacheResult = true)
+                }
+            else if ref.canIgnoreMethodCall(target) then
+              Hot
+            else
+              // no source code available
+              promoteArgs()
+              // try promoting the receiver as last resort
+              val hasErrors = Reporter.hasErrors { ref.promote("try promote value to hot") }
+              if hasErrors then
+                val error = CallUnknown(target)(trace.toVector)
+                reporter.report(error)
+              Hot
+          else if target.exists then
+            // method call resolves to a field
+            val obj = ref.objekt
+            if obj.hasField(target) then
+              obj.field(target)
+            else
+              value.select(target, receiver, needResolve = false)
+          else
+            if ref.klass.isSubClass(receiver.widenSingleton.classSymbol) then
+              report.error("[Internal error] Unexpected resolution failure: ref.klass = " + ref.klass.show + ", meth = " + meth.show + Trace.show, Trace.position)
+              Hot
+            else
+              // This is possible due to incorrect type cast.
+              // See tests/init/pos/Type.scala
+              Hot
+
+        case Fun(body, thisV, klass) =>
+          // meth == NoSymbol for poly functions
+          if meth.name.toString == "tupled" then value // a call like `fun.tupled`
+          else
+            promoteArgs()
+            eval(body, thisV, klass, cacheResult = true)
+
+        case RefSet(refs) =>
+          refs.map(_.call(meth, args, receiver, superType)).join
+      }
+    }
+
+    def callConstructor(ctor: Symbol, args: List[ArgInfo]): Contextual[Value] = log("call " + ctor.show + ", args = " + args.map(_.value.show), printer, (_: Value).show) {
+      // init "fake" param fields for parameters of primary and secondary constructors
+      def addParamsAsFields(args: List[Value], ref: Ref, ctorDef: DefDef) =
+        val params = ctorDef.termParamss.flatten.map(_.symbol)
+        assert(args.size == params.size, "arguments = " + args.size + ", params = " + params.size)
+        for (param, value) <- params.zip(args) do
+          ref.updateField(param, value)
+          printer.println(param.show + " initialized with " + value)
+
+      value match {
+        case Hot | Cold | _: RefSet | _: Fun =>
+          report.error("[Internal error] unexpected constructor call, meth = " + ctor + ", value = " + value + Trace.show, Trace.position)
+          Hot
+
+        case ref: Warm if ref.isPopulatingParams =>
+          if ctor.hasSource then
+            val cls = ctor.owner.enclosingClass.asClass
+            val ddef = ctor.defTree.asInstanceOf[DefDef]
+            val args2 = args.map(_.value).widenArgs
+            addParamsAsFields(args2, ref, ddef)
+            if ctor.isPrimaryConstructor then
+              val tpl = cls.defTree.asInstanceOf[TypeDef].rhs.asInstanceOf[Template]
+              extendTrace(cls.defTree) { init(tpl, ref, cls) }
+            else
+              val initCall = ddef.rhs match
+                case Block(call :: _, _) => call
+                case call => call
+              extendTrace(ddef) { eval(initCall, ref, cls) }
+            end if
+          else
+            Hot
+
+        case ref: Ref =>
+          if ctor.hasSource then
+            val cls = ctor.owner.enclosingClass.asClass
+            val ddef = ctor.defTree.asInstanceOf[DefDef]
+            val args2 = args.map(_.value).widenArgs
+            addParamsAsFields(args2, ref, ddef)
+            if ctor.isPrimaryConstructor then
+              val tpl = cls.defTree.asInstanceOf[TypeDef].rhs.asInstanceOf[Template]
+              extendTrace(cls.defTree) { eval(tpl, ref, cls, cacheResult = true) }
+              ref
+            else
+              extendTrace(ddef) { eval(ddef.rhs, ref, cls, cacheResult = true) }
+          else if ref.canIgnoreMethodCall(ctor) then
+            Hot
+          else
+            // no source code available
+            val error = CallUnknown(ctor)(trace.toVector)
+            reporter.report(error)
+            Hot
+      }
+
+    }
+
+    /** Handle a new expression `new p.C` where `p` is abstracted by `value` */
+    def instantiate(klass: ClassSymbol, ctor: Symbol, args: List[ArgInfo]): Contextual[Value] = log("instantiating " + klass.show + ", value = " + value + ", args = " + args.map(_.value.show), printer, (_: Value).show) {
+      def tryLeak(warm: Warm, nonHotOuterClass: Symbol, argValues: List[Value]): Contextual[Value] =
+        val argInfos2 = args.zip(argValues).map { (argInfo, v) => argInfo.copy(value = v) }
+        val errors = Reporter.stopEarly {
+          given Trace = Trace.empty
+          warm.callConstructor(ctor, argInfos2)
+        }
+        if errors.nonEmpty then
+          val indices =
+            for
+              (arg, i) <- argValues.zipWithIndex
+              if arg.isCold
+            yield
+              i + 1
+
+          val error = UnsafeLeaking(errors.head, nonHotOuterClass, indices)(trace.toVector)
+          reporter.report(error)
+          Hot
+        else
+          warm
+
+      if promoted.isCurrentObjectPromoted then Hot
+      else value match {
+        case Hot  =>
+          var allHot = true
+          val args2 = args.map { arg =>
+            val hasErrors = Reporter.hasErrors { arg.promote }
+            allHot = allHot && !hasErrors
+            if hasErrors then arg.value.widenArg
+            else Hot
+          }
+
+          if allHot then
+            Hot
+          else
+            val outer = Hot
+            val warm = Warm(klass, outer, ctor, args2).ensureObjectExists()
+            tryLeak(warm, NoSymbol, args2)
+
+        case Cold =>
+          val error = CallCold(ctor)(trace.toVector)
+          reporter.report(error)
+          Hot
+
+        case ref: Ref =>
+          // widen the outer to finitize the domain
+          val outer = ref match
+            case warm @ Warm(_, _: Warm, _, _) =>
+              // the widened warm object might not exist in the heap
+              warm.copy(outer = Cold).ensureObjectExistsAndPopulated()
+            case _ => ref
+
+          val argsWidened = args.map(_.value).widenArgs
+          val warm = Warm(klass, outer, ctor, argsWidened).ensureObjectExists()
+          if argsWidened.exists(_.isCold) then
+            tryLeak(warm, klass.owner.lexicallyEnclosingClass, argsWidened)
+          else
+            val argInfos2 = args.zip(argsWidened).map { (argInfo, v) => argInfo.copy(value = v) }
+            warm.callConstructor(ctor, argInfos2)
+            warm
+
+        case Fun(body, thisV, klass) =>
+          report.error("[Internal error] unexpected tree in instantiating a function, fun = " + body.show + Trace.show, Trace.position)
+          Hot
+
+        case RefSet(refs) =>
+          refs.map(_.instantiate(klass, ctor, args)).join
+      }
+    }
+  end extension
+
+  extension (ref: Ref)
+    def accessLocal(tmref: TermRef, klass: ClassSymbol): Contextual[Value] =
+      val sym = tmref.symbol
+
+      if sym.is(Flags.Param) && sym.owner.isConstructor then
+        val enclosingClass = sym.owner.enclosingClass.asClass
+        val thisValue2 = resolveThis(enclosingClass, ref, klass)
+        thisValue2 match
+        case Hot => Hot
+        case ref: Ref => ref.objekt.field(sym)
+        case _ =>
+            report.error("[Internal error] unexpected this value accessing local variable, sym = " + sym.show + ", thisValue = " + thisValue2.show + Trace.show, Trace.position)
+            Hot
+      else if sym.is(Flags.Param) then
+        Hot
+      else
+        sym.defTree match {
+          case vdef: ValDef =>
+            // resolve this for local variable
+            val enclosingClass = sym.owner.enclosingClass.asClass
+            val thisValue2 = resolveThis(enclosingClass, ref, klass)
+            thisValue2 match
+              case Hot => Hot
+
+              case Cold => Cold
+
+              case ref: Ref => eval(vdef.rhs, ref, enclosingClass)
+
+              case _ =>
+                 report.error("[Internal error] unexpected this value when accessing local variable, sym = " + sym.show + ", thisValue = " + thisValue2.show + Trace.show, Trace.position)
+                 Hot
+            end match
+
+          case _ => Hot
+        }
+  end extension
+
+// ----- Promotion ----------------------------------------------------
+  extension (ref: Ref)
+    /** Whether the object is fully assigned
+     *
+     *  It means all fields and outers are set. For performance, we don't check
+     *  outers here, because Scala semantics ensure that they are always set
+     *  before any user code in the constructor.
+     *
+     *  Note that `isFullyFilled = true` does not mean we can use the
+     *  object freely, as its fields or outers may still reach uninitialized
+     *  objects.
+     */
+    def isFullyFilled: Contextual[Boolean] = log("isFullyFilled " + ref, printer) {
+      val obj = ref.objekt
+      ref.klass.baseClasses.forall { klass =>
+        !klass.hasSource || {
+          val nonInits = klass.info.decls.filter { member =>
+            !member.isOneOf(Flags.Method | Flags.Lazy | Flags.Deferred)
+            && !member.isType
+            && !obj.hasField(member)
+          }
+          printer.println("nonInits = " + nonInits)
+          nonInits.isEmpty
+        }
+      }
+    }
+
+    def nonInitFields(): Contextual[List[Symbol]] =
+      val obj = ref.objekt
+      ref.klass.baseClasses.flatMap { klass =>
+        if klass.hasSource then
+          klass.info.decls.filter { member =>
+            !member.isOneOf(Flags.Method | Flags.Lazy | Flags.Deferred)
+            && !member.isType
+            && !obj.hasField(member)
+          }
+        else
+          Nil
+      }
+
+  end extension
+
+  extension (thisRef: ThisRef)
+    def tryPromoteCurrentObject(): Contextual[Boolean] = log("tryPromoteCurrentObject ", printer) {
+      if promoted.isCurrentObjectPromoted then
+        true
+      else if thisRef.isFullyFilled then
+        // If we have all fields initialized, then we can promote This to hot.
+        promoted.promoteCurrent(thisRef)
+        true
+      else
+        false
+    }
+
+  extension (value: Value)
+    /** Promotion of values to hot */
+    def promote(msg: String): Contextual[Unit] = log("promoting " + value + ", promoted = " + promoted, printer) {
+      if !promoted.isCurrentObjectPromoted then
+
+        value match
+        case Hot   =>
+
+        case Cold  =>
+          reporter.report(PromoteError(msg)(trace.toVector))
+
+        case thisRef: ThisRef =>
+          val emptyFields = thisRef.nonInitFields()
+          if emptyFields.isEmpty then
+            promoted.promoteCurrent(thisRef)
+          else
+            val fields = "Non initialized field(s): " + emptyFields.map(_.show).mkString(", ") + "."
+            reporter.report(PromoteError(msg + "\n" + fields)(trace.toVector))
+
+        case warm: Warm =>
+          if !promoted.contains(warm) then
+            promoted.add(warm)
+            val errors = warm.tryPromote(msg)
+            if errors.nonEmpty then promoted.remove(warm)
+            reporter.reportAll(errors)
+
+        case fun @ Fun(body, thisV, klass) =>
+          if !promoted.contains(fun) then
+            val errors = Reporter.stopEarly {
+              val res = {
+                given Trace = Trace.empty
+                eval(body, thisV, klass)
+              }
+              given Trace = Trace.empty.add(body)
+              res.promote("The function return value is not hot. Found = " + res.show + ".")
+            }
+            if errors.nonEmpty then
+              reporter.report(UnsafePromotion(msg, errors.head)(trace.toVector))
+            else
+              promoted.add(fun)
+
+        case RefSet(refs) =>
+          refs.foreach(_.promote(msg))
+    }
+  end extension
+
+  extension (warm: Warm)
+    /** Try early promotion of warm objects
+     *
+     *  Promotion is expensive and should only be performed for small classes.
+     *
+     *  1. for each concrete method `m` of the warm object:
+     *     call the method and promote the result
+     *
+     *  2. for each concrete field `f` of the warm object:
+     *     promote the field value
+     *
+     *  If the object contains nested classes as members, the checker simply
+     *  reports a warning to avoid expensive checks.
+     *
+     */
+    def tryPromote(msg: String): Contextual[List[Error]] = log("promote " + warm.show + ", promoted = " + promoted, printer) {
+      val obj = warm.objekt
+
+      def doPromote(klass: ClassSymbol, subClass: ClassSymbol, subClassSegmentHot: Boolean)(using Reporter): Unit =
+        val outer = obj.outer(klass)
+        val isHotSegment = outer.isHot && {
+          val ctor = klass.primaryConstructor
+          val ctorDef = ctor.defTree.asInstanceOf[DefDef]
+          val params = ctorDef.termParamss.flatten.map(_.symbol)
+          // We have cached all parameters on the object
+          params.forall(param => obj.field(param).isHot)
+        }
+
+        // Check invariant: subClassSegmentHot ==> isHotSegment
+        //
+        // This invariant holds because of the Scala/Java/JVM restriction that we cannot use `this` in super constructor calls.
+        if subClassSegmentHot && !isHotSegment then
+          report.error("[Internal error] Expect current segment to hot in promotion, current klass = " + klass.show +
+              ", subclass = " + subClass.show + Trace.show, Trace.position)
+
+        // If the outer and parameters of a class are all hot, then accessing fields and methods of the current
+        // segment of the object should be OK. They may only create problems via virtual method calls on `this`, but
+        // those methods are checked as part of the check for the class where they are defined.
+        if !isHotSegment then
+          for member <- klass.info.decls do
+            if member.isClass then
+              val error = PromoteError("Promotion cancelled as the value contains inner " + member.show + ".")(Vector.empty)
+              reporter.report(error)
+            else if !member.isType && !member.isConstructor  && !member.is(Flags.Deferred) then
+              given Trace = Trace.empty
+              if member.is(Flags.Method, butNot = Flags.Accessor) then
+                val args = member.info.paramInfoss.flatten.map(_ => ArgInfo(Hot, Trace.empty))
+                val res = warm.call(member, args, receiver = warm.klass.typeRef, superType = NoType)
+                withTrace(trace.add(member.defTree)) {
+                  res.promote("Cannot prove that the return value of " + member.show + " is hot. Found = " + res.show + ".")
+                }
+              else
+                val res = warm.select(member, receiver = warm.klass.typeRef)
+                withTrace(trace.add(member.defTree)) {
+                  res.promote("Cannot prove that the field " + member.show + " is hot. Found = " + res.show + ".")
+                }
+          end for
+
+        // Promote parents
+        //
+        // Note that a parameterized trait may only get parameters from the class that extends the trait.
+        // A trait may not supply constructor arguments to another trait.
+        if !klass.is(Flags.Trait) then
+          val superCls = klass.superClass
+          if superCls.hasSource then doPromote(superCls.asClass, klass, isHotSegment)
+          val mixins = klass.baseClasses.tail.takeWhile(_ != superCls)
+          for mixin <- mixins if mixin.hasSource do doPromote(mixin.asClass, klass, isHotSegment)
+      end doPromote
+
+      val errors = Reporter.stopEarly {
+        doPromote(warm.klass, subClass = warm.klass, subClassSegmentHot = false)
+      }
+
+      if errors.isEmpty then Nil
+      else UnsafePromotion(msg, errors.head)(trace.toVector) :: Nil
+    }
+
+  end extension
+
+// ----- Policies ------------------------------------------------------
+  extension (value: Ref)
+    /** Can the method call on `value` be ignored?
+     *
+     *  Note: assume overriding resolution has been performed.
+     */
+    def canIgnoreMethodCall(meth: Symbol)(using Context): Boolean =
+      val cls = meth.owner
+      cls == defn.AnyClass ||
+      cls == defn.AnyValClass ||
+      cls == defn.ObjectClass
+
+// ----- API --------------------------------
+
+  /** Check an individual class
+   *
+   *  The class to be checked must be an instantiable concrete class.
+   */
+  private def checkClass(classSym: ClassSymbol)(using Cache, Context): Unit =
+    val thisRef = ThisRef(classSym)
+    val tpl = classSym.defTree.asInstanceOf[TypeDef].rhs.asInstanceOf[Template]
+
+    @tailrec
+    def iterate(): Unit = {
+      given Promoted = Promoted.empty(classSym)
+      given Trace = Trace.empty.add(classSym.defTree)
+      given reporter: Reporter.BufferedReporter = new Reporter.BufferedReporter
+
+      thisRef.ensureFresh()
+
+      // set up constructor parameters
+      for param <- tpl.constr.termParamss.flatten do
+        thisRef.updateField(param.symbol, Hot)
+
+      log("checking " + classSym) { eval(tpl, thisRef, classSym) }
+      reporter.errors.foreach(_.issue)
+
+      if cache.hasChanged && reporter.errors.isEmpty then
+        // code to prepare cache and heap for next iteration
+        cache.prepareForNextIteration()
+        iterate()
+      else
+        cache.prepareForNextClass()
+    }
+
+    iterate()
+  end checkClass
+
+  /**
+   * Check the specified concrete classes
+   */
+  def checkClasses(classes: List[ClassSymbol])(using Context): Unit =
+    given Cache()
+    for classSym <- classes if isConcreteClass(classSym) do
+      checkClass(classSym)
+
+// ----- Semantic definition --------------------------------
+
+  /** Utility definition used for better error-reporting of argument errors */
+  case class ArgInfo(value: Value, trace: Trace):
+    def promote: Contextual[Unit] = withTrace(trace) {
+      value.promote("Cannot prove the method argument is hot. Only hot values are safe to leak.\nFound = " + value.show + ".")
+    }
+
+  /** Evaluate an expression with the given value for `this` in a given class `klass`
+   *
+   *  Note that `klass` might be a super class of the object referred by `thisV`.
+   *  The parameter `klass` is needed for `this` resolution. Consider the following code:
+   *
+   *  class A {
+   *    A.this
+   *    class B extends A { A.this }
+   *  }
+   *
+   *  As can be seen above, the meaning of the expression `A.this` depends on where
+   *  it is located.
+   *
+   *  This method only handles cache logic and delegates the work to `cases`.
+   *
+   * @param expr        The expression to be evaluated.
+   * @param thisV       The value for `C.this` where `C` is represented by the parameter `klass`.
+   * @param klass       The enclosing class where the expression is located.
+   * @param cacheResult It is used to reduce the size of the cache.
+   */
+  def eval(expr: Tree, thisV: Ref, klass: ClassSymbol, cacheResult: Boolean = false): Contextual[Value] = log("evaluating " + expr.show + ", this = " + thisV.show + " in " + klass.show, printer, (_: Value).show) {
+    cache.get(thisV, expr) match
+    case Some(value) => value
+    case None =>
+      cache.assume(thisV, expr, cacheResult) { cases(expr, thisV, klass) }
+  }
+
+  /** Evaluate a list of expressions */
+  def eval(exprs: List[Tree], thisV: Ref, klass: ClassSymbol): Contextual[List[Value]] =
+    exprs.map { expr => eval(expr, thisV, klass) }
+
+  /** Evaluate arguments of methods */
+  def evalArgs(args: List[Arg], thisV: Ref, klass: ClassSymbol): Contextual[List[ArgInfo]] =
+    val argInfos = new mutable.ArrayBuffer[ArgInfo]
+    args.foreach { arg =>
+      val res =
+        if arg.isByName then
+          Fun(arg.tree, thisV, klass)
+        else
+          eval(arg.tree, thisV, klass)
+
+      argInfos += ArgInfo(res, trace.add(arg.tree))
+    }
+    argInfos.toList
+
+  /** Handles the evaluation of different expressions
+   *
+   *  Note: Recursive call should go to `eval` instead of `cases`.
+   *
+   * @param expr   The expression to be evaluated.
+   * @param thisV  The value for `C.this` where `C` is represented by the parameter `klass`.
+   * @param klass  The enclosing class where the expression `expr` is located.
+   */
+  def cases(expr: Tree, thisV: Ref, klass: ClassSymbol): Contextual[Value] =
+    val trace2 = trace.add(expr)
+    expr match
+      case Ident(nme.WILDCARD) =>
+        // TODO:  disallow `var x: T = _`
+        Hot
+
+      case id @ Ident(name) if !id.symbol.is(Flags.Method)  =>
+        assert(name.isTermName, "type trees should not reach here")
+        withTrace(trace2) { cases(expr.tpe, thisV, klass) }
+
+      case NewExpr(tref, New(tpt), ctor, argss) =>
+        // check args
+        val args = evalArgs(argss.flatten, thisV, klass)
+
+        val cls = tref.classSymbol.asClass
+        withTrace(trace2) {
+          val outer = outerValue(tref, thisV, klass)
+          outer.instantiate(cls, ctor, args)
+        }
+
+      case Call(ref, argss) =>
+        // check args
+        val args = evalArgs(argss.flatten, thisV, klass)
+
+        ref match
+        case Select(supert: Super, _) =>
+          val SuperType(thisTp, superTp) = supert.tpe: @unchecked
+          val thisValue2 = extendTrace(ref) { resolveThis(thisTp.classSymbol.asClass, thisV, klass) }
+          withTrace(trace2) { thisValue2.call(ref.symbol, args, thisTp, superTp) }
+
+        case Select(qual, _) =>
+          val receiver = eval(qual, thisV, klass)
+          if ref.symbol.isConstructor then
+            withTrace(trace2) { receiver.callConstructor(ref.symbol, args) }
+          else
+            withTrace(trace2) { receiver.call(ref.symbol, args, receiver = qual.tpe, superType = NoType) }
+
+        case id: Ident =>
+          id.tpe match
+          case TermRef(NoPrefix, _) =>
+            // resolve this for the local method
+            val enclosingClass = id.symbol.owner.enclosingClass.asClass
+            val thisValue2 = extendTrace(ref) { resolveThis(enclosingClass, thisV, klass) }
+            // local methods are not a member, but we can reuse the method `call`
+            withTrace(trace2) { thisValue2.call(id.symbol, args, receiver = NoType, superType = NoType, needResolve = false) }
+          case TermRef(prefix, _) =>
+            val receiver = cases(prefix, thisV, klass)
+            if id.symbol.isConstructor then
+              withTrace(trace2) { receiver.callConstructor(id.symbol, args) }
+            else
+              withTrace(trace2) { receiver.call(id.symbol, args, receiver = prefix, superType = NoType) }
+
+      case Select(qualifier, name) =>
+        val qual = eval(qualifier, thisV, klass)
+
+        name match
+          case OuterSelectName(_, _) =>
+            val current = qualifier.tpe.classSymbol
+            val target = expr.tpe.widenSingleton.classSymbol.asClass
+            withTrace(trace2) {
+              resolveThis(target, qual, current.asClass)
+            }
+          case _ =>
+            withTrace(trace2) { qual.select(expr.symbol, receiver = qualifier.tpe) }
+
+      case _: This =>
+        cases(expr.tpe, thisV, klass)
+
+      case Literal(_) =>
+        Hot
+
+      case Typed(expr, tpt) =>
+        if (tpt.tpe.hasAnnotation(defn.UncheckedAnnot))
+          Hot
+        else
+          checkTermUsage(tpt, thisV, klass)
+          eval(expr, thisV, klass)
+
+      case NamedArg(name, arg) =>
+        eval(arg, thisV, klass)
+
+      case Assign(lhs, rhs) =>
+        lhs match
+        case Select(qual, _) =>
+          eval(qual, thisV, klass)
+          val res = eval(rhs, thisV, klass)
+          extendTrace(expr) {
+            res.ensureHot("The RHS of reassignment must be hot. Found = " + res.show + ". ")
+          }
+        case id: Ident =>
+          val res = eval(rhs, thisV, klass)
+          extendTrace(expr) {
+            res.ensureHot("The RHS of reassignment must be hot. Found = " + res.show + ". ")
+          }
+
+      case closureDef(ddef) =>
+        Fun(ddef.rhs, thisV, klass)
+
+      case PolyFun(body) =>
+        Fun(body, thisV, klass)
+
+      case Block(stats, expr) =>
+        eval(stats, thisV, klass)
+        eval(expr, thisV, klass)
+
+      case If(cond, thenp, elsep) =>
+        eval(cond :: thenp :: elsep :: Nil, thisV, klass).join
+
+      case Annotated(arg, annot) =>
+        if (expr.tpe.hasAnnotation(defn.UncheckedAnnot)) Hot
+        else eval(arg, thisV, klass)
+
+      case Match(selector, cases) =>
+        val res = eval(selector, thisV, klass)
+        extendTrace(selector) {
+          res.ensureHot("The value to be matched needs to be hot. Found = " + res.show + ". ")
+        }
+        eval(cases.map(_.body), thisV, klass).join
+
+      case Return(expr, from) =>
+        val res = eval(expr, thisV, klass)
+        extendTrace(expr) {
+          res.ensureHot("return expression must be hot. Found = " + res.show + ". ")
+        }
+
+      case WhileDo(cond, body) =>
+        eval(cond :: body :: Nil, thisV, klass)
+        Hot
+
+      case Labeled(_, expr) =>
+        eval(expr, thisV, klass)
+
+      case Try(block, cases, finalizer) =>
+        eval(block, thisV, klass)
+        if !finalizer.isEmpty then
+          eval(finalizer, thisV, klass)
+        eval(cases.map(_.body), thisV, klass).join
+
+      case SeqLiteral(elems, elemtpt) =>
+        elems.map { elem => eval(elem, thisV, klass) }.join
+
+      case Inlined(call, bindings, expansion) =>
+        eval(bindings, thisV, klass)
+        withTrace(trace2) { eval(expansion, thisV, klass) }
+
+      case Thicket(List()) =>
+        // possible in try/catch/finally, see tests/crash/i6914.scala
+        Hot
+
+      case vdef : ValDef =>
+        // local val definition
+        eval(vdef.rhs, thisV, klass)
+
+      case ddef : DefDef =>
+        // local method
+        Hot
+
+      case tdef: TypeDef =>
+        // local type definition
+        if tdef.isClassDef then
+          Hot
+        else
+          checkTermUsage(tdef.rhs, thisV, klass)
+          Hot
+
+      case tpl: Template =>
+        init(tpl, thisV, klass)
+
+      case _: Import | _: Export =>
+        Hot
+
+      case _ =>
+        report.error("[Internal error] unexpected tree" + Trace.show, expr)
+        Hot
+
+  /** Handle semantics of leaf nodes
+   *
+   * For leaf nodes, their semantics is determined by their types.
+   *
+   * @param tp      The type to be evaluated.
+   * @param thisV   The value for `C.this` where `C` is represented by the parameter `klass`.
+   * @param klass   The enclosing class where the type `tp` is located.
+   */
+  def cases(tp: Type, thisV: Ref, klass: ClassSymbol): Contextual[Value] = log("evaluating " + tp.show, printer, (_: Value).show) {
+    tp match
+      case _: ConstantType =>
+        Hot
+
+      case tmref: TermRef if tmref.prefix == NoPrefix =>
+        thisV.accessLocal(tmref, klass)
+
+      case tmref: TermRef =>
+        val cls = tmref.widenSingleton.classSymbol
+        if cls.exists && cls.isStaticOwner then
+          if klass.isContainedIn(cls) then
+            resolveThis(cls.asClass, thisV, klass)
+          else if cls.isContainedIn(promoted.entryClass) then
+            cases(tmref.prefix, thisV, klass).select(tmref.symbol, receiver = tmref.prefix)
+          else
+            Hot
+        else
+          cases(tmref.prefix, thisV, klass).select(tmref.symbol, receiver = tmref.prefix)
+
+      case tp @ ThisType(tref) =>
+        val cls = tref.classSymbol.asClass
+        if cls.isStaticOwner && !klass.isContainedIn(cls) then
+          // O.this outside the body of the object O
+          Hot
+        else
+          resolveThis(cls, thisV, klass)
+
+      case _: TermParamRef | _: RecThis  =>
+        // possible from checking effects of types
+        Hot
+
+      case _ =>
+        report.error("[Internal error] unexpected type " + tp + Trace.show, Trace.position)
+        Hot
+  }
+
+  /** Resolve C.this that appear in `klass`
+   *
+   * @param target  The class symbol for `C` for which `C.this` is to be resolved.
+   * @param thisV   The value for `D.this` where `D` is represented by the parameter `klass`.
+   * @param klass   The enclosing class where the type `C.this` is located.
+   */
+  def resolveThis(target: ClassSymbol, thisV: Value, klass: ClassSymbol): Contextual[Value] = log("resolving " + target.show + ", this = " + thisV.show + " in " + klass.show, printer, (_: Value).show) {
+    if target == klass then thisV
+    else if target.is(Flags.Package) then Hot
+    else
+      thisV match
+        case Hot => Hot
+        case ref: Ref =>
+          val obj = ref.objekt
+          val outerCls = klass.owner.lexicallyEnclosingClass.asClass
+          if !obj.hasOuter(klass) then
+            val error = "[Internal error] outer not yet initialized, target = " + target + ", klass = " + klass + ", object = " + obj + Trace.show
+            report.error(error, Trace.position)
+            Hot
+          else
+            resolveThis(target, obj.outer(klass), outerCls)
+        case RefSet(refs) =>
+          refs.map(ref => resolveThis(target, ref, klass)).join
+        case fun: Fun =>
+          report.error("[Internal error] unexpected thisV = " + thisV + ", target = " + target.show + ", klass = " + klass.show + Trace.show, Trace.position)
+          Cold
+        case Cold => Cold
+
+  }
+
+  /** Compute the outer value that correspond to `tref.prefix`
+   *
+   * @param tref    The type whose prefix is to be evaluated.
+   * @param thisV   The value for `C.this` where `C` is represented by the parameter `klass`.
+   * @param klass   The enclosing class where the type `tref` is located.
+   */
+  def outerValue(tref: TypeRef, thisV: Ref, klass: ClassSymbol): Contextual[Value] =
+    val cls = tref.classSymbol.asClass
+    if tref.prefix == NoPrefix then
+      val enclosing = cls.owner.lexicallyEnclosingClass.asClass
+      val outerV = resolveThis(enclosing, thisV, klass)
+      outerV
+    else
+      if cls.isAllOf(Flags.JavaInterface) then Hot
+      else cases(tref.prefix, thisV, klass)
+
+  /** Initialize part of an abstract object in `klass` of the inheritance chain
+   *
+   * @param tpl       The class body to be evaluated.
+   * @param thisV     The value of the current object to be initialized.
+   * @param klass     The class to which the template belongs.
+   */
+  def init(tpl: Template, thisV: Ref, klass: ClassSymbol): Contextual[Value] = log("init " + klass.show, printer, (_: Value).show) {
+    val paramsMap = tpl.constr.termParamss.flatten.map { vdef =>
+      vdef.name -> thisV.objekt.field(vdef.symbol)
+    }.toMap
+
+    // init param fields
+    klass.paramGetters.foreach { acc =>
+      val value = paramsMap(acc.name.toTermName)
+      thisV.updateField(acc, value)
+      printer.println(acc.show + " initialized with " + value)
+    }
+
+    // Tasks is used to schedule super constructor calls.
+    // Super constructor calls are delayed until all outers are set.
+    type Tasks = mutable.ArrayBuffer[() => Unit]
+    def superCall(tref: TypeRef, ctor: Symbol, args: List[ArgInfo], tasks: Tasks): Unit =
+      val cls = tref.classSymbol.asClass
+      // update outer for super class
+      val res = outerValue(tref, thisV, klass)
+      thisV.updateOuter(cls, res)
+
+      // follow constructor
+      if cls.hasSource then
+        tasks.append { () =>
+          printer.println("init super class " + cls.show)
+          thisV.callConstructor(ctor, args)
+          ()
+        }
+
+    // parents
+    def initParent(parent: Tree, tasks: Tasks) =
+      parent match
+      case tree @ Block(stats, NewExpr(tref, New(tpt), ctor, argss)) =>  // can happen
+        eval(stats, thisV, klass)
+        val args = evalArgs(argss.flatten, thisV, klass)
+        superCall(tref, ctor, args, tasks)
+
+      case tree @ NewExpr(tref, New(tpt), ctor, argss) =>       // extends A(args)
+        val args = evalArgs(argss.flatten, thisV, klass)
+        superCall(tref, ctor, args, tasks)
+
+      case _ =>   // extends A or extends A[T]
+        val tref = typeRefOf(parent.tpe)
+        superCall(tref, tref.classSymbol.primaryConstructor, Nil, tasks)
+
+    // see spec 5.1 about "Template Evaluation".
+    // https://www.scala-lang.org/files/archive/spec/2.13/05-classes-and-objects.html
+    if !klass.is(Flags.Trait) then
+      // outers are set first
+      val tasks = new mutable.ArrayBuffer[() => Unit]
+
+      // 1. first init parent class recursively
+      // 2. initialize traits according to linearization order
+      val superParent = tpl.parents.head
+      val superCls = superParent.tpe.classSymbol.asClass
+      extendTrace(superParent) { initParent(superParent, tasks) }
+
+      val parents = tpl.parents.tail
+      val mixins = klass.baseClasses.tail.takeWhile(_ != superCls)
+
+      // The interesting case is the outers for traits.  The compiler
+      // synthesizes proxy accessors for the outers in the class that extends
+      // the trait. As those outers must be stable values, they are initialized
+      // immediately following class parameters and before super constructor
+      // calls and user code in the class body.
+      mixins.reverse.foreach { mixin =>
+        parents.find(_.tpe.classSymbol == mixin) match
+        case Some(parent) =>
+          extendTrace(parent) { initParent(parent, tasks) }
+        case None =>
+          // According to the language spec, if the mixin trait requires
+          // arguments, then the class must provide arguments to it explicitly
+          // in the parent list. That means we will encounter it in the Some
+          // branch.
+          //
+          // When a trait A extends a parameterized trait B, it cannot provide
+          // term arguments to B. That can only be done in a concrete class.
+          val tref = typeRefOf(klass.typeRef.baseType(mixin).typeConstructor)
+          val ctor = tref.classSymbol.primaryConstructor
+          if ctor.exists then extendTrace(superParent) {
+            superCall(tref, ctor, Nil, tasks)
+          }
+      }
+
+      // initialize super classes after outers are set
+      tasks.foreach(((task: () => Unit) => task()).unsafeBoxFunArg)
+        // !cc! .asInstanceOf needed to convert from `(() => Unit) -> Unit` to  `(box () => Unit) -> Unit`.
+    end if
+
+    var fieldsChanged = true
+
+    // class body
+    if thisV.isThisRef || !thisV.asInstanceOf[Warm].isPopulatingParams then tpl.body.foreach {
+      case vdef : ValDef if !vdef.symbol.is(Flags.Lazy) && !vdef.rhs.isEmpty =>
+        val res = eval(vdef.rhs, thisV, klass)
+        // TODO: Improve promotion to avoid handling enum initialization specially
+        //
+        // The failing case is tests/init/pos/i12544.scala due to promotion failure.
+        if vdef.symbol.name == nme.DOLLAR_VALUES
+           && vdef.symbol.is(Flags.Synthetic)
+           && vdef.symbol.owner.companionClass.is(Flags.Enum)
+        then
+          thisV.updateField(vdef.symbol, Hot)
+        else
+          thisV.updateField(vdef.symbol, res)
+        fieldsChanged = true
+
+      case _: MemberDef =>
+
+      case tree =>
+        if fieldsChanged && thisV.isThisRef then
+          thisV.asInstanceOf[ThisRef].tryPromoteCurrentObject()
+        fieldsChanged = false
+        eval(tree, thisV, klass)
+    }
+
+    // ensure we try promotion once even if class body is empty
+    if fieldsChanged && thisV.isThisRef then
+      thisV.asInstanceOf[ThisRef].tryPromoteCurrentObject()
+
+    // The result value is ignored, use Hot to avoid futile fixed point computation
+    Hot
+  }
+
+  /** Check that path in path-dependent types are initialized
+   *
+   *  This is intended to avoid type soundness issues in Dotty.
+   */
+  def checkTermUsage(tpt: Tree, thisV: Ref, klass: ClassSymbol): Contextual[Unit] =
+    val traverser = new TypeTraverser:
+      def traverse(tp: Type): Unit =
+        tp match
+        case TermRef(_: SingletonType, _) =>
+          extendTrace(tpt) { cases(tp, thisV, klass) }
+        case _ =>
+          traverseChildren(tp)
+
+    traverser.traverse(tpt.tpe)
+
+// ----- Utility methods and extractors --------------------------------
+
+  def typeRefOf(tp: Type)(using Context): TypeRef = tp.dealias.typeConstructor match
+    case tref: TypeRef => tref
+    case hklambda: HKTypeLambda => typeRefOf(hklambda.resType)
+
+
+  opaque type Arg  = Tree | ByNameArg
+  case class ByNameArg(tree: Tree)
+
+  extension (arg: Arg)
+    def isByName = arg.isInstanceOf[ByNameArg]
+    def tree: Tree = arg match
+      case t: Tree      => t
+      case ByNameArg(t) => t
+
+  object Call:
+
+    def unapply(tree: Tree)(using Context): Option[(Tree, List[List[Arg]])] =
+      tree match
+      case Apply(fn, args) =>
+        val argTps = fn.tpe.widen match
+          case mt: MethodType => mt.paramInfos
+        val normArgs: List[Arg] = args.zip(argTps).map {
+          case (arg, _: ExprType) => ByNameArg(arg)
+          case (arg, _)           => arg
+        }
+        unapply(fn) match
+        case Some((ref, args0)) => Some((ref, args0 :+ normArgs))
+        case None => None
+
+      case TypeApply(fn, targs) =>
+        unapply(fn)
+
+      case ref: RefTree if ref.tpe.widenSingleton.isInstanceOf[MethodicType] =>
+        Some((ref, Nil))
+
+      case _ => None
+
+  object NewExpr:
+    def unapply(tree: Tree)(using Context): Option[(TypeRef, New, Symbol, List[List[Arg]])] =
+      tree match
+      case Call(fn @ Select(newTree: New, init), argss) if init == nme.CONSTRUCTOR =>
+        val tref = typeRefOf(newTree.tpe)
+        Some((tref, newTree, fn.symbol, argss))
+      case _ => None
+
+  object PolyFun:
+    def unapply(tree: Tree)(using Context): Option[Tree] =
+      tree match
+      case Block((cdef: TypeDef) :: Nil, Typed(NewExpr(tref, _, _, _), _))
+      if tref.symbol.isAnonymousClass && tref <:< defn.PolyFunctionType
+      =>
+        val body = cdef.rhs.asInstanceOf[Template].body
+        val apply = body.head.asInstanceOf[DefDef]
+        Some(apply.rhs)
+      case _ =>
+        None
+
+  extension (symbol: Symbol) def hasSource(using Context): Boolean =
+    !symbol.defTree.isEmpty
+
+  def resolve(cls: ClassSymbol, sym: Symbol)(using Context): Symbol = log("resove " + cls + ", " + sym, printer, (_: Symbol).show) {
+    if (sym.isEffectivelyFinal || sym.isConstructor) sym
+    else sym.matchingMember(cls.appliedRef)
+  }
+
+  private def isConcreteClass(cls: ClassSymbol)(using Context) = {
+    val instantiable: Boolean =
+      cls.is(Flags.Module) ||
+      !cls.isOneOf(Flags.AbstractOrTrait) && {
+        // see `Checking.checkInstantiable` in typer
+        val tp = cls.appliedRef
+        val stp = SkolemType(tp)
+        val selfType = cls.givenSelfType.asSeenFrom(stp, cls)
+        !selfType.exists || stp <:< selfType
+      }
+
+    // A concrete class may not be instantiated if the self type is not satisfied
+    instantiable && cls.enclosingPackageClass != defn.StdLibPatchesPackage.moduleClass
+  }
diff --git a/tests/pos-with-compiler-cc/dotc/transform/localopt/FormatChecker.scala b/tests/pos-with-compiler-cc/dotc/transform/localopt/FormatChecker.scala
new file mode 100644
index 000000000000..ff8d89920791
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/transform/localopt/FormatChecker.scala
@@ -0,0 +1,286 @@
+package dotty.tools.dotc
+package transform.localopt
+
+import scala.annotation.tailrec
+import scala.collection.mutable.ListBuffer
+import scala.util.chaining.*
+import scala.util.matching.Regex.Match
+
+
+import PartialFunction.cond
+
+import dotty.tools.dotc.ast.tpd.{Match => _, *}
+import dotty.tools.dotc.core.Contexts._
+import dotty.tools.dotc.core.Symbols._
+import dotty.tools.dotc.core.Types._
+import dotty.tools.dotc.core.Phases.typerPhase
+import dotty.tools.dotc.util.Spans.Span
+
+/** Formatter string checker. */
+class TypedFormatChecker(partsElems: List[Tree], parts: List[String], args: List[Tree])(using Context):
+
+  val argTypes = args.map(_.tpe)
+  val actuals = ListBuffer.empty[Tree]
+
+  // count of args, for checking indexes
+  val argc = argTypes.length
+
+  // Pick the first runtime type which the i'th arg can satisfy.
+  // If conversion is required, implementation must emit it.
+  def argType(argi: Int, types: Type*): Type =
+    require(argi < argc, s"$argi out of range picking from $types")
+    val tpe = argTypes(argi)
+    types.find(t => argConformsTo(argi, tpe, t))
+      .orElse(types.find(t => argConvertsTo(argi, tpe, t)))
+      .getOrElse {
+        report.argError(s"Found: ${tpe.show}, Required: ${types.map(_.show).mkString(", ")}", argi)
+        actuals += args(argi)
+        types.head
+      }
+
+  object formattableTypes:
+    val FormattableType = requiredClassRef("java.util.Formattable")
+    val BigIntType      = requiredClassRef("scala.math.BigInt")
+    val BigDecimalType  = requiredClassRef("scala.math.BigDecimal")
+    val CalendarType    = requiredClassRef("java.util.Calendar")
+    val DateType        = requiredClassRef("java.util.Date")
+  import formattableTypes.*
+  def argConformsTo(argi: Int, arg: Type, target: Type): Boolean = (arg <:< target).tap(if _ then actuals += args(argi))
+  def argConvertsTo(argi: Int, arg: Type, target: Type): Boolean =
+    import typer.Implicits.SearchSuccess
+    atPhase(typerPhase) {
+      ctx.typer.inferView(args(argi), target) match
+        case SearchSuccess(view, ref, _, _) => actuals += view ; true
+        case _ => false
+    }
+
+  // match a conversion specifier
+  val formatPattern = """%(?:(\d+)\$)?([-#+ 0,(<]+)?(\d+)?(\.\d+)?([tT]?[%a-zA-Z])?""".r
+
+  // ordinal is the regex group index in the format pattern
+  enum SpecGroup:
+    case Spec, Index, Flags, Width, Precision, CC
+  import SpecGroup.*
+
+  /** For N part strings and N-1 args to interpolate, normalize parts and check arg types.
+   *
+   *  Returns normalized part strings and args, where args correcpond to conversions in tail of parts.
+   */
+  def checked: (List[String], List[Tree]) =
+    val amended = ListBuffer.empty[String]
+    val convert = ListBuffer.empty[Conversion]
+
+    @tailrec
+    def loop(remaining: List[String], n: Int): Unit =
+      remaining match
+        case part0 :: more =>
+          def badPart(t: Throwable): String = "".tap(_ => report.partError(t.getMessage.nn, index = n, offset = 0))
+          val part = try StringContext.processEscapes(part0) catch badPart
+          val matches = formatPattern.findAllMatchIn(part)
+
+          def insertStringConversion(): Unit =
+            amended += "%s" + part
+            convert += Conversion(formatPattern.findAllMatchIn("%s").next(), n)  // improve
+            argType(n-1, defn.AnyType)
+          def errorLeading(op: Conversion) = op.errorAt(Spec)(s"conversions must follow a splice; ${Conversion.literalHelp}")
+          def accept(op: Conversion): Unit =
+            if !op.isLeading then errorLeading(op)
+            op.accepts(argType(n-1, op.acceptableVariants*))
+            amended += part
+            convert += op
+
+          // after the first part, a leading specifier is required for the interpolated arg; %s is supplied if needed
+          if n == 0 then amended += part
+          else if !matches.hasNext then insertStringConversion()
+          else
+            val cv = Conversion(matches.next(), n)
+            if cv.isLiteral then insertStringConversion()
+            else if cv.isIndexed then
+              if cv.index.getOrElse(-1) == n then accept(cv) else insertStringConversion()
+            else if !cv.isError then accept(cv)
+
+          // any remaining conversions in this part must be either literals or indexed
+          while matches.hasNext do
+            val cv = Conversion(matches.next(), n)
+            if n == 0 && cv.hasFlag('<') then cv.badFlag('<', "No last arg")
+            else if !cv.isLiteral && !cv.isIndexed then errorLeading(cv)
+
+          loop(more, n + 1)
+        case Nil => ()
+    end loop
+
+    loop(parts, n = 0)
+    if reported then (Nil, Nil)
+    else
+      assert(argc == actuals.size, s"Expected ${argc} args but got ${actuals.size} for [${parts.mkString(", ")}]")
+      (amended.toList, actuals.toList)
+  end checked
+
+  extension (descriptor: Match)
+    def at(g: SpecGroup): Int = descriptor.start(g.ordinal)
+    def end(g: SpecGroup): Int = descriptor.end(g.ordinal)
+    def offset(g: SpecGroup, i: Int = 0): Int = at(g) + i
+    def group(g: SpecGroup): Option[String] = Option(descriptor.group(g.ordinal))
+    def stringOf(g: SpecGroup): String = group(g).getOrElse("")
+    def intOf(g: SpecGroup): Option[Int] = group(g).map(_.toInt)
+
+  extension (inline value: Boolean)
+    inline def or(inline body: => Unit): Boolean     = value || { body ; false }
+    inline def orElse(inline body: => Unit): Boolean = value || { body ; true }
+    inline def and(inline body: => Unit): Boolean    = value && { body ; true }
+    inline def but(inline body: => Unit): Boolean    = value && { body ; false }
+
+  enum Kind:
+    case StringXn, HashXn, BooleanXn, CharacterXn, IntegralXn, FloatingPointXn, DateTimeXn, LiteralXn, ErrorXn
+  import Kind.*
+
+  /** A conversion specifier matched in the argi'th string part, with `argc` arguments to interpolate.
+   */
+  final class Conversion(val descriptor: Match, val argi: Int, val kind: Kind):
+    // the descriptor fields
+    val index: Option[Int]     = descriptor.intOf(Index)
+    val flags: String          = descriptor.stringOf(Flags)
+    val width: Option[Int]     = descriptor.intOf(Width)
+    val precision: Option[Int] = descriptor.group(Precision).map(_.drop(1).toInt)
+    val op: String             = descriptor.stringOf(CC)
+
+    // the conversion char is the head of the op string (but see DateTimeXn)
+    val cc: Char =
+      kind match
+        case ErrorXn => if op.isEmpty then '?' else op(0)
+        case DateTimeXn => if op.length > 1 then op(1) else '?'
+        case _ => op(0)
+
+    def isIndexed: Boolean = index.nonEmpty || hasFlag('<')
+    def isError: Boolean   = kind == ErrorXn
+    def isLiteral: Boolean = kind == LiteralXn
+
+    // descriptor is at index 0 of the part string
+    def isLeading: Boolean = descriptor.at(Spec) == 0
+
+    // true if passes.
+    def verify: Boolean =
+      // various assertions
+      def goodies = goodFlags && goodIndex
+      def noFlags = flags.isEmpty or errorAt(Flags)("flags not allowed")
+      def noWidth = width.isEmpty or errorAt(Width)("width not allowed")
+      def noPrecision = precision.isEmpty or errorAt(Precision)("precision not allowed")
+      def only_-(msg: String) =
+        val badFlags = flags.filterNot { case '-' | '<' => true case _ => false }
+        badFlags.isEmpty or badFlag(badFlags(0), s"Only '-' allowed for $msg")
+      def goodFlags =
+        val badFlags = flags.filterNot(okFlags.contains)
+        for f <- badFlags do badFlag(f, s"Illegal flag '$f'")
+        badFlags.isEmpty
+      def goodIndex =
+        if index.nonEmpty && hasFlag('<') then warningAt(Index)("Argument index ignored if '<' flag is present")
+        val okRange = index.map(i => i > 0 && i <= argc).getOrElse(true)
+        okRange || hasFlag('<') or errorAt(Index)("Argument index out of range")
+    // begin verify
+      kind match
+        case StringXn        => goodies
+        case BooleanXn       => goodies
+        case HashXn          => goodies
+        case CharacterXn     => goodies && noPrecision && only_-("c conversion")
+        case IntegralXn      =>
+          def d_# = cc == 'd' && hasFlag('#') and badFlag('#', "# not allowed for d conversion")
+          def x_comma = cc != 'd' && hasFlag(',') and badFlag(',', "',' only allowed for d conversion of integral types")
+          goodies && noPrecision && !d_# && !x_comma
+        case FloatingPointXn =>
+          goodies && (cc match
+            case 'a' | 'A' =>
+              val badFlags = ",(".filter(hasFlag)
+              noPrecision && badFlags.isEmpty or badFlags.foreach(badf => badFlag(badf, s"'$badf' not allowed for a, A"))
+            case _ => true
+          )
+        case DateTimeXn      =>
+          def hasCC = op.length == 2 or errorAt(CC)("Date/time conversion must have two characters")
+          def goodCC = "HIklMSLNpzZsQBbhAaCYyjmdeRTrDFc".contains(cc) or errorAt(CC, 1)(s"'$cc' doesn't seem to be a date or time conversion")
+          goodies && hasCC && goodCC && noPrecision && only_-("date/time conversions")
+        case LiteralXn       =>
+          op match
+            case "%" => goodies && noPrecision and width.foreach(_ => warningAt(Width)("width ignored on literal"))
+            case "n" => noFlags && noWidth && noPrecision
+        case ErrorXn         =>
+          errorAt(CC)(s"illegal conversion character '$cc'")
+          false
+    end verify
+
+    // is the specifier OK with the given arg
+    def accepts(arg: Type): Boolean =
+      kind match
+        case BooleanXn  => arg == defn.BooleanType orElse warningAt(CC)("Boolean format is null test for non-Boolean")
+        case IntegralXn =>
+          arg == BigIntType || !cond(cc) {
+            case 'o' | 'x' | 'X' if hasAnyFlag("+ (") => "+ (".filter(hasFlag).foreach(bad => badFlag(bad, s"only use '$bad' for BigInt conversions to o, x, X")) ; true
+          }
+        case _ => true
+
+    // what arg type if any does the conversion accept
+    def acceptableVariants: List[Type] =
+      kind match
+        case StringXn        => if hasFlag('#') then FormattableType :: Nil else defn.AnyType :: Nil
+        case BooleanXn       => defn.BooleanType :: defn.NullType :: Nil
+        case HashXn          => defn.AnyType :: Nil
+        case CharacterXn     => defn.CharType :: defn.ByteType :: defn.ShortType :: defn.IntType :: Nil
+        case IntegralXn      => defn.IntType :: defn.LongType :: defn.ByteType :: defn.ShortType :: BigIntType :: Nil
+        case FloatingPointXn => defn.DoubleType :: defn.FloatType :: BigDecimalType :: Nil
+        case DateTimeXn      => defn.LongType :: CalendarType :: DateType :: Nil
+        case LiteralXn       => Nil
+        case ErrorXn         => Nil
+
+    // what flags does the conversion accept?
+    private def okFlags: String =
+      kind match
+        case StringXn => "-#<"
+        case BooleanXn | HashXn => "-<"
+        case LiteralXn => "-"
+        case _ => "-#+ 0,(<"
+
+    def hasFlag(f: Char) = flags.contains(f)
+    def hasAnyFlag(fs: String) = fs.exists(hasFlag)
+
+    def badFlag(f: Char, msg: String) =
+      val i = flags.indexOf(f) match { case -1 => 0 case j => j }
+      errorAt(Flags, i)(msg)
+
+    def errorAt(g: SpecGroup, i: Int = 0)(msg: String)   = report.partError(msg, argi, descriptor.offset(g, i), descriptor.end(g))
+    def warningAt(g: SpecGroup, i: Int = 0)(msg: String) = report.partWarning(msg, argi, descriptor.offset(g, i), descriptor.end(g))
+
+  object Conversion:
+    def apply(m: Match, i: Int): Conversion =
+      def kindOf(cc: Char) = cc match
+        case 's' | 'S' => StringXn
+        case 'h' | 'H' => HashXn
+        case 'b' | 'B' => BooleanXn
+        case 'c' | 'C' => CharacterXn
+        case 'd' | 'o' |
+             'x' | 'X' => IntegralXn
+        case 'e' | 'E' |
+             'f' |
+             'g' | 'G' |
+             'a' | 'A' => FloatingPointXn
+        case 't' | 'T' => DateTimeXn
+        case '%' | 'n' => LiteralXn
+        case _         => ErrorXn
+      end kindOf
+      m.group(CC) match
+        case Some(cc) => new Conversion(m, i, kindOf(cc(0))).tap(_.verify)
+        case None     => new Conversion(m, i, ErrorXn).tap(_.errorAt(Spec)(s"Missing conversion operator in '${m.matched}'; $literalHelp"))
+    end apply
+    val literalHelp = "use %% for literal %, %n for newline"
+  end Conversion
+
+  var reported = false
+
+  private def partPosAt(index: Int, offset: Int, end: Int) =
+    val pos = partsElems(index).sourcePos
+    val bgn = pos.span.start + offset
+    val fin = if end < 0 then pos.span.end else pos.span.start + end
+    pos.withSpan(Span(bgn, fin, bgn))
+
+  extension (r: report.type)
+    def argError(message: String, index: Int): Unit = r.error(message, args(index).srcPos).tap(_ => reported = true)
+    def partError(message: String, index: Int, offset: Int, end: Int = -1): Unit = r.error(message, partPosAt(index, offset, end)).tap(_ => reported = true)
+    def partWarning(message: String, index: Int, offset: Int, end: Int = -1): Unit = r.warning(message, partPosAt(index, offset, end)).tap(_ => reported = true)
+end TypedFormatChecker
diff --git a/tests/pos-with-compiler-cc/dotc/transform/localopt/FormatInterpolatorTransform.scala b/tests/pos-with-compiler-cc/dotc/transform/localopt/FormatInterpolatorTransform.scala
new file mode 100644
index 000000000000..79d94c26c692
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/transform/localopt/FormatInterpolatorTransform.scala
@@ -0,0 +1,39 @@
+package dotty.tools.dotc
+package transform.localopt
+
+import dotty.tools.dotc.ast.tpd.*
+import dotty.tools.dotc.core.Constants.Constant
+import dotty.tools.dotc.core.Contexts.*
+
+object FormatInterpolatorTransform:
+
+  /** For f"${arg}%xpart", check format conversions and return (format, args)
+   *  suitable for String.format(format, args).
+   */
+  def checked(fun: Tree, args0: Tree)(using Context): (Tree, Tree) =
+    val (partsExpr, parts) = fun match
+      case TypeApply(Select(Apply(_, (parts: SeqLiteral) :: Nil), _), _) =>
+        (parts.elems, parts.elems.map { case Literal(Constant(s: String)) => s })
+      case _ =>
+        report.error("Expected statically known StringContext", fun.srcPos)
+        (Nil, Nil)
+    val (args, elemtpt) = args0 match
+      case seqlit: SeqLiteral => (seqlit.elems, seqlit.elemtpt)
+      case _ =>
+        report.error("Expected statically known argument list", args0.srcPos)
+        (Nil, EmptyTree)
+
+    def literally(s: String) = Literal(Constant(s))
+    if parts.lengthIs != args.length + 1 then
+      val badParts =
+        if parts.isEmpty then "there are no parts"
+        else s"too ${if parts.lengthIs > args.length + 1 then "few" else "many"} arguments for interpolated string"
+      report.error(badParts, fun.srcPos)
+      (literally(""), args0)
+    else
+      val checker = TypedFormatChecker(partsExpr, parts, args)
+      val (format, formatArgs) = checker.checked
+      if format.isEmpty then (literally(parts.mkString), args0)
+      else (literally(format.mkString), SeqLiteral(formatArgs.toList, elemtpt))
+  end checked
+end FormatInterpolatorTransform
diff --git a/tests/pos-with-compiler-cc/dotc/transform/localopt/StringInterpolatorOpt.scala b/tests/pos-with-compiler-cc/dotc/transform/localopt/StringInterpolatorOpt.scala
new file mode 100644
index 000000000000..5cad7ba72831
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/transform/localopt/StringInterpolatorOpt.scala
@@ -0,0 +1,170 @@
+package dotty.tools.dotc
+package transform.localopt
+
+import scala.language.unsafeNulls
+
+import dotty.tools.dotc.ast.tpd
+import dotty.tools.dotc.core.Decorators._
+import dotty.tools.dotc.core.Constants.Constant
+import dotty.tools.dotc.core.Contexts._
+import dotty.tools.dotc.core.StdNames._
+import dotty.tools.dotc.core.Symbols._
+import dotty.tools.dotc.core.Types._
+import dotty.tools.dotc.transform.MegaPhase.MiniPhase
+import dotty.tools.dotc.typer.ConstFold
+
+/** MiniPhase to transform s and raw string interpolators from using StringContext to string
+ *  concatenation. Since string concatenation uses the Java String builder, we get a performance
+ *  improvement in terms of these two interpolators.
+ *
+ *  More info here:
+ *  https://medium.com/@dkomanov/scala-string-interpolation-performance-21dc85e83afd
+ */
+class StringInterpolatorOpt extends MiniPhase:
+  import tpd.*
+
+  override def phaseName: String = StringInterpolatorOpt.name
+
+  override def description: String = StringInterpolatorOpt.description
+
+  override def checkPostCondition(tree: tpd.Tree)(using Context): Unit =
+    tree match
+      case tree: RefTree =>
+        val sym = tree.symbol
+        assert(!StringInterpolatorOpt.isCompilerIntrinsic(sym),
+          i"$tree in ${ctx.owner.showLocated} should have been rewritten by phase $phaseName")
+      case _ =>
+
+  /** Matches a list of constant literals */
+  private object Literals:
+    def unapply(tree: SeqLiteral)(using Context): Option[List[Literal]] =
+      tree.elems match
+        case literals if literals.forall(_.isInstanceOf[Literal]) => Some(literals.map(_.asInstanceOf[Literal]))
+        case _ => None
+
+  private object StringContextApply:
+    def unapply(tree: Select)(using Context): Boolean =
+      (tree.symbol eq defn.StringContextModule_apply) && (tree.qualifier.symbol eq defn.StringContextModule)
+
+  /** Matches an s or raw string interpolator */
+  private object SOrRawInterpolator:
+    def unapply(tree: Tree)(using Context): Option[(List[Literal], List[Tree])] =
+      tree match
+        case Apply(Select(Apply(StringContextApply(), List(Literals(strs))), _), List(SeqLiteral(elems, _)))
+        if elems.length == strs.length - 1 => Some(strs, elems)
+        case _ => None
+
+  //Extract the position from InvalidUnicodeEscapeException
+  //which due to bincompat reasons is unaccessible.
+  //TODO: remove once there is less restrictive bincompat
+  private object InvalidEscapePosition:
+    def unapply(t: Throwable): Option[Int] = t match
+      case iee: StringContext.InvalidEscapeException => Some(iee.index)
+      case iae: IllegalArgumentException => iae.getMessage() match
+        case s"""invalid unicode escape at index $index of $_""" => index.toIntOption
+        case _ => None
+      case _ => None
+
+  /** Match trees that resemble s and raw string interpolations. In the case of the s
+   *  interpolator, escapes the string constants. Exposes the string constants as well as
+   *  the variable references.
+   */
+  private object StringContextIntrinsic:
+    def unapply(tree: Apply)(using Context): Option[(List[Literal], List[Tree])] =
+      tree match
+        case SOrRawInterpolator(strs, elems) =>
+          if tree.symbol == defn.StringContext_raw then Some(strs, elems)
+          else // tree.symbol == defn.StringContextS
+            import dotty.tools.dotc.util.SourcePosition
+            var stringPosition: SourcePosition = null
+            try
+              val escapedStrs = strs.map { str =>
+                stringPosition = str.sourcePos
+                val escaped = StringContext.processEscapes(str.const.stringValue)
+                cpy.Literal(str)(Constant(escaped))
+              }
+              Some(escapedStrs, elems)
+            catch
+              case t @ InvalidEscapePosition(p) =>
+                val errorSpan = stringPosition.span.startPos.shift(p)
+                val errorPosition = stringPosition.withSpan(errorSpan)
+                report.error(t.getMessage() + "\n", errorPosition)
+                None
+        case _ => None
+
+  override def transformApply(tree: Apply)(using Context): Tree =
+    def mkConcat(strs: List[Literal], elems: List[Tree]): Tree =
+      val stri = strs.iterator
+      val elemi = elems.iterator
+      var result: Tree = stri.next
+      def concat(tree: Tree): Unit =
+        result = result.select(defn.String_+).appliedTo(tree).withSpan(tree.span)
+      while elemi.hasNext
+      do
+        concat(elemi.next)
+        val str = stri.next
+        if !str.const.stringValue.isEmpty then concat(str)
+      result
+    end mkConcat
+    val sym = tree.symbol
+    // Test names first to avoid loading scala.StringContext if not used, and common names first
+    val isInterpolatedMethod =
+      sym.name match
+        case nme.s    => sym eq defn.StringContext_s
+        case nme.raw_ => sym eq defn.StringContext_raw
+        case nme.f    => sym eq defn.StringContext_f
+        case _        => false
+    // Perform format checking and normalization, then make it StringOps(fmt).format(args1) with tweaked args
+    def transformF(fun: Tree, args: Tree): Tree =
+      val (fmt, args1) = FormatInterpolatorTransform.checked(fun, args)
+      resolveConstructor(defn.StringOps.typeRef, List(fmt))
+        .select(nme.format)
+        .appliedTo(args1)
+    // Starting with Scala 2.13, s and raw are macros in the standard
+    // library, so we need to expand them manually.
+    // sc.s(args)    -->   standardInterpolator(processEscapes, args, sc.parts)
+    // sc.raw(args)  -->   standardInterpolator(x => x,         args, sc.parts)
+    def transformS(fun: Tree, args: Tree, isRaw: Boolean): Tree =
+      val pre = fun match
+        case Select(pre, _) => pre
+        case intp: Ident    => tpd.desugarIdentPrefix(intp)
+      val stringToString = defn.StringContextModule_processEscapes.info.asInstanceOf[MethodType]
+      val process = tpd.Lambda(stringToString, args =>
+        if isRaw then args.head else ref(defn.StringContextModule_processEscapes).appliedToTermArgs(args)
+      )
+      evalOnce(pre) { sc =>
+        val parts = sc.select(defn.StringContext_parts)
+        ref(defn.StringContextModule_standardInterpolator)
+          .appliedToTermArgs(List(process, args, parts))
+      }
+    end transformS
+    // begin transformApply
+    if isInterpolatedMethod then
+      (tree: @unchecked) match
+        case StringContextIntrinsic(strs: List[Literal], elems: List[Tree]) =>
+          mkConcat(strs, elems)
+        case Apply(intp, args :: Nil) =>
+          if sym eq defn.StringContext_f then transformF(intp, args)
+          else transformS(intp, args, isRaw = sym eq defn.StringContext_raw)
+    else
+      tree.tpe match
+        case _: ConstantType => tree
+        case _ =>
+          ConstFold.Apply(tree).tpe match
+            case ConstantType(x) => Literal(x).withSpan(tree.span).ensureConforms(tree.tpe)
+            case _ => tree
+
+  override def transformSelect(tree: Select)(using Context): Tree =
+    ConstFold.Select(tree).tpe match
+      case ConstantType(x) => Literal(x).withSpan(tree.span).ensureConforms(tree.tpe)
+      case _ => tree
+
+object StringInterpolatorOpt:
+  val name: String = "interpolators"
+  val description: String = "optimize s, f, and raw string interpolators"
+
+  /** Is this symbol one of the s, f or raw string interpolator? */
+  def isCompilerIntrinsic(sym: Symbol)(using Context): Boolean =
+    sym == defn.StringContext_s ||
+    sym == defn.StringContext_f ||
+    sym == defn.StringContext_raw
diff --git a/tests/pos-with-compiler-cc/dotc/transform/patmat/Space.scala b/tests/pos-with-compiler-cc/dotc/transform/patmat/Space.scala
new file mode 100644
index 000000000000..ca0e149f881f
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/transform/patmat/Space.scala
@@ -0,0 +1,964 @@
+package dotty.tools
+package dotc
+package transform
+package patmat
+
+import core._
+import Types._
+import TypeUtils._
+import Contexts._
+import Flags._
+import ast._
+import Decorators._
+import Symbols._
+import StdNames._
+import NameOps._
+import Constants._
+import typer._
+import Applications._
+import Inferencing._
+import ProtoTypes._
+import transform.SymUtils._
+import reporting._
+import config.Printers.{exhaustivity => debug}
+import util.{SrcPos, NoSourcePosition}
+import collection.mutable
+
+/** Space logic for checking exhaustivity and unreachability of pattern matching
+ *
+ *  Space can be thought of as a set of possible values. A type or a pattern
+ *  both refer to spaces. The space of a type is the values that inhabit the
+ *  type. The space of a pattern is the values that can be covered by the
+ *  pattern.
+ *
+ *  Space is recursively defined as follows:
+ *
+ *      1. `Empty` is a space
+ *      2. For a type T, `Typ(T)` is a space
+ *      3. A union of spaces `S1 | S2 | ...` is a space
+ *      4. `Prod(S1, S2, ..., Sn)` is a product space.
+ *
+ *  For the problem of exhaustivity check, its formulation in terms of space is as follows:
+ *
+ *      Is the space Typ(T) a subspace of the union of space covered by all the patterns?
+ *
+ *  The problem of unreachable patterns can be formulated as follows:
+ *
+ *      Is the space covered by a pattern a subspace of the space covered by previous patterns?
+ *
+ *  Assumption:
+ *    (1) One case class cannot be inherited directly or indirectly by another
+ *        case class.
+ *    (2) Inheritance of a case class cannot be well handled by the algorithm.
+ *
+ */
+
+
+/** space definition */
+sealed trait Space
+
+/** Empty space */
+case object Empty extends Space
+
+/** Space representing the set of all values of a type
+ *
+ * @param tp: the type this space represents
+ * @param decomposed: does the space result from decomposition? Used for pretty print
+ *
+ */
+case class Typ(tp: Type, decomposed: Boolean = true) extends Space
+
+/** Space representing an extractor pattern */
+case class Prod(tp: Type, unappTp: TermRef, params: List[Space]) extends Space
+
+/** Union of spaces */
+case class Or(spaces: Seq[Space]) extends Space
+
+/** abstract space logic */
+trait SpaceLogic {
+  /** Is `tp1` a subtype of `tp2`? */
+  def isSubType(tp1: Type, tp2: Type): Boolean
+
+  /** True if we can assume that the two unapply methods are the same.
+   *  That is, given the same parameter, they return the same result.
+   *
+   *  We assume that unapply methods are pure, but the same method may
+   *  be called with different prefixes, thus behaving differently.
+   */
+  def isSameUnapply(tp1: TermRef, tp2: TermRef): Boolean
+
+  /** Return a space containing the values of both types.
+   *
+   * The types should be atomic (non-decomposable) and unrelated (neither
+   * should be a subtype of the other).
+   */
+  def intersectUnrelatedAtomicTypes(tp1: Type, tp2: Type): Space
+
+  /** Is the type `tp` decomposable? i.e. all values of the type can be covered
+   *  by its decomposed types.
+   *
+   * Abstract sealed class, OrType, Boolean and Java enums can be decomposed.
+   */
+  def canDecompose(tp: Type): Boolean
+
+  /** Return term parameter types of the extractor `unapp` */
+  def signature(unapp: TermRef, scrutineeTp: Type, argLen: Int): List[Type]
+
+  /** Get components of decomposable types */
+  def decompose(tp: Type): List[Typ]
+
+  /** Whether the extractor covers the given type */
+  def covers(unapp: TermRef, scrutineeTp: Type, argLen: Int): Boolean
+
+  /** Display space in string format */
+  def show(sp: Space): String
+
+  /** Simplify space such that a space equal to `Empty` becomes `Empty` */
+  def simplify(space: Space)(using Context): Space = trace(s"simplify ${show(space)} --> ", debug, show)(space match {
+    case Prod(tp, fun, spaces) =>
+      val sps = spaces.map(simplify(_))
+      if (sps.contains(Empty)) Empty
+      else if (canDecompose(tp) && decompose(tp).isEmpty) Empty
+      else Prod(tp, fun, sps)
+    case Or(spaces) =>
+      val spaces2 = spaces.map(simplify(_)).filter(_ != Empty)
+      if spaces2.isEmpty then Empty
+      else if spaces2.lengthCompare(1) == 0 then spaces2.head
+      else Or(spaces2)
+    case Typ(tp, _) =>
+      if (canDecompose(tp) && decompose(tp).isEmpty) Empty
+      else space
+    case _ => space
+  })
+
+  /** Remove a space if it's a subspace of remaining spaces
+   *
+   *  Note: `dedup` will return the same result if the sequence >= 10
+   */
+  def dedup(spaces: Seq[Space])(using Context): Seq[Space] =
+    if (spaces.lengthCompare(1) <= 0 || spaces.lengthCompare(10) >= 0) spaces
+    else {
+      val res = spaces.map(sp => (sp, spaces.filter(_ ne sp))).find {
+        case (sp, sps) => isSubspace(sp, Or(LazyList(sps: _*)))
+      }
+      if (res.isEmpty) spaces
+      else res.get._2
+    }
+
+  /** Flatten space to get rid of `Or` for pretty print */
+  def flatten(space: Space)(using Context): Seq[Space] = space match {
+    case Prod(tp, fun, spaces) =>
+      val ss = LazyList(spaces: _*).map(flatten)
+
+      ss.foldLeft(LazyList(Nil : List[Space])) { (acc, flat) =>
+        for { sps <- acc; s <- flat }
+        yield sps :+ s
+      }.map { sps =>
+        Prod(tp, fun, sps)
+      }
+
+    case Or(spaces) =>
+      LazyList(spaces: _*).flatMap(flatten)
+
+    case _ =>
+      List(space)
+  }
+
+  /** Is `a` a subspace of `b`? Equivalent to `a - b == Empty`, but faster */
+  def isSubspace(a: Space, b: Space)(using Context): Boolean = trace(s"isSubspace(${show(a)}, ${show(b)})", debug) {
+    def tryDecompose1(tp: Type) = canDecompose(tp) && isSubspace(Or(decompose(tp)), b)
+    def tryDecompose2(tp: Type) = canDecompose(tp) && isSubspace(a, Or(decompose(tp)))
+
+    (simplify(a), simplify(b)) match {
+      case (Empty, _) => true
+      case (_, Empty) => false
+      case (Or(ss), _) =>
+        ss.forall(isSubspace(_, b))
+      case (Typ(tp1, _), Typ(tp2, _)) =>
+        isSubType(tp1, tp2)
+        || canDecompose(tp1) && tryDecompose1(tp1)
+        || canDecompose(tp2) && tryDecompose2(tp2)
+      case (Typ(tp1, _), Or(ss)) =>  // optimization: don't go to subtraction too early
+        ss.exists(isSubspace(a, _)) || tryDecompose1(tp1)
+      case (_, Or(_)) =>
+        simplify(minus(a, b)) == Empty
+      case (Prod(tp1, _, _), Typ(tp2, _)) =>
+        isSubType(tp1, tp2)
+      case (Typ(tp1, _), Prod(tp2, fun, ss)) =>
+        isSubType(tp1, tp2)
+        && covers(fun, tp1, ss.length)
+        && isSubspace(Prod(tp2, fun, signature(fun, tp2, ss.length).map(Typ(_, false))), b)
+      case (Prod(_, fun1, ss1), Prod(_, fun2, ss2)) =>
+        isSameUnapply(fun1, fun2) && ss1.zip(ss2).forall((isSubspace _).tupled)
+    }
+  }
+
+  /** Intersection of two spaces  */
+  def intersect(a: Space, b: Space)(using Context): Space = trace(s"${show(a)} & ${show(b)}", debug, show) {
+    def tryDecompose1(tp: Type) = intersect(Or(decompose(tp)), b)
+    def tryDecompose2(tp: Type) = intersect(a, Or(decompose(tp)))
+
+    (a, b) match {
+      case (Empty, _) | (_, Empty) => Empty
+      case (_, Or(ss)) => Or(ss.map(intersect(a, _)).filter(_ ne Empty))
+      case (Or(ss), _) => Or(ss.map(intersect(_, b)).filter(_ ne Empty))
+      case (Typ(tp1, _), Typ(tp2, _)) =>
+        if (isSubType(tp1, tp2)) a
+        else if (isSubType(tp2, tp1)) b
+        else if (canDecompose(tp1)) tryDecompose1(tp1)
+        else if (canDecompose(tp2)) tryDecompose2(tp2)
+        else intersectUnrelatedAtomicTypes(tp1, tp2)
+      case (Typ(tp1, _), Prod(tp2, fun, ss)) =>
+        if (isSubType(tp2, tp1)) b
+        else if (canDecompose(tp1)) tryDecompose1(tp1)
+        else if (isSubType(tp1, tp2)) a // problematic corner case: inheriting a case class
+        else intersectUnrelatedAtomicTypes(tp1, tp2) match
+          case Typ(tp, _) => Prod(tp, fun, ss)
+          case sp         => sp
+      case (Prod(tp1, fun, ss), Typ(tp2, _)) =>
+        if (isSubType(tp1, tp2)) a
+        else if (canDecompose(tp2)) tryDecompose2(tp2)
+        else if (isSubType(tp2, tp1)) a  // problematic corner case: inheriting a case class
+        else intersectUnrelatedAtomicTypes(tp1, tp2) match
+          case Typ(tp, _) => Prod(tp, fun, ss)
+          case sp         => sp
+      case (Prod(tp1, fun1, ss1), Prod(tp2, fun2, ss2)) =>
+        if (!isSameUnapply(fun1, fun2)) intersectUnrelatedAtomicTypes(tp1, tp2) match
+          case Typ(tp, _) => Prod(tp, fun1, ss1)
+          case sp         => sp
+        else if (ss1.zip(ss2).exists(p => simplify(intersect(p._1, p._2)) == Empty)) Empty
+        else Prod(tp1, fun1, ss1.zip(ss2).map((intersect _).tupled))
+    }
+  }
+
+  /** The space of a not covered by b */
+  def minus(a: Space, b: Space)(using Context): Space = trace(s"${show(a)} - ${show(b)}", debug, show) {
+    def tryDecompose1(tp: Type) = minus(Or(decompose(tp)), b)
+    def tryDecompose2(tp: Type) = minus(a, Or(decompose(tp)))
+
+    (a, b) match {
+      case (Empty, _) => Empty
+      case (_, Empty) => a
+      case (Typ(tp1, _), Typ(tp2, _)) =>
+        if (isSubType(tp1, tp2)) Empty
+        else if (canDecompose(tp1)) tryDecompose1(tp1)
+        else if (canDecompose(tp2)) tryDecompose2(tp2)
+        else a
+      case (Typ(tp1, _), Prod(tp2, fun, ss)) =>
+        // rationale: every instance of `tp1` is covered by `tp2(_)`
+        if isSubType(tp1, tp2) && covers(fun, tp1, ss.length) then
+          minus(Prod(tp1, fun, signature(fun, tp1, ss.length).map(Typ(_, false))), b)
+        else if canDecompose(tp1) then
+          tryDecompose1(tp1)
+        else
+          a
+      case (Or(ss), _) =>
+        Or(ss.map(minus(_, b)))
+      case (_, Or(ss)) =>
+        ss.foldLeft(a)(minus)
+      case (Prod(tp1, fun, ss), Typ(tp2, _)) =>
+        // uncovered corner case: tp2 :< tp1, may happen when inheriting case class
+        if (isSubType(tp1, tp2))
+          Empty
+        else if (simplify(a) == Empty)
+           Empty
+        else if (canDecompose(tp2))
+          tryDecompose2(tp2)
+        else
+          a
+      case (Prod(tp1, fun1, ss1), Prod(tp2, fun2, ss2)) =>
+        if (!isSameUnapply(fun1, fun2)) return a
+        if (fun1.symbol.name == nme.unapply && ss1.length != ss2.length) return a
+
+        val range = (0 until ss1.size).toList
+        val cache = Array.fill[Space | Null](ss2.length)(null)
+        def sub(i: Int) =
+          if cache(i) == null then
+            cache(i) = minus(ss1(i), ss2(i))
+          cache(i).nn
+        end sub
+
+        if range.exists(i => isSubspace(ss1(i), sub(i))) then a
+        else if cache.forall(sub => isSubspace(sub.nn, Empty)) then Empty
+        else
+          // `(_, _, _) - (Some, None, _)` becomes `(None, _, _) | (_, Some, _) | (_, _, Empty)`
+          val spaces = LazyList(range: _*).flatMap { i =>
+            flatten(sub(i)).map(s => Prod(tp1, fun1, ss1.updated(i, s)))
+          }
+          Or(spaces)
+    }
+  }
+}
+
+object SpaceEngine {
+
+  /** Is the unapply or unapplySeq irrefutable?
+   *  @param  unapp   The unapply function reference
+   */
+  def isIrrefutable(unapp: TermRef, argLen: Int)(using Context): Boolean = {
+    val unappResult = unapp.widen.finalResultType
+    unappResult.isRef(defn.SomeClass)
+    || unappResult <:< ConstantType(Constant(true)) // only for unapply
+    || (unapp.symbol.is(Synthetic) && unapp.symbol.owner.linkedClass.is(Case))  // scala2 compatibility
+    || unapplySeqTypeElemTp(unappResult).exists // only for unapplySeq
+    || isProductMatch(unappResult, argLen)
+    || {
+      val isEmptyTp = extractorMemberType(unappResult, nme.isEmpty, NoSourcePosition)
+      isEmptyTp <:< ConstantType(Constant(false))
+    }
+  }
+
+  /** Is the unapply or unapplySeq irrefutable?
+   *  @param  unapp   The unapply function tree
+   */
+  def isIrrefutable(unapp: tpd.Tree, argLen: Int)(using Context): Boolean = {
+    tpd.funPart(unapp).tpe match
+      case funRef: TermRef => isIrrefutable(funRef, argLen)
+      case _: ErrorType => false
+  }
+}
+
+/** Scala implementation of space logic */
+class SpaceEngine(using Context) extends SpaceLogic {
+  import tpd._
+
+  private val scalaSeqFactoryClass = defn.SeqFactoryClass
+  private val scalaListType        = defn.ListClass.typeRef
+  private val scalaNilType         = defn.NilModule.termRef
+  private val scalaConsType        = defn.ConsClass.typeRef
+
+  private val constantNullType     = ConstantType(Constant(null))
+
+  override def intersectUnrelatedAtomicTypes(tp1: Type, tp2: Type): Space = trace(s"atomic intersection: ${AndType(tp1, tp2).show}", debug) {
+    // Precondition: !isSubType(tp1, tp2) && !isSubType(tp2, tp1).
+    if !ctx.mode.is(Mode.SafeNulls) && (tp1.isNullType || tp2.isNullType) then
+      // Since projections of types don't include null, intersection with null is empty.
+      Empty
+    else
+      val intersection = Typ(AndType(tp1, tp2), decomposed = false)
+      // unrelated numeric value classes can equal each other, so let's not consider type space intersection empty
+      if tp1.classSymbol.isNumericValueClass && tp2.classSymbol.isNumericValueClass then intersection
+      else if isPrimToBox(tp1, tp2) || isPrimToBox(tp2, tp1) then intersection
+      else if TypeComparer.provablyDisjoint(tp1, tp2) then Empty
+      else intersection
+  }
+
+  /** Return the space that represents the pattern `pat` */
+  def project(pat: Tree): Space = pat match {
+    case Literal(c) =>
+      if (c.value.isInstanceOf[Symbol])
+        Typ(c.value.asInstanceOf[Symbol].termRef, decomposed = false)
+      else
+        Typ(ConstantType(c), decomposed = false)
+
+    case pat: Ident if isBackquoted(pat) =>
+      Typ(pat.tpe, decomposed = false)
+
+    case Ident(_) | Select(_, _) =>
+      Typ(erase(pat.tpe.stripAnnots.widenSkolem, isValue = true), decomposed = false)
+
+    case Alternative(trees) =>
+      Or(trees.map(project(_)))
+
+    case Bind(_, pat) =>
+      project(pat)
+
+    case SeqLiteral(pats, _) =>
+      projectSeq(pats)
+
+    case UnApply(fun, _, pats) =>
+      val fun1 = funPart(fun)
+      val funRef = fun1.tpe.asInstanceOf[TermRef]
+      if (fun.symbol.name == nme.unapplySeq)
+        val (arity, elemTp, resultTp) = unapplySeqInfo(fun.tpe.widen.finalResultType, fun.srcPos)
+        if (fun.symbol.owner == scalaSeqFactoryClass && scalaListType.appliedTo(elemTp) <:< pat.tpe)
+          // The exhaustivity and reachability logic already handles decomposing sum types (into its subclasses)
+          // and product types (into its components).  To get better counter-examples for patterns that are of type
+          // List (or a super-type of list, like LinearSeq) we project them into spaces that use `::` and Nil.
+          // Doing so with a pattern of `case Seq() =>` with a scrutinee of type `Vector()` doesn't work because the
+          // space is then discarded leading to a false positive reachability warning, see #13931.
+          projectSeq(pats)
+        else {
+          if (elemTp.exists)
+            Prod(erase(pat.tpe.stripAnnots, isValue = false), funRef, projectSeq(pats) :: Nil)
+          else
+            Prod(erase(pat.tpe.stripAnnots, isValue = false), funRef, pats.take(arity - 1).map(project) :+ projectSeq(pats.drop(arity - 1)))
+        }
+      else
+        Prod(erase(pat.tpe.stripAnnots, isValue = false), funRef, pats.map(project))
+
+    case Typed(pat @ UnApply(_, _, _), _) =>
+      project(pat)
+
+    case Typed(_, tpt) =>
+      Typ(erase(tpt.tpe.stripAnnots, isValue = true), decomposed = false)
+
+    case This(_) =>
+      Typ(pat.tpe.stripAnnots, decomposed = false)
+
+    case EmptyTree =>         // default rethrow clause of try/catch, check tests/patmat/try2.scala
+      Typ(WildcardType, decomposed = false)
+
+    case Block(Nil, expr) =>
+      project(expr)
+
+    case _ =>
+      // Pattern is an arbitrary expression; assume a skolem (i.e. an unknown value) of the pattern type
+      Typ(pat.tpe.narrow, decomposed = false)
+  }
+
+  private def project(tp: Type): Space = tp match {
+    case OrType(tp1, tp2) => Or(project(tp1) :: project(tp2) :: Nil)
+    case tp => Typ(tp, decomposed = true)
+  }
+
+  private def unapplySeqInfo(resTp: Type, pos: SrcPos): (Int, Type, Type) = {
+    var resultTp = resTp
+    var elemTp = unapplySeqTypeElemTp(resultTp)
+    var arity = productArity(resultTp, pos)
+    if (!elemTp.exists && arity <= 0) {
+      resultTp = resTp.select(nme.get).finalResultType
+      elemTp = unapplySeqTypeElemTp(resultTp.widen)
+      arity = productSelectorTypes(resultTp, pos).size
+    }
+    (arity, elemTp, resultTp)
+  }
+
+  /** Erase pattern bound types with WildcardType
+   *
+   *  For example, the type `C[T$1]` should match any `C[?]`, thus
+   *  `v` should be `WildcardType` instead of `T$1`:
+   *
+   *     sealed trait B
+   *     case class C[T](v: T) extends B
+   *     (b: B) match {
+   *        case C(v) =>      //    case C.unapply[T$1 @ T$1](v @ _):C[T$1]
+   *     }
+   *
+   *  However, we cannot use WildcardType for Array[?], due to that
+   *  `Array[WildcardType] <: Array[Array[WildcardType]]`, which may
+   *  cause false unreachable warnings. See tests/patmat/t2425.scala
+   *
+   *  We cannot use type erasure here, as it would lose the constraints
+   *  involving GADTs. For example, in the following code, type
+   *  erasure would loose the constraint that `x` and `y` must be
+   *  the same type, resulting in false inexhaustive warnings:
+   *
+   *     sealed trait Expr[T]
+   *     case class IntExpr(x: Int) extends Expr[Int]
+   *     case class BooleanExpr(b: Boolean) extends Expr[Boolean]
+   *
+   *     def foo[T](x: Expr[T], y: Expr[T]) = (x, y) match {
+   *       case (IntExpr(_), IntExpr(_)) =>
+   *       case (BooleanExpr(_), BooleanExpr(_)) =>
+   *     }
+   *
+   *  @param inArray whether `tp` is a type argument to `Array`
+   *  @param isValue whether `tp` is the type which match against values
+   *
+   *  If `isValue` is true, then pattern-bound symbols are erased to its upper bound.
+   *  This is needed to avoid spurious unreachable warnings. See tests/patmat/i6197.scala.
+   */
+  private def erase(tp: Type, inArray: Boolean = false, isValue: Boolean = false): Type = trace(i"$tp erased to", debug) {
+
+    tp match {
+      case tp @ AppliedType(tycon, args) =>
+        if tycon.typeSymbol.isPatternBound then return WildcardType
+
+        val args2 =
+          if (tycon.isRef(defn.ArrayClass)) args.map(arg => erase(arg, inArray = true, isValue = false))
+          else args.map(arg => erase(arg, inArray = false, isValue = false))
+        tp.derivedAppliedType(erase(tycon, inArray, isValue = false), args2)
+
+      case tp @ OrType(tp1, tp2) =>
+        OrType(erase(tp1, inArray, isValue), erase(tp2, inArray, isValue), tp.isSoft)
+
+      case AndType(tp1, tp2) =>
+        AndType(erase(tp1, inArray, isValue), erase(tp2, inArray, isValue))
+
+      case tp @ RefinedType(parent, _, _) =>
+        erase(parent, inArray, isValue)
+
+      case tref: TypeRef if tref.symbol.isPatternBound =>
+        if inArray then tref.underlying
+        else if isValue then tref.superType
+        else WildcardType
+
+      case _ => tp
+    }
+  }
+
+  /** Space of the pattern: unapplySeq(a, b, c: _*)
+   */
+  def projectSeq(pats: List[Tree]): Space = {
+    if (pats.isEmpty) return Typ(scalaNilType, false)
+
+    val (items, zero) = if (isWildcardStarArg(pats.last))
+      (pats.init, Typ(scalaListType.appliedTo(pats.last.tpe.elemType), false))
+    else
+      (pats, Typ(scalaNilType, false))
+
+    val unapplyTp = scalaConsType.classSymbol.companionModule.termRef.select(nme.unapply)
+    items.foldRight[Space](zero) { (pat, acc) =>
+      val consTp = scalaConsType.appliedTo(pats.head.tpe.widen)
+      Prod(consTp, unapplyTp, project(pat) :: acc :: Nil)
+    }
+  }
+
+  def isPrimToBox(tp: Type, pt: Type): Boolean =
+    tp.isPrimitiveValueType && (defn.boxedType(tp).classSymbol eq pt.classSymbol)
+
+  private val isSubspaceCache = mutable.HashMap.empty[(Space, Space, Context), Boolean]
+
+  override def isSubspace(a: Space, b: Space)(using Context): Boolean =
+    isSubspaceCache.getOrElseUpdate((a, b, ctx), super.isSubspace(a, b))
+
+  /** Is `tp1` a subtype of `tp2`?  */
+  def isSubType(tp1: Type, tp2: Type): Boolean = trace(i"$tp1 <:< $tp2", debug, show = true) {
+    if tp1 == constantNullType && !ctx.mode.is(Mode.SafeNulls)
+    then tp2 == constantNullType
+    else tp1 <:< tp2
+  }
+
+  def isSameUnapply(tp1: TermRef, tp2: TermRef): Boolean =
+    // always assume two TypeTest[S, T].unapply are the same if they are equal in types
+    (tp1.prefix.isStable && tp2.prefix.isStable || tp1.symbol == defn.TypeTest_unapply)
+    && tp1 =:= tp2
+
+  /** Parameter types of the case class type `tp`. Adapted from `unapplyPlan` in patternMatcher  */
+  def signature(unapp: TermRef, scrutineeTp: Type, argLen: Int): List[Type] = {
+    val unappSym = unapp.symbol
+
+    // println("scrutineeTp = " + scrutineeTp.show)
+
+    val mt: MethodType = unapp.widen match {
+      case mt: MethodType => mt
+      case pt: PolyType   =>
+          val tvars = pt.paramInfos.map(newTypeVar(_))
+          val mt = pt.instantiate(tvars).asInstanceOf[MethodType]
+          scrutineeTp <:< mt.paramInfos(0)
+          // force type inference to infer a narrower type: could be singleton
+          // see tests/patmat/i4227.scala
+          mt.paramInfos(0) <:< scrutineeTp
+          instantiateSelected(mt, tvars)
+          isFullyDefined(mt, ForceDegree.all)
+          mt
+    }
+
+    // Case unapply:
+    // 1. return types of constructor fields if the extractor is synthesized for Scala2 case classes & length match
+    // 2. return Nil if unapply returns Boolean  (boolean pattern)
+    // 3. return product selector types if unapply returns a product type (product pattern)
+    // 4. return product selectors of `T` where `def get: T` is a member of the return type of unapply & length match (named-based pattern)
+    // 5. otherwise, return `T` where `def get: T` is a member of the return type of unapply
+    //
+    // Case unapplySeq:
+    // 1. return the type `List[T]` where `T` is the element type of the unapplySeq return type `Seq[T]`
+
+    val resTp = ctx.typeAssigner.safeSubstMethodParams(mt, scrutineeTp :: Nil).finalResultType
+
+    val sig =
+      if (resTp.isRef(defn.BooleanClass))
+        List()
+      else {
+        val isUnapplySeq = unappSym.name == nme.unapplySeq
+
+        if (isUnapplySeq) {
+          val (arity, elemTp, resultTp) = unapplySeqInfo(resTp, unappSym.srcPos)
+          if (elemTp.exists) scalaListType.appliedTo(elemTp) :: Nil
+          else {
+            val sels = productSeqSelectors(resultTp, arity, unappSym.srcPos)
+            sels.init :+ scalaListType.appliedTo(sels.last)
+          }
+        }
+        else {
+          val arity = productArity(resTp, unappSym.srcPos)
+          if (arity > 0)
+            productSelectorTypes(resTp, unappSym.srcPos)
+          else {
+            val getTp = resTp.select(nme.get).finalResultType.widenTermRefExpr
+            if (argLen == 1) getTp :: Nil
+            else productSelectorTypes(getTp, unappSym.srcPos)
+          }
+        }
+      }
+
+    debug.println(s"signature of ${unappSym.showFullName} ----> ${sig.map(_.show).mkString(", ")}")
+
+    sig.map(_.annotatedToRepeated)
+  }
+
+  /** Whether the extractor covers the given type */
+  def covers(unapp: TermRef, scrutineeTp: Type, argLen: Int): Boolean =
+    SpaceEngine.isIrrefutable(unapp, argLen) || unapp.symbol == defn.TypeTest_unapply && {
+      val AppliedType(_, _ :: tp :: Nil) = unapp.prefix.widen.dealias: @unchecked
+      scrutineeTp <:< tp
+    }
+
+  /** Decompose a type into subspaces -- assume the type can be decomposed */
+  def decompose(tp: Type): List[Typ] =
+    tp.dealias match {
+      case AndType(tp1, tp2) =>
+        def decomposeComponent(tpA: Type, tpB: Type): List[Typ] =
+          decompose(tpA).flatMap {
+            case Typ(tp, _) =>
+              if tp <:< tpB then
+                Typ(tp, decomposed = true) :: Nil
+              else if tpB <:< tp then
+                Typ(tpB, decomposed = true) :: Nil
+              else if TypeComparer.provablyDisjoint(tp, tpB) then
+                Nil
+              else
+                Typ(AndType(tp, tpB), decomposed = true) :: Nil
+          }
+
+        if canDecompose(tp1) then
+          decomposeComponent(tp1, tp2)
+        else
+          decomposeComponent(tp2, tp1)
+
+      case OrType(tp1, tp2) => List(Typ(tp1, true), Typ(tp2, true))
+      case tp if tp.isRef(defn.BooleanClass) =>
+        List(
+          Typ(ConstantType(Constant(true)), true),
+          Typ(ConstantType(Constant(false)), true)
+        )
+      case tp if tp.isRef(defn.UnitClass) =>
+        Typ(ConstantType(Constant(())), true) :: Nil
+      case tp if tp.classSymbol.isAllOf(JavaEnumTrait) =>
+        tp.classSymbol.children.map(sym => Typ(sym.termRef, true))
+      case tp =>
+        def getChildren(sym: Symbol): List[Symbol] =
+          sym.children.flatMap { child =>
+            if child eq sym then List(sym) // i3145: sealed trait Baz, val x = new Baz {}, Baz.children returns Baz...
+            else if tp.classSymbol == defn.TupleClass || tp.classSymbol == defn.NonEmptyTupleClass then
+              List(child) // TupleN and TupleXXL classes are used for Tuple, but they aren't Tuple's children
+            else if (child.is(Private) || child.is(Sealed)) && child.isOneOf(AbstractOrTrait) then getChildren(child)
+            else List(child)
+          }
+        val children = getChildren(tp.classSymbol)
+        debug.println(s"candidates for ${tp.show} : [${children.map(_.show).mkString(", ")}]")
+
+        val parts = children.map { sym =>
+          val sym1 = if (sym.is(ModuleClass)) sym.sourceModule else sym
+          val refined = TypeOps.refineUsingParent(tp, sym1)
+
+          debug.println(sym1.show + " refined to " + refined.show)
+
+          def inhabited(tp: Type): Boolean =
+            tp.dealias match {
+              case AndType(tp1, tp2) => !TypeComparer.provablyDisjoint(tp1, tp2)
+              case OrType(tp1, tp2) => inhabited(tp1) || inhabited(tp2)
+              case tp: RefinedType => inhabited(tp.parent)
+              case tp: TypeRef => inhabited(tp.prefix)
+              case _ => true
+            }
+
+          if (inhabited(refined)) refined
+          else NoType
+        } filter(_.exists)
+
+        debug.println(s"${tp.show} decomposes to [${parts.map(_.show).mkString(", ")}]")
+
+        parts.map(Typ(_, true))
+    }
+
+  /** Abstract sealed types, or-types, Boolean and Java enums can be decomposed */
+  def canDecompose(tp: Type): Boolean =
+    val res = tp.dealias match
+      case _: SingletonType => false
+      case _: OrType => true
+      case and: AndType => canDecompose(and.tp1) || canDecompose(and.tp2)
+      case _ =>
+        val cls = tp.classSymbol
+        cls.is(Sealed)
+        && cls.isOneOf(AbstractOrTrait)
+        && !cls.hasAnonymousChild
+        && cls.children.nonEmpty
+        || cls.isAllOf(JavaEnumTrait)
+        || tp.isRef(defn.BooleanClass)
+        || tp.isRef(defn.UnitClass)
+    //debug.println(s"decomposable: ${tp.show} = $res")
+    res
+
+  /** Show friendly type name with current scope in mind
+   *
+   *  E.g.    C.this.B     -->  B     if current owner is C
+   *          C.this.x.T   -->  x.T   if current owner is C
+   *          X[T]         -->  X
+   *          C            -->  C     if current owner is C !!!
+   *
+   */
+  def showType(tp: Type, showTypeArgs: Boolean = false): String = {
+    val enclosingCls = ctx.owner.enclosingClass
+
+    def isOmittable(sym: Symbol) =
+      sym.isEffectiveRoot || sym.isAnonymousClass || sym.name.isReplWrapperName ||
+        ctx.definitions.unqualifiedOwnerTypes.exists(_.symbol == sym) ||
+        sym.showFullName.startsWith("scala.") ||
+        sym == enclosingCls || sym == enclosingCls.sourceModule
+
+    def refinePrefix(tp: Type): String = tp match {
+      case NoPrefix => ""
+      case tp: NamedType if isOmittable(tp.symbol) => ""
+      case tp: ThisType => refinePrefix(tp.tref)
+      case tp: RefinedType => refinePrefix(tp.parent)
+      case tp: NamedType => tp.name.show.stripSuffix("$")
+      case tp: TypeVar => refinePrefix(tp.instanceOpt)
+      case _ => tp.show
+    }
+
+    def refine(tp: Type): String = tp.stripped match {
+      case tp: RefinedType => refine(tp.parent)
+      case tp: AppliedType =>
+        refine(tp.typeConstructor) + (
+          if (showTypeArgs) tp.argInfos.map(refine).mkString("[", ",", "]")
+          else ""
+        )
+      case tp: ThisType => refine(tp.tref)
+      case tp: NamedType =>
+        val pre = refinePrefix(tp.prefix)
+        if (tp.name == tpnme.higherKinds) pre
+        else if (pre.isEmpty) tp.name.show.stripSuffix("$")
+        else pre + "." + tp.name.show.stripSuffix("$")
+      case tp: OrType => refine(tp.tp1) + " | " + refine(tp.tp2)
+      case _: TypeBounds => "_"
+      case _ => tp.show.stripSuffix("$")
+    }
+
+    refine(tp)
+  }
+
+  /** Whether the counterexample is satisfiable. The space is flattened and non-empty. */
+  def satisfiable(sp: Space): Boolean = {
+    def impossible: Nothing = throw new AssertionError("`satisfiable` only accepts flattened space.")
+
+    def genConstraint(space: Space): List[(Type, Type)] = space match {
+      case Prod(tp, unappTp, ss) =>
+        val tps = signature(unappTp, tp, ss.length)
+        ss.zip(tps).flatMap {
+          case (sp : Prod, tp) => sp.tp -> tp :: genConstraint(sp)
+          case (Typ(tp1, _), tp2) => tp1 -> tp2 :: Nil
+          case _ => impossible
+        }
+      case Typ(_, _) => Nil
+      case _ => impossible
+    }
+
+    def checkConstraint(constrs: List[(Type, Type)])(using Context): Boolean = {
+      val tvarMap = collection.mutable.Map.empty[Symbol, TypeVar]
+      val typeParamMap = new TypeMap() {
+        override def apply(tp: Type): Type = tp match {
+          case tref: TypeRef if tref.symbol.is(TypeParam) =>
+            tvarMap.getOrElseUpdate(tref.symbol, newTypeVar(tref.underlying.bounds))
+          case tp => mapOver(tp)
+        }
+      }
+
+      constrs.forall { case (tp1, tp2) => typeParamMap(tp1) <:< typeParamMap(tp2) }
+    }
+
+    checkConstraint(genConstraint(sp))(using ctx.fresh.setNewTyperState())
+  }
+
+  def show(ss: Seq[Space]): String = ss.map(show).mkString(", ")
+
+  /** Display spaces */
+  def show(s: Space): String = {
+    def params(tp: Type): List[Type] = tp.classSymbol.primaryConstructor.info.firstParamTypes
+
+    /** does the companion object of the given symbol have custom unapply */
+    def hasCustomUnapply(sym: Symbol): Boolean = {
+      val companion = sym.companionModule
+      companion.findMember(nme.unapply, NoPrefix, required = EmptyFlags, excluded = Synthetic).exists ||
+        companion.findMember(nme.unapplySeq, NoPrefix, required = EmptyFlags, excluded = Synthetic).exists
+    }
+
+    def doShow(s: Space, flattenList: Boolean = false): String = s match {
+      case Empty => "empty"
+      case Typ(c: ConstantType, _) => "" + c.value.value
+      case Typ(tp: TermRef, _) =>
+        if (flattenList && tp <:< scalaNilType) ""
+        else tp.symbol.showName
+      case Typ(tp, decomposed) =>
+
+        val sym = tp.classSymbol
+
+        if (ctx.definitions.isTupleNType(tp))
+          params(tp).map(_ => "_").mkString("(", ", ", ")")
+        else if (scalaListType.isRef(sym))
+          if (flattenList) "_*" else "_: List"
+        else if (scalaConsType.isRef(sym))
+          if (flattenList) "_, _*"  else "List(_, _*)"
+        else if (tp.classSymbol.is(Sealed) && tp.classSymbol.hasAnonymousChild)
+          "_: " + showType(tp) + " (anonymous)"
+        else if (tp.classSymbol.is(CaseClass) && !hasCustomUnapply(tp.classSymbol))
+        // use constructor syntax for case class
+          showType(tp) + params(tp).map(_ => "_").mkString("(", ", ", ")")
+        else if (decomposed) "_: " + showType(tp, showTypeArgs = true)
+        else "_"
+      case Prod(tp, fun, params) =>
+        if (ctx.definitions.isTupleNType(tp))
+          "(" + params.map(doShow(_)).mkString(", ") + ")"
+        else if (tp.isRef(scalaConsType.symbol))
+          if (flattenList) params.map(doShow(_, flattenList)).filter(_.nonEmpty).mkString(", ")
+          else params.map(doShow(_, flattenList = true)).filter(!_.isEmpty).mkString("List(", ", ", ")")
+        else {
+          val sym = fun.symbol
+          val isUnapplySeq = sym.name.eq(nme.unapplySeq)
+          val paramsStr = params.map(doShow(_, flattenList = isUnapplySeq)).mkString("(", ", ", ")")
+          showType(fun.prefix) + paramsStr
+        }
+      case Or(ss) =>
+        ss.map(doShow(_, flattenList)).mkString(" | ")
+    }
+
+    doShow(s, flattenList = false)
+  }
+
+  private def exhaustivityCheckable(sel: Tree): Boolean = {
+    val seen = collection.mutable.Set.empty[Type]
+
+    // Possible to check everything, but be compatible with scalac by default
+    def isCheckable(tp: Type): Boolean =
+      val tpw = tp.widen.dealias
+      val classSym = tpw.classSymbol
+      classSym.is(Sealed) ||
+      tpw.isInstanceOf[OrType] ||
+      (tpw.isInstanceOf[AndType] && {
+        val and = tpw.asInstanceOf[AndType]
+        isCheckable(and.tp1) || isCheckable(and.tp2)
+      }) ||
+      tpw.isRef(defn.BooleanClass) ||
+      classSym.isAllOf(JavaEnumTrait) ||
+      classSym.is(Case) && {
+        if seen.add(tpw) then productSelectorTypes(tpw, sel.srcPos).exists(isCheckable(_))
+        else true // recursive case class: return true and other members can still fail the check
+      }
+
+    val res = !sel.tpe.hasAnnotation(defn.UncheckedAnnot) && {
+      ctx.settings.YcheckAllPatmat.value
+      || isCheckable(sel.tpe)
+    }
+
+    debug.println(s"exhaustivity checkable: ${sel.show} = $res")
+    res
+  }
+
+  /** Whehter counter-examples should be further checked? True for GADTs. */
+  private def shouldCheckExamples(tp: Type): Boolean =
+    new TypeAccumulator[Boolean] {
+      override def apply(b: Boolean, tp: Type): Boolean = tp match {
+        case tref: TypeRef if tref.symbol.is(TypeParam) && variance != 1 => true
+        case tp => b || foldOver(b, tp)
+      }
+    }.apply(false, tp)
+
+  /** Return the underlying type of non-module, non-constant, non-enum case singleton types.
+   *  Also widen ExprType to its result type, and rewrap any annotation wrappers.
+   *  For example, with `val opt = None`, widen `opt.type` to `None.type`. */
+  def toUnderlying(tp: Type): Type = trace(i"toUnderlying($tp)", show = true)(tp match {
+    case _: ConstantType                            => tp
+    case tp: TermRef if tp.symbol.is(Module)        => tp
+    case tp: TermRef if tp.symbol.isAllOf(EnumCase) => tp
+    case tp: SingletonType                          => toUnderlying(tp.underlying)
+    case tp: ExprType                               => toUnderlying(tp.resultType)
+    case AnnotatedType(tp, annot)                   => AnnotatedType(toUnderlying(tp), annot)
+    case _                                          => tp
+  })
+
+  def checkExhaustivity(_match: Match): Unit = {
+    val Match(sel, cases) = _match
+    debug.println(i"checking exhaustivity of ${_match}")
+
+    if (!exhaustivityCheckable(sel)) return
+
+    val selTyp = toUnderlying(sel.tpe).dealias
+    debug.println(i"selTyp = $selTyp")
+
+    val patternSpace = Or(cases.foldLeft(List.empty[Space]) { (acc, x) =>
+      val space = if (x.guard.isEmpty) project(x.pat) else Empty
+      debug.println(s"${x.pat.show} ====> ${show(space)}")
+      space :: acc
+    })
+
+    val checkGADTSAT = shouldCheckExamples(selTyp)
+
+    val uncovered =
+      flatten(simplify(minus(project(selTyp), patternSpace))).filter({ s =>
+        s != Empty && (!checkGADTSAT || satisfiable(s))
+      })
+
+
+    if uncovered.nonEmpty then
+      val hasMore = uncovered.lengthCompare(6) > 0
+      val deduped = dedup(uncovered.take(6))
+      report.warning(PatternMatchExhaustivity(show(deduped), hasMore), sel.srcPos)
+  }
+
+  private def redundancyCheckable(sel: Tree): Boolean =
+    // Ignore Expr[T] and Type[T] for unreachability as a special case.
+    // Quote patterns produce repeated calls to the same unapply method, but with different implicit parameters.
+    // Since we assume that repeated calls to the same unapply method overlap
+    // and implicit parameters cannot normally differ between two patterns in one `match`,
+    // the easiest solution is just to ignore Expr[T] and Type[T].
+    !sel.tpe.hasAnnotation(defn.UncheckedAnnot)
+    && !sel.tpe.widen.isRef(defn.QuotedExprClass)
+    && !sel.tpe.widen.isRef(defn.QuotedTypeClass)
+
+  def checkRedundancy(_match: Match): Unit = {
+    val Match(sel, _) = _match
+    val cases = _match.cases.toIndexedSeq
+    debug.println(i"checking redundancy in $_match")
+
+    if (!redundancyCheckable(sel)) return
+
+    val selTyp = toUnderlying(sel.tpe).dealias
+    debug.println(i"selTyp = $selTyp")
+
+    val isNullable = selTyp.classSymbol.isNullableClass
+    val targetSpace = if isNullable
+      then project(OrType(selTyp, constantNullType, soft = false))
+      else project(selTyp)
+    debug.println(s"targetSpace: ${show(targetSpace)}")
+
+    var i        = 0
+    val len      = cases.length
+    var prevs    = List.empty[Space]
+    var deferred = List.empty[Tree]
+
+    while (i < len) {
+      val CaseDef(pat, guard, _) = cases(i)
+
+      debug.println(i"case pattern: $pat")
+
+      val curr = project(pat)
+      debug.println(i"reachable? ${show(curr)}")
+
+      val prev = simplify(Or(prevs))
+      debug.println(s"prev: ${show(prev)}")
+
+      val covered = simplify(intersect(curr, targetSpace))
+      debug.println(s"covered: ${show(covered)}")
+
+      if prev == Empty && covered == Empty then // defer until a case is reachable
+        deferred ::= pat
+      else {
+        for (pat <- deferred.reverseIterator)
+          report.warning(MatchCaseUnreachable(), pat.srcPos)
+        if pat != EmptyTree // rethrow case of catch uses EmptyTree
+            && isSubspace(covered, prev)
+        then {
+          val nullOnly = isNullable && i == len - 1 && isWildcardArg(pat)
+          val msg = if nullOnly then MatchCaseOnlyNullWarning() else MatchCaseUnreachable()
+          report.warning(msg, pat.srcPos)
+        }
+        deferred = Nil
+      }
+
+      // in redundancy check, take guard as false in order to soundly approximate
+      prevs ::= (if guard.isEmpty then covered else Empty)
+      i += 1
+    }
+  }
+}
diff --git a/tests/pos-with-compiler-cc/dotc/transform/sjs/AddLocalJSFakeNews.scala b/tests/pos-with-compiler-cc/dotc/transform/sjs/AddLocalJSFakeNews.scala
new file mode 100644
index 000000000000..8851e641122f
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/transform/sjs/AddLocalJSFakeNews.scala
@@ -0,0 +1,98 @@
+package dotty.tools
+package dotc
+package transform
+package sjs
+
+import MegaPhase._
+import core.Constants
+import core.Contexts._
+import core.Decorators._
+import core.StdNames.nme
+import core.Symbols._
+
+import dotty.tools.backend.sjs.JSDefinitions.jsdefn
+
+/** Adds fake calls to the constructors of local JS classes in calls to
+ *  `createLocalJSClass`.
+ *
+ *  Given a call of the form
+ *  {{{
+ *  scala.scalajs.runtime.createLocalJSClass(classOf[C], jsClassValue, ???)
+ *  }}}
+ *  this phase fills in the `???` with an array of calls to the constructors
+ *  of `C`, like
+ *  {{{
+ *  [ new C(), new C(???, ???) : Object ]
+ *  }}}
+ *
+ *  If the class `C` has an outer pointer, as determined by the `ExplicitOuter`
+ *  phase, the calls to the constructor insert a reference to the outer
+ *  instance:
+ *  {{{
+ *  [ new C(Enclosing.this), new C(Enclosing.this, ???, ???) : Object ]
+ *  }}}
+ *
+ *  The `LambdaLift` phase will further expand those constructor calls with
+ *  values for captures. The back-end will extract the values of the outer
+ *  pointer and/or the captures to introduce them as JS class captures.
+ *
+ *  Since we need to insert fake `new C()` calls, this scheme does not work for
+ *  abstract local classes. We therefore reject them as implementation
+ *  restriction in `PrepJSInterop`.
+ *
+ *  This phase complements `ExplicitJSClasses`. The latter cannot create the
+ *  fake new invocations because that would require inventing sound type
+ *  arguments for the class' type parameters in order not to break Ycheck.
+ */
+class AddLocalJSFakeNews extends MiniPhase { thisPhase =>
+  import ExplicitOuter.outer
+  import ast.tpd._
+
+  override def phaseName: String = AddLocalJSFakeNews.name
+
+  override def description: String = AddLocalJSFakeNews.description
+
+  override def isEnabled(using Context): Boolean =
+    ctx.settings.scalajs.value
+
+  override def runsAfter: Set[String] = Set(Erasure.name)
+
+  override def transformApply(tree: Apply)(using Context): Tree = {
+    if (tree.symbol == jsdefn.Runtime_createLocalJSClass) {
+      val classValueArg :: superClassValueArg :: _ :: Nil = tree.args: @unchecked
+      val cls = classValueArg match {
+        case Literal(constant) if constant.tag == Constants.ClazzTag =>
+          constant.typeValue.typeSymbol.asClass
+        case _ =>
+          // this shouldn't happen
+          report.error(i"unexpected $classValueArg for the first argument to `createLocalJSClass`", classValueArg)
+          jsdefn.JSObjectClass
+      }
+
+      val fakeNews = {
+        val ctors = cls.info.decls.lookupAll(nme.CONSTRUCTOR).toList.reverse
+        val elems = ctors.map(ctor => fakeNew(cls, ctor.asTerm))
+        JavaSeqLiteral(elems, TypeTree(defn.ObjectType))
+      }
+
+      cpy.Apply(tree)(tree.fun, classValueArg :: superClassValueArg :: fakeNews :: Nil)
+    } else {
+      tree
+    }
+  }
+
+  /** Creates a fake invocation of the given class with the given constructor. */
+  private def fakeNew(cls: ClassSymbol, ctor: TermSymbol)(using Context): Tree = {
+    val tycon = cls.typeRef
+    val outerArgs = outer.argsForNew(cls, tycon)
+    val nonOuterArgCount = ctor.info.firstParamTypes.size - outerArgs.size
+    val nonOuterArgs = List.fill(nonOuterArgCount)(ref(defn.Predef_undefined).appliedToNone)
+
+    New(tycon, ctor, outerArgs ::: nonOuterArgs)
+  }
+}
+
+object AddLocalJSFakeNews {
+  val name: String = "addLocalJSFakeNews"
+  val description: String = "adds fake new invocations to local JS classes in calls to `createLocalJSClass`"
+}
diff --git a/tests/pos-with-compiler-cc/dotc/transform/sjs/ExplicitJSClasses.scala b/tests/pos-with-compiler-cc/dotc/transform/sjs/ExplicitJSClasses.scala
new file mode 100644
index 000000000000..a7f6d3e7dea7
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/transform/sjs/ExplicitJSClasses.scala
@@ -0,0 +1,730 @@
+package dotty.tools
+package dotc
+package transform
+package sjs
+
+
+import MegaPhase._
+import core.Annotations._
+import core.Constants._
+import core.Denotations._
+import core.DenotTransformers._
+import core.Symbols._
+import core.Contexts._
+import core.Types._
+import core.Flags._
+import core.Decorators._
+import core.StdNames.nme
+import core.SymDenotations.SymDenotation
+import core.Names._
+import core.NameKinds._
+import SymUtils._
+
+import util.Store
+
+import dotty.tools.backend.sjs.JSDefinitions.jsdefn
+
+import JSSymUtils._
+
+/** This phase makes all JS classes explicit (their definitions and references to them).
+ *
+ *  This phase is the equivalent of the two phases `ExplicitInnerJS` and
+ *  `ExplicitLocalJS` from Scala 2. It performs the following transformations:
+ *
+ *  (A) For every inner JS class `Inner` in a class or trait `Outer`, create a
+ *      field `Outer.Inner\$jsclass` to hold the JS class value of `Inner`.
+ *  (B) For every exposed object `Inner` in a static owner `Outer`, create an
+ *      explicit exposed getter `Outer.Inner\$jsobject`.
+ *  (C) For every local JS class `Local`, create a local val `Local\$jsclass`
+ *      to hold the JS class value of `Local`.
+ *  (D) Desugar calls like `x.isInstanceOf[C]` into
+ *      `js.special.instanceof(x, js.constructorOf[C])` when `C` is a nested
+ *      JS class.
+ *  (E) Wrap every `new C` call and `super[C]` reference of a nested JS class
+ *      `C` with `withContextualJSClassValue(js.constructorOf[C], ...)`.
+ *  (F) Desugar calls to `js.constructorOf[C]` (including those generated by
+ *      the previous transformations) into either `runtime.constructorOf` or
+ *      access to the `\$jsclass` fields/vals.
+ *  (G) Adjust the `NoInits` flag of traits:
+ *      - for JS traits, always add the flag
+ *      - for Scala trait that contain a JS class, remove the flag
+ *
+ *  Note that in this comment, and more largely in this phase, by "class" we
+ *  mean *only* `class`es. `trait`s and `object`s are not implied.
+ *
+ *  --------------------------------------
+ *
+ *  (A) `Inner\$jsclass` fields
+ *
+ *  Roughly, for every inner JS class of the form:
+ *  {{{
+ *  class Outer {
+ *    class Inner extends ParentJSClass
+ *  }
+ *  }}}
+ *  this phase creates a field `Inner\$jsclass` in `Outer` to hold the JS class
+ *  value for `Inner`. The rhs of that field is a call to a magic method, used
+ *  to retain information that the back-end will need.
+ *  {{{
+ *  class Outer {
+ *    <synthetic> val Inner\$jsclass: AnyRef =
+ *      createJSClass(classOf[Inner], js.constructorOf[ParentJSClass])
+ *
+ *    class Inner extends ParentJSClass
+ *  }
+ *  }}}
+ *
+ *  These fields will be read by code generated in step (F).
+ *
+ *  A `\$jsclass` field is also generated for classes declared inside *static
+ *  JS objects*. Indeed, even though those classes have a unique, globally
+ *  accessible class value, that class value needs to be *exposed* as a field
+ *  of the enclosing object. In those cases, the rhs of the field is a direct
+ *  call to `js.constructorOf[Inner]`, which becomes
+ *  `runtime.constructorOf(classOf[Inner])`.
+ *
+ *  For the following input:
+ *  {{{
+ *  object Outer extends js.Object {
+ *    class InnerClass extends ParentJSClass
+ *  }
+ *  }}}
+ *  this phase will generate
+ *  {{{
+ *  object Outer extends js.Object {
+ *    @ExposedJSMember @JSName("InnerClass")
+ *    val InnerClass\$jsclass: AnyRef = runtime.constructorOf(classOf[InnerClass])
+ *  }
+ *  }}}
+ *
+ *  The `\$jsclass` fields must also be added to outer classes and traits
+ *  coming from separate compilation, therefore this phase is an
+ *  `InfoTransform`.
+ *
+ *  --------------------------------------
+ *
+ *  (B) `Inner\$jsobject` exposed getters
+ *
+ *  For *modules* declared inside static JS objects, we generate an explicit
+ *  exposed getter as well. For non-static objects, dotc already generates a
+ *  getter with the `@ExposedJSMember` annotation, so we do not need to do
+ *  anything. But for static objects, it doesn't, so we have to do it ourselves
+ *  here.
+ *
+ *  For the following input:
+ *  {{{
+ *  object Outer extends js.Object {
+ *    object InnerObject extends ParentJSClass
+ *  }
+ *  }}}
+ *  this phase will generate
+ *  {{{
+ *  object Outer extends js.Object {
+ *    @ExposedJSMember @JSName("InnerObject")
+ *    def InnerObject\$jsobject: AnyRef = InnerObject
+ *  }
+ *  }}}
+ *
+ *  --------------------------------------
+ *
+ *  (C) `Local\$jsclass` vals and vars
+ *
+ *  Similarly to how step (A) creates explicit fields in the enclosing
+ *  templates of inner JS classes and traits to hold the JS class values, this
+ *  phase creates local vals for local JS classes in the enclosing statement
+ *  list.
+ *
+ *  For every local JS class of the form:
+ *  {{{
+ *  def outer() = {
+ *    class Local extends ParentJSClass
+ *  }
+ *  }}}
+ *  this phase creates a local `val Local\$jslass` in the body of `outer()` to
+ *  hold the JS class value for `Local`. The rhs of that val is a call to a
+ *  magic method, used to retain information that the back-end will need:
+ *
+ *  - A reified reference to `class Local`, in the form of a `classOf`
+ *  - An explicit reference to the super JS class value, i.e., the desugaring
+ *    of `js.constructorOf[ParentJSClass]`
+ *  - An array of fake `new` expressions for all overloaded constructors.
+ *
+ *  The latter will be augmented by `LambdaLift` with the appropriate actual
+ *  parameters for the captures of `Local`, which will be needed by the
+ *  back-end. In code, this looks like:
+ *  {{{
+ *  def outer() = {
+ *    class Local extends ParentJSClass
+ *    val Local\$jsclass: AnyRef = createLocalJSClass(
+ *        classOf[Local],
+ *        js.constructorOf[ParentJSClass],
+ *        ???)
+ *  }
+ *  }}}
+ *
+ *  The third argument `???` is a placeholder, which will be filled in by
+ *  `AddLocalJSFakeNews` with fake new invocations for the all the constructors
+ *  of `Local`. We cannot do it at this phase because that would require
+ *  inventing sound type arguments for the type parameters of `Local` out of
+ *  thin air.
+ *
+ *  If the body of `Local` references itself, then the `val Local\$jsclass` is
+ *  instead declared as a `var` to work around the cyclic dependency:
+ *  {{{
+ *  def outer() = {
+ *    var Local\$jsclass: AnyRef = null
+ *    class Local extends ParentJSClass {
+ *      def newLocal = new Local // self-reference
+ *    }
+ *    Local\$jsclass = createLocalJSClass(...)
+ *  }
+ *  }}}
+ *
+ *  --------------------------------------
+ *
+ *  (D) Insertion of `withContextualJSClassValue` calls
+ *
+ *  For any nested JS class `C`, this phase performs the following
+ *  transformations:
+ *
+ *  - `new C[...Ts](...args)` desugars into
+ *    `withContextualJSClassValue(js.constructorOf[C], new C[...Ts](...args))`,
+ *    so that the back-end receives a reified reference to the JS class value.
+ *  - In the same spirit, for `D extends C`, `D.super[C].m[...Ts](...args)`
+ *    desugars into
+ *    `withContextualJSClassValue(js.constructorOf[C], D.super[C].m[...Ts](...args))`.
+ *
+ *  For any nested JS *object*, their (only) instantiation point of the form
+ *  `new O$()` is rewritten as
+ *  `withContextualJSClassValue(js.constructorOf[ParentClassOfO], new O$())`,
+ *  so that the back-end receives a reified reference to the parent class of
+ *  `O`.
+ *
+ *  A similar treatment is applied on anonymous JS classes, which basically
+ *  define something very similar to an `object`, although without their own JS
+ *  class.
+ *
+ *  --------------------------------------
+ *
+ *  (E) Desugar `x.isInstanceOf[C]` for nested JS classes
+ *
+ *  They are desugared into `js.special.instanceof(x, js.constructorOf[C])`.
+ *
+ *  --------------------------------------
+ *
+ *  (F) Desugar `js.constructorOf[C]`
+ *
+ *  Finally, this phase rewrites all calls to `js.constructorOf[C]`, including
+ *  the ones generated by the previous steps. The transformation depends on the
+ *  nature of `C`:
+ *
+ *  - If `C` is a statically accessible class, desugar to
+ *    `runtime.constructorOf(classOf[C])` so that the reified symbol survives
+ *    erasure and reaches the back-end.
+ *  - If `C` is an inner JS class, it must be of the form `path.D` for some
+ *    pair (`path`, `D`), and we desugar it to `path.D\$jsclass`, using the
+ *    field created by step (A) (it is an error if `C` is of the form
+ *    `Enclosing#D`).
+ *  - If `C` is a local JS class, desugar to `C\$jsclass`, using the local val
+ *    created by step (C).
+ */
+class ExplicitJSClasses extends MiniPhase with InfoTransformer { thisPhase =>
+  import ExplicitJSClasses._
+  import ast.tpd._
+
+  override def phaseName: String = ExplicitJSClasses.name
+
+  override def description: String = ExplicitJSClasses.description
+
+  private var MyState: Store.Location[MyState] = _
+  private def myState(using Context) = ctx.store(MyState)
+
+  override def initContext(ctx: FreshContext): Unit =
+    MyState = ctx.addLocation[MyState]()
+
+  override def isEnabled(using Context): Boolean =
+    ctx.settings.scalajs.value
+
+  override def runsAfter: Set[String] = Set(PatternMatcher.name, HoistSuperArgs.name)
+
+  override def changesMembers: Boolean = true // the phase adds fields for inner JS classes
+
+  /** Is the given symbol an owner that might receive `\$jsclass` and/or `\$jsobject` fields?
+   *
+   *  This applies if either or both of the following are true:
+   *  - It is not a static owner, or
+   *  - It is a non-native JS object.
+   *
+   *  The latter is necessary for scala-js/scala-js#4086.
+   */
+  private def mayNeedJSClassOrJSObjectFields(sym: Symbol)(using Context): Boolean = {
+    !sym.isStaticOwner
+      || (sym.is(ModuleClass) && sym.hasAnnotation(jsdefn.JSTypeAnnot) && !sym.hasAnnotation(jsdefn.JSNativeAnnot))
+  }
+
+  /** Is the given symbol a JS class (that is not a trait nor an object)? */
+  private def isJSClass(sym: Symbol)(using Context): Boolean = {
+    sym.isClass &&
+    !sym.isOneOf(Trait | Module) &&
+    sym.hasAnnotation(jsdefn.JSTypeAnnot)
+  }
+
+  /** Is the given symbol a Module that should be exposed? */
+  private def isExposedModule(sym: Symbol)(using Context): Boolean =
+    sym.is(Module) && sym.hasAnnotation(jsdefn.ExposedJSMemberAnnot)
+
+  /** Is the gen clazz an inner or local JS class? */
+  private def isInnerOrLocalJSClass(sym: Symbol)(using Context): Boolean =
+    isInnerJSClass(sym) || isLocalJSClass(sym)
+
+  /** Is the given clazz an inner JS class? */
+  private def isInnerJSClass(clazz: Symbol)(using Context): Boolean =
+    isInnerJSClassOrObject(clazz) && !isConsideredAnObject(clazz)
+
+  /** Is the given clazz a local JS class? */
+  private def isLocalJSClass(clazz: Symbol)(using Context): Boolean =
+    isLocalJSClassOrObject(clazz) && !isConsideredAnObject(clazz)
+
+  /** Is the gen clazz an inner or local JS class or object? */
+  private def isInnerOrLocalJSClassOrObject(sym: Symbol)(using Context): Boolean =
+    isInnerJSClassOrObject(sym) || isLocalJSClassOrObject(sym)
+
+  /** Is the given clazz an inner JS class or object? */
+  private def isInnerJSClassOrObject(clazz: Symbol)(using Context): Boolean = {
+    clazz.hasAnnotation(jsdefn.JSTypeAnnot)
+      && !clazz.isOneOf(PackageClass | Trait)
+      && !clazz.isStatic
+      && !clazz.isLocalToBlock
+  }
+
+  /** Is the given clazz a local JS class or object? */
+  private def isLocalJSClassOrObject(clazz: Symbol)(using Context): Boolean =
+    clazz.isLocalToBlock && !clazz.is(Trait) && clazz.hasAnnotation(jsdefn.JSTypeAnnot)
+
+  /** Is the given clazz an inner or local JS object? */
+  private def isInnerOrLocalJSObject(clazz: Symbol)(using Context): Boolean =
+    isInnerOrLocalJSClassOrObject(clazz) && isConsideredAnObject(clazz)
+
+  /** Is the given clazz considered to be an object for the purposes of this phase?
+   *  This is true for module classes and for anonymous JS classes.
+   */
+  private def isConsideredAnObject(clazz: Symbol)(using Context): Boolean =
+    clazz.is(ModuleClass) || clazz.isAnonymousClass
+
+  private def jsclassFieldName(clazzName: TypeName): TermName =
+    clazzName.toTermName ++ "$jsname"
+
+  private def jsclassAccessorFor(clazz: Symbol)(using Context): TermSymbol =
+    clazz.owner.info.decls.lookup(jsclassFieldName(clazz.name.asTypeName)).asTerm
+
+  private def jsobjectGetterName(moduleName: TermName): TermName =
+    moduleName ++ "$jsobject"
+
+  private def jsobjectGetterNameFor(moduleSym: Symbol)(using Context): TermName =
+    jsobjectGetterName(moduleSym.name.asTermName)
+
+  private def makeJSNameAnnotation(argument: String)(using Context): Annotation = {
+    val annotClass = jsdefn.JSNameAnnot
+    val stringCtor = annotClass.info.decl(nme.CONSTRUCTOR).suchThat { ctor =>
+      ctor.info match {
+        case mt: MethodType => mt.paramInfos.nonEmpty && mt.paramInfos.head.derivesFrom(defn.StringClass)
+        case _              => false
+      }
+    }.symbol.asTerm
+    Annotation(New(annotClass.typeRef, stringCtor, Literal(Constant(argument)) :: Nil))
+  }
+
+  override def transformInfo(tp: Type, sym: Symbol)(using Context): Type = tp match {
+    case tp @ ClassInfo(_, cls, _, decls, _) if !cls.is(JavaDefined) && mayNeedJSClassOrJSObjectFields(cls) =>
+      val innerJSClasses = decls.filter(isJSClass)
+
+      val innerObjectsForAdHocExposed =
+        if (!cls.isStaticOwner) Nil // those already have a module accessor
+        else decls.filter(isExposedModule)
+
+      if (innerJSClasses.isEmpty && innerObjectsForAdHocExposed.isEmpty) {
+        tp
+      } else {
+        def addAnnots(sym: Symbol, symForName: Symbol): Unit = {
+          val jsNameAnnot = symForName.getAnnotation(jsdefn.JSNameAnnot).getOrElse {
+            makeJSNameAnnotation(symForName.defaultJSName)
+          }
+          sym.addAnnotation(jsNameAnnot)
+          sym.addAnnotation(jsdefn.ExposedJSMemberAnnot)
+        }
+
+        val clsIsJSClass = cls.hasAnnotation(jsdefn.JSTypeAnnot)
+
+        val decls1 = decls.cloneScope
+
+        for (innerJSClass <- innerJSClasses) {
+          def addAnnotsIfInJSClass(sym: Symbol): Unit = {
+            if (clsIsJSClass)
+              addAnnots(sym, innerJSClass)
+          }
+
+          val fieldName = jsclassFieldName(innerJSClass.name.asTypeName)
+          val fieldFlags = SyntheticArtifact
+          val field = newSymbol(cls, fieldName, fieldFlags, defn.AnyRefType, coord = innerJSClass.coord)
+          addAnnotsIfInJSClass(field)
+          decls1.enter(field)
+        }
+
+        // scala-js/scala-js#4086 Create exposed getters for exposed objects in static JS objects
+        for (innerObject <- innerObjectsForAdHocExposed) {
+          assert(clsIsJSClass && cls.is(ModuleClass) && cls.isStatic,
+              i"trying to ad-hoc expose objects in non-JS static object ${cls.fullName}")
+
+          val getterName = jsobjectGetterNameFor(innerObject)
+          val getterFlags = Method | SyntheticArtifact
+          val getter = newSymbol(cls, getterName, getterFlags, ExprType(defn.AnyRefType), coord = innerObject.coord)
+          addAnnots(getter, innerObject)
+          decls1.enter(getter)
+        }
+
+        tp.derivedClassInfo(decls = decls1)
+      }
+
+    case _ =>
+      tp
+  }
+
+  /** Adjust the `NoInits` flag of Scala traits containing a JS class and of JS traits. */
+  override def transform(ref: SingleDenotation)(using Context): SingleDenotation = {
+    super.transform(ref) match {
+      case ref1: SymDenotation if ref1.is(Trait, butNot = JavaDefined) =>
+        val isJSType = ref1.hasAnnotation(jsdefn.JSTypeAnnot)
+        if (ref1.is(NoInits)) {
+          // If one of the decls is a JS class, there is now some initialization code to create the JS class
+          if (!isJSType && ref1.info.decls.exists(isJSClass))
+            ref1.copySymDenotation(initFlags = ref1.flags &~ NoInits)
+          else
+            ref1
+        } else {
+          // JS traits never have an initializer, no matter what dotc thinks
+          if (isJSType)
+            ref1.copySymDenotation(initFlags = ref1.flags | NoInits)
+          else
+            ref1
+        }
+      case ref1 =>
+        ref1
+    }
+  }
+
+  override def infoMayChange(sym: Symbol)(using Context): Boolean =
+    sym.isClass && !sym.is(JavaDefined)
+
+  override def prepareForUnit(tree: Tree)(using Context): Context =
+    ctx.fresh.updateStore(MyState, new MyState())
+
+  /** Populate `nestedObject2superTypeConstructor` for inner objects at the start of
+   *  a `Block` or `Template`, so that they are visible even before their
+   *  definition (in their enclosing scope).
+   */
+  private def populateNestedObject2superClassTpe(stats: List[Tree])(using Context): Unit = {
+    for (stat <- stats) {
+      stat match {
+        case cd @ TypeDef(_, rhs) if cd.isClassDef && isInnerOrLocalJSObject(cd.symbol) =>
+          myState.nestedObject2superTypeConstructor(cd.symbol) = extractSuperTypeConstructor(rhs)
+        case _ =>
+      }
+    }
+  }
+
+  override def prepareForBlock(tree: Block)(using Context): Context = {
+    populateNestedObject2superClassTpe(tree.stats)
+    ctx
+  }
+
+  override def prepareForTemplate(tree: Template)(using Context): Context = {
+    populateNestedObject2superClassTpe(tree.body)
+    ctx
+  }
+
+  // This method implements steps (A) and (B)
+  override def transformTemplate(tree: Template)(using Context): Tree = {
+    val cls = ctx.owner.asClass
+
+    /* The `parents` of a Template have the same trees as `new` invocations
+     * of the parent classes and traits. That means that `transformApply` may
+     * have wrapped them in a `withContextualJSClassValue`, not knowing where
+     * they belong in the larger tree.
+     * We now unwrap those, canceling out that effect.
+     * TODO Is there a better way to do this?
+     */
+    val fixedParents =
+      if (!cls.isJSType) tree.parents // fast path
+      else tree.parents.mapConserve(unwrapWithContextualJSClassValue(_))
+
+    if (!mayNeedJSClassOrJSObjectFields(cls)) {
+      if (fixedParents eq tree.parents) tree
+      else cpy.Template(tree)(parents = fixedParents)
+    } else {
+      val newStats = List.newBuilder[Tree]
+      for (stat <- tree.body) {
+        stat match {
+          case stat: TypeDef if stat.isClassDef && isJSClass(stat.symbol) =>
+            val innerClassSym = stat.symbol.asClass
+            val jsclassAccessor = jsclassAccessorFor(innerClassSym)
+
+            val rhs = if (cls.hasAnnotation(jsdefn.JSNativeAnnot)) {
+              ref(jsdefn.JSPackage_native)
+            } else {
+              val clazzValue = clsOf(innerClassSym.typeRef)
+              if (cls.isStaticOwner) {
+                // scala-js/scala-js#4086
+                ref(jsdefn.Runtime_constructorOf).appliedTo(clazzValue)
+              } else {
+                val parentTpe = extractSuperTypeConstructor(stat.rhs)
+                val superClassCtor = genJSConstructorOf(tree, parentTpe)
+                ref(jsdefn.Runtime_createInnerJSClass).appliedTo(clazzValue, superClassCtor)
+              }
+            }
+
+            newStats += ValDef(jsclassAccessor, rhs)
+
+          case stat: ValDef if cls.isStaticOwner && isExposedModule(stat.symbol) =>
+            // scala-js/scala-js#4086
+            val moduleSym = stat.symbol
+            val getter = cls.info.decls.lookup(jsobjectGetterNameFor(moduleSym)).asTerm
+            newStats += DefDef(getter, ref(moduleSym))
+
+          case _ =>
+            () // nothing to do
+        }
+
+        newStats += stat
+      }
+
+      cpy.Template(tree)(tree.constr, fixedParents, Nil, tree.self, newStats.result())
+    }
+  }
+
+  // This method, together with transformTypeDef, implements step (C)
+  override def prepareForTypeDef(tree: TypeDef)(using Context): Context = {
+    val sym = tree.symbol
+    if (sym.isClass && isLocalJSClass(sym)) {
+      val jsclassValName = LocalJSClassValueName.fresh(sym.name.toTermName)
+      val jsclassVal = newSymbol(ctx.owner, jsclassValName, EmptyFlags, defn.AnyRefType, coord = tree.span)
+      myState.localClass2jsclassVal(sym) = jsclassVal
+      myState.notYetReferencedLocalClasses += sym
+    }
+    ctx
+  }
+
+  // This method, together with prepareForTypeDef, implements step (C)
+  override def transformTypeDef(tree: TypeDef)(using Context): Tree = {
+    val sym = tree.symbol
+    if (sym.isClass && isLocalJSClass(sym)) {
+      val cls = sym.asClass
+
+      val rhs = {
+        val typeRef = tree.tpe
+        val clazzValue = clsOf(typeRef)
+        val superClassCtor = genJSConstructorOf(tree, extractSuperTypeConstructor(tree.rhs))
+        ref(jsdefn.Runtime_createLocalJSClass).appliedTo(clazzValue, superClassCtor, ref(defn.Predef_undefined))
+      }
+
+      val jsclassVal = myState.localClass2jsclassVal(sym)
+      if (myState.notYetReferencedLocalClasses.remove(cls)) {
+        Thicket(List(tree, ValDef(jsclassVal, rhs)))
+      } else {
+        /* We are using `jsclassVal` inside the definition of the class.
+         * We need to declare it as var before and initialize it after the class definition.
+         */
+        jsclassVal.setFlag(Mutable)
+        Thicket(List(
+            ValDef(jsclassVal, Literal(Constant(null))),
+            tree,
+            Assign(ref(jsclassVal), rhs)
+        ))
+      }
+    } else {
+      tree
+    }
+  }
+
+  // This method, together with transformTypeApply and transformSelect, implements step (E)
+  override def transformApply(tree: Apply)(using Context): Tree = {
+    if (!isFullyApplied(tree)) {
+      tree
+    } else {
+      val sym = tree.symbol
+
+      if (sym.isConstructor) {
+        /* Wrap `new`s to inner and local JS classes and objects with
+         * `withContextualJSClassValue`, to preserve a reified reference to
+         * the necessary JS class value (the class itself for classes, or the
+         * super class for objects).
+         */
+        val cls = sym.owner
+        if (isInnerOrLocalJSClassOrObject(cls)) {
+          if (!isConsideredAnObject(cls)) {
+            methPart(tree) match {
+              case Select(n @ New(tpt), _) =>
+                val jsclassValue = genJSConstructorOf(tpt, n.tpe)
+                wrapWithContextualJSClassValue(jsclassValue)(tree)
+              case _ =>
+                // Super constructor call or this()-constructor call
+                tree
+            }
+          } else {
+            wrapWithContextualJSClassValue(myState.nestedObject2superTypeConstructor(cls))(tree)
+          }
+        } else {
+          tree
+        }
+      } else {
+        maybeWrapSuperCallWithContextualJSClassValue(tree)
+      }
+    }
+  }
+
+  // This method, together with transformApply and transformSelect, implements step (E)
+  // It also implements step (D) and (F)
+  override def transformTypeApply(tree: TypeApply)(using Context): Tree = {
+    if (!isFullyApplied(tree)) {
+      tree
+    } else {
+      val sym = tree.symbol
+
+      def isTypeTreeForInnerOrLocalJSClass(tpeArg: Tree): Boolean = {
+        val tpeSym = tpeArg.tpe.typeSymbol
+        tpeSym.exists && isInnerOrLocalJSClass(tpeSym)
+      }
+
+      tree match {
+        // Desugar js.constructorOf[T]
+        case TypeApply(fun, tpt :: Nil) if sym == jsdefn.JSPackage_constructorOf =>
+          genJSConstructorOf(tree, tpt.tpe).cast(jsdefn.JSDynamicType)
+
+        // Translate x.isInstanceOf[T] for inner and local JS classes
+        case TypeApply(fun @ Select(obj, _), tpeArg :: Nil)
+            if sym == defn.Any_isInstanceOf && isTypeTreeForInnerOrLocalJSClass(tpeArg) =>
+          val jsCtorOf = genJSConstructorOf(tree, tpeArg.tpe)
+          ref(jsdefn.Special_instanceof).appliedTo(obj, jsCtorOf)
+
+        case _ =>
+          maybeWrapSuperCallWithContextualJSClassValue(tree)
+      }
+    }
+  }
+
+  // This method, together with transformApply and transformTypeApply, implements step (E)
+  override def transformSelect(tree: Select)(using Context): Tree = {
+    if (!isFullyApplied(tree)) {
+      tree
+    } else {
+      maybeWrapSuperCallWithContextualJSClassValue(tree)
+    }
+  }
+
+  /** Tests whether this tree is fully applied, i.e., it does not need any
+   *  additional `TypeApply` or `Apply` to lead to a value.
+   *
+   *  In this phase, `transformApply`, `transformTypeApply` and `transformSelect`
+   *  must only operate on fully applied selections and applications.
+   */
+  private def isFullyApplied(tree: Tree)(using Context): Boolean =
+    !tree.tpe.widenTermRefExpr.isInstanceOf[MethodOrPoly]
+
+  /** Wraps `super` calls to inner and local JS classes with
+   *  `withContextualJSClassValue`, to preserve a reified reference to the
+   *  necessary JS class value (that of the super class).
+   */
+  private def maybeWrapSuperCallWithContextualJSClassValue(tree: Tree)(using Context): Tree = {
+    methPart(tree) match {
+      case Select(sup: Super, _) if isInnerOrLocalJSClass(sup.symbol.asClass.superClass) =>
+        wrapWithContextualJSClassValue(sup.symbol.asClass.superClass.typeRef)(tree)
+      case _ =>
+        tree
+    }
+  }
+
+  /** Generates the desugared version of `js.constructorOf[tpe]`.
+   *
+   *  This is the meat of step (F).
+   */
+  private def genJSConstructorOf(tree: Tree, tpe0: Type)(using Context): Tree = {
+    val tpe = tpe0.underlyingClassRef(refinementOK = false) match {
+      case typeRef: TypeRef => typeRef
+      case _ =>
+        // This should not have passed the checks in PrepJSInterop
+        report.error(i"class type required but found $tpe0", tree)
+        jsdefn.JSObjectType
+    }
+    val cls = tpe.typeSymbol
+
+    // This should not have passed the checks in PrepJSInterop
+    assert(!cls.isOneOf(Trait | ModuleClass),
+        i"non-trait class type required but $tpe found for genJSConstructorOf at ${tree.sourcePos}")
+
+    if (isInnerJSClass(cls)) {
+      // Use the $jsclass field in the outer instance
+      val prefix: Type = tpe.prefix
+      if (prefix.isStable) {
+        val jsclassAccessor = jsclassAccessorFor(cls)
+        ref(NamedType(prefix, jsclassAccessor.name, jsclassAccessor.denot))
+      } else {
+        report.error(i"stable reference to a JS class required but $tpe found", tree)
+        ref(defn.Predef_undefined)
+      }
+    } else if (isLocalJSClass(cls)) {
+      // Use the local `val` that stores the JS class value
+      val state = myState
+      val jsclassVal = state.localClass2jsclassVal(cls)
+      state.notYetReferencedLocalClasses -= cls
+      ref(jsclassVal)
+    } else {
+      // Defer translation to `LoadJSConstructor` to the back-end
+      ref(jsdefn.Runtime_constructorOf).appliedTo(clsOf(tpe))
+    }
+  }
+
+  private def wrapWithContextualJSClassValue(jsClassType: Type)(tree: Tree)(using Context): Tree =
+    wrapWithContextualJSClassValue(genJSConstructorOf(tree, jsClassType))(tree)
+
+  private def wrapWithContextualJSClassValue(jsClassValue: Tree)(tree: Tree)(using Context): Tree =
+    ref(jsdefn.Runtime_withContextualJSClassValue).appliedToType(tree.tpe).appliedTo(jsClassValue, tree)
+
+  private def unwrapWithContextualJSClassValue(tree: Tree)(using Context): Tree = tree match {
+    case Apply(fun, jsClassValue :: actualTree :: Nil)
+        if fun.symbol == jsdefn.Runtime_withContextualJSClassValue =>
+      actualTree
+    case _ =>
+      tree
+  }
+
+  /** Extracts the super type constructor of a `Template`, without type
+   *  parameters, so that the type is well-formed outside of the `Template`,
+   *  i.e., at the same level where the corresponding `TypeDef` is defined.
+   *
+   *  For example, for the Template of a class definition like
+   *  {{{
+   *  class Foo[...Ts] extends pre.Parent[...Us](...args) with ... { ... }
+   *  }}}
+   *  we extract the type constructor `pre.Parent`, without its type
+   *  parameters.
+   *
+   *  Since the result is not necessarily *-kinded, its applicability is
+   *  limited. It seems to be sufficient to put in a `classOf`, though, which
+   *  is what we care about.
+   */
+  private def extractSuperTypeConstructor(typeDefRhs: Tree)(using Context): Type =
+    typeDefRhs.asInstanceOf[Template].parents.head.tpe.dealias.typeConstructor
+}
+
+object ExplicitJSClasses {
+  val name: String = "explicitJSClasses"
+  val description: String = "make all JS classes explicit"
+
+  val LocalJSClassValueName: UniqueNameKind = new UniqueNameKind("$jsclass")
+
+  private final class MyState {
+    val nestedObject2superTypeConstructor:  MutableSymbolMap[Type] = new MutableSymbolMap[Type]
+    val localClass2jsclassVal: MutableSymbolMap[TermSymbol] = new MutableSymbolMap[TermSymbol]
+    val notYetReferencedLocalClasses: util.HashSet[Symbol] = new util.HashSet[Symbol]
+      // !cc! type ascriptions needed for 3 vals above, otherwise they get strange inferred types
+  }
+}
diff --git a/tests/pos-with-compiler-cc/dotc/transform/sjs/JSExportUtils.scala b/tests/pos-with-compiler-cc/dotc/transform/sjs/JSExportUtils.scala
new file mode 100644
index 000000000000..9abf9a919d6d
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/transform/sjs/JSExportUtils.scala
@@ -0,0 +1,38 @@
+package dotty.tools.dotc
+package transform
+package sjs
+
+import scala.language.unsafeNulls
+
+import core._
+import NameKinds.DefaultGetterName
+import Names._
+
+
+/** Utilities for JS exports handling. */
+object JSExportUtils {
+  private inline val ExportPrefix = "$js$exported$"
+  private inline val MethodExportPrefix = ExportPrefix + "meth$"
+  private inline val PropExportPrefix = ExportPrefix + "prop$"
+
+  /** Creates a name for an export specification. */
+  def makeExportName(jsName: String, isProp: Boolean): TermName = {
+    val prefix = if (isProp) PropExportPrefix else MethodExportPrefix
+    termName(prefix + jsName)
+  }
+
+  /** Is this symbol an export forwarder? */
+  def isExportName(name: Name): Boolean =
+    name.startsWith(ExportPrefix) && !name.is(DefaultGetterName)
+
+  /** Retrieves the originally assigned jsName of this export and whether it is a property. */
+  def exportNameInfo(name: Name): (String, Boolean) = {
+    val nameString = name.toString()
+    if (nameString.startsWith(MethodExportPrefix))
+      (nameString.substring(MethodExportPrefix.length), false)
+    else if (nameString.startsWith(PropExportPrefix))
+      (nameString.substring(PropExportPrefix.length), true)
+    else
+      throw new IllegalArgumentException(s"non-exported name passed to jsExportInfo: $name")
+  }
+}
diff --git a/tests/pos-with-compiler-cc/dotc/transform/sjs/JSSymUtils.scala b/tests/pos-with-compiler-cc/dotc/transform/sjs/JSSymUtils.scala
new file mode 100644
index 000000000000..30eed76b18ec
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/transform/sjs/JSSymUtils.scala
@@ -0,0 +1,255 @@
+package dotty.tools.dotc
+package transform
+package sjs
+
+import core._
+import Constants._
+import Contexts._
+import Flags._
+import NameOps._
+import Names._
+import Phases._
+import StdNames._
+import Symbols._
+import SymUtils._
+import ast.Trees._
+import Types._
+
+import dotty.tools.backend.sjs.JSDefinitions.jsdefn
+
+import org.scalajs.ir.{Trees => js}
+
+/** Additional extensions for `Symbol`s that are only relevant for Scala.js. */
+object JSSymUtils {
+  /** The result type for `sym.jsName`.
+   *
+   *  It is either a literal string, or a computed name represented by a reference
+   *  to a static `Symbol` (a `dotc.core.Symbols.Symbol`, not a `js.Symbol`).
+   */
+  enum JSName {
+    case Literal(name: String)
+    case Computed(sym: Symbol)
+
+    def displayName(using Context): String = this match {
+      case Literal(name) => name
+      case Computed(sym) => sym.fullName.toString()
+    }
+  }
+
+  enum JSCallingConvention {
+    case Call, BracketAccess, BracketCall
+    case Method(name: JSName)
+    case Property(name: JSName)
+    case UnaryOp(code: js.JSUnaryOp.Code)
+    case BinaryOp(code: js.JSBinaryOp.Code)
+
+    def displayName(using Context): String = this match {
+      case Call           => "function application"
+      case BracketAccess  => "bracket access"
+      case BracketCall    => "bracket call"
+      case Method(name)   => "method '" + name.displayName + "'"
+      case Property(name) => "property '" + name.displayName + "'"
+      case UnaryOp(code)  => "unary operator"
+      case BinaryOp(code) => "binary operator"
+    }
+  }
+
+  object JSCallingConvention {
+    def of(sym: Symbol)(using Context): JSCallingConvention = {
+      assert(sym.isTerm, s"got non-term symbol: $sym")
+
+      if (isJSBracketAccess(sym)) {
+        BracketAccess
+      } else if (isJSBracketCall(sym)) {
+        BracketCall
+      } else {
+        def default = {
+          val jsName = sym.jsName
+          if (sym.isJSProperty) Property(jsName)
+          else Method(jsName)
+        }
+
+        if (!sym.hasAnnotation(jsdefn.JSNameAnnot)) {
+          lazy val pc = sym.info.paramNamess.map(_.size).sum
+
+          sym.name match {
+            case nme.apply                             => Call
+            case JSUnaryOpMethodName(code) if pc == 0  => UnaryOp(code)
+            case JSBinaryOpMethodName(code) if pc == 1 => BinaryOp(code)
+            case _                                     => default
+          }
+        } else {
+          default
+        }
+      }
+    }
+  }
+
+  /** Info about a Scala method param when called as JS method.
+   *
+   *  @param info
+   *    Parameter type (type of a single element if repeated).
+   *  @param repeated
+   *    Whether the parameter is repeated.
+   *  @param capture
+   *    Whether the parameter is a capture.
+   */
+  final class JSParamInfo(
+    val info: Type,
+    val repeated: Boolean = false,
+    val capture: Boolean = false
+  ) {
+    override def toString(): String =
+      s"ParamSpec($info, repeated = $repeated, capture = $capture)"
+  }
+
+  extension (sym: Symbol) {
+    /** Is this symbol a JavaScript type? */
+    def isJSType(using Context): Boolean =
+      sym.hasAnnotation(jsdefn.JSTypeAnnot)
+
+    /** Is this symbol a non-native JS class? */
+    def isNonNativeJSClass(using Context): Boolean =
+      sym.isJSType && !sym.hasAnnotation(jsdefn.JSNativeAnnot)
+
+    /** Is this symbol a nested JS class, i.e., an inner or local JS class? */
+    def isNestedJSClass(using Context): Boolean =
+      !sym.isStatic && sym.isJSType
+
+    /** Tests whether the given member is exposed, i.e., whether it was
+     *  originally a public or protected member of a non-native JS class.
+     */
+    def isJSExposed(using Context): Boolean = {
+      !sym.is(Bridge) && {
+        sym.hasAnnotation(jsdefn.ExposedJSMemberAnnot)
+          || (sym.is(Accessor) && sym.field.hasAnnotation(jsdefn.ExposedJSMemberAnnot))
+      }
+    }
+
+    /** Should this symbol be translated into a JS getter? */
+    def isJSGetter(using Context): Boolean = {
+      sym.is(Module)
+        || !sym.is(Method)
+        || (sym.info.firstParamTypes.isEmpty && atPhaseNoLater(erasurePhase)(sym.info.isParameterless))
+    }
+
+    /** Should this symbol be translated into a JS setter? */
+    def isJSSetter(using Context): Boolean =
+      sym.originalName.isSetterName && sym.is(Method)
+
+    /** Is this symbol a JS getter or setter? */
+    def isJSProperty(using Context): Boolean =
+      sym.isJSGetter || sym.isJSSetter
+
+    /** Should this symbol be translated into a JS bracket access? */
+    def isJSBracketAccess(using Context): Boolean =
+      sym.hasAnnotation(jsdefn.JSBracketAccessAnnot)
+
+    /** Should this symbol be translated into a JS bracket call? */
+    def isJSBracketCall(using Context): Boolean =
+      sym.hasAnnotation(jsdefn.JSBracketCallAnnot)
+
+    def jsCallingConvention(using Context): JSCallingConvention =
+      JSCallingConvention.of(sym)
+
+    def hasJSCallCallingConvention(using Context): Boolean =
+      sym.jsCallingConvention == JSCallingConvention.Call
+
+    /** Gets the unqualified JS name of the symbol.
+     *
+     *  If it is not explicitly specified with an `@JSName` annotation, the
+     *  JS name is inferred from the Scala name.
+     */
+    def jsName(using Context): JSName = {
+      sym.getAnnotation(jsdefn.JSNameAnnot).fold[JSName] {
+        JSName.Literal(defaultJSName)
+      } { annotation =>
+        annotation.arguments.head match {
+          case Literal(Constant(name: String)) => JSName.Literal(name)
+          case tree                            => JSName.Computed(tree.symbol)
+        }
+      }
+    }
+
+    def defaultJSName(using Context): String =
+      if (sym.isTerm) sym.asTerm.name.unexpandedName.getterName.toString()
+      else sym.name.unexpandedName.stripModuleClassSuffix.toString()
+
+    def jsParamInfos(using Context): List[JSParamInfo] = {
+      assert(sym.is(Method), s"trying to take JS param info of non-method: $sym")
+
+      def paramNamesAndTypes(using Context): List[(Names.TermName, Type)] =
+        sym.info.paramNamess.flatten.zip(sym.info.paramInfoss.flatten)
+
+      val paramInfosAtElimRepeated = atPhase(elimRepeatedPhase) {
+        val list =
+          for ((name, info) <- paramNamesAndTypes) yield {
+            val v =
+              if (info.isRepeatedParam) Some(info.repeatedToSingle.widenDealias)
+              else None
+            name -> v
+          }
+        list.toMap
+      }
+
+      val paramInfosAtElimEVT = atPhase(elimErasedValueTypePhase) {
+        paramNamesAndTypes.toMap
+      }
+
+      for ((paramName, paramInfoNow) <- paramNamesAndTypes) yield {
+        paramInfosAtElimRepeated.get(paramName) match {
+          case None =>
+            // This is a capture parameter introduced by erasure or lambdalift
+            new JSParamInfo(paramInfoNow, capture = true)
+
+          case Some(Some(info)) =>
+            new JSParamInfo(info, repeated = true)
+
+          case Some(None) =>
+            val info = paramInfosAtElimEVT.getOrElse(paramName, paramInfoNow)
+            new JSParamInfo(info)
+        }
+      }
+    }
+  }
+
+  private object JSUnaryOpMethodName {
+    private val map = Map(
+      nme.UNARY_+ -> js.JSUnaryOp.+,
+      nme.UNARY_- -> js.JSUnaryOp.-,
+      nme.UNARY_~ -> js.JSUnaryOp.~,
+      nme.UNARY_! -> js.JSUnaryOp.!
+    )
+
+    def unapply(name: TermName): Option[js.JSUnaryOp.Code] =
+      map.get(name)
+  }
+
+  private object JSBinaryOpMethodName {
+    private val map = Map(
+      nme.ADD -> js.JSBinaryOp.+,
+      nme.SUB -> js.JSBinaryOp.-,
+      nme.MUL -> js.JSBinaryOp.*,
+      nme.DIV -> js.JSBinaryOp./,
+      nme.MOD -> js.JSBinaryOp.%,
+
+      nme.LSL -> js.JSBinaryOp.<<,
+      nme.ASR -> js.JSBinaryOp.>>,
+      nme.LSR -> js.JSBinaryOp.>>>,
+      nme.OR  -> js.JSBinaryOp.|,
+      nme.AND -> js.JSBinaryOp.&,
+      nme.XOR -> js.JSBinaryOp.^,
+
+      nme.LT -> js.JSBinaryOp.<,
+      nme.LE -> js.JSBinaryOp.<=,
+      nme.GT -> js.JSBinaryOp.>,
+      nme.GE -> js.JSBinaryOp.>=,
+
+      nme.ZAND -> js.JSBinaryOp.&&,
+      nme.ZOR  -> js.JSBinaryOp.||
+    )
+
+    def unapply(name: TermName): Option[js.JSBinaryOp.Code] =
+      map.get(name)
+  }
+}
diff --git a/tests/pos-with-compiler-cc/dotc/transform/sjs/JUnitBootstrappers.scala b/tests/pos-with-compiler-cc/dotc/transform/sjs/JUnitBootstrappers.scala
new file mode 100644
index 000000000000..817a6c5afabc
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/transform/sjs/JUnitBootstrappers.scala
@@ -0,0 +1,331 @@
+package dotty.tools.dotc
+package transform
+package sjs
+
+import scala.annotation.tailrec
+
+import dotty.tools.dotc.core._
+import Constants._
+import Contexts._
+import Flags._
+import Names._
+import Scopes._
+import Symbols._
+import StdNames._
+import Types._
+
+import dotty.tools.dotc.transform.MegaPhase._
+
+import dotty.tools.backend.sjs.JSDefinitions.jsdefn
+
+/** Generates JUnit bootstrapper objects for Scala.js.
+ *
+ *  On the JVM, JUnit uses run-time reflection to list and invoke JUnit-related
+ *  methods. They are identified by annotations such as `@Test`, `@Before`,
+ *  etc. In Scala.js, there is no such reflection for methods and annotations,
+ *  so a different strategy is used: this phase performs the necessary
+ *  inspections at compile-time, and generates a so-called bootstrapper object
+ *  where all those metadata have been reified.
+ *
+ *  With an example: given the following JUnit test class:
+ *
+ *  ```
+ *  class MyTest {
+ *    @Before def myBefore(): Unit = ...
+ *    @Before def otherBefore(): Unit = ...
+ *
+ *    @Test def syncTest(): Unit = ...
+ *    @Test def asyncTest(): Future[Try[Unit]] = ...
+ *
+ *    @Ignore @Test def ignoredTest(): Unit = ...
+ *  }
+ *
+ *  object MyTest {
+ *    @AfterClass def myAfterClass(): Unit = ...
+ *  }
+ *  ```
+ *
+ *  this phase generates the following bootstrapper module class:
+ *
+ *  ```
+ *  object MyTest$scalajs$junit$bootstrapper extends Object with Bootstrapper {
+ *    def beforeClass(): Unit = {
+ *      // nothing, since there is no @BeforeClass method in object MyTest
+ *    }
+ *
+ *    def afterClass(): Unit = {
+ *      MyTest.myAfterClass()
+ *    }
+ *
+ *    def before(instance: Object): Unit = {
+ *      // typically 0 or 1, but also support 2 or more
+ *      instance.asInstanceOf[MyTest].myBefore()
+ *      instance.asInstanceOf[MyTest].otherBefore()
+ *    }
+ *
+ *    def after(instance: Object): Unit = {
+ *      // nothing, since there is no @After method in class MyTest
+ *    }
+ *
+ *    def tests(): Array[TestMetadata] = Array(
+ *      new TestMetadata("syncTest", false, new org.junit.Test()),
+ *      new TestMetadata("asyncTest", false, new org.junit.Test()),
+ *      new TestMetadata("ignoredTest", true, new org.junit.Test()),
+ *    )
+ *
+ *    def invokeTest(instance: Object, name: String): Future[Unit] = {
+ *      val castInstance: MyTest = instance.asInstanceOf[MyTest]
+ *      if ("syncTest".equals(name))
+ *        Future.successful(scala.util.Success(castInstance.syncTest()))
+ *      else if ("asyncTest".equals(name))
+ *        castInstance.asyncTest() // asyncTest() already returns a Future[Try[Unit]]
+ *      else if ("ignoredTest".equals(name))
+ *        Future.successful(scala.util.Success(castInstance.ignoredTest()))
+ *      else
+ *        throw new NoSuchMethodException(name)
+ *    }
+ *
+ *    def newInstance(): Object = new MyTest()
+ *  }
+ *  ```
+ *
+ *  Note that the support for test methods returning `Future`s is specific to
+ *  Scala.js, and not advertised as a public feature. It is necessary to test
+ *  some things in Scala.js itself, but outside users should use a testing
+ *  framework with official asynchronous support instead.
+ *
+ *  Because `Booststrapper` is annotated with `@EnableReflectiveInstantiation`,
+ *  the run-time implementation of JUnit for Scala.js can load the bootstrapper
+ *  module using `scala.scalajs.reflect.Reflect`, and then use the methods of
+ *  Bootstrapper, which are implemented in the bootstrapper object, to perform
+ *  test discovery and invocation.
+ *
+ *  TODO At the moment, this phase does not handle `@Test` annotations with
+ *  parameters, notably the expected exception class. This should be handled at
+ *  some point in the future.
+ */
+class JUnitBootstrappers extends MiniPhase {
+  import JUnitBootstrappers._
+  import ast.tpd._
+
+  override def phaseName: String = JUnitBootstrappers.name
+
+  override def description: String = JUnitBootstrappers.description
+
+  override def isEnabled(using Context): Boolean =
+    super.isEnabled && ctx.settings.scalajs.value
+
+  // The actual transform -------------------------------
+
+  override def transformPackageDef(tree: PackageDef)(using Context): Tree = {
+    val junitdefn = jsdefn.junit
+
+    @tailrec
+    def hasTests(sym: ClassSymbol): Boolean = {
+      sym.info.decls.exists(m => m.is(Method) && m.hasAnnotation(junitdefn.TestAnnotClass)) ||
+      sym.superClass.exists && hasTests(sym.superClass.asClass)
+    }
+
+    def isTestClass(sym: Symbol): Boolean = {
+      sym.isClass &&
+      !sym.isOneOf(ModuleClass | Abstract | Trait) &&
+      hasTests(sym.asClass)
+    }
+
+    val bootstrappers = tree.stats.collect {
+      case clDef: TypeDef if isTestClass(clDef.symbol) =>
+        genBootstrapper(clDef.symbol.asClass)
+    }
+
+    if (bootstrappers.isEmpty) tree
+    else cpy.PackageDef(tree)(tree.pid, tree.stats ::: bootstrappers)
+  }
+
+  private def genBootstrapper(testClass: ClassSymbol)(using Context): TypeDef = {
+    val junitdefn = jsdefn.junit
+
+    /* The name of the bootstrapper module. It is derived from the test class name by
+     * appending a specific suffix string mandated "by spec". It will indeed also be
+     * computed as such at run-time by the Scala.js JUnit Runtime support. Therefore,
+     * it must *not* be a dotc semantic name.
+     */
+    val bootstrapperName = (testClass.name ++ "$scalajs$junit$bootstrapper").toTermName
+
+    val owner = testClass.owner
+    val moduleSym = newCompleteModuleSymbol(owner, bootstrapperName,
+      Synthetic, Synthetic,
+      List(defn.ObjectType, junitdefn.BootstrapperType), newScope,
+      coord = testClass.span, assocFile = testClass.assocFile).entered
+    val classSym = moduleSym.moduleClass.asClass
+
+    val constr = genConstructor(classSym)
+
+    val testMethods = annotatedMethods(testClass, junitdefn.TestAnnotClass)
+
+    val defs = List(
+      genCallOnModule(classSym, junitNme.beforeClass, testClass.companionModule, junitdefn.BeforeClassAnnotClass),
+      genCallOnModule(classSym, junitNme.afterClass, testClass.companionModule, junitdefn.AfterClassAnnotClass),
+      genCallOnParam(classSym, junitNme.before, testClass, junitdefn.BeforeAnnotClass),
+      genCallOnParam(classSym, junitNme.after, testClass, junitdefn.AfterAnnotClass),
+      genTests(classSym, testMethods),
+      genInvokeTest(classSym, testClass, testMethods),
+      genNewInstance(classSym, testClass)
+    )
+
+    sbt.APIUtils.registerDummyClass(classSym)
+
+    ClassDef(classSym, constr, defs)
+  }
+
+  private def genConstructor(owner: ClassSymbol)(using Context): DefDef = {
+    val sym = newDefaultConstructor(owner).entered
+    DefDef(sym, {
+      Block(
+        Super(This(owner), tpnme.EMPTY).select(defn.ObjectClass.primaryConstructor).appliedToNone :: Nil,
+        unitLiteral
+      )
+    })
+  }
+
+  private def genCallOnModule(owner: ClassSymbol, name: TermName, module: Symbol, annot: Symbol)(using Context): DefDef = {
+    val sym = newSymbol(owner, name, Synthetic | Method,
+      MethodType(Nil, Nil, defn.UnitType)).entered
+
+    DefDef(sym, {
+      if (module.exists) {
+        val calls = annotatedMethods(module.moduleClass.asClass, annot)
+          .map(m => Apply(ref(module).select(m), Nil))
+        Block(calls, unitLiteral)
+      } else {
+        unitLiteral
+      }
+    })
+  }
+
+  private def genCallOnParam(owner: ClassSymbol, name: TermName, testClass: ClassSymbol, annot: Symbol)(using Context): DefDef = {
+    val sym = newSymbol(owner, name, Synthetic | Method,
+      MethodType(junitNme.instance :: Nil, defn.ObjectType :: Nil, defn.UnitType)).entered
+
+    DefDef(sym, { (paramRefss: List[List[Tree]]) =>
+      val List(List(instanceParamRef)) = paramRefss
+      val calls = annotatedMethods(testClass, annot)
+        .map(m => Apply(instanceParamRef.cast(testClass.typeRef).select(m), Nil))
+      Block(calls, unitLiteral)
+    })
+  }
+
+  private def genTests(owner: ClassSymbol, tests: List[Symbol])(using Context): DefDef = {
+    val junitdefn = jsdefn.junit
+
+    val sym = newSymbol(owner, junitNme.tests, Synthetic | Method,
+      MethodType(Nil, defn.ArrayOf(junitdefn.TestMetadataType))).entered
+
+    DefDef(sym, {
+      val metadata = for (test <- tests) yield {
+        val name = Literal(Constant(test.name.mangledString))
+        val ignored = Literal(Constant(test.hasAnnotation(junitdefn.IgnoreAnnotClass)))
+        val testAnnot = test.getAnnotation(junitdefn.TestAnnotClass).get
+
+        val mappedArguments = testAnnot.arguments.flatMap{
+          // Since classOf[...] in annotations would not be transformed, grab the resulting class constant here
+          case NamedArg(expectedName: SimpleName, TypeApply(Ident(nme.classOf), fstArg :: _))
+            if expectedName.toString == "expected" => Some(clsOf(fstArg.tpe))
+          // The only other valid argument to @Test annotations is timeout
+          case NamedArg(timeoutName: TermName, timeoutLiteral: Literal)
+            if timeoutName.toString == "timeout" => Some(timeoutLiteral)
+          case other => {
+            val shownName = other match {
+              case NamedArg(name, _) => name.show(using ctx)
+              case other => other.show(using ctx)
+            }
+            report.error(s"$shownName is an unsupported argument for the JUnit @Test annotation in this position", other.sourcePos)
+            None
+          }
+        }
+
+        val reifiedAnnot = resolveConstructor(junitdefn.TestAnnotType, mappedArguments)
+        New(junitdefn.TestMetadataType, List(name, ignored, reifiedAnnot))
+      }
+      JavaSeqLiteral(metadata, TypeTree(junitdefn.TestMetadataType))
+    })
+  }
+
+  private def genInvokeTest(owner: ClassSymbol, testClass: ClassSymbol, tests: List[Symbol])(using Context): DefDef = {
+    val junitdefn = jsdefn.junit
+
+    val sym = newSymbol(owner, junitNme.invokeTest, Synthetic | Method,
+      MethodType(List(junitNme.instance, junitNme.name), List(defn.ObjectType, defn.StringType), junitdefn.FutureType)).entered
+
+    DefDef(sym, { (paramRefss: List[List[Tree]]) =>
+      val List(List(instanceParamRef, nameParamRef)) = paramRefss
+      val castInstanceSym = newSymbol(sym, junitNme.castInstance, Synthetic, testClass.typeRef, coord = owner.span)
+      Block(
+        ValDef(castInstanceSym, instanceParamRef.cast(testClass.typeRef)) :: Nil,
+        tests.foldRight[Tree] {
+          val tp = junitdefn.NoSuchMethodExceptionType
+          Throw(resolveConstructor(tp, nameParamRef :: Nil))
+        } { (test, next) =>
+          If(Literal(Constant(test.name.mangledString)).select(defn.Any_equals).appliedTo(nameParamRef),
+            genTestInvocation(testClass, test, ref(castInstanceSym)),
+            next)
+        }
+      )
+    })
+  }
+
+  private def genTestInvocation(testClass: ClassSymbol, testMethod: Symbol, instance: Tree)(using Context): Tree = {
+    val junitdefn = jsdefn.junit
+
+    val resultType = testMethod.info.resultType
+    if (resultType.isRef(defn.UnitClass)) {
+      val newSuccess = ref(junitdefn.SuccessModule_apply).appliedTo(ref(defn.BoxedUnit_UNIT))
+      Block(
+        instance.select(testMethod).appliedToNone :: Nil,
+        ref(junitdefn.FutureModule_successful).appliedTo(newSuccess)
+      )
+    } else if (resultType.isRef(junitdefn.FutureClass)) {
+      instance.select(testMethod).appliedToNone
+    } else {
+      // We lie in the error message to not expose that we support async testing.
+      report.error("JUnit test must have Unit return type", testMethod.sourcePos)
+      EmptyTree
+    }
+  }
+
+  private def genNewInstance(owner: ClassSymbol, testClass: ClassSymbol)(using Context): DefDef = {
+    val sym = newSymbol(owner, junitNme.newInstance, Synthetic | Method,
+      MethodType(Nil, defn.ObjectType)).entered
+
+    DefDef(sym, New(testClass.typeRef, Nil))
+  }
+
+  private def castParam(param: Symbol, clazz: Symbol)(using Context): Tree =
+    ref(param).cast(clazz.typeRef)
+
+  private def annotatedMethods(owner: ClassSymbol, annot: Symbol)(using Context): List[Symbol] =
+    owner.info
+      .membersBasedOnFlags(Method, EmptyFlags)
+      .filter(_.symbol.hasAnnotation(annot))
+      .map(_.symbol)
+      .toList
+}
+
+object JUnitBootstrappers {
+  val name: String = "junitBootstrappers"
+  val description: String = "generate JUnit-specific bootstrapper classes for Scala.js"
+
+  private object junitNme {
+    val beforeClass: TermName = termName("beforeClass")
+    val afterClass: TermName = termName("afterClass")
+    val before: TermName = termName("before")
+    val after: TermName = termName("after")
+    val tests: TermName = termName("tests")
+    val invokeTest: TermName = termName("invokeTest")
+    val newInstance: TermName = termName("newInstance")
+
+    val instance: TermName = termName("instance")
+    val name: TermName = termName("name")
+    val castInstance: TermName = termName("castInstance")
+  }
+
+}
diff --git a/tests/pos-with-compiler-cc/dotc/transform/sjs/PrepJSExports.scala b/tests/pos-with-compiler-cc/dotc/transform/sjs/PrepJSExports.scala
new file mode 100644
index 000000000000..b0de197635e9
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/transform/sjs/PrepJSExports.scala
@@ -0,0 +1,467 @@
+package dotty.tools.dotc
+package transform
+package sjs
+
+import dotty.tools.dotc.ast.tpd
+import dotty.tools.dotc.core._
+import Contexts._
+import Decorators._
+import Denotations._
+import Flags._
+import NameKinds.DefaultGetterName
+import StdNames._
+import Symbols._
+import SymUtils._
+import Types._
+
+import util.Spans.Span
+import util.SrcPos
+
+import dotty.tools.backend.sjs.JSDefinitions.jsdefn
+import JSExportUtils._
+import JSSymUtils._
+
+import org.scalajs.ir.Names.DefaultModuleID
+import org.scalajs.ir.Trees.TopLevelExportDef.isValidTopLevelExportName
+
+object PrepJSExports {
+  import tpd._
+  import PrepJSInterop.{checkSetterSignature, isJSAny, isPrivateMaybeWithin}
+
+  private sealed abstract class ExportDestination
+
+  private object ExportDestination {
+    /** Export in the "normal" way: as an instance member, or at the top-level
+     *  for naturally top-level things (classes and modules).
+     */
+    case object Normal extends ExportDestination
+
+    /** Export at the top-level. */
+    final case class TopLevel(moduleID: String) extends ExportDestination
+
+    /** Export as a static member of the companion class. */
+    case object Static extends ExportDestination
+  }
+
+  private final case class ExportInfo(jsName: String, destination: ExportDestination)(val pos: SrcPos)
+
+  /** Checks a class or module class for export.
+   *
+   *  Note that non-module Scala classes are never actually exported; their constructors are.
+   *  However, the checks are performed on the class when the class is annotated.
+   */
+  def checkClassOrModuleExports(sym: Symbol)(using Context): Unit = {
+    val exports = exportsOf(sym)
+    if (exports.nonEmpty)
+      checkClassOrModuleExports(sym, exports.head.pos)
+  }
+
+  /** Generate the exporter for the given DefDef or ValDef.
+   *
+   *  If this DefDef is a constructor, it is registered to be exported by
+   *  GenJSCode instead and no trees are returned.
+   */
+  def genExportMember(baseSym: Symbol)(using Context): List[Tree] = {
+    val clsSym = baseSym.owner
+
+    val exports = exportsOf(baseSym)
+
+    // Helper function for errors
+    def err(msg: String): List[Tree] = {
+      report.error(msg, exports.head.pos)
+      Nil
+    }
+
+    def memType = if (baseSym.isConstructor) "constructor" else "method"
+
+    if (exports.isEmpty) {
+      Nil
+    } else if (!hasLegalExportVisibility(baseSym)) {
+      err(s"You may only export public and protected ${memType}s")
+    } else if (baseSym.is(Inline)) {
+      err("You may not export an inline method")
+    } else if (isJSAny(clsSym)) {
+      err(s"You may not export a $memType of a subclass of js.Any")
+    } else if (baseSym.isLocalToBlock) {
+      err("You may not export a local definition")
+    } else if (hasIllegalRepeatedParam(baseSym)) {
+      err(s"In an exported $memType, a *-parameter must come last (through all parameter lists)")
+    } else if (hasIllegalDefaultParam(baseSym)) {
+      err(s"In an exported $memType, all parameters with defaults must be at the end")
+    } else if (baseSym.isConstructor) {
+      // Constructors do not need an exporter method. We only perform the checks at this phase.
+      checkClassOrModuleExports(clsSym, exports.head.pos)
+      Nil
+    } else {
+      assert(!baseSym.is(Bridge), s"genExportMember called for bridge symbol $baseSym")
+      val normalExports = exports.filter(_.destination == ExportDestination.Normal)
+      normalExports.flatMap(exp => genExportDefs(baseSym, exp.jsName, exp.pos.span))
+    }
+  }
+
+  /** Check a class or module for export.
+   *
+   *  There are 2 ways that this method can be reached:
+   *  - via `registerClassExports`
+   *  - via `genExportMember` (constructor of Scala class)
+   */
+  private def checkClassOrModuleExports(sym: Symbol, errPos: SrcPos)(using Context): Unit = {
+    val isMod = sym.is(ModuleClass)
+
+    def err(msg: String): Unit =
+      report.error(msg, errPos)
+
+    def hasAnyNonPrivateCtor: Boolean =
+      sym.info.decl(nme.CONSTRUCTOR).hasAltWith(denot => !isPrivateMaybeWithin(denot.symbol))
+
+    if (sym.is(Trait)) {
+      err("You may not export a trait")
+    } else if (sym.hasAnnotation(jsdefn.JSNativeAnnot)) {
+      err("You may not export a native JS " + (if (isMod) "object" else "class"))
+    } else if (!hasLegalExportVisibility(sym)) {
+      err("You may only export public and protected " + (if (isMod) "objects" else "classes"))
+    } else if (isJSAny(sym.owner)) {
+      err("You may not export a " + (if (isMod) "object" else "class") + " in a subclass of js.Any")
+    } else if (sym.isLocalToBlock) {
+      err("You may not export a local " + (if (isMod) "object" else "class"))
+    } else if (!sym.isStatic) {
+      if (isMod)
+        err("You may not export a nested object")
+      else
+        err("You may not export a nested class. Create an exported factory method in the outer class to work around this limitation.")
+    } else if (sym.is(Abstract, butNot = Trait) && !isJSAny(sym)) {
+      err("You may not export an abstract class")
+    } else if (!isMod && !hasAnyNonPrivateCtor) {
+      /* This test is only relevant for JS classes but doesn't hurt for Scala
+       * classes as we could not reach it if there were only private
+       * constructors.
+       */
+      err("You may not export a class that has only private constructors")
+    } else {
+      // OK
+    }
+  }
+
+  /** Computes the ExportInfos for sym from its annotations. */
+  private def exportsOf(sym: Symbol)(using Context): List[ExportInfo] = {
+    val trgSym = {
+      def isOwnerScalaClass = !sym.owner.is(ModuleClass) && !isJSAny(sym.owner)
+
+      // For primary Scala class constructors, look on the class itself
+      if (sym.isPrimaryConstructor && isOwnerScalaClass) sym.owner
+      else sym
+    }
+
+    val JSExportAnnot = jsdefn.JSExportAnnot
+    val JSExportTopLevelAnnot = jsdefn.JSExportTopLevelAnnot
+    val JSExportStaticAnnot = jsdefn.JSExportStaticAnnot
+    val JSExportAllAnnot = jsdefn.JSExportAllAnnot
+
+    // Annotations that are directly on the member
+    val directMemberAnnots = Set[Symbol](JSExportAnnot, JSExportTopLevelAnnot, JSExportStaticAnnot)
+    val directAnnots = trgSym.annotations.filter(annot => directMemberAnnots.contains(annot.symbol))
+
+    // Is this a member export (i.e. not a class or module export)?
+    val isMember = !sym.isClass && !sym.isConstructor
+
+    // Annotations for this member on the whole unit
+    val unitAnnots = {
+      if (isMember && sym.isPublic && !sym.is(Synthetic))
+        sym.owner.annotations.filter(_.symbol == JSExportAllAnnot)
+      else
+        Nil
+    }
+
+    val allExportInfos = for {
+      annot <- directAnnots ++ unitAnnots
+    } yield {
+      val isExportAll = annot.symbol == JSExportAllAnnot
+      val isTopLevelExport = annot.symbol == JSExportTopLevelAnnot
+      val isStaticExport = annot.symbol == JSExportStaticAnnot
+      val hasExplicitName = annot.arguments.nonEmpty
+
+      val exportPos: SrcPos = if (isExportAll) sym else annot.tree
+
+      assert(!isTopLevelExport || hasExplicitName,
+          em"Found a top-level export without an explicit name at ${exportPos.sourcePos}")
+
+      val name = {
+        if (hasExplicitName) {
+          annot.argumentConstantString(0).getOrElse {
+            report.error(
+                s"The argument to ${annot.symbol.name} must be a literal string",
+                annot.arguments(0))
+            "dummy"
+          }
+        } else {
+          sym.defaultJSName
+        }
+      }
+
+      val destination = {
+        if (isTopLevelExport) {
+          val moduleID = if (annot.arguments.size == 1) {
+            DefaultModuleID
+          } else {
+            annot.argumentConstantString(1).getOrElse {
+              report.error("moduleID must be a literal string", annot.arguments(1))
+              DefaultModuleID
+            }
+          }
+
+          ExportDestination.TopLevel(moduleID)
+        } else if (isStaticExport) {
+          ExportDestination.Static
+        } else {
+          ExportDestination.Normal
+        }
+      }
+
+      // Enforce proper setter signature
+      if (sym.isJSSetter)
+        checkSetterSignature(sym, exportPos, exported = true)
+
+      // Enforce no __ in name
+      if (!isTopLevelExport && name.contains("__"))
+        report.error("An exported name may not contain a double underscore (`__`)", exportPos)
+
+      /* Illegal function application exports, i.e., method named 'apply'
+       * without an explicit export name.
+       */
+      if (isMember && !hasExplicitName && sym.name == nme.apply) {
+        destination match {
+          case ExportDestination.Normal =>
+            def shouldBeTolerated = {
+              isExportAll && directAnnots.exists { annot =>
+                annot.symbol == JSExportAnnot &&
+                annot.arguments.nonEmpty &&
+                annot.argumentConstantString(0).contains("apply")
+              }
+            }
+
+            // Don't allow apply without explicit name
+            if (!shouldBeTolerated) {
+              report.error(
+                  "A member cannot be exported to function application. " +
+                  "Add @JSExport(\"apply\") to export under the name apply.",
+                  exportPos)
+            }
+
+          case _: ExportDestination.TopLevel =>
+            throw new AssertionError(
+                em"Found a top-level export without an explicit name at ${exportPos.sourcePos}")
+
+          case ExportDestination.Static =>
+            report.error(
+                "A member cannot be exported to function application as static. " +
+                "Use @JSExportStatic(\"apply\") to export it under the name 'apply'.",
+                exportPos)
+        }
+      }
+
+      val symOwner =
+        if (sym.isConstructor) sym.owner.owner
+        else sym.owner
+
+      // Destination-specific restrictions
+      destination match {
+        case ExportDestination.Normal =>
+          // Make sure we do not override the default export of toString
+          def isIllegalToString = {
+            isMember && name == "toString" && sym.name != nme.toString_ &&
+            sym.info.paramInfoss.forall(_.isEmpty) && !sym.isJSGetter
+          }
+          if (isIllegalToString) {
+            report.error(
+                "You may not export a zero-argument method named other than 'toString' under the name 'toString'",
+                exportPos)
+          }
+
+          // Disallow @JSExport at the top-level, as well as on objects and classes
+          if (symOwner.is(Package) || symOwner.isPackageObject) {
+            report.error("@JSExport is forbidden on top-level definitions. Use @JSExportTopLevel instead.", exportPos)
+          } else if (!isMember && !sym.is(Trait)) {
+            report.error(
+                "@JSExport is forbidden on objects and classes. Use @JSExport'ed factory methods instead.",
+                exportPos)
+          }
+
+        case _: ExportDestination.TopLevel =>
+          if (sym.is(Lazy))
+            report.error("You may not export a lazy val to the top level", exportPos)
+          else if (sym.is(Method, butNot = Accessor) && sym.isJSProperty)
+            report.error("You may not export a getter or a setter to the top level", exportPos)
+
+          /* Disallow non-static methods.
+           * Note: Non-static classes have more specific error messages in checkClassOrModuleExports.
+           */
+          if (sym.isTerm && (!symOwner.isStatic || !symOwner.is(ModuleClass)))
+            report.error("Only static objects may export their members to the top level", exportPos)
+
+          // The top-level name must be a valid JS identifier
+          if (!isValidTopLevelExportName(name))
+            report.error("The top-level export name must be a valid JavaScript identifier name", exportPos)
+
+        case ExportDestination.Static =>
+          def companionIsNonNativeJSClass: Boolean = {
+            val companion = symOwner.companionClass
+            companion != NoSymbol
+              && !companion.is(Trait)
+              && isJSAny(companion)
+              && !companion.hasAnnotation(jsdefn.JSNativeAnnot)
+          }
+
+          if (!symOwner.isStatic || !symOwner.is(ModuleClass) || !companionIsNonNativeJSClass) {
+            report.error(
+                "Only a static object whose companion class is a non-native JS class may export its members as static.",
+                exportPos)
+          }
+
+          if (isMember) {
+            if (sym.is(Lazy))
+              report.error("You may not export a lazy val as static", exportPos)
+          } else {
+            if (sym.is(Trait))
+              report.error("You may not export a trait as static.", exportPos)
+            else
+              report.error("Implementation restriction: cannot export a class or object as static", exportPos)
+          }
+      }
+
+      ExportInfo(name, destination)(exportPos)
+    }
+
+    allExportInfos.filter(_.destination == ExportDestination.Normal)
+      .groupBy(_.jsName)
+      .filter { case (jsName, group) =>
+        if (jsName == "apply" && group.size == 2)
+          // @JSExportAll and single @JSExport("apply") should not be warned.
+          !unitAnnots.exists(_.symbol == JSExportAllAnnot)
+        else
+          group.size > 1
+      }
+      .foreach(_ => report.warning("Found duplicate @JSExport", sym))
+
+    /* Make sure that no field is exported *twice* as static, nor both as
+     * static and as top-level (it is possible to export a field several times
+     * as top-level, though).
+     */
+    if (!sym.is(Method)) {
+      for (firstStatic <- allExportInfos.find(_.destination == ExportDestination.Static)) {
+        for (duplicate <- allExportInfos) {
+          duplicate.destination match {
+            case ExportDestination.Normal =>
+              // OK
+            case ExportDestination.Static =>
+              if (duplicate ne firstStatic) {
+                report.error(
+                    "Fields (val or var) cannot be exported as static more than once",
+                    duplicate.pos)
+              }
+            case _: ExportDestination.TopLevel =>
+              report.error(
+                  "Fields (val or var) cannot be exported both as static and at the top-level",
+                  duplicate.pos)
+          }
+        }
+      }
+    }
+
+    allExportInfos.distinct
+  }
+
+  /** Generates an exporter for a DefDef including default parameter methods. */
+  private def genExportDefs(defSym: Symbol, jsName: String, span: Span)(using Context): List[Tree] = {
+    val clsSym = defSym.owner.asClass
+
+    // Create symbol for new method
+    val name = makeExportName(jsName, !defSym.is(Method) || defSym.isJSProperty)
+    val flags = (defSym.flags | Method | Synthetic)
+      &~ (Deferred | Accessor | ParamAccessor | CaseAccessor | Mutable | Lazy | Override)
+    val info =
+      if (defSym.isConstructor) defSym.info
+      else if (defSym.is(Method)) finalResultTypeToAny(defSym.info)
+      else ExprType(defn.AnyType)
+    val expSym = newSymbol(clsSym, name, flags, info, defSym.privateWithin, span).entered
+
+    // Construct exporter DefDef tree
+    val exporter = genProxyDefDef(clsSym, defSym, expSym, span)
+
+    // Construct exporters for default getters
+    val defaultGetters = if (!defSym.hasDefaultParams) {
+      Nil
+    } else {
+      for {
+        (param, i) <- defSym.paramSymss.flatten.zipWithIndex
+        if param.is(HasDefault)
+      } yield {
+        genExportDefaultGetter(clsSym, defSym, expSym, i, span)
+      }
+    }
+
+    exporter :: defaultGetters
+  }
+
+  private def genExportDefaultGetter(clsSym: ClassSymbol, trgMethod: Symbol,
+      exporter: Symbol, paramPos: Int, span: Span)(using Context): Tree = {
+
+    // Get default getter method we'll copy
+    val trgGetterDenot = defaultGetterDenot(clsSym, trgMethod, paramPos)
+
+    assert(trgGetterDenot.exists, em"Cannot find default getter for param $paramPos of $trgMethod")
+
+    // Although the following must be true in a correct program, we cannot
+    // assert, since a graceful failure message is only generated later
+    if (!trgGetterDenot.isOverloaded) {
+      val trgGetter = trgGetterDenot.symbol
+      val expGetterName = DefaultGetterName(exporter.name.asTermName, paramPos)
+      val expGetter = newSymbol(clsSym, expGetterName, trgGetter.flags, trgGetter.info,
+          trgGetter.privateWithin, coord = span).entered
+      genProxyDefDef(clsSym, trgGetter, expGetter, span)
+    } else {
+      EmptyTree
+    }
+  }
+
+  private def defaultGetterDenot(targetSym: Symbol, sym: Symbol, paramIndex: Int)(using Context): Denotation =
+    targetSym.info.member(DefaultGetterName(sym.name.asTermName, paramIndex))
+
+  /** generate a DefDef tree (from [[proxySym]]) that calls [[trgSym]] */
+  private def genProxyDefDef(clsSym: ClassSymbol, trgSym: Symbol,
+      proxySym: TermSymbol, span: Span)(using Context): Tree = {
+
+    DefDef(proxySym, { argss =>
+      This(clsSym).select(trgSym).appliedToArgss(argss)
+    }).withSpan(span)
+  }
+
+  /** Changes the final result type of a type `tpe` to Any. */
+  private def finalResultTypeToAny(tpe: Type)(using Context): Type = tpe match {
+    case tpe: MethodType =>
+      MethodType(tpe.paramNames, tpe.paramInfos, finalResultTypeToAny(tpe.resultType))
+    case _: ExprType =>
+      ExprType(defn.AnyType)
+    case tpe: PolyType =>
+      PolyType(tpe.paramNames)(
+          x => tpe.paramInfos.mapConserve(_.subst(tpe, x).bounds),
+          x => finalResultTypeToAny(tpe.resultType.subst(tpe, x)))
+    case _ =>
+      defn.AnyType
+  }
+
+  /** Whether the given symbol has a visibility that allows exporting */
+  private def hasLegalExportVisibility(sym: Symbol)(using Context): Boolean =
+    sym.isPublic || sym.is(Protected, butNot = Local)
+
+  /** Checks whether this type has a repeated parameter elsewhere than at the end of all the params. */
+  private def hasIllegalRepeatedParam(sym: Symbol)(using Context): Boolean = {
+    val paramInfos = sym.info.paramInfoss.flatten
+    paramInfos.nonEmpty && paramInfos.init.exists(_.isRepeatedParam)
+  }
+
+  /** Checks whether there are default parameters not at the end of the flattened parameter list. */
+  private def hasIllegalDefaultParam(sym: Symbol)(using Context): Boolean = {
+    sym.hasDefaultParams
+      && sym.paramSymss.flatten.reverse.dropWhile(_.is(HasDefault)).exists(_.is(HasDefault))
+  }
+}
diff --git a/tests/pos-with-compiler-cc/dotc/transform/sjs/PrepJSInterop.scala b/tests/pos-with-compiler-cc/dotc/transform/sjs/PrepJSInterop.scala
new file mode 100644
index 000000000000..e75769147f80
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/transform/sjs/PrepJSInterop.scala
@@ -0,0 +1,1327 @@
+package dotty.tools.dotc
+package transform
+package sjs
+
+import scala.collection.mutable
+
+import ast.tpd
+import core._
+import typer.Checking
+import util.SrcPos
+import Annotations._
+import Constants._
+import Contexts._
+import Decorators._
+import DenotTransformers._
+import Flags._
+import NameKinds.{DefaultGetterName, ModuleClassName}
+import NameOps._
+import StdNames._
+import Symbols._
+import SymUtils._
+import Types._
+
+import JSSymUtils._
+
+import org.scalajs.ir.Trees.JSGlobalRef
+
+import dotty.tools.backend.sjs.JSDefinitions.jsdefn
+
+/** A macro transform that runs after typer and before pickler to perform
+ *  additional Scala.js-specific checks and transformations necessary for
+ *  interoperability with JavaScript.
+ *
+ *  It performs the following functions:
+ *
+ *  - Sanity checks for the js.Any hierarchy
+ *  - Annotate subclasses of js.Any to be treated specially
+ *  - Create JSExport methods: Dummy methods that are propagated
+ *    through the whole compiler chain to mark exports. This allows
+ *    exports to have the same semantics than methods.
+ *
+ *  This is the equivalent of `PrepJSInterop` in Scala 2, minus the handling
+ *  of `scala.Enumeration`.
+ *
+ *  The reason for making this a macro transform is that some functions (in particular
+ *  all the checks that behave differently depending on properties of classes in
+ *  the enclosing class chain) are naturally top-down and don't lend themselves to the
+ *  bottom-up approach of a mini phase.
+ *
+ *  In addition, the addition of export forwarders must be done before pickling to
+ *  be signature-compatible with scalac, and there are only macro transforms before
+ *  pickling.
+ */
+class PrepJSInterop extends MacroTransform with IdentityDenotTransformer { thisPhase =>
+  import PrepJSInterop._
+  import tpd._
+
+  override def phaseName: String = PrepJSInterop.name
+
+  override def description: String = PrepJSInterop.description
+
+  override def isEnabled(using Context): Boolean =
+    ctx.settings.scalajs.value
+
+  override def changesMembers: Boolean = true // the phase adds export forwarders
+
+  protected def newTransformer(using Context): Transformer =
+    new ScalaJSPrepJSInteropTransformer
+
+  class ScalaJSPrepJSInteropTransformer extends Transformer with Checking {
+    import PrepJSExports._
+
+    /** Kind of the directly enclosing (most nested) owner. */
+    private var enclosingOwner: OwnerKind = OwnerKind.None
+
+    /** Cumulative kinds of all enclosing owners. */
+    private var allEnclosingOwners: OwnerKind = OwnerKind.None
+
+    /** Nicer syntax for `allEnclosingOwners is kind`. */
+    private def anyEnclosingOwner: OwnerKind = allEnclosingOwners
+
+    private def enterOwner[A](kind: OwnerKind)(body: => A): A = {
+      require(kind.isBaseKind, kind)
+      val oldEnclosingOwner = enclosingOwner
+      val oldAllEnclosingOwners = allEnclosingOwners
+      enclosingOwner = kind
+      allEnclosingOwners |= kind
+      try {
+        body
+      } finally {
+        enclosingOwner = oldEnclosingOwner
+        allEnclosingOwners = oldAllEnclosingOwners
+      }
+    }
+
+    /** DefDefs in class templates that export methods to JavaScript */
+    private val exporters = mutable.Map.empty[Symbol, mutable.ListBuffer[Tree]]
+
+    override def transform(tree: Tree)(using Context): Tree = {
+      tree match {
+        case tree: ValDef if tree.symbol.is(Module) =>
+          /* Never apply this transformation on the term definition of modules.
+           * Instead, all relevant checks are performed on the module class definition.
+           * We still need to mark exposed if required, since that needs to be done
+           * on the module symbol, not its module class.
+           */
+          markExposedIfRequired(tree.symbol)
+          super.transform(tree)
+
+        case tree: MemberDef => transformMemberDef(tree)
+        case tree: Template  => transformTemplate(tree)
+        case _               => transformStatOrExpr(tree)
+      }
+    }
+
+    private def transformMemberDef(tree: MemberDef)(using Context): Tree = {
+      val sym = tree.symbol
+
+      checkInternalAnnotations(sym)
+
+      stripJSAnnotsOnExported(sym)
+
+      /* Checks related to @js.native:
+       * - if @js.native, verify that it is allowed in this context, and if
+       *   yes, compute and store the JS native load spec
+       * - if not @js.native, verify that we do not use any other annotation
+       *   reserved for @js.native members (namely, JS native load spec annots)
+       */
+      val isJSNative = sym.getAnnotation(jsdefn.JSNativeAnnot) match {
+        case Some(annot) =>
+          checkJSNativeDefinition(tree, annot.tree, sym)
+          true
+        case None =>
+          checkJSNativeSpecificAnnotsOnNonJSNative(tree)
+          false
+      }
+
+      checkJSNameAnnots(sym)
+      constFoldJSExportTopLevelAndStaticAnnotations(sym)
+
+      markExposedIfRequired(tree.symbol)
+
+      tree match {
+        case tree: TypeDef if tree.isClassDef =>
+          checkClassOrModuleExports(sym)
+
+          if (isJSAny(sym))
+            transformJSClassDef(tree)
+          else
+            transformScalaClassDef(tree)
+
+        case _: TypeDef =>
+          super.transform(tree)
+
+        case tree: ValOrDefDef =>
+          // Prepare exports
+          exporters.getOrElseUpdate(sym.owner, mutable.ListBuffer.empty) ++= genExportMember(sym)
+
+          if (sym.isLocalToBlock)
+            super.transform(tree)
+          else if (isJSNative)
+            transformJSNativeValOrDefDef(tree)
+          else if (enclosingOwner is OwnerKind.JSType)
+            transformValOrDefDefInJSType(tree)
+          else
+            transformScalaValOrDefDef(tree)
+      }
+    }
+
+    private def transformScalaClassDef(tree: TypeDef)(using Context): Tree = {
+      val sym = tree.symbol
+
+      // In native JS things, only js.Any stuff is allowed
+      if (enclosingOwner is OwnerKind.JSNative) {
+        /* We have to allow synthetic companion objects here, as they get
+         * generated when a nested native JS class has default arguments in
+         * its constructor (see #1891).
+         */
+        if (!sym.is(Synthetic)) {
+          report.error(
+              "Native JS traits, classes and objects cannot contain inner Scala traits, classes or objects (i.e., not extending js.Any)",
+              tree)
+        }
+      }
+
+      if (sym == jsdefn.PseudoUnionClass)
+        sym.addAnnotation(jsdefn.JSTypeAnnot)
+
+      val kind = if (sym.isSubClass(jsdefn.scalaEnumeration.EnumerationClass)) {
+        if (sym.is(Module)) OwnerKind.EnumMod
+        else if (sym == jsdefn.scalaEnumeration.EnumerationClass) OwnerKind.EnumImpl
+        else OwnerKind.EnumClass
+      } else {
+        if (sym.is(Module)) OwnerKind.NonEnumScalaMod
+        else OwnerKind.NonEnumScalaClass
+      }
+      enterOwner(kind) {
+        super.transform(tree)
+      }
+    }
+
+    private def transformTemplate(tree: Template)(using Context): Template = {
+      // First, recursively transform the template
+      val transformedTree = super.transform(tree).asInstanceOf[Template]
+
+      val clsSym = ctx.owner
+
+      // Check that @JSExportStatic fields come first
+      if (clsSym.is(ModuleClass)) { // quick check to avoid useless work
+        var foundStatOrNonStaticVal: Boolean = false
+        for (tree <- transformedTree.body) {
+          tree match {
+            case vd: ValDef if vd.symbol.hasAnnotation(jsdefn.JSExportStaticAnnot) =>
+              if (foundStatOrNonStaticVal) {
+                report.error(
+                    "@JSExportStatic vals and vars must be defined before any other val/var, and before any constructor statement.",
+                    vd)
+              }
+            case vd: ValDef if !vd.symbol.is(Lazy) =>
+              foundStatOrNonStaticVal = true
+            case _: MemberDef =>
+            case _ =>
+              foundStatOrNonStaticVal = true
+          }
+        }
+      }
+
+      // Add exports to the template, if there are any
+      exporters.get(clsSym).fold {
+        transformedTree
+      } { exports =>
+        checkNoDoubleDeclaration(clsSym)
+
+        cpy.Template(transformedTree)(
+          transformedTree.constr,
+          transformedTree.parents,
+          Nil,
+          transformedTree.self,
+          transformedTree.body ::: exports.toList
+        )
+      }
+    }
+
+    private def transformStatOrExpr(tree: Tree)(using Context): Tree = {
+      tree match {
+        case Closure(env, call, functionalInterface) =>
+          val tpeSym = functionalInterface.tpe.typeSymbol
+          if (tpeSym.isJSType) {
+            def reportError(reasonAndExplanation: String): Unit = {
+              report.error(
+                  "Using an anonymous function as a SAM for the JavaScript type " +
+                  i"${tpeSym.fullName} is not allowed because " +
+                  reasonAndExplanation,
+                  tree)
+            }
+            if (!tpeSym.is(Trait) || tpeSym.asClass.superClass != jsdefn.JSFunctionClass) {
+              reportError(
+                  "it is not a trait extending js.Function. " +
+                  "Use an anonymous class instead.")
+            } else if (tpeSym.hasAnnotation(jsdefn.JSNativeAnnot)) {
+              reportError(
+                  "it is a native JS type. " +
+                  "It is not possible to directly implement it.")
+            } else if (!tree.tpe.possibleSamMethods.exists(_.symbol.hasJSCallCallingConvention)) {
+              reportError(
+                  "its single abstract method is not named `apply`. " +
+                  "Use an anonymous class instead.")
+            }
+          }
+          super.transform(tree)
+
+        // Validate js.constructorOf[T]
+        case TypeApply(ctorOfTree, List(tpeArg))
+            if ctorOfTree.symbol == jsdefn.JSPackage_constructorOf =>
+          validateJSConstructorOf(tree, tpeArg)
+          super.transform(tree)
+
+        /* Rewrite js.ConstructorTag.materialize[T] into
+         * runtime.newConstructorTag[T](js.constructorOf[T])
+         */
+        case TypeApply(ctorOfTree, List(tpeArg))
+            if ctorOfTree.symbol == jsdefn.JSConstructorTag_materialize =>
+          validateJSConstructorOf(tree, tpeArg)
+          val ctorOf = ref(jsdefn.JSPackage_constructorOf).appliedToTypeTree(tpeArg)
+          ref(jsdefn.Runtime_newConstructorTag).appliedToType(tpeArg.tpe).appliedTo(ctorOf)
+
+        /* Rewrite js.dynamicImport[T](body) into
+         *
+         * runtime.dynamicImport[T](
+         *   new DynamicImportThunk { def apply(): Any = body }
+         * )
+         */
+        case Apply(TypeApply(fun, List(tpeArg)), List(body))
+            if fun.symbol == jsdefn.JSPackage_dynamicImport =>
+          val span = tree.span
+          val currentOwner = ctx.owner
+
+          assert(currentOwner.isTerm, s"unexpected owner: $currentOwner at ${tree.sourcePos}")
+
+          // new DynamicImportThunk { def apply(): Any = body }
+          val dynamicImportThunkAnonClass = AnonClass(currentOwner, List(jsdefn.DynamicImportThunkType), span) { cls =>
+            val applySym = newSymbol(cls, nme.apply, Method, MethodType(Nil, Nil, defn.AnyType), coord = span).entered
+            val newBody = transform(body).changeOwnerAfter(currentOwner, applySym, thisPhase)
+            val applyDefDef = DefDef(applySym, newBody)
+            List(applyDefDef)
+          }
+
+          // runtime.DynamicImport[A](new ...)
+          ref(jsdefn.Runtime_dynamicImport)
+            .appliedToTypeTree(tpeArg)
+            .appliedTo(dynamicImportThunkAnonClass)
+
+        // Compile-time errors and warnings for js.Dynamic.literal
+        case Apply(Apply(fun, nameArgs), args)
+            if fun.symbol == jsdefn.JSDynamicLiteral_applyDynamic ||
+              fun.symbol == jsdefn.JSDynamicLiteral_applyDynamicNamed =>
+          // Check that the first argument list is a constant string "apply"
+          nameArgs match {
+            case List(Literal(Constant(s: String))) =>
+              if (s != "apply")
+                report.error(i"js.Dynamic.literal does not have a method named $s", tree)
+            case _ =>
+              report.error(i"js.Dynamic.literal.${tree.symbol.name} may not be called directly", tree)
+          }
+
+          // TODO Warn for known duplicate property names
+
+          super.transform(tree)
+
+        // Warnings for scala.Enumeration.Value that could not be transformed
+        case _:Ident | _:Select | _:Apply if jsdefn.scalaEnumeration.isValueMethodNoName(tree.symbol) =>
+          report.warning(
+              "Could not transform call to scala.Enumeration.Value.\n" +
+              "The resulting program is unlikely to function properly as this operation requires reflection.",
+              tree)
+          super.transform(tree)
+
+        // Warnings for scala.Enumeration.Value with a `null` name
+        case Apply(_, args) if jsdefn.scalaEnumeration.isValueMethodName(tree.symbol) && isNullLiteral(args.last) =>
+          report.warning(
+              "Passing null as name to scala.Enumeration.Value requires reflection at run-time.\n" +
+              "The resulting program is unlikely to function properly.",
+              tree)
+          super.transform(tree)
+
+        // Warnings for scala.Enumeration.Val without name
+        case _: Apply if jsdefn.scalaEnumeration.isValCtorNoName(tree.symbol) =>
+          report.warning(
+              "Calls to the non-string constructors of scala.Enumeration.Val require reflection at run-time.\n" +
+              "The resulting program is unlikely to function properly.",
+              tree)
+          super.transform(tree)
+
+        // Warnings for scala.Enumeration.Val with a `null` name
+        case Apply(_, args) if jsdefn.scalaEnumeration.isValCtorName(tree.symbol) && isNullLiteral(args.last) =>
+          report.warning(
+              "Passing null as name to a constructor of scala.Enumeration.Val requires reflection at run-time.\n" +
+              "The resulting program is unlikely to function properly.",
+              tree)
+          super.transform(tree)
+
+        case _: Export =>
+          if enclosingOwner is OwnerKind.JSNative then
+            report.error("Native JS traits, classes and objects cannot contain exported definitions.", tree)
+          else if enclosingOwner is OwnerKind.JSTrait then
+            report.error("Non-native JS traits cannot contain exported definitions.", tree)
+
+          super.transform(tree)
+
+        case _ =>
+          super.transform(tree)
+      }
+    }
+
+    private def isNullLiteral(tree: Tree): Boolean = tree match
+      case Literal(Constant(null)) => true
+      case _                       => false
+
+    private def validateJSConstructorOf(tree: Tree, tpeArg: Tree)(using Context): Unit = {
+      val tpe = checkClassType(tpeArg.tpe, tpeArg.srcPos, traitReq = false, stablePrefixReq = false)
+
+      tpe.underlyingClassRef(refinementOK = false) match {
+        case typeRef: TypeRef if typeRef.symbol.isOneOf(Trait | ModuleClass) =>
+          report.error(i"non-trait class type required but $tpe found", tpeArg)
+        case _ =>
+          // an error was already reported above
+      }
+    }
+
+    /** Performs checks and rewrites specific to classes / objects extending `js.Any`. */
+    private def transformJSClassDef(classDef: TypeDef)(using Context): Tree = {
+      val sym = classDef.symbol.asClass
+      val isJSNative = sym.hasAnnotation(jsdefn.JSNativeAnnot)
+
+      sym.addAnnotation(jsdefn.JSTypeAnnot)
+
+      // Forbid @EnableReflectiveInstantiation on JS types
+      sym.getAnnotation(jsdefn.EnableReflectiveInstantiationAnnot).foreach { annot =>
+        report.error(
+            "@EnableReflectiveInstantiation cannot be used on types extending js.Any.",
+            annot.tree)
+      }
+
+      // Forbid package objects that extends js.Any
+      if (sym.isPackageObject)
+        report.error("Package objects may not extend js.Any.", classDef)
+
+      // Check that we do not have a case modifier
+      if (sym.is(Case)) {
+        report.error(
+            "Classes and objects extending js.Any may not have a case modifier",
+            classDef)
+      }
+
+      // Check the parents
+      for (parentSym <- sym.parentSyms) {
+        parentSym match {
+          case parentSym if parentSym == defn.ObjectClass =>
+            // AnyRef is valid, except for non-native JS classes and objects
+            if (!isJSNative && !sym.is(Trait)) {
+              report.error(
+                  "Non-native JS classes and objects cannot directly extend AnyRef. They must extend a JS class (native or not).",
+                  classDef)
+            }
+          case parentSym if isJSAny(parentSym) =>
+            // A non-native JS type cannot extend a native JS trait
+            // Otherwise, extending a JS type is valid
+            if (!isJSNative && parentSym.is(Trait) && parentSym.hasAnnotation(jsdefn.JSNativeAnnot)) {
+              report.error(
+                  "Non-native JS types cannot directly extend native JS traits.",
+                  classDef)
+            }
+          case parentSym if parentSym == defn.DynamicClass =>
+            /* We have to allow scala.Dynamic to be able to define js.Dynamic
+             * and similar constructs.
+             * This causes the unsoundness filed as scala-js/scala-js#1385.
+             */
+          case parentSym =>
+            /* This is a Scala class or trait other than AnyRef and Dynamic,
+             * which is never valid.
+             */
+            report.error(
+                i"${sym.name} extends ${parentSym.fullName} which does not extend js.Any.",
+                classDef)
+        }
+      }
+
+      // Checks for non-native JS stuff
+      if (!isJSNative) {
+        // It cannot be in a native JS class or trait
+        if (enclosingOwner is OwnerKind.JSNativeClass) {
+          report.error(
+              "Native JS classes and traits cannot contain non-native JS classes, traits or objects",
+              classDef)
+        }
+
+        // Unless it is a trait, it cannot be in a native JS object
+        if (!sym.is(Trait) && (enclosingOwner is OwnerKind.JSNativeMod)) {
+          report.error(
+              "Native JS objects cannot contain inner non-native JS classes or objects",
+              classDef)
+        }
+
+        // Local JS classes cannot be abstract (implementation restriction)
+        if (sym.is(Abstract, butNot = Trait) && sym.isLocalToBlock) {
+          report.error(
+              "Implementation restriction: local JS classes cannot be abstract",
+              classDef)
+        }
+      }
+
+      // Check for consistency of JS semantics across overriding
+      val overridingPairsCursor = new OverridingPairs.Cursor(sym)
+      while (overridingPairsCursor.hasNext) {
+        val overriding = overridingPairsCursor.overriding
+        val overridden = overridingPairsCursor.overridden
+        overridingPairsCursor.next() // prepare for next turn
+
+        val clsSym = sym
+
+        if (overriding.isTerm) {
+          def errorPos = {
+            if (clsSym == overriding.owner) overriding.srcPos
+            else if (clsSym == overridden.owner) overridden.srcPos
+            else clsSym.srcPos
+          }
+
+          // Some utils inspired by RefChecks
+
+          def infoString0(sym: Symbol, showLocation: Boolean): String = {
+            val sym1 = sym.underlyingSymbol
+            def info = clsSym.thisType.memberInfo(sym1)
+            val infoStr =
+              if (sym1.is(Module)) ""
+              else i" of type $info"
+            val ccStr = s" called from JS as '${sym.jsCallingConvention.displayName}'"
+            i"${if (showLocation) sym1.showLocated else sym1}$infoStr$ccStr"
+          }
+
+          def infoString(sym: Symbol): String = infoString0(sym, sym.owner != clsSym)
+          def infoStringWithLocation(sym: Symbol): String = infoString0(sym, true)
+
+          def emitOverrideError(msg: String): Unit = {
+            report.error(
+              "error overriding %s;\n  %s %s".format(
+                infoStringWithLocation(overridden), infoString(overriding), msg),
+              errorPos)
+          }
+
+          // Check for overrides with different JS names - issue scala-js/scala-js#1983
+          if (overriding.jsCallingConvention != overridden.jsCallingConvention)
+            emitOverrideError("has a different JS calling convention")
+
+          /* Cannot override a non-@JSOptional with an @JSOptional. Unfortunately
+           * at this point the symbols do not have @JSOptional yet, so we need
+           * to detect whether it would be applied.
+           */
+          if (!isJSNative) {
+            def isJSOptional(sym: Symbol): Boolean = {
+              sym.owner.is(Trait) && !sym.is(Deferred) && !sym.isConstructor &&
+              !sym.owner.hasAnnotation(jsdefn.JSNativeAnnot)
+            }
+            if (isJSOptional(overriding) && !(overridden.is(Deferred) || isJSOptional(overridden)))
+              emitOverrideError("cannot override a concrete member in a non-native JS trait")
+          }
+        }
+      }
+
+      val kind = {
+        if (!isJSNative) {
+          if (sym.is(ModuleClass)) OwnerKind.JSMod
+          else if (sym.is(Trait)) OwnerKind.JSTrait
+          else OwnerKind.JSNonTraitClass
+        } else {
+          if (sym.is(ModuleClass)) OwnerKind.JSNativeMod
+          else OwnerKind.JSNativeClass
+        }
+      }
+      enterOwner(kind) {
+        super.transform(classDef)
+      }
+    }
+
+    private def checkJSNativeDefinition(treePos: SrcPos, annotPos: SrcPos, sym: Symbol)(using Context): Unit = {
+      // Check if we may have a JS native here
+      if (sym.isLocalToBlock) {
+        report.error("@js.native is not allowed on local definitions", annotPos)
+      } else if (!sym.isClass && (anyEnclosingOwner is (OwnerKind.ScalaClass | OwnerKind.JSType))) {
+        report.error("@js.native vals and defs can only appear in static Scala objects", annotPos)
+      } else if (sym.isClass && !isJSAny(sym)) {
+        report.error("Classes, traits and objects not extending js.Any may not have an @js.native annotation", annotPos)
+      } else if (anyEnclosingOwner is OwnerKind.ScalaClass) {
+        report.error("Scala traits and classes may not have native JS members", annotPos)
+      } else if (enclosingOwner is OwnerKind.JSNonNative) {
+        report.error("non-native JS classes, traits and objects may not have native JS members", annotPos)
+      } else {
+        // The symbol can be annotated with @js.native. Now check its JS native loading spec.
+        if (sym.is(Trait)) {
+          for (annot <- sym.annotations) {
+            val annotSym = annot.symbol
+            if (isJSNativeLoadingSpecAnnot(annotSym))
+              report.error(i"Traits may not have an @${annotSym.name} annotation.", annot.tree)
+          }
+        } else {
+          checkJSNativeLoadSpecOf(treePos, sym)
+        }
+      }
+    }
+
+    private def checkJSNativeLoadSpecOf(pos: SrcPos, sym: Symbol)(using Context): Unit = {
+
+      def checkGlobalRefName(globalRef: String): Unit = {
+        if (!JSGlobalRef.isValidJSGlobalRefName(globalRef))
+          report.error(s"The name of a JS global variable must be a valid JS identifier (got '$globalRef')", pos)
+      }
+
+      if (enclosingOwner is OwnerKind.JSNative) {
+        /* We cannot get here for @js.native vals and defs. That would mean we
+         * have an @js.native val/def inside a JavaScript type, which is not
+         * allowed and already caught in checkJSNativeDefinition().
+         */
+        assert(sym.isClass,
+            s"undetected @js.native val or def ${sym.fullName} inside JS type at $pos")
+
+        for (annot <- sym.annotations) {
+          val annotSym = annot.symbol
+          if (isJSNativeLoadingSpecAnnot(annotSym))
+            report.error(i"Nested JS classes and objects cannot have an @${annotSym.name} annotation.", annot.tree)
+        }
+
+        if (sym.owner.isStaticOwner) {
+          for (annot <- sym.annotations) {
+            if (annot.symbol == jsdefn.JSNameAnnot && !(annot.arguments.head.tpe.derivesFrom(defn.StringClass))) {
+              report.error(
+                  "Implementation restriction: " +
+                  "@JSName with a js.Symbol is not supported on nested native classes and objects",
+                  annot.tree)
+            }
+          }
+
+          if (sym.owner.hasAnnotation(jsdefn.JSGlobalScopeAnnot)) {
+            val jsName = sym.jsName match {
+              case JSName.Literal(jsName) =>
+                checkGlobalRefName(jsName)
+              case JSName.Computed(_) =>
+                () // compile error above or in `checkJSNameArgument`
+            }
+          }
+        }
+      } else {
+        def checkGlobalRefPath(pathName: String): Unit = {
+          val dotIndex = pathName.indexOf('.')
+          val globalRef =
+            if (dotIndex < 0) pathName
+            else pathName.substring(0, dotIndex).nn
+          checkGlobalRefName(globalRef)
+        }
+
+        checkAndGetJSNativeLoadingSpecAnnotOf(pos, sym) match {
+          case Some(annot) if annot.symbol == jsdefn.JSGlobalScopeAnnot =>
+            if (!sym.is(Module)) {
+              report.error(
+                  "@JSGlobalScope can only be used on native JS objects (with @js.native).",
+                  annot.tree)
+            }
+
+          case Some(annot) if annot.symbol == jsdefn.JSGlobalAnnot =>
+            checkJSGlobalLiteral(annot)
+            val pathName = annot.argumentConstantString(0).getOrElse {
+              val symTermName = sym.name.exclude(NameKinds.ModuleClassName).toTermName
+              if (symTermName == nme.apply) {
+                report.error(
+                    "Native JS definitions named 'apply' must have an explicit name in @JSGlobal",
+                    annot.tree)
+              } else if (symTermName.isSetterName) {
+                report.error(
+                    "Native JS definitions with a name ending in '_=' must have an explicit name in @JSGlobal",
+                    annot.tree)
+              }
+              sym.defaultJSName
+            }
+            checkGlobalRefPath(pathName)
+
+          case Some(annot) if annot.symbol == jsdefn.JSImportAnnot =>
+            checkJSImportLiteral(annot)
+            if (annot.arguments.sizeIs < 2) {
+              val symTermName = sym.name.exclude(NameKinds.ModuleClassName).toTermName
+              if (symTermName == nme.apply) {
+                report.error(
+                    "Native JS definitions named 'apply' must have an explicit name in @JSImport",
+                    annot.tree)
+              } else if (symTermName.isSetterName) {
+                report.error(
+                    "Native JS definitions with a name ending in '_=' must have an explicit name in @JSImport",
+                    annot.tree)
+              }
+            }
+            annot.argumentConstantString(2).foreach { globalPathName =>
+              checkGlobalRefPath(globalPathName)
+            }
+
+          case _ =>
+            // We already emitted an error in checkAndGetJSNativeLoadingSpecAnnotOf
+            ()
+        }
+      }
+    }
+
+    /** Transforms a non-`@js.native` ValDef or DefDef in a Scala class. */
+    private def transformScalaValOrDefDef(tree: ValOrDefDef)(using Context): Tree = {
+      tree match {
+        // Catch ValDefs in enumerations with simple calls to Value
+        case vd: ValDef
+            if (enclosingOwner is OwnerKind.Enum) && jsdefn.scalaEnumeration.isValueMethodNoName(vd.rhs.symbol) =>
+          val enumDefn = jsdefn.scalaEnumeration
+
+          // Extract the Int argument if it is present
+          val optIntArg = vd.rhs match {
+            case _:Select | _:Ident      => None
+            case Apply(_, intArg :: Nil) => Some(intArg)
+          }
+
+          val defaultName = vd.name.getterName.encode.toString
+
+          /* Construct the following tree
+           *
+           *   if (nextName != null && nextName.hasNext)
+           *     nextName.next()
+           *   else
+           *     <defaultName>
+           */
+          val thisClass = vd.symbol.owner.asClass
+          val nextNameTree = This(thisClass).select(enumDefn.Enumeration_nextName)
+          val nullCompTree = nextNameTree.select(nme.NE).appliedTo(Literal(Constant(null)))
+          val hasNextTree = nextNameTree.select(enumDefn.hasNext)
+          val condTree = nullCompTree.select(nme.ZAND).appliedTo(hasNextTree)
+          val nameTree = If(condTree, nextNameTree.select(enumDefn.next).appliedToNone, Literal(Constant(defaultName)))
+
+          val newRhs = optIntArg match {
+            case None =>
+              This(thisClass).select(enumDefn.Enumeration_Value_StringArg).appliedTo(nameTree)
+            case Some(intArg) =>
+              This(thisClass).select(enumDefn.Enumeration_Value_IntStringArg).appliedTo(intArg, nameTree)
+          }
+
+          cpy.ValDef(vd)(rhs = newRhs)
+
+        case _ =>
+          super.transform(tree)
+      }
+    }
+
+    /** Verify a ValOrDefDef that is annotated with `@js.native`. */
+    private def transformJSNativeValOrDefDef(tree: ValOrDefDef)(using Context): ValOrDefDef = {
+      val sym = tree.symbol
+
+      def annotPos(annotSym: Symbol): SrcPos =
+        sym.getAnnotation(annotSym).get.tree
+
+      if (sym.is(Lazy) || sym.isJSSetter)
+        report.error("@js.native is not allowed on vars, lazy vals and setter defs", annotPos(jsdefn.JSNativeAnnot))
+      else if (sym.isJSBracketAccess)
+        report.error("@JSBracketAccess is not allowed on @js.native vals and defs", annotPos(jsdefn.JSBracketAccessAnnot))
+      else if (sym.isJSBracketCall)
+        report.error("@JSBracketCall is not allowed on @js.native vals and defs", annotPos(jsdefn.JSBracketCallAnnot))
+
+      checkRHSCallsJSNative(tree, "@js.native members")
+
+      // Check that we do not override or implement anything from a superclass
+      val overriddenSymbols = sym.allOverriddenSymbols
+      if (overriddenSymbols.hasNext) {
+        val overridden = overriddenSymbols.next()
+        val verb = if (overridden.is(Deferred)) "implement" else "override"
+        report.error(i"An @js.native member cannot $verb the inherited member ${overridden.fullName}", tree)
+      }
+
+      tree
+    }
+
+    /** Verify a ValOrDefDef inside a js.Any */
+    private def transformValOrDefDefInJSType(tree: ValOrDefDef)(using Context): Tree = {
+      val sym = tree.symbol
+
+      assert(!sym.isLocalToBlock, i"$tree at ${tree.span}")
+
+      sym.name match {
+        case nme.apply if !sym.hasAnnotation(jsdefn.JSNameAnnot) && (!sym.is(Method) || sym.isJSGetter) =>
+          report.error(
+              "A member named apply represents function application in JavaScript. " +
+              "A parameterless member should be exported as a property. " +
+              "You must add @JSName(\"apply\")",
+              sym)
+
+        case nme.equals_ if sym.info.matches(defn.Any_equals.info) =>
+          report.error(
+              "error overriding method equals(that: Any): Boolean in a JS class;\n" +
+              "  method equals(that: Any): Boolean is considered final in trait js.Any;\n" +
+              "  if you want to define a method named \"equals\" in JavaScript, use a different name and add @JSName(\"equals\").",
+              sym)
+
+        case nme.hashCode_ if sym.info.matches(defn.Any_hashCode.info) =>
+          report.error(
+              "error overriding method hashCode(): Int in a JS class;\n" +
+              "  method hashCode(): Int is considered final in trait js.Any;\n" +
+              "  if you want to define a method named \"hashCode\" in JavaScript, use a different name and add @JSName(\"hashCode\").",
+              sym)
+
+        case _ =>
+      }
+
+      if (sym.isJSSetter)
+        checkSetterSignature(sym, tree, exported = false)
+
+      if (enclosingOwner is OwnerKind.JSNonNative) {
+        JSCallingConvention.of(sym) match {
+          case JSCallingConvention.Property(_) => // checked above
+          case JSCallingConvention.Method(_)   => // no checks needed
+
+          case JSCallingConvention.Call if !sym.is(Deferred) =>
+            report.error("A non-native JS class cannot declare a concrete method named `apply` without `@JSName`", tree)
+
+          case JSCallingConvention.Call => // if sym.isDeferred
+            /* Allow an abstract `def apply` only if the owner is a plausible
+             * JS function SAM trait.
+             */
+            val owner = sym.owner
+            val isPlausibleJSFunctionType = {
+              owner.is(Trait) &&
+              owner.asClass.superClass == jsdefn.JSFunctionClass &&
+              owner.typeRef.possibleSamMethods.map(_.symbol) == Seq(sym) &&
+              !sym.info.isInstanceOf[PolyType]
+            }
+            if (!isPlausibleJSFunctionType) {
+              report.error(
+                  "A non-native JS type can only declare an abstract method named `apply` without `@JSName` " +
+                  "if it is the SAM of a trait that extends js.Function",
+                  tree)
+            }
+
+          case JSCallingConvention.BracketAccess =>
+            report.error("@JSBracketAccess is not allowed in non-native JS classes", tree)
+          case JSCallingConvention.BracketCall =>
+            report.error("@JSBracketCall is not allowed in non-native JS classes", tree)
+          case JSCallingConvention.UnaryOp(_) =>
+            report.error("A non-native JS class cannot declare a method named like a unary operation without `@JSName`", tree)
+          case JSCallingConvention.BinaryOp(_) =>
+            report.error("A non-native JS class cannot declare a method named like a binary operation without `@JSName`", tree)
+        }
+      } else {
+        def checkNoDefaultOrRepeated(subject: String) = {
+          if (sym.info.paramInfoss.flatten.exists(_.isRepeatedParam))
+            report.error(s"$subject may not have repeated parameters", tree)
+          if (sym.hasDefaultParams)
+            report.error(s"$subject may not have default parameters", tree)
+        }
+
+        JSCallingConvention.of(sym) match {
+          case JSCallingConvention.Property(_) => // checked above
+          case JSCallingConvention.Method(_)   => // no checks needed
+          case JSCallingConvention.Call        => // no checks needed
+          case JSCallingConvention.UnaryOp(_)  => // no checks needed
+
+          case JSCallingConvention.BinaryOp(_) =>
+            checkNoDefaultOrRepeated("methods representing binary operations")
+
+          case JSCallingConvention.BracketAccess =>
+            val paramCount = sym.info.paramNamess.map(_.size).sum
+            if (paramCount != 1 && paramCount != 2)
+              report.error("@JSBracketAccess methods must have one or two parameters", tree)
+            else if (paramCount == 2 && !sym.info.finalResultType.isRef(defn.UnitClass))
+              report.error("@JSBracketAccess methods with two parameters must return Unit", tree)
+
+            checkNoDefaultOrRepeated("@JSBracketAccess methods")
+
+          case JSCallingConvention.BracketCall =>
+            // JS bracket calls must have at least one non-repeated parameter
+            sym.info.stripPoly match {
+              case mt: MethodType if mt.paramInfos.nonEmpty && !mt.paramInfos.head.isRepeatedParam =>
+                // ok
+              case _ =>
+                report.error("@JSBracketCall methods must have at least one non-repeated parameter", tree)
+            }
+        }
+      }
+
+      if (sym.hasAnnotation(defn.NativeAnnot)) {
+        // Native methods are not allowed
+        report.error("Methods in a js.Any may not be @native", tree)
+      }
+
+      /* In native JS types, there should not be any private member, except
+       * private[this] constructors.
+       */
+      if ((enclosingOwner is OwnerKind.JSNative) && isPrivateMaybeWithin(sym)) {
+        if (sym.isClassConstructor) {
+          if (!sym.isAllOf(PrivateLocal)) {
+            report.error(
+                "Native JS classes may not have private constructors. " +
+                "Use `private[this]` to declare an internal constructor.",
+                sym)
+          }
+        } else if (!sym.is(ParamAccessor)) {
+          report.error(
+              "Native JS classes may not have private members. " +
+              "Use a public member in a private facade instead.",
+              tree)
+        }
+      }
+
+      if (enclosingOwner is OwnerKind.JSNonNative) {
+        // Private methods cannot be overloaded
+        if (sym.is(Method) && isPrivateMaybeWithin(sym)) {
+          val alts = sym.owner.info.memberBasedOnFlags(sym.name, required = Method)
+          if (alts.isOverloaded) {
+            report.error(
+                "Private methods in non-native JS classes cannot be overloaded. Use different names instead.",
+                tree)
+          }
+        }
+
+        // private[Scope] methods must be final
+        if (!sym.isOneOf(Final | Protected) && sym.privateWithin.exists && !sym.isClassConstructor)
+          report.error("Qualified private members in non-native JS classes must be final", tree)
+
+        // Traits must be pure interfaces, except for js.undefined members
+        if (sym.owner.is(Trait) && sym.isTerm && !sym.isConstructor) {
+          if (sym.is(Method) && isPrivateMaybeWithin(sym)) {
+            report.error("A non-native JS trait cannot contain private members", tree)
+          } else if (sym.is(Lazy)) {
+            report.error("A non-native JS trait cannot contain lazy vals", tree)
+          } else if (!sym.is(Deferred)) {
+            /* Tell the back-end not to emit this thing. In fact, this only
+             * matters for mixed-in members created from this member.
+             */
+            sym.addAnnotation(jsdefn.JSOptionalAnnot)
+
+            if (!sym.isSetter) {
+              // Check that methods do not have parens
+              if (sym.is(Method, butNot = Accessor) && sym.info.stripPoly.isInstanceOf[MethodType])
+                report.error("In non-native JS traits, defs with parentheses must be abstract.", tree.rhs)
+
+              // Check that the rhs is `js.undefined`
+              tree.rhs match {
+                case sel: Select if sel.symbol == jsdefn.JSPackage_undefined =>
+                  // ok
+                case Apply(Apply(TypeApply(fromTypeConstructorFun, _), (sel: Select) :: Nil), _)
+                    if sel.symbol == jsdefn.JSPackage_undefined
+                        && fromTypeConstructorFun.symbol == jsdefn.PseudoUnion_fromTypeConstructor =>
+                  // ok: js.|.fromTypeConstructor(js.undefined)(...)
+                case _ =>
+                  report.error(
+                      "Members of non-native JS traits must either be abstract, or their right-hand-side must be `js.undefined`.",
+                      tree)
+              }
+            }
+          }
+        }
+      } else { // enclosingOwner isnt OwnerKind.JSNonNative
+        // Check that the rhs is valid
+        if (sym.isPrimaryConstructor || sym.isOneOf(Param | ParamAccessor | Deferred | Synthetic)
+            || sym.name.is(DefaultGetterName) || sym.isSetter) {
+          /* Ignore, i.e., allow:
+           * - primary constructor
+           * - all kinds of parameters
+           * - setters
+           * - default parameter getters (i.e., the default value of parameters)
+           * - abstract members
+           * - synthetic members (to avoid double errors with case classes, e.g. generated copy method)
+           */
+        } else if (sym.isConstructor) {
+          // Force secondary ctor to have only a call to the primary ctor inside
+          tree.rhs match {
+            case Block(List(Apply(trg, _)), Literal(Constant(())))
+                if trg.symbol.isPrimaryConstructor && trg.symbol.owner == sym.owner =>
+              // everything is fine here
+            case _ =>
+              report.error(
+                  "A secondary constructor of a native JS class may only call the primary constructor",
+                  tree.rhs)
+          }
+        } else {
+          // Check that the tree's rhs is exactly `= js.native`
+          checkRHSCallsJSNative(tree, "Concrete members of JS native types")
+        }
+      }
+
+      super.transform(tree)
+    }
+
+    /** Removes annotations from exported definitions (e.g. `export foo.bar`):
+     *  - `js.native`
+     *  - `js.annotation.*`
+     */
+    private def stripJSAnnotsOnExported(sym: Symbol)(using Context): Unit =
+      if !sym.is(Exported) then
+        return // only remove annotations from exported definitions
+
+      val JSNativeAnnot = jsdefn.JSNativeAnnot
+      val JSAnnotPackage = jsdefn.JSAnnotPackage
+
+      extension (sym: Symbol) def isJSAnnot =
+        (sym eq JSNativeAnnot) || (sym.owner eq JSAnnotPackage)
+
+      val newAnnots = sym.annotations.filterConserve(!_.symbol.isJSAnnot)
+      if newAnnots ne sym.annotations then
+        sym.annotations = newAnnots
+    end stripJSAnnotsOnExported
+
+    private def checkRHSCallsJSNative(tree: ValOrDefDef, longKindStr: String)(using Context): Unit = {
+      if tree.symbol.is(Exported) then
+        return // we already report an error that exports are not allowed here, this prevents extra errors.
+
+      // Check that the rhs is exactly `= js.native`
+      tree.rhs match {
+        case sel: Select if sel.symbol == jsdefn.JSPackage_native =>
+          // ok
+        case _ =>
+          val pos = if (tree.rhs != EmptyTree) tree.rhs.srcPos else tree.srcPos
+          report.error(s"$longKindStr may only call js.native.", pos)
+      }
+
+      // Check that the result type was explicitly specified
+      // (This is stronger than Scala 2, which only warns, and only if it was inferred as Nothing.)
+      if (tree.tpt.isInstanceOf[InferredTypeTree])
+        report.error(i"The type of ${tree.name} must be explicitly specified because it is JS native.", tree)
+    }
+
+    private def checkJSNativeSpecificAnnotsOnNonJSNative(memberDef: MemberDef)(using Context): Unit = {
+      for (annot <- memberDef.symbol.annotations) {
+        annot.symbol match {
+          case annotSym if annotSym == jsdefn.JSGlobalAnnot =>
+            report.error("@JSGlobal can only be used on native JS definitions (with @js.native).", annot.tree)
+          case annotSym if annotSym == jsdefn.JSImportAnnot =>
+            report.error("@JSImport can only be used on native JS definitions (with @js.native).", annot.tree)
+          case annotSym if annotSym == jsdefn.JSGlobalScopeAnnot =>
+            report.error("@JSGlobalScope can only be used on native JS objects (with @js.native).", annot.tree)
+          case _ =>
+            // ok
+        }
+      }
+    }
+
+    private def checkJSNameAnnots(sym: Symbol)(using Context): Unit = {
+      val allJSNameAnnots = sym.annotations.filter(_.symbol == jsdefn.JSNameAnnot).reverse
+
+      for (annot <- allJSNameAnnots.headOption) {
+        // Check everything about the first @JSName annotation
+        if (sym.isLocalToBlock || (enclosingOwner isnt OwnerKind.JSType))
+          report.error("@JSName can only be used on members of JS types.", annot.tree)
+        else if (sym.is(Trait))
+          report.error("@JSName cannot be used on traits.", annot.tree)
+        else if (isPrivateMaybeWithin(sym))
+          report.error("@JSName cannot be used on private members.", annot.tree)
+        else
+          checkJSNameArgument(sym, annot)
+
+        // Check that there is at most one @JSName annotation.
+        for (duplicate <- allJSNameAnnots.tail)
+          report.error("Duplicate @JSName annotation.", duplicate.tree)
+      }
+    }
+
+    /** Checks that the argument to `@JSName` annotations on `memberSym` is legal.
+     *
+     *  Reports an error on each annotation where this is not the case.
+     *  One one `@JSName` annotation is allowed, but that is handled somewhere else.
+     */
+    private def checkJSNameArgument(memberSym: Symbol, annot: Annotation)(using Context): Unit = {
+      val argTree = annot.arguments.head
+      if (argTree.tpe.derivesFrom(defn.StringClass)) {
+        // We have a String. It must be a literal.
+        if (!annot.argumentConstantString(0).isDefined)
+          report.error("A String argument to JSName must be a literal string", argTree)
+      } else {
+        // We have a js.Symbol. It must be a stable reference.
+        val sym = argTree.symbol
+        if (!sym.isStatic || !sym.isStableMember) {
+          report.error("A js.Symbol argument to JSName must be a static, stable identifier", argTree)
+        } else if ((enclosingOwner is OwnerKind.JSNonNative) && sym.owner == memberSym.owner) {
+          report.warning(
+              "This symbol is defined in the same object as the annotation's target. " +
+              "This will cause a stackoverflow at runtime",
+              argTree)
+        }
+      }
+    }
+
+    /** Constant-folds arguments to `@JSExportTopLevel` and `@JSExportStatic`.
+     *
+     *  Unlike scalac, dotc does not constant-fold expressions in annotations.
+     *  Our back-end needs to have access to the arguments to those two
+     *  annotations as literal strings, so we specifically constant-fold them
+     *  here.
+     */
+    private def constFoldJSExportTopLevelAndStaticAnnotations(sym: Symbol)(using Context): Unit = {
+      val annots = sym.annotations
+      val newAnnots = annots.mapConserve { annot =>
+        if (annot.symbol == jsdefn.JSExportTopLevelAnnot || annot.symbol == jsdefn.JSExportStaticAnnot) {
+          annot.tree match {
+            case app @ Apply(fun, args) =>
+              val newArgs = args.mapConserve { arg =>
+                arg match {
+                  case _: Literal =>
+                    arg
+                  case _ =>
+                    arg.tpe.widenTermRefExpr.normalized match {
+                      case ConstantType(c) => Literal(c).withSpan(arg.span)
+                      case _               => arg // PrepJSExports will emit an error for those cases
+                    }
+                }
+              }
+              if (newArgs eq args)
+                annot
+              else
+                Annotation(cpy.Apply(app)(fun, newArgs))
+            case _ =>
+              annot
+          }
+        } else {
+          annot
+        }
+      }
+      if (newAnnots ne annots)
+        sym.annotations = newAnnots
+    }
+
+    /** Mark the symbol as exposed if it is a non-private term member of a
+     *  non-native JS class.
+     *
+     *  @param sym
+     *    The symbol, which must be the module symbol for a module, not its
+     *    module class symbol.
+     */
+    private def markExposedIfRequired(sym: Symbol)(using Context): Unit = {
+      val shouldBeExposed: Boolean = {
+        // it is a term member
+        sym.isTerm &&
+        // it is a member of a non-native JS class
+        (enclosingOwner is OwnerKind.JSNonNative) && !sym.isLocalToBlock &&
+        // it is not synthetic
+        !sym.isOneOf(Synthetic) &&
+        // it is not private
+        !isPrivateMaybeWithin(sym) &&
+        // it is not a constructor
+        !sym.isConstructor &&
+        // it is not a default getter
+        !sym.name.is(DefaultGetterName)
+      }
+
+      if (shouldBeExposed)
+        sym.addAnnotation(jsdefn.ExposedJSMemberAnnot)
+    }
+  }
+}
+
+object PrepJSInterop {
+  val name: String = "prepjsinterop"
+  val description: String = "additional checks and transformations for Scala.js"
+
+  private final class OwnerKind private (private val baseKinds: Int) extends AnyVal {
+
+    inline def isBaseKind: Boolean =
+      Integer.lowestOneBit(baseKinds) == baseKinds && baseKinds != 0 // exactly 1 bit on
+
+    // cannot be `inline` because it accesses the private constructor
+    @inline def |(that: OwnerKind): OwnerKind =
+      new OwnerKind(this.baseKinds | that.baseKinds)
+
+    inline def is(that: OwnerKind): Boolean =
+      (this.baseKinds & that.baseKinds) != 0
+
+    inline def isnt(that: OwnerKind): Boolean =
+      !this.is(that)
+  }
+
+  private object OwnerKind {
+    /** No owner, i.e., we are at the top-level. */
+    val None = new OwnerKind(0x00)
+
+    // Base kinds - those form a partition of all possible enclosing owners
+
+    /** A Scala class/trait. */
+    val NonEnumScalaClass = new OwnerKind(0x01)
+    /** A Scala object. */
+    val NonEnumScalaMod = new OwnerKind(0x02)
+    /** A native JS class/trait, which extends js.Any. */
+    val JSNativeClass = new OwnerKind(0x04)
+    /** A native JS object, which extends js.Any. */
+    val JSNativeMod = new OwnerKind(0x08)
+    /** A non-native JS class (not a trait). */
+    val JSNonTraitClass = new OwnerKind(0x10)
+    /** A non-native JS trait. */
+    val JSTrait = new OwnerKind(0x20)
+    /** A non-native JS object. */
+    val JSMod = new OwnerKind(0x40)
+    /** A Scala class/trait that extends Enumeration. */
+    val EnumClass = new OwnerKind(0x80)
+    /** A Scala object that extends Enumeration. */
+    val EnumMod = new OwnerKind(0x100)
+    /** The Enumeration class itself. */
+    val EnumImpl = new OwnerKind(0x200)
+
+    // Compound kinds
+
+    /** A Scala class/trait, possibly Enumeration-related. */
+    val ScalaClass = NonEnumScalaClass | EnumClass | EnumImpl
+    /** A Scala object, possibly Enumeration-related. */
+    val ScalaMod = NonEnumScalaMod | EnumMod
+
+    /** A Scala class, trait or object, i.e., anything not extending js.Any. */
+    val ScalaType = ScalaClass | ScalaMod
+
+    /** A Scala class/trait/object extending Enumeration, but not Enumeration itself. */
+    val Enum = EnumClass | EnumMod
+
+    /** A native JS class/trait/object. */
+    val JSNative = JSNativeClass | JSNativeMod
+    /** A non-native JS class/trait/object. */
+    val JSNonNative = JSNonTraitClass | JSTrait | JSMod
+    /** A JS type, i.e., something extending js.Any. */
+    val JSType = JSNative | JSNonNative
+
+    /** Any kind of class/trait, i.e., a Scala or JS class/trait. */
+    val AnyClass = ScalaClass | JSNativeClass | JSNonTraitClass | JSTrait
+  }
+
+  /** Tests if the symbol extend `js.Any`.
+   *
+   *  This is different from `sym.isJSType` because it returns `false` for the
+   *  pseudo-union type.
+   */
+  def isJSAny(sym: Symbol)(using Context): Boolean =
+    sym.isSubClass(jsdefn.JSAnyClass)
+
+  /** Checks that a setter has the right signature.
+   *
+   *  Reports error messages otherwise.
+   */
+  def checkSetterSignature(sym: Symbol, pos: SrcPos, exported: Boolean)(using Context): Unit = {
+    val typeStr = if (exported) "Exported" else "JS"
+
+    val tpe = sym.info
+
+    // The result type must be Unit
+    if (!tpe.resultType.isRef(defn.UnitClass))
+      report.error(s"$typeStr setters must return Unit", pos)
+
+    // There must be exactly one non-varargs, non-default parameter
+    tpe.paramInfoss match {
+      case List(List(argInfo)) =>
+        // Arg list is OK. Do additional checks.
+        if (tpe.isVarArgsMethod)
+          report.error(s"$typeStr setters may not have repeated params", pos)
+        if (sym.hasDefaultParams)
+          report.error(s"$typeStr setters may not have default params", pos)
+
+      case _ =>
+        report.error(s"$typeStr setters must have exactly one argument", pos)
+    }
+  }
+
+  /** Tests whether the symbol has `private` in any form, either `private`,
+   *  `private[this]` or `private[Enclosing]`.
+   */
+  def isPrivateMaybeWithin(sym: Symbol)(using Context): Boolean =
+    sym.is(Private) || (sym.privateWithin.exists && !sym.is(Protected))
+
+  /** Checks that the optional argument to an `@JSGlobal` annotation is a
+   *  literal.
+   *
+   *  Reports an error on the annotation if it is not the case.
+   */
+  private def checkJSGlobalLiteral(annot: Annotation)(using Context): Unit = {
+    if (annot.arguments.nonEmpty) {
+      assert(annot.arguments.size == 1,
+          s"@JSGlobal annotation $annot has more than 1 argument")
+
+      val argIsValid = annot.argumentConstantString(0).isDefined
+      if (!argIsValid)
+        report.error("The argument to @JSGlobal must be a literal string.", annot.arguments.head)
+    }
+  }
+
+  /** Checks that arguments to an `@JSImport` annotation are literals.
+   *
+   *  The second argument can also be the singleton `JSImport.Namespace`
+   *  object.
+   *
+   *  Reports an error on the annotation if it is not the case.
+   */
+  private def checkJSImportLiteral(annot: Annotation)(using Context): Unit = {
+    val args = annot.arguments
+    val argCount = args.size
+    assert(argCount >= 1 && argCount <= 3,
+        i"@JSImport annotation $annot does not have between 1 and 3 arguments")
+
+    val firstArgIsValid = annot.argumentConstantString(0).isDefined
+    if (!firstArgIsValid)
+      report.error("The first argument to @JSImport must be a literal string.", args.head)
+
+    val secondArgIsValid = argCount < 2 || annot.argumentConstantString(1).isDefined || args(1).symbol == jsdefn.JSImportNamespaceModule
+    if (!secondArgIsValid)
+      report.error("The second argument to @JSImport must be literal string or the JSImport.Namespace object.", args(1))
+
+    val thirdArgIsValid = argCount < 3 || annot.argumentConstantString(2).isDefined
+    if (!thirdArgIsValid)
+      report.error("The third argument to @JSImport, when present, must be a literal string.", args(2))
+  }
+
+  private def checkAndGetJSNativeLoadingSpecAnnotOf(pos: SrcPos, sym: Symbol)(
+      using Context): Option[Annotation] = {
+
+    // Must not have @JSName
+
+    for (annot <- sym.getAnnotation(jsdefn.JSNameAnnot))
+      report.error("@JSName can only be used on members of JS types.", annot.tree)
+
+    // Must have exactly one JS native load spec annotation
+
+    val annots = sym.annotations.filter(annot => isJSNativeLoadingSpecAnnot(annot.symbol))
+
+    val badAnnotCountMsg =
+      if (sym.is(Module)) "Native JS objects must have exactly one annotation among @JSGlobal, @JSImport and @JSGlobalScope."
+      else "Native JS classes, vals and defs must have exactly one annotation among @JSGlobal and @JSImport."
+
+    annots match {
+      case Nil =>
+        report.error(badAnnotCountMsg, pos)
+        None
+      case result :: Nil =>
+        Some(result)
+      case _ =>
+        // Annotations are stored in reverse order, which we re-reverse now
+        val result :: duplicates = annots.reverse: @unchecked
+        for (annot <- duplicates)
+          report.error(badAnnotCountMsg, annot.tree)
+        Some(result)
+    }
+  }
+
+  /* Note that we consider @JSGlobalScope as a JS native loading spec because
+   * it's convenient for the purposes of PrepJSInterop. Actually @JSGlobalScope
+   * objects do not receive a JS loading spec in their IR.
+   */
+  private def isJSNativeLoadingSpecAnnot(sym: Symbol)(using Context): Boolean = {
+    sym == jsdefn.JSGlobalAnnot
+      || sym == jsdefn.JSImportAnnot
+      || sym == jsdefn.JSGlobalScopeAnnot
+  }
+
+  private def checkInternalAnnotations(sym: Symbol)(using Context): Unit = {
+    /** Returns true iff it is a compiler annotations. */
+    def isCompilerAnnotation(annotation: Annotation): Boolean = {
+      annotation.symbol == jsdefn.ExposedJSMemberAnnot
+        || annotation.symbol == jsdefn.JSTypeAnnot
+        || annotation.symbol == jsdefn.JSOptionalAnnot
+    }
+
+    for (annotation <- sym.annotations) {
+      if (isCompilerAnnotation(annotation)) {
+        report.error(
+            i"@${annotation.symbol.fullName} is for compiler internal use only. Do not use it yourself.",
+            annotation.tree)
+      }
+    }
+  }
+}
diff --git a/tests/pos-with-compiler-cc/dotc/typer/Applications.scala b/tests/pos-with-compiler-cc/dotc/typer/Applications.scala
new file mode 100644
index 000000000000..c62efa71fceb
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/typer/Applications.scala
@@ -0,0 +1,2383 @@
+package dotty.tools
+package dotc
+package typer
+
+import core._
+import ast.{Trees, tpd, untpd, desugar}
+import util.Stats.record
+import util.{SrcPos, NoSourcePosition}
+import Trees.Untyped
+import Contexts._
+import Flags._
+import Symbols._
+import Denotations.Denotation
+import Types._
+import Decorators._
+import ErrorReporting._
+import Trees._
+import Names._
+import StdNames._
+import ContextOps._
+import NameKinds.DefaultGetterName
+import ProtoTypes._
+import Inferencing._
+import reporting._
+import transform.TypeUtils._
+import transform.SymUtils._
+import Nullables._
+import config.Feature
+
+import collection.mutable
+import config.Printers.{overload, typr, unapp}
+import TypeApplications._
+import Annotations.Annotation
+
+import Constants.{Constant, IntTag}
+import Denotations.SingleDenotation
+import annotation.threadUnsafe
+
+import scala.util.control.NonFatal
+
+object Applications {
+  import tpd._
+
+  def extractorMember(tp: Type, name: Name)(using Context): SingleDenotation =
+    tp.member(name).suchThat(sym => sym.info.isParameterless && sym.info.widenExpr.isValueType)
+
+  def extractorMemberType(tp: Type, name: Name, errorPos: SrcPos)(using Context): Type = {
+    val ref = extractorMember(tp, name)
+    if (ref.isOverloaded)
+      errorType(i"Overloaded reference to $ref is not allowed in extractor", errorPos)
+    ref.info.widenExpr.annotatedToRepeated
+  }
+
+  /** Does `tp` fit the "product match" conditions as an unapply result type
+   *  for a pattern with `numArgs` subpatterns?
+   *  This is the case if `tp` has members `_1` to `_N` where `N == numArgs`.
+   */
+  def isProductMatch(tp: Type, numArgs: Int, errorPos: SrcPos = NoSourcePosition)(using Context): Boolean =
+    numArgs > 0 && productArity(tp, errorPos) == numArgs
+
+  /** Does `tp` fit the "product-seq match" conditions as an unapply result type
+   *  for a pattern with `numArgs` subpatterns?
+   *  This is the case if (1) `tp` has members `_1` to `_N` where `N <= numArgs + 1`.
+   *                      (2) `tp._N` conforms to Seq match
+   */
+  def isProductSeqMatch(tp: Type, numArgs: Int, errorPos: SrcPos = NoSourcePosition)(using Context): Boolean = {
+    val arity = productArity(tp, errorPos)
+    arity > 0 && arity <= numArgs + 1 &&
+      unapplySeqTypeElemTp(productSelectorTypes(tp, errorPos).last).exists
+  }
+
+  /** Does `tp` fit the "get match" conditions as an unapply result type?
+   *  This is the case of `tp` has a `get` member as well as a
+   *  parameterless `isEmpty` member of result type `Boolean`.
+   */
+  def isGetMatch(tp: Type, errorPos: SrcPos = NoSourcePosition)(using Context): Boolean =
+    extractorMemberType(tp, nme.isEmpty, errorPos).widenSingleton.isRef(defn.BooleanClass) &&
+    extractorMemberType(tp, nme.get, errorPos).exists
+
+  /** If `getType` is of the form:
+    *  ```
+    *  {
+    *    def lengthCompare(len: Int): Int // or, def length: Int
+    *    def apply(i: Int): T = a(i)
+    *    def drop(n: Int): scala.collection.Seq[T]
+    *    def toSeq: scala.collection.Seq[T]
+    *  }
+    *  ```
+    *  returns `T`, otherwise NoType.
+    */
+  def unapplySeqTypeElemTp(getTp: Type)(using Context): Type = {
+    def lengthTp = ExprType(defn.IntType)
+    def lengthCompareTp = MethodType(List(defn.IntType), defn.IntType)
+    def applyTp(elemTp: Type) = MethodType(List(defn.IntType), elemTp)
+    def dropTp(elemTp: Type) = MethodType(List(defn.IntType), defn.CollectionSeqType.appliedTo(elemTp))
+    def toSeqTp(elemTp: Type) = ExprType(defn.CollectionSeqType.appliedTo(elemTp))
+
+    // the result type of `def apply(i: Int): T`
+    val elemTp = getTp.member(nme.apply).suchThat(_.info <:< applyTp(WildcardType)).info.resultType
+
+    def hasMethod(name: Name, tp: Type) =
+      getTp.member(name).suchThat(getTp.memberInfo(_) <:< tp).exists
+
+    val isValid =
+      elemTp.exists &&
+      (hasMethod(nme.lengthCompare, lengthCompareTp) || hasMethod(nme.length, lengthTp)) &&
+      hasMethod(nme.drop, dropTp(elemTp)) &&
+      hasMethod(nme.toSeq, toSeqTp(elemTp))
+
+    if (isValid) elemTp else NoType
+  }
+
+  def productSelectorTypes(tp: Type, errorPos: SrcPos)(using Context): List[Type] = {
+    val sels = for (n <- Iterator.from(0)) yield extractorMemberType(tp, nme.selectorName(n), errorPos)
+    sels.takeWhile(_.exists).toList
+  }
+
+  def tupleComponentTypes(tp: Type)(using Context): List[Type] =
+    tp.widenExpr.dealias.normalized match
+    case tp: AppliedType =>
+      if defn.isTupleClass(tp.tycon.typeSymbol) then
+        tp.args
+      else if tp.tycon.derivesFrom(defn.PairClass) then
+        val List(head, tail) = tp.args
+        head :: tupleComponentTypes(tail)
+      else
+        Nil
+    case _ =>
+      Nil
+
+  def productArity(tp: Type, errorPos: SrcPos = NoSourcePosition)(using Context): Int =
+    if (defn.isProductSubType(tp)) productSelectorTypes(tp, errorPos).size else -1
+
+  def productSelectors(tp: Type)(using Context): List[Symbol] = {
+    val sels = for (n <- Iterator.from(0)) yield
+      tp.member(nme.selectorName(n)).suchThat(_.info.isParameterless).symbol
+    sels.takeWhile(_.exists).toList
+  }
+
+  def getUnapplySelectors(tp: Type, args: List[untpd.Tree], pos: SrcPos)(using Context): List[Type] =
+    if (args.length > 1 && !(tp.derivesFrom(defn.SeqClass))) {
+      val sels = productSelectorTypes(tp, pos)
+      if (sels.length == args.length) sels
+      else tp :: Nil
+    }
+    else tp :: Nil
+
+  def productSeqSelectors(tp: Type, argsNum: Int, pos: SrcPos)(using Context): List[Type] = {
+    val selTps = productSelectorTypes(tp, pos)
+    val arity = selTps.length
+    val elemTp = unapplySeqTypeElemTp(selTps.last)
+    (0 until argsNum).map(i => if (i < arity - 1) selTps(i) else elemTp).toList
+  }
+
+  def unapplyArgs(unapplyResult: Type, unapplyFn: Tree, args: List[untpd.Tree], pos: SrcPos)(using Context): List[Type] = {
+    def getName(fn: Tree): Name =
+      fn match
+        case TypeApply(fn, _) => getName(fn)
+        case Apply(fn, _) => getName(fn)
+        case fn: RefTree => fn.name
+    val unapplyName = getName(unapplyFn) // tolerate structural `unapply`, which does not have a symbol
+
+    def getTp = extractorMemberType(unapplyResult, nme.get, pos)
+
+    def fail = {
+      report.error(UnapplyInvalidReturnType(unapplyResult, unapplyName), pos)
+      Nil
+    }
+
+    def unapplySeq(tp: Type)(fallback: => List[Type]): List[Type] = {
+      val elemTp = unapplySeqTypeElemTp(tp)
+      if (elemTp.exists) args.map(Function.const(elemTp))
+      else if (isProductSeqMatch(tp, args.length, pos)) productSeqSelectors(tp, args.length, pos)
+      else if tp.derivesFrom(defn.NonEmptyTupleClass) then foldApplyTupleType(tp)
+      else fallback
+    }
+
+    if (unapplyName == nme.unapplySeq)
+      unapplySeq(unapplyResult) {
+        if (isGetMatch(unapplyResult, pos)) unapplySeq(getTp)(fail)
+        else fail
+      }
+    else {
+      assert(unapplyName == nme.unapply)
+      if (isProductMatch(unapplyResult, args.length, pos))
+        productSelectorTypes(unapplyResult, pos)
+      else if (isGetMatch(unapplyResult, pos))
+        getUnapplySelectors(getTp, args, pos)
+      else if (unapplyResult.widenSingleton isRef defn.BooleanClass)
+        Nil
+      else if (defn.isProductSubType(unapplyResult) && productArity(unapplyResult, pos) != 0)
+        productSelectorTypes(unapplyResult, pos)
+          // this will cause a "wrong number of arguments in pattern" error later on,
+          // which is better than the message in `fail`.
+      else if unapplyResult.derivesFrom(defn.NonEmptyTupleClass) then
+        foldApplyTupleType(unapplyResult)
+      else fail
+    }
+  }
+
+  def foldApplyTupleType(tp: Type)(using Context): List[Type] =
+    object tupleFold extends TypeAccumulator[List[Type]]:
+      override def apply(accum: List[Type], t: Type): List[Type] =
+        t match
+          case AppliedType(tycon, x :: x2 :: Nil) if tycon.typeSymbol == defn.PairClass =>
+            apply(x :: accum, x2)
+          case x => foldOver(accum, x)
+    end tupleFold
+    tupleFold(Nil, tp).reverse
+
+  def wrapDefs(defs: mutable.ListBuffer[Tree] | Null, tree: Tree)(using Context): Tree =
+    if (defs != null && defs.nonEmpty) tpd.Block(defs.toList, tree) else tree
+
+  /** Optionally, if `sym` is a symbol created by `resolveMapped`, i.e. representing
+   *  a mapped alternative, the original prefix of the alternative and the number of
+   *  skipped term parameters.
+   */
+  private def mappedAltInfo(sym: Symbol)(using Context): Option[(Type, Int)] =
+    for ann <- sym.getAnnotation(defn.MappedAlternativeAnnot) yield
+      val AppliedType(_, pre :: ConstantType(c) :: Nil) = ann.tree.tpe: @unchecked
+      (pre, c.intValue)
+
+  /** Find reference to default parameter getter for parameter #n in current
+   *  parameter list, or EmptyTree if none was found.
+   *  @param fn       the tree referring to the function part of this call
+   *  @param n        the index of the parameter in the parameter list of the call
+   *  @param testOnly true iff we just to find out whether a getter exists
+   */
+  def findDefaultGetter(fn: Tree, n: Int, testOnly: Boolean)(using Context): Tree =
+    def reifyPrefix(pre: Type): Tree = pre match
+      case pre: SingletonType => singleton(pre, needLoad = !testOnly)
+      case pre if testOnly =>
+        // In this case it is safe to skolemize now; we will produce a stable prefix for the actual call.
+        ref(pre.narrow)
+      case _ => EmptyTree
+
+    if fn.symbol.hasDefaultParams then
+      val meth = fn.symbol.asTerm
+      val idx = n + numArgs(fn)
+      methPart(fn) match
+        case Select(receiver, _) =>
+          findDefaultGetter(meth, receiver, idx)
+        case mr => mappedAltInfo(meth) match
+          case Some((pre, skipped)) =>
+            findDefaultGetter(meth, reifyPrefix(pre), idx + skipped)
+          case None =>
+            findDefaultGetter(meth, reifyPrefix(mr.tpe.normalizedPrefix), idx)
+    else EmptyTree // structural applies don't have symbols or defaults
+  end findDefaultGetter
+
+  /** Find reference to default parameter getter for method `meth` numbered `idx`
+   *  selected from given `receiver`, or EmptyTree if none was found.
+   *  @param meth     the called method (can be mapped by resolveMapped)
+   *  @param receiver the receiver of the original method call, which determines
+   *                  where default getters are found
+   *  @param idx      the index of the searched for default getter, as encoded in its name
+   */
+  def findDefaultGetter(meth: TermSymbol, receiver: Tree, idx: Int)(using Context): Tree =
+    val getterPrefix =
+      if (meth.is(Synthetic) && meth.name == nme.apply) nme.CONSTRUCTOR else meth.name
+    val getterName = DefaultGetterName(getterPrefix, idx)
+
+    if receiver.isEmpty then
+      def findGetter(cx: Context): Tree =
+        if cx eq NoContext then EmptyTree
+        else if cx.scope != cx.outer.scope
+            && cx.denotNamed(meth.name).hasAltWith(_.symbol == meth) then
+          val denot = cx.denotNamed(getterName)
+          if denot.exists then ref(TermRef(cx.owner.thisType, getterName, denot))
+          else findGetter(cx.outer)
+        else findGetter(cx.outer)
+      findGetter(ctx)
+    else
+      def selectGetter(qual: Tree): Tree =
+        val getterDenot = qual.tpe.member(getterName)
+        if (getterDenot.exists) qual.select(TermRef(qual.tpe, getterName, getterDenot))
+        else EmptyTree
+      if !meth.isClassConstructor then
+        selectGetter(receiver)
+      else
+        // default getters for class constructors are found in the companion object
+        val cls = meth.owner
+        val companion = cls.companionModule
+        if companion.isTerm then
+          val prefix = receiver.tpe.baseType(cls).normalizedPrefix
+          if prefix.exists then selectGetter(ref(TermRef(prefix, companion.asTerm)))
+          else EmptyTree
+        else EmptyTree
+  end findDefaultGetter
+
+  /** Splice new method reference `meth` into existing application `app` */
+  private def spliceMeth(meth: Tree, app: Tree)(using Context): Tree = app match {
+    case Apply(fn, args) =>
+      // Constructors always have one leading non-implicit parameter list.
+      // Empty list is inserted for constructors where the first parameter list is implicit.
+      //
+      // Therefore, we need to ignore the first empty argument list.
+      // This is needed for the test tests/neg/i12344.scala
+      //
+      // see NamerOps.normalizeIfConstructor
+      //
+      if args == Nil
+         && !fn.isInstanceOf[Apply]
+         && app.tpe.isImplicitMethod
+         && fn.symbol.isConstructor
+      then meth
+      else spliceMeth(meth, fn).appliedToArgs(args)
+    case TypeApply(fn, targs) =>
+      // Note: It is important that the type arguments `targs` are passed in new trees
+      // instead of being spliced in literally. Otherwise, a type argument to a default
+      // method could be constructed as the definition site of the type variable for
+      // that default constructor. This would interpolate type variables too early,
+      // causing lots of tests (among them tasty_unpickleScala2) to fail.
+      //
+      // The test case is in i1757.scala. Here we have a variable `s` and a method `cpy`
+      // defined like this:
+      //
+      //      var s
+      //      def cpy[X](b: List[Int] = b): B[X] = new B[X](b)
+      //
+      // The call `s.cpy()` then gets expanded to
+      //
+      //      { val $1$: B[Int] = this.s
+      //        $1$.cpy[X']($1$.cpy$default$1[X']
+      //      }
+      //
+      // A type variable gets interpolated if it does not appear in the type
+      // of the current tree and the current tree contains the variable's "definition".
+      // Previously, the polymorphic function tree to which the variable was first added
+      // was taken as the variable's definition. But that fails here because that
+      // tree was `s.cpy` but got transformed into `$1$.cpy`. We now take the type argument
+      // [X'] of the variable as its definition tree, which is more robust. But then
+      // it's crucial that the type tree is not copied directly as argument to
+      // `cpy$default$1`. If it was, the variable `X'` would already be interpolated
+      // when typing the default argument, which is too early.
+      spliceMeth(meth, fn).appliedToTypes(targs.tpes)
+    case _ => meth
+  }
+
+  def defaultArgument(fn: Tree, n: Int, testOnly: Boolean)(using Context): Tree =
+    val getter = findDefaultGetter(fn, n, testOnly)
+    if getter.isEmpty then getter
+    else spliceMeth(getter.withSpan(fn.span), fn)
+}
+
+trait Applications extends Compatibility {
+  self: Typer & Dynamic =>
+
+  import Applications._
+  import tpd.{ cpy => _, _ }
+  import untpd.cpy
+
+  /** @tparam Arg       the type of arguments, could be tpd.Tree, untpd.Tree, or Type
+   *  @param methRef    the reference to the method of the application
+   *  @param funType    the type of the function part of the application
+   *  @param args       the arguments of the application
+   *  @param resultType the expected result type of the application
+   */
+  abstract class Application[Arg](methRef: TermRef, funType: Type, args: List[Arg], resultType: Type)(using Context) {
+
+    /** The type of typed arguments: either tpd.Tree or Type */
+    type TypedArg
+
+    /** The kind of application that gets typed */
+    def applyKind: ApplyKind
+
+    /** Given an original argument and the type of the corresponding formal
+     *  parameter, produce a typed argument.
+     */
+    protected def typedArg(arg: Arg, formal: Type): TypedArg
+
+    /** Turn a typed tree into an argument */
+    protected def treeToArg(arg: Tree): Arg
+
+    /** Check that argument corresponds to type `formal` and
+     *  possibly add it to the list of adapted arguments
+     */
+    protected def addArg(arg: TypedArg, formal: Type): Unit
+
+    /** Is this an argument of the form `expr: _*` or a RepeatedParamType
+     *  derived from such an argument?
+     */
+    protected def isVarArg(arg: Arg): Boolean
+
+    /** If constructing trees, turn last `n` processed arguments into a
+     *  `SeqLiteral` tree with element type `elemFormal`.
+     */
+    protected def makeVarArg(n: Int, elemFormal: Type): Unit
+
+    /** If all `args` have primitive numeric types, make sure it's the same one */
+    protected def harmonizeArgs(args: List[TypedArg]): List[TypedArg]
+
+    /** Signal failure with given message at position of given argument */
+    protected def fail(msg: Message, arg: Arg): Unit
+
+    /** Signal failure with given message at position of the application itself */
+    protected def fail(msg: Message): Unit
+
+    protected def appPos: SrcPos
+
+    /** The current function part, which might be affected by lifting.
+     */
+    protected def normalizedFun: Tree
+
+    protected def typeOfArg(arg: Arg): Type
+
+    /** If constructing trees, pull out all parts of the function
+     *  which are not idempotent into separate prefix definitions
+     */
+    protected def liftFun(): Unit = ()
+
+    /** Whether `liftFun` is needed? It is the case if default arguments are used.
+     */
+    protected def needLiftFun: Boolean = {
+      def requiredArgNum(tp: Type): Int = tp.widen match {
+        case funType: MethodType =>
+          val paramInfos = funType.paramInfos
+          val argsNum = paramInfos.size
+          if (argsNum >= 1 && paramInfos.last.isRepeatedParam)
+            // Repeated arguments do not count as required arguments
+            argsNum - 1
+          else
+            argsNum
+        case funType: PolyType => requiredArgNum(funType.resultType)
+        case tp => args.size
+      }
+
+      !isJavaAnnotConstr(methRef.symbol) &&
+      args.size < requiredArgNum(funType)
+    }
+
+    /** A flag signalling that the typechecking the application was so far successful */
+    private var _ok = true
+
+    def ok: Boolean = _ok
+    def ok_=(x: Boolean): Unit = _ok = x
+
+    /** The function's type after widening and instantiating polytypes
+     *  with TypeParamRefs in constraint set
+     */
+    @threadUnsafe lazy val methType: Type = liftedFunType.widen match {
+      case funType: MethodType => funType
+      case funType: PolyType => instantiateWithTypeVars(funType)
+      case tp => tp //was: funType
+    }
+
+    @threadUnsafe lazy val liftedFunType: Type =
+      if (needLiftFun) {
+        liftFun()
+        normalizedFun.tpe
+      }
+      else funType
+
+    /** The arguments re-ordered so that each named argument matches the
+     *  same-named formal parameter.
+     */
+    @threadUnsafe lazy val orderedArgs: List[Arg] =
+      if (hasNamedArg(args))
+        reorder(args.asInstanceOf[List[untpd.Tree]]).asInstanceOf[List[Arg]]
+      else
+        args
+
+    protected def init(): Unit = methType match {
+      case methType: MethodType =>
+        val resultApprox = resultTypeApprox(methType)
+        val sym = methRef.symbol
+        if ctx.typerState.isCommittable then
+          // Here we call `resultType` only to accumulate constraints (even if
+          // it fails, we might be able to heal the expression to conform to the
+          // result type) so don't check for views since `viewExists` doesn't
+          // have any side-effect and would only slow the compiler down (cf #14333).
+          NoViewsAllowed.constrainResult(sym, resultApprox, resultType)
+        else if !constrainResult(sym, resultApprox, resultType) then
+          // Here we actually record that this alternative failed so that
+          // overloading resolution might prune it.
+          fail(TypeMismatch(methType.resultType, resultType, None))
+
+        // match all arguments with corresponding formal parameters
+        matchArgs(orderedArgs, methType.paramInfos, 0)
+      case _ =>
+        if (methType.isError) ok = false
+        else fail(s"$methString does not take parameters".toMessage)
+    }
+
+    /** The application was successful */
+    def success: Boolean = ok
+
+    protected def methodType: MethodType = methType.asInstanceOf[MethodType]
+    private def methString: String =
+      def infoStr = if methType.isErroneous then "" else i": $methType"
+      i"${err.refStr(methRef)}$infoStr"
+
+    /** Re-order arguments to correctly align named arguments */
+    def reorder[T >: Untyped](args: List[Trees.Tree[T]]): List[Trees.Tree[T]] = {
+
+      /** @param pnames    The list of parameter names that are missing arguments
+       *  @param args      The list of arguments that are not yet passed, or that are waiting to be dropped
+       *  @param nameToArg A map from as yet unseen names to named arguments
+       *  @param toDrop    A set of names that have already be passed as named arguments
+       *
+       *  For a well-typed application we have the invariants
+       *
+       *  1. `(args diff toDrop)` can be reordered to match `pnames`
+       *  2. For every `(name -> arg)` in `nameToArg`, `arg` is an element of `args`
+       */
+      def handleNamed(pnames: List[Name], args: List[Trees.Tree[T]],
+                      nameToArg: Map[Name, Trees.NamedArg[T]], toDrop: Set[Name]): List[Trees.Tree[T]] = pnames match {
+        case pname :: pnames1 if nameToArg contains pname =>
+          // there is a named argument for this parameter; pick it
+          nameToArg(pname) :: handleNamed(pnames1, args, nameToArg - pname, toDrop + pname)
+        case _ =>
+          def pnamesRest = if (pnames.isEmpty) pnames else pnames.tail
+          args match {
+            case (arg @ NamedArg(aname, _)) :: args1 =>
+              if (toDrop contains aname) // argument is already passed
+                handleNamed(pnames, args1, nameToArg, toDrop - aname)
+              else if ((nameToArg contains aname) && pnames.nonEmpty) // argument is missing, pass an empty tree
+                genericEmptyTree :: handleNamed(pnames.tail, args, nameToArg, toDrop)
+              else { // name not (or no longer) available for named arg
+                def msg =
+                  if (methodType.paramNames contains aname)
+                    s"parameter $aname of $methString is already instantiated"
+                  else
+                    s"$methString does not have a parameter $aname"
+                fail(msg.toMessage, arg.asInstanceOf[Arg])
+                arg :: handleNamed(pnamesRest, args1, nameToArg, toDrop)
+              }
+            case arg :: args1 =>
+              arg :: handleNamed(pnamesRest, args1, nameToArg, toDrop) // unnamed argument; pick it
+            case Nil => // no more args, continue to pick up any preceding named args
+              if (pnames.isEmpty) Nil
+              else handleNamed(pnamesRest, args, nameToArg, toDrop)
+          }
+      }
+
+      def handlePositional(pnames: List[Name], args: List[Trees.Tree[T]]): List[Trees.Tree[T]] =
+        args match {
+          case (arg: NamedArg @unchecked) :: _ =>
+            val nameAssocs = for (case arg @ NamedArg(name, _) <- args) yield (name, arg)
+            handleNamed(pnames, args, nameAssocs.toMap, Set())
+          case arg :: args1 =>
+            arg :: handlePositional(if (pnames.isEmpty) Nil else pnames.tail, args1)
+          case Nil => Nil
+        }
+
+      handlePositional(methodType.paramNames, args)
+    }
+
+    /** Is `sym` a constructor of a Java-defined annotation? */
+    def isJavaAnnotConstr(sym: Symbol): Boolean =
+      sym.is(JavaDefined) && sym.isConstructor && sym.owner.derivesFrom(defn.AnnotationClass)
+
+    /** Match re-ordered arguments against formal parameters
+     *  @param n   The position of the first parameter in formals in `methType`.
+     */
+    def matchArgs(args: List[Arg], formals: List[Type], n: Int): Unit =
+      if (success) formals match {
+        case formal :: formals1 =>
+
+          def checkNoVarArg(arg: Arg) =
+            if !ctx.isAfterTyper && isVarArg(arg) then
+              val addendum =
+                if formal.isRepeatedParam then
+                  i"it is not the only argument to be passed to the corresponding repeated parameter $formal"
+                else
+                  i"the corresponding parameter has type $formal which is not a repeated parameter type"
+              fail(em"Sequence argument type annotation `*` cannot be used here:\n$addendum".toMessage, arg)
+
+          /** Add result of typing argument `arg` against parameter type `formal`.
+           *  @return  The remaining formal parameter types. If the method is parameter-dependent
+           *           this means substituting the actual argument type for the current formal parameter
+           *           in the remaining formal parameters.
+           */
+          def addTyped(arg: Arg): List[Type] =
+            if !formal.isRepeatedParam then checkNoVarArg(arg)
+            addArg(typedArg(arg, formal), formal)
+            if methodType.isParamDependent && typeOfArg(arg).exists then
+              // `typeOfArg(arg)` could be missing because the evaluation of `arg` produced type errors
+              formals1.mapconserve(safeSubstParam(_, methodType.paramRefs(n), typeOfArg(arg)))
+            else
+              formals1
+
+          def missingArg(n: Int): Unit =
+            fail(MissingArgument(methodType.paramNames(n), methString))
+
+          def tryDefault(n: Int, args1: List[Arg]): Unit = {
+            val sym = methRef.symbol
+            val testOnly = this.isInstanceOf[TestApplication[?]]
+
+            val defaultArg =
+              if (isJavaAnnotConstr(sym)) {
+                val cinfo = sym.owner.asClass.classInfo
+                val pname = methodType.paramNames(n)
+                val hasDefault = cinfo.member(pname)
+                  .suchThat(d => d.is(Method) && d.hasAnnotation(defn.AnnotationDefaultAnnot)).exists
+
+                // Use `_` as a placeholder for the default value of an
+                // annotation parameter, this will be recognized by the backend.
+                if (hasDefault)
+                  tpd.Underscore(formal)
+                else
+                  EmptyTree
+              }
+              else defaultArgument(normalizedFun, n, testOnly)
+
+            def implicitArg = implicitArgTree(formal, appPos.span)
+
+            if !defaultArg.isEmpty then
+              defaultArg.tpe.widen match
+                case _: MethodOrPoly if testOnly => matchArgs(args1, formals1, n + 1)
+                case _ => matchArgs(args1, addTyped(treeToArg(defaultArg)), n + 1)
+            else if methodType.isContextualMethod && ctx.mode.is(Mode.ImplicitsEnabled) then
+              matchArgs(args1, addTyped(treeToArg(implicitArg)), n + 1)
+            else
+              missingArg(n)
+          }
+
+          if (formal.isRepeatedParam)
+            args match {
+              case arg :: Nil if isVarArg(arg) =>
+                addTyped(arg)
+              case (arg @ Typed(Literal(Constant(null)), _)) :: Nil if ctx.isAfterTyper =>
+                addTyped(arg)
+              case _ =>
+                val elemFormal = formal.widenExpr.argTypesLo.head
+                val typedArgs =
+                  harmonic(harmonizeArgs, elemFormal) {
+                    args.map { arg =>
+                      checkNoVarArg(arg)
+                      typedArg(arg, elemFormal)
+                    }
+                  }
+                typedArgs.foreach(addArg(_, elemFormal))
+                makeVarArg(args.length, elemFormal)
+            }
+          else args match {
+            case EmptyTree :: args1 =>
+              tryDefault(n, args1)
+            case arg :: args1 =>
+              matchArgs(args1, addTyped(arg), n + 1)
+            case nil =>
+              tryDefault(n, args)
+          }
+
+        case nil =>
+          args match {
+            case arg :: args1 =>
+              def msg = arg match
+                case untpd.Tuple(Nil)
+                if applyKind == ApplyKind.InfixTuple && funType.widen.isNullaryMethod =>
+                  i"can't supply unit value with infix notation because nullary $methString takes no arguments; use dotted invocation instead: (...).${methRef.name}()"
+                case _ =>
+                  i"too many arguments for $methString"
+              fail(msg.toMessage, arg)
+            case nil =>
+          }
+      }
+  }
+
+  /** The degree to which an argument has to match a formal parameter */
+  enum ArgMatch:
+    case Compatible    // argument is compatible with formal
+    case CompatibleCAP // capture-converted argument is compatible with formal
+
+  /** Subclass of Application for the cases where we are interested only
+   *  in a "can/cannot apply" answer, without needing to construct trees or
+   *  issue error messages.
+   */
+  abstract class TestApplication[Arg](methRef: TermRef, funType: Type, args: List[Arg], resultType: Type, argMatch: ArgMatch)(using Context)
+  extends Application[Arg](methRef, funType, args, resultType) {
+    type TypedArg = Arg
+    type Result = Unit
+
+    def applyKind = ApplyKind.Regular
+
+    protected def argOK(arg: TypedArg, formal: Type): Boolean = argType(arg, formal) match
+      case ref: TermRef if ref.denot.isOverloaded =>
+        // in this case we could not resolve overloading because no alternative
+        // matches expected type
+        false
+      case argtpe =>
+        val argtpe1 = argtpe.widen
+
+        def SAMargOK =
+          defn.isFunctionType(argtpe1) && formal.match
+            case SAMType(sam) => argtpe <:< sam.toFunctionType(isJava = formal.classSymbol.is(JavaDefined))
+            case _ => false
+
+        isCompatible(argtpe, formal)
+        // Only allow SAM-conversion to PartialFunction if implicit conversions
+        // are enabled. This is necessary to avoid ambiguity between an overload
+        // taking a PartialFunction and one taking a Function1 because
+        // PartialFunction extends Function1 but Function1 is SAM-convertible to
+        // PartialFunction. Concretely, given:
+        //
+        //   def foo(a: Int => Int): Unit = println("1")
+        //   def foo(a: PartialFunction[Int, Int]): Unit = println("2")
+        //
+        // - `foo(x => x)` will print 1, because the PartialFunction overload
+        //   won't be seen as applicable in the first call to
+        //   `resolveOverloaded`, this behavior happens to match what Java does
+        //   since PartialFunction is not a SAM type according to Java
+        //   (`isDefined` is abstract).
+        // - `foo { case x if x % 2 == 0 => x }` will print 2, because both
+        //    overloads are applicable, but PartialFunction is a subtype of
+        //    Function1 so it's more specific.
+        || (!formal.isRef(defn.PartialFunctionClass) || ctx.mode.is(Mode.ImplicitsEnabled)) && SAMargOK
+        || argMatch == ArgMatch.CompatibleCAP
+            && {
+              val argtpe1 = argtpe.widen
+              val captured = captureWildcards(argtpe1)
+              (captured ne argtpe1) && isCompatible(captured, formal.widenExpr)
+            }
+
+    /** The type of the given argument */
+    protected def argType(arg: Arg, formal: Type): Type
+
+    def typedArg(arg: Arg, formal: Type): Arg = arg
+    final def addArg(arg: TypedArg, formal: Type): Unit = ok = ok & argOK(arg, formal)
+    def makeVarArg(n: Int, elemFormal: Type): Unit = {}
+    def fail(msg: Message, arg: Arg): Unit =
+      ok = false
+    def fail(msg: Message): Unit =
+      ok = false
+    def appPos: SrcPos = NoSourcePosition
+    @threadUnsafe lazy val normalizedFun: Tree = ref(methRef, needLoad = false)
+    init()
+  }
+
+  /** Subclass of Application for applicability tests with type arguments and value
+   *  argument trees.
+   */
+  class ApplicableToTrees(methRef: TermRef, args: List[Tree], resultType: Type, argMatch: ArgMatch)(using Context)
+  extends TestApplication(methRef, methRef.widen, args, resultType, argMatch) {
+    def argType(arg: Tree, formal: Type): Type =
+      if untpd.isContextualClosure(arg) && defn.isContextFunctionType(formal) then arg.tpe
+      else normalize(arg.tpe, formal)
+    def treeToArg(arg: Tree): Tree = arg
+    def isVarArg(arg: Tree): Boolean = tpd.isWildcardStarArg(arg)
+    def typeOfArg(arg: Tree): Type = arg.tpe
+    def harmonizeArgs(args: List[Tree]): List[Tree] = harmonize(args)
+  }
+
+  /** Subclass of Application for applicability tests with value argument types. */
+  class ApplicableToTypes(methRef: TermRef, args: List[Type], resultType: Type, argMatch: ArgMatch)(using Context)
+  extends TestApplication(methRef, methRef, args, resultType, argMatch) {
+    def argType(arg: Type, formal: Type): Type = arg
+    def treeToArg(arg: Tree): Type = arg.tpe
+    def isVarArg(arg: Type): Boolean = arg.isRepeatedParam
+    def typeOfArg(arg: Type): Type = arg
+    def harmonizeArgs(args: List[Type]): List[Type] = harmonizeTypes(args)
+  }
+
+  /** Subclass of Application for type checking an Apply node, where
+   *  types of arguments are either known or unknown.
+   */
+  abstract class TypedApply[T >: Untyped](
+    app: untpd.Apply, fun: Tree, methRef: TermRef, args: List[Trees.Tree[T]], resultType: Type,
+    override val applyKind: ApplyKind)(using Context)
+  extends Application(methRef, fun.tpe, args, resultType) {
+    type TypedArg = Tree
+    def isVarArg(arg: Trees.Tree[T]): Boolean = untpd.isWildcardStarArg(arg)
+    private var typedArgBuf = new mutable.ListBuffer[Tree]
+    private var liftedDefs: mutable.ListBuffer[Tree] | Null = null
+    private var myNormalizedFun: Tree = fun
+    init()
+
+    def addArg(arg: Tree, formal: Type): Unit =
+      typedArgBuf += adapt(arg, formal.widenExpr)
+
+    def makeVarArg(n: Int, elemFormal: Type): Unit = {
+      val args = typedArgBuf.takeRight(n).toList
+      typedArgBuf.dropRightInPlace(n)
+      val elemtpt = TypeTree(elemFormal)
+      typedArgBuf += seqToRepeated(SeqLiteral(args, elemtpt))
+    }
+
+    def harmonizeArgs(args: List[TypedArg]): List[Tree] =
+      // harmonize args only if resType depends on parameter types
+      if (isFullyDefined(methodType.resType, ForceDegree.none)) args
+      else harmonize(args)
+
+    override def appPos: SrcPos = app.srcPos
+
+    def fail(msg: Message, arg: Trees.Tree[T]): Unit = {
+      report.error(msg, arg.srcPos)
+      ok = false
+    }
+
+    def fail(msg: Message): Unit = {
+      report.error(msg, app.srcPos)
+      ok = false
+    }
+
+    def normalizedFun:  Tree = myNormalizedFun
+
+    private def lifter(using Context) =
+      if (methRef.symbol.hasDefaultParams) LiftComplex else LiftImpure
+
+    override def liftFun(): Unit =
+      if (liftedDefs == null) {
+        liftedDefs = new mutable.ListBuffer[Tree]
+        myNormalizedFun = lifter.liftApp(liftedDefs.uncheckedNN, myNormalizedFun)
+      }
+
+    /** The index of the first difference between lists of trees `xs` and `ys`
+     *  -1 if there are no differences.
+     */
+    private def firstDiff[T <: Trees.Tree[?]](xs: List[T], ys: List[T], n: Int = 0): Int = xs match {
+      case x :: xs1 =>
+        ys match {
+          case y :: ys1 => if (x ne y) n else firstDiff(xs1, ys1, n + 1)
+          case nil => n
+        }
+      case nil =>
+        ys match {
+          case y :: ys1 => n
+          case nil => -1
+        }
+    }
+    private def sameSeq[T <: Trees.Tree[?]](xs: List[T], ys: List[T]): Boolean = firstDiff(xs, ys) < 0
+
+    /** An argument is safe if it is a pure expression or a default getter call
+     *  If all arguments are safe, no reordering is necessary
+     */
+    def isSafeArg(arg: Tree) =
+      isPureExpr(arg)
+      || arg.isInstanceOf[RefTree | Apply | TypeApply] && arg.symbol.name.is(DefaultGetterName)
+
+    val result:   Tree = {
+      var typedArgs = typedArgBuf.toList
+      def app0 = cpy.Apply(app)(normalizedFun, typedArgs) // needs to be a `def` because typedArgs can change later
+      val app1 =
+        if (!success) app0.withType(UnspecifiedErrorType)
+        else {
+          if !sameSeq(args, orderedArgs)
+             && !isJavaAnnotConstr(methRef.symbol)
+             && !typedArgs.forall(isSafeArg)
+          then
+            // need to lift arguments to maintain evaluation order in the
+            // presence of argument reorderings.
+
+            liftFun()
+
+            // lift arguments in the definition order
+            val argDefBuf = mutable.ListBuffer.empty[Tree]
+            typedArgs = lifter.liftArgs(argDefBuf, methType, typedArgs)
+            // Lifted arguments ordered based on the original order of typedArgBuf and
+            // with all non-explicit default parameters at the end in declaration order.
+            val orderedArgDefs = {
+              // Indices of original typed arguments that are lifted by liftArgs
+              val impureArgIndices = typedArgBuf.zipWithIndex.collect {
+                case (arg, idx) if !lifter.noLift(arg) => idx
+              }
+              def position(arg: Trees.Tree[T]) = {
+                val i = args.indexOf(arg)
+                if (i >= 0) i else orderedArgs.length
+              }
+              // The original indices of all ordered arguments, as an array
+              val originalIndices = orderedArgs.map(position).toArray
+              // Assuming stable sorting all non-explicit default parameters will remain in the end with the same order
+              val defaultParamIndex = typedArgs.size
+              // A map from lifted argument index to the corresponding position in the original argument list
+              def originalIndex(n: Int) =
+                if (n < originalIndices.length) originalIndices(n) else orderedArgs.length
+              scala.util.Sorting.stableSort[(Tree, Int), Int](
+                argDefBuf.zip(impureArgIndices), (arg, idx) => originalIndex(idx)).map(_._1)
+            }
+            liftedDefs.nn ++= orderedArgDefs
+          end if
+          if (sameSeq(typedArgs, args)) // trick to cut down on tree copying
+            typedArgs = args.asInstanceOf[List[Tree]]
+          assignType(app0, normalizedFun, typedArgs)
+        }
+      wrapDefs(liftedDefs, app1)
+    }
+  }
+
+  /** Subclass of Application for type checking an Apply node with untyped arguments. */
+  class ApplyToUntyped(
+    app: untpd.Apply, fun: Tree, methRef: TermRef, proto: FunProto,
+    resultType: Type)(using Context)
+  extends TypedApply(app, fun, methRef, proto.args, resultType, proto.applyKind) {
+    def typedArg(arg: untpd.Tree, formal: Type): TypedArg = proto.typedArg(arg, formal)
+    def treeToArg(arg: Tree): untpd.Tree = untpd.TypedSplice(arg)
+    def typeOfArg(arg: untpd.Tree): Type = proto.typeOfArg(arg)
+  }
+
+  /** Subclass of Application for type checking an Apply node with typed arguments. */
+  class ApplyToTyped(
+    app: untpd.Apply, fun: Tree, methRef: TermRef, args: List[Tree],
+    resultType: Type, applyKind: ApplyKind)(using Context)
+  extends TypedApply(app, fun, methRef, args, resultType, applyKind) {
+    def typedArg(arg: Tree, formal: Type): TypedArg = arg
+    def treeToArg(arg: Tree): Tree = arg
+    def typeOfArg(arg: Tree): Type = arg.tpe
+  }
+
+  /** If `app` is a `this(...)` constructor call, the this-call argument context,
+   *  otherwise the current context.
+   */
+  def argCtx(app: untpd.Tree)(using Context): Context =
+    if (ctx.owner.isClassConstructor && untpd.isSelfConstrCall(app)) ctx.thisCallArgContext
+    else ctx
+
+  /** Typecheck application. Result could be an `Apply` node,
+   *  or, if application is an operator assignment, also an `Assign` or
+   *  Block node.
+   */
+  def typedApply(tree: untpd.Apply, pt: Type)(using Context): Tree = {
+
+    def realApply(using Context): Tree = {
+      val resultProto = tree.fun match
+        case Select(New(tpt), _) if pt.isInstanceOf[ValueType] =>
+          if tpt.isType && typedAheadType(tpt).tpe.typeSymbol.typeParams.isEmpty then
+            IgnoredProto(pt)
+          else
+            pt // Don't ignore expected value types of `new` expressions with parameterized type.
+                // If we have a `new C()` with expected type `C[T]` we want to use the type to
+                // instantiate `C` immediately. This is necessary since `C` might _also_ have using
+                // clauses that we want to instantiate with the best available type. See i15664.scala.
+        case _ => IgnoredProto(pt)
+          // Do ignore other expected result types, since there might be an implicit conversion
+          // on the result. We could drop this if we disallow unrestricted implicit conversions.
+      val originalProto =
+        new FunProto(tree.args, resultProto)(this, tree.applyKind)(using argCtx(tree))
+      record("typedApply")
+      val fun1 = typedExpr(tree.fun, originalProto)
+
+      // If adaptation created a tupled dual of `originalProto`, pick the right version
+      // (tupled or not) of originalProto to proceed.
+      val proto =
+        if originalProto.hasTupledDual && needsTupledDual(fun1.tpe, originalProto)
+        then originalProto.tupledDual
+        else originalProto
+
+      /** Type application where arguments come from prototype, and no implicits are inserted */
+      def simpleApply(fun1: Tree, proto: FunProto)(using Context): Tree =
+        methPart(fun1).tpe match {
+          case funRef: TermRef =>
+            val app = ApplyTo(tree, fun1, funRef, proto, pt)
+            convertNewGenericArray(
+              widenEnumCase(
+                postProcessByNameArgs(funRef, app).computeNullable(),
+                pt))
+          case _ =>
+            handleUnexpectedFunType(tree, fun1)
+        }
+
+      /** Try same application with an implicit inserted around the qualifier of the function
+       *  part. Return an optional value to indicate success.
+       */
+      def tryWithImplicitOnQualifier(fun1: Tree, proto: FunProto)(using Context): Option[Tree] =
+        if ctx.mode.is(Mode.SynthesizeExtMethodReceiver) || proto.hasErrorArg then
+          // Suppress insertion of apply or implicit conversion on extension method receiver
+          // or if argument is erroneous by itself.
+          None
+        else
+          tryInsertImplicitOnQualifier(fun1, proto, ctx.typerState.ownedVars) flatMap { fun2 =>
+            tryEither {
+              Some(simpleApply(fun2, proto)): Option[Tree]
+            } {
+              (_, _) => None
+            }
+          }
+
+      fun1.tpe match {
+        case err: ErrorType => cpy.Apply(tree)(fun1, proto.typedArgs()).withType(err)
+        case TryDynamicCallType =>
+          val isInsertedApply = fun1 match {
+            case Select(_, nme.apply) => fun1.span.isSynthetic
+            case TypeApply(sel @ Select(_, nme.apply), _) => sel.span.isSynthetic
+            /* TODO Get rid of this case. It is still syntax-based, therefore unreliable.
+             * It is necessary for things like `someDynamic[T](...)`, because in that case,
+             * somehow typedFunPart returns a tree that was typed as `TryDynamicCallType`,
+             * so clearly with the view that an apply insertion was necessary, but doesn't
+             * actually insert the apply!
+             * This is probably something wrong in apply insertion, but I (@sjrd) am out of
+             * my depth there.
+             * In the meantime, this makes tests pass.
+             */
+            case TypeApply(fun, _) => !fun.isInstanceOf[Select]
+            case _ => false
+          }
+          typedDynamicApply(tree, isInsertedApply, pt)
+        case _ =>
+          if (originalProto.isDropped) fun1
+          else if (fun1.symbol == defn.Compiletime_summonFrom)
+            // Special handling of `summonFrom { ... }`.
+            // We currently cannot use a macro for that since unlike other inline methods
+            // summonFrom needs to expand lazily. For instance, in
+            //
+            //    summonFrom {
+            //      case given A[t] =>
+            //        summonFrom
+            //          case given `t` => ...
+            //        }
+            //    }
+            //
+            // the second `summonFrom` should expand only once the first `summonFrom` is
+            // evaluated and `t` is bound. But normal inline expansion does not behave that
+            // way: arguments to inline function are expanded before the function call.
+            // To make this work using regular inlining, we'd need a way to annotate
+            // an inline function that it should expand only if there are no enclosing
+            // applications of inline functions.
+            tree.args match {
+              case (arg @ Match(EmptyTree, cases)) :: Nil =>
+                cases.foreach { (t: untpd.CaseDef) => t match // !cc! explicity typed scrutinee is needed
+                  case CaseDef(Typed(_: untpd.Ident, _), _, _) => // OK
+                  case CaseDef(Bind(_, Typed(_: untpd.Ident, _)), _, _) => // OK
+                  case CaseDef(Ident(name), _, _) if name == nme.WILDCARD => // Ok
+                  case CaseDef(pat, _, _) =>
+                    report.error(UnexpectedPatternForSummonFrom(pat), pat.srcPos)
+                }
+                typed(untpd.InlineMatch(EmptyTree, cases).withSpan(tree.span), pt)
+              case _ =>
+                errorTree(tree, em"argument to summonFrom must be a pattern matching closure")
+            }
+          else
+            tryEither {
+              simpleApply(fun1, proto)
+            } {
+              (failedVal, failedState) =>
+                def fail = { failedState.commit(); failedVal }
+                // Try once with original prototype and once (if different) with tupled one.
+                // The reason we need to try both is that the decision whether to use tupled
+                // or not was already taken but might have to be revised when an implicit
+                // is inserted on the qualifier.
+                tryWithImplicitOnQualifier(fun1, originalProto).getOrElse(
+                  if (proto eq originalProto) fail
+                  else tryWithImplicitOnQualifier(fun1, proto).getOrElse(fail))
+            }
+      }
+    }
+
+    /** Convert expression like
+     *
+     *     e += (args)
+     *
+     *  where the lifted-for-assignment version of e is { val xs = es; e' } to
+     *
+     *     { val xs = es; e' = e' + args }
+     */
+    def typedOpAssign(using Context): Tree = {
+      val (lhs1, name, rhss) = (tree: @unchecked) match
+        case Apply(Select(lhs, name), rhss) => (typedExpr(lhs), name, rhss)
+        case Apply(untpd.TypedSplice(Select(lhs1, name)), rhss) => (lhs1, name, rhss)
+      val liftedDefs = new mutable.ListBuffer[Tree]
+      val lhs2 = untpd.TypedSplice(LiftComplex.liftAssigned(liftedDefs, lhs1))
+      val assign = untpd.Assign(lhs2,
+          untpd.Apply(untpd.Select(lhs2, name.asSimpleName.dropRight(1)), rhss))
+      wrapDefs(liftedDefs, typed(assign))
+    }
+
+    val app1 =
+      if (untpd.isOpAssign(tree))
+        tryEither {
+          realApply
+        } { (failedVal, failedState) =>
+          tryEither {
+            typedOpAssign
+          } { (_, _) =>
+            failedState.commit()
+            failedVal
+          }
+        }
+      else {
+        val app = tree.fun match
+          case _: untpd.Splice if ctx.mode.is(Mode.QuotedPattern) => typedAppliedSplice(tree, pt)
+          case _ => realApply
+        app match {
+          case Apply(fn @ Select(left, _), right :: Nil) if fn.hasType =>
+            val op = fn.symbol
+            if (op == defn.Any_== || op == defn.Any_!=)
+              checkCanEqual(left.tpe.widen, right.tpe.widen, app.span)
+          case _ =>
+        }
+        app
+      }
+    app1 match {
+      case Apply(Block(stats, fn), args) =>
+        tpd.cpy.Block(app1)(stats, tpd.cpy.Apply(app1)(fn, args))
+      case _ =>
+        app1
+    }
+  }
+
+  /** Typecheck an Apply node with a typed function and possibly-typed arguments coming from `proto` */
+  def ApplyTo(app: untpd.Apply, fun: tpd.Tree, methRef: TermRef, proto: FunProto, resultType: Type)(using Context): tpd.Tree =
+    val typer = ctx.typer
+    if (proto.allArgTypesAreCurrent())
+      typer.ApplyToTyped(app, fun, methRef, proto.typedArgs(), resultType, proto.applyKind).result
+    else
+      typer.ApplyToUntyped(app, fun, methRef, proto, resultType)(
+        using fun.nullableInArgContext(using argCtx(app))).result
+
+  /** Overridden in ReTyper to handle primitive operations that can be generated after erasure */
+  protected def handleUnexpectedFunType(tree: untpd.Apply, fun: Tree)(using Context): Tree =
+    if ctx.reporter.errorsReported then
+      throw TypeError(i"unexpected function type: ${methPart(fun).tpe}")
+    else
+      throw Error(i"unexpected type.\n  fun = $fun,\n  methPart(fun) = ${methPart(fun)},\n  methPart(fun).tpe = ${methPart(fun).tpe},\n  tpe = ${fun.tpe}")
+
+  def typedNamedArgs(args: List[untpd.Tree])(using Context): List[NamedArg] =
+    for (case arg @ NamedArg(id, argtpt) <- args) yield {
+      if !Feature.namedTypeArgsEnabled then
+        report.error(
+          i"""Named type arguments are experimental,
+             |they must be enabled with a `experimental.namedTypeArguments` language import or setting""",
+          arg.srcPos)
+      val argtpt1 = typedType(argtpt)
+      cpy.NamedArg(arg)(id, argtpt1).withType(argtpt1.tpe)
+    }
+
+  def typedTypeApply(tree: untpd.TypeApply, pt: Type)(using Context): Tree = {
+    if (ctx.mode.is(Mode.Pattern))
+      return errorTree(tree, "invalid pattern")
+
+    val isNamed = hasNamedArg(tree.args)
+    val typedArgs = if (isNamed) typedNamedArgs(tree.args) else tree.args.mapconserve(typedType(_))
+    record("typedTypeApply")
+    typedExpr(tree.fun, PolyProto(typedArgs, pt)) match {
+      case _: TypeApply if !ctx.isAfterTyper =>
+        errorTree(tree, "illegal repeated type application")
+      case typedFn =>
+        typedFn.tpe.widen match {
+          case pt: PolyType =>
+            if (typedArgs.length <= pt.paramInfos.length && !isNamed)
+              if (typedFn.symbol == defn.Predef_classOf && typedArgs.nonEmpty) {
+                val arg = typedArgs.head
+                if (!arg.symbol.is(Module)) // Allow `classOf[Foo.type]` if `Foo` is an object
+                  checkClassType(arg.tpe, arg.srcPos, traitReq = false, stablePrefixReq = false)
+              }
+          case _ =>
+        }
+        def tryDynamicTypeApply(): Tree = typedFn match {
+          case typedFn: Select if !pt.isInstanceOf[FunProto] => typedDynamicSelect(typedFn, typedArgs.map(untpd.TypedSplice(_)), pt)
+          case _                                             => tree.withType(TryDynamicCallType)
+        }
+        if (typedFn.tpe eq TryDynamicCallType) tryDynamicTypeApply()
+        else assignType(cpy.TypeApply(tree)(typedFn, typedArgs), typedFn, typedArgs)
+    }
+  }
+
+  /** Rewrite `new Array[T](....)` if T is an unbounded generic to calls to newGenericArray.
+   *  It is performed during typer as creation of generic arrays needs a classTag.
+   *  we rely on implicit search to find one.
+   */
+  def convertNewGenericArray(tree: Tree)(using Context): Tree = tree match {
+    case Apply(TypeApply(tycon, targs@(targ :: Nil)), args) if tycon.symbol == defn.ArrayConstructor =>
+      fullyDefinedType(tree.tpe, "array", tree.srcPos)
+
+      def newGenericArrayCall =
+        ref(defn.DottyArraysModule)
+          .select(defn.newGenericArrayMethod).withSpan(tree.span)
+          .appliedToTypeTrees(targs).appliedToTermArgs(args)
+
+      if (TypeErasure.isGeneric(targ.tpe))
+        newGenericArrayCall
+      else tree
+    case _ =>
+      tree
+  }
+
+  /** Is `tp` a unary function type or an overloaded type with with only unary function
+   *  types as alternatives?
+   */
+  def isUnary(tp: Type)(using Context): Boolean = tp match {
+    case tp: MethodicType =>
+      tp.firstParamTypes match {
+        case ptype :: Nil => !ptype.isRepeatedParam
+        case _ => false
+      }
+    case tp: TermRef =>
+      tp.denot.alternatives.forall(alt => isUnary(alt.info))
+    case _ =>
+      false
+  }
+
+  /** Should we tuple or untuple the argument before application?
+    *  If auto-tupling is enabled then
+    *
+    *   - we tuple n-ary arguments where n > 0 if the function consists
+    *     only of unary alternatives
+    *   - we untuple tuple arguments of infix operations if the function
+    *     does not consist only of unary alternatives.
+    */
+  def needsTupledDual(funType: Type, pt: FunProto)(using Context): Boolean =
+    pt.args match
+      case untpd.Tuple(elems) :: Nil =>
+        elems.length > 1
+        && pt.applyKind == ApplyKind.InfixTuple
+        && !isUnary(funType)
+      case args =>
+        args.lengthCompare(1) > 0
+        && isUnary(funType)
+        && Feature.autoTuplingEnabled
+
+  /** If `tree` is a complete application of a compiler-generated `apply`
+   *  or `copy` method of an enum case, widen its type to the underlying
+   *  type by means of a type ascription, as long as the widened type is
+   *  still compatible with the expected type.
+   *  The underlying type is the intersection of all class parents of the
+   *  original type.
+   */
+  def widenEnumCase(tree: Tree, pt: Type)(using Context): Tree =
+    val sym = tree.symbol
+    def isEnumCopy = sym.name == nme.copy && sym.owner.isEnumCase
+    def isEnumApply = sym.name == nme.apply && sym.owner.linkedClass.isEnumCase
+    if sym.is(Synthetic) && (isEnumApply || isEnumCopy)
+       && tree.tpe.classSymbol.isEnumCase
+       && tree.tpe.widen.isValueType
+    then
+      val widened = TypeComparer.dropTransparentTraits(
+        tree.tpe.parents.reduceLeft(TypeComparer.andType(_, _)),
+        pt)
+      if widened <:< pt then Typed(tree, TypeTree(widened))
+      else tree
+    else tree
+
+  /** Does `state` contain a  "NotAMember" or "MissingIdent" message as
+   *  first pending error message? That message would be
+   *  `$memberName is not a member of ...` or `Not found: $memberName`.
+   *  If memberName is empty, any name will do.
+   */
+  def saysNotFound(state: TyperState, memberName: Name)(using Context): Boolean =
+    state.reporter.pendingMessages match
+      case dia :: _ =>
+        dia.msg match
+          case msg: NotFoundMsg => memberName.isEmpty || msg.name == memberName
+          case _ => false
+      case _ => false
+
+  def typedUnApply(tree: untpd.Apply, selType: Type)(using Context): Tree = {
+    record("typedUnApply")
+    val Apply(qual, args) = tree
+    if !ctx.mode.is(Mode.InTypeTest) then
+      checkMatchable(selType, tree.srcPos, pattern = true)
+
+    def notAnExtractor(tree: Tree): Tree =
+      // prefer inner errors
+      // e.g. report not found ident instead of not an extractor in tests/neg/i2950.scala
+      if (!tree.tpe.isError && tree.tpe.isErroneous) tree
+      else errorTree(tree, NotAnExtractor(qual))
+
+    /** Report errors buffered in state.
+     *  @pre state has errors to report
+     *  If there is a single error stating that "unapply" is not a member, print
+     *  the more informative "notAnExtractor" message instead.
+     */
+    def reportErrors(tree: Tree, state: TyperState): Tree =
+      assert(state.reporter.hasErrors)
+      if saysNotFound(state, nme.unapply) then notAnExtractor(tree)
+      else
+        state.reporter.flush()
+        tree
+
+    /** If this is a term ref tree, try to typecheck with its type name.
+     *  If this refers to a type alias, follow the alias, and if
+     *  one finds a class, reference the class companion module.
+     */
+    def followTypeAlias(tree: untpd.Tree): untpd.Tree = {
+      tree match {
+        case tree: untpd.RefTree =>
+          val nestedCtx = ctx.fresh.setNewTyperState()
+          val ttree =
+            typedType(untpd.rename(tree, tree.name.toTypeName))(using nestedCtx)
+          ttree.tpe match {
+            case alias: TypeRef if alias.info.isTypeAlias && !nestedCtx.reporter.hasErrors =>
+              Inferencing.companionRef(alias) match {
+                case companion: TermRef => return untpd.ref(companion).withSpan(tree.span)
+                case _ =>
+              }
+            case _ =>
+          }
+        case _ =>
+      }
+      untpd.EmptyTree
+    }
+
+    /** A typed qual.unapply or qual.unapplySeq tree, if this typechecks.
+     *  Otherwise fallBack with (maltyped) qual.unapply as argument
+     *  Note: requires special handling for overloaded occurrences of
+     *  unapply or unapplySeq. We first try to find a non-overloaded
+     *  method which matches any type. If that fails, we try to find an
+     *  overloaded variant which matches one of the argument types.
+     *  In fact, overloaded unapply's are problematic because a non-
+     *  overloaded unapply does *not* need to be applicable to its argument
+     *  whereas overloaded variants need to have a conforming variant.
+     */
+    def trySelectUnapply(qual: untpd.Tree)(fallBack: (Tree, TyperState) => Tree): Tree = {
+      // try first for non-overloaded, then for overloaded occurrences
+      def tryWithName(name: TermName)(fallBack: (Tree, TyperState) => Tree)(using Context): Tree =
+
+        def tryWithProto(qual: untpd.Tree, targs: List[Tree], pt: Type)(using Context) =
+          val proto = UnapplyFunProto(pt, this)
+          val unapp = untpd.Select(qual, name)
+          val result =
+            if targs.isEmpty then typedExpr(unapp, proto)
+            else typedExpr(unapp, PolyProto(targs, proto)).appliedToTypeTrees(targs)
+          if !result.symbol.exists
+             || result.symbol.name == name
+             || ctx.reporter.hasErrors
+          then result
+          else notAnExtractor(result)
+          	// It might be that the result of typedExpr is an `apply` selection or implicit conversion.
+          	// Reject in this case.
+
+        def tryWithTypeArgs(qual: untpd.Tree, targs: List[Tree])(fallBack: (Tree, TyperState) => Tree): Tree =
+          tryEither {
+            tryWithProto(qual, targs, selType)
+          } {
+            (sel, state) =>
+              tryEither {
+                tryWithProto(qual, targs, WildcardType)
+              } {
+                (_, _) => fallBack(sel, state)
+              }
+          }
+
+        qual match
+          case TypeApply(qual1, targs) =>
+            tryWithTypeArgs(qual1, targs.mapconserve(typedType(_)))((t, ts) =>
+              tryWithTypeArgs(qual, Nil)(fallBack))
+          case _ =>
+            tryWithTypeArgs(qual, Nil)(fallBack)
+      end tryWithName
+
+      // try first for unapply, then for unapplySeq
+      tryWithName(nme.unapply) {
+        (sel, state) =>
+          tryWithName(nme.unapplySeq) {
+            (sel2, state2) =>
+              // if both fail, return unapply error, unless that is simply a
+              // "not a member", and the unapplySeq error is more refined.
+              if saysNotFound(state, nme.unapply) && !saysNotFound(state2, nme.unapplySeq)
+              then fallBack(sel2, state2)
+              else fallBack(sel, state)
+          }
+      }
+    }
+
+    /** Produce a typed qual.unapply or qual.unapplySeq tree, or
+     *  else if this fails follow a type alias and try again.
+     */
+    var unapplyFn =
+      trySelectUnapply(qual) {
+        (sel, state) =>
+          val qual1 = followTypeAlias(qual)
+          if (qual1.isEmpty) reportErrors(sel, state)
+          else trySelectUnapply(qual1) {
+            (_, state) => reportErrors(sel, state)
+          }
+      }
+
+    /** Add a `Bind` node for each `bound` symbol in a type application `unapp` */
+    def addBinders(unapp: Tree, bound: List[Symbol]) = unapp match {
+      case TypeApply(fn, args) =>
+        var remain = bound.toSet
+        def addBinder(arg: Tree) = arg.tpe.stripTypeVar match {
+          case ref: TypeRef if remain.contains(ref.symbol) =>
+            remain -= ref.symbol
+            tpd.Bind(ref.symbol, Ident(ref))
+          case _ =>
+            arg
+        }
+        tpd.cpy.TypeApply(unapp)(fn, args.mapConserve(addBinder))
+      case _ =>
+        unapp
+    }
+
+    unapplyFn.tpe.widen match {
+      case mt: MethodType if mt.paramInfos.length == 1 =>
+        val unapplyArgType = mt.paramInfos.head
+        unapp.println(i"unapp arg tpe = $unapplyArgType, pt = $selType")
+        val ownType =
+          if (selType <:< unapplyArgType) {
+            unapp.println(i"case 1 $unapplyArgType ${ctx.typerState.constraint}")
+            fullyDefinedType(unapplyArgType, "pattern selector", tree.srcPos)
+            selType.dropAnnot(defn.UncheckedAnnot) // need to drop @unchecked. Just because the selector is @unchecked, the pattern isn't.
+          }
+          else {
+            // We ignore whether constraining the pattern succeeded.
+            // Constraining only fails if the pattern cannot possibly match,
+            // but useless pattern checks detect more such cases, so we simply rely on them instead.
+            withMode(Mode.GadtConstraintInference)(TypeComparer.constrainPatternType(unapplyArgType, selType))
+            val patternBound = maximizeType(unapplyArgType, unapplyFn.span.endPos)
+            if (patternBound.nonEmpty) unapplyFn = addBinders(unapplyFn, patternBound)
+            unapp.println(i"case 2 $unapplyArgType ${ctx.typerState.constraint}")
+            unapplyArgType
+          }
+        val dummyArg = dummyTreeOfType(ownType)
+        val unapplyApp = typedExpr(untpd.TypedSplice(Apply(unapplyFn, dummyArg :: Nil)))
+        def unapplyImplicits(unapp: Tree): List[Tree] = {
+          val res = List.newBuilder[Tree]
+          def loop(unapp: Tree): Unit = unapp match {
+            case Apply(Apply(unapply, `dummyArg` :: Nil), args2) => assert(args2.nonEmpty); res ++= args2
+            case Apply(unapply, `dummyArg` :: Nil) =>
+            case Inlined(u, _, _) => loop(u)
+            case DynamicUnapply(_) => report.error("Structural unapply is not supported", unapplyFn.srcPos)
+            case Apply(fn, args) => assert(args.nonEmpty); loop(fn); res ++= args
+            case _ => ().assertingErrorsReported
+          }
+          loop(unapp)
+          res.result()
+        }
+
+        var argTypes = unapplyArgs(unapplyApp.tpe, unapplyFn, args, tree.srcPos)
+        for (argType <- argTypes) assert(!isBounds(argType), unapplyApp.tpe.show)
+        val bunchedArgs = argTypes match {
+          case argType :: Nil =>
+            if (args.lengthCompare(1) > 0 && Feature.autoTuplingEnabled && defn.isTupleNType(argType)) untpd.Tuple(args) :: Nil
+            else args
+          case _ => args
+        }
+        if (argTypes.length != bunchedArgs.length) {
+          report.error(UnapplyInvalidNumberOfArguments(qual, argTypes), tree.srcPos)
+          argTypes = argTypes.take(args.length) ++
+            List.fill(argTypes.length - args.length)(WildcardType)
+        }
+        val unapplyPatterns = bunchedArgs.lazyZip(argTypes) map (typed(_, _))
+        val result = assignType(cpy.UnApply(tree)(unapplyFn, unapplyImplicits(unapplyApp), unapplyPatterns), ownType)
+        unapp.println(s"unapply patterns = $unapplyPatterns")
+        if (ownType.stripped eq selType.stripped) || ownType.isError then result
+        else tryWithTypeTest(Typed(result, TypeTree(ownType)), selType)
+      case tp =>
+        val unapplyErr = if (tp.isError) unapplyFn else notAnExtractor(unapplyFn)
+        val typedArgsErr = args mapconserve (typed(_, defn.AnyType))
+        cpy.UnApply(tree)(unapplyErr, Nil, typedArgsErr) withType unapplyErr.tpe
+    }
+  }
+
+  /** A typed unapply hook, can be overridden by re any-typers between frontend
+   *  and pattern matcher.
+   */
+  def typedUnApply(tree: untpd.UnApply, selType: Type)(using Context): UnApply =
+    throw new UnsupportedOperationException("cannot type check an UnApply node")
+
+  /** Is given method reference applicable to argument trees `args`?
+   *  @param  resultType   The expected result type of the application
+   */
+  def isApplicableMethodRef(methRef: TermRef, args: List[Tree], resultType: Type, keepConstraint: Boolean, argMatch: ArgMatch)(using Context): Boolean = {
+    def isApp(using Context): Boolean =
+      new ApplicableToTrees(methRef, args, resultType, argMatch).success
+    if (keepConstraint) isApp else explore(isApp)
+  }
+
+  /** Is given method reference applicable to argument types `args`?
+   *  @param  resultType   The expected result type of the application
+   */
+  def isApplicableMethodRef(methRef: TermRef, args: List[Type], resultType: Type, argMatch: ArgMatch)(using Context): Boolean =
+    explore(new ApplicableToTypes(methRef, args, resultType, argMatch).success)
+
+  /** Is given type applicable to argument trees `args`, possibly after inserting an `apply`?
+   *  @param  resultType   The expected result type of the application
+   */
+  def isApplicableType(tp: Type, args: List[Tree], resultType: Type, keepConstraint: Boolean)(using Context): Boolean =
+    onMethod(tp, args.nonEmpty) {
+      isApplicableMethodRef(_, args, resultType, keepConstraint, ArgMatch.Compatible)
+    }
+
+  /** Is given type applicable to argument types `args`, possibly after inserting an `apply`?
+   *  @param  resultType   The expected result type of the application
+   */
+  def isApplicableType(tp: Type, args: List[Type], resultType: Type)(using Context): Boolean =
+    onMethod(tp, args.nonEmpty) {
+      isApplicableMethodRef(_, args, resultType, ArgMatch.Compatible)
+    }
+
+  private def onMethod(tp: Type, followApply: Boolean)(p: TermRef => Boolean)(using Context): Boolean = tp match {
+    case methRef: TermRef if methRef.widenSingleton.isInstanceOf[MethodicType] =>
+      p(methRef)
+    case mt: MethodicType =>
+      p(mt.narrow)
+    case _ =>
+      followApply && tp.member(nme.apply).hasAltWith(d => p(TermRef(tp, nme.apply, d)))
+  }
+
+  /** Does `tp` have an extension method named `xname` with this-argument `argType` and
+   *  result matching `resultType`?
+   */
+  def hasExtensionMethodNamed(tp: Type, xname: TermName, argType: Type, resultType: Type)(using Context) = {
+    def qualifies(mbr: Denotation) =
+      mbr.exists
+      && isApplicableType(
+            normalize(tp.select(xname, mbr), WildcardType),
+            argType :: Nil, resultType)
+    tp.memberBasedOnFlags(xname, required = ExtensionMethod) match {
+      case mbr: SingleDenotation => qualifies(mbr)
+      case mbr => mbr.hasAltWith(qualifies(_))
+    }
+  }
+
+  /** Drop any leading type or implicit parameter sections */
+  def stripInferrable(tp: Type)(using Context): Type = tp match {
+    case mt: MethodType if mt.isImplicitMethod =>
+      stripInferrable(resultTypeApprox(mt))
+    case pt: PolyType =>
+      stripInferrable(pt.resType)
+    case _ =>
+      tp
+  }
+
+  /** Drop any leading implicit parameter sections */
+  def stripImplicit(tp: Type)(using Context): Type = tp match {
+    case mt: MethodType if mt.isImplicitMethod =>
+      stripImplicit(resultTypeApprox(mt))
+    case pt: PolyType =>
+      pt.derivedLambdaType(pt.paramNames, pt.paramInfos, stripImplicit(pt.resultType)).asInstanceOf[PolyType].flatten
+    case _ =>
+      tp
+  }
+
+  /** Compare owner inheritance level.
+    *  @param    sym1 The first owner
+    *  @param    sym2 The second owner
+    *  @return    1   if `sym1` properly derives from `sym2`
+    *            -1   if `sym2` properly derives from `sym1`
+    *             0   otherwise
+    *  Module classes also inherit the relationship from their companions. This means,
+    *  if no direct derivation exists between `sym1` and `sym2` also perform the following
+    *  tests:
+    *   - If both sym1 and sym1 are module classes that have companion classes,
+    *     and sym2 does not inherit implicit members from a base class (#),
+    *     compare the companion classes.
+    *   - If sym1 is a module class with a companion, and sym2 is a normal class or trait,
+    *     compare the companion with sym2.
+    *
+    *  Condition (#) is necessary to make `compareOwner(_, _) > 0` a transitive relation.
+    *  For instance:
+    *
+    *    class A extends B
+    *    object A { given a ... }
+    *    class B
+    *    object B extends C { given b ... }
+    *    class C { given c }
+    *
+    *  Then without (#), and taking A$ for the module class of A,
+    *  compareOwner(A$, B$) = 1 and compareOwner(B$, C) == 1,
+    *  but compareOwner(A$, C) == 0.
+    *  Violating transitivity in this way is bad, since it makes implicit search
+    *  outcomes compilation order dependent. E.g. if we compare `b` with `c`
+    *  first, we pick `b`. Then, if we compare `a` and `b`, we pick `a` as
+    *  solution of the search. But if we start with comparing `a` with `c`,
+    *  we get an ambiguity.
+    *
+    *  With the added condition (#), compareOwner(A$, B$) == 0.
+    *  This means we get an ambiguity between `a` and `b` in all cases.
+    */
+  def compareOwner(sym1: Symbol, sym2: Symbol)(using Context): Int =
+    if sym1 == sym2 then 0
+    else if sym1.isSubClass(sym2) then 1
+    else if sym2.isSubClass(sym1) then -1
+    else if sym1.is(Module) then
+      val cls1 = sym1.companionClass
+      if sym2.is(Module) then
+        if sym2.thisType.implicitMembers.forall(_.symbol.owner == sym2) then // test for (#)
+          compareOwner(cls1, sym2.companionClass)
+        else 0
+      else compareOwner(cls1, sym2)
+    else 0
+
+  /** Compare two alternatives of an overloaded call or an implicit search.
+   *
+   *  @param  alt1, alt2      Non-overloaded references indicating the two choices
+   *  @return  1   if 1st alternative is preferred over 2nd
+   *          -1   if 2nd alternative is preferred over 1st
+   *           0   if neither alternative is preferred over the other
+   *
+   *  Normal symbols are always preferred over constructor proxies. Otherwise,
+   *  an alternative A1 is preferred over an alternative A2 if it wins in a tournament
+   *  that awards one point for each of the following:
+   *
+   *   - A1's owner derives from A2's owner.
+   *   - A1's type is more specific than A2's type.
+   *
+   *  If that tournament yields a draw, a tiebreak is applied where
+   *  an alternative that takes more implicit parameters wins over one
+   *  that takes fewer.
+   */
+  def compare(alt1: TermRef, alt2: TermRef)(using Context): Int = trace(i"compare($alt1, $alt2)", overload) {
+    record("resolveOverloaded.compare")
+
+    /** Is alternative `alt1` with type `tp1` as specific as alternative
+     *  `alt2` with type `tp2` ?
+     *
+     *    1. A method `alt1` of type `(p1: T1, ..., pn: Tn)U` is as specific as `alt2`
+     *       if `alt1` is nullary or `alt2` is applicable to arguments (p1, ..., pn) of
+     *       types T1,...,Tn. If the last parameter `pn` has a vararg type T*, then
+     *       `alt1` must be applicable to arbitrary numbers of `T` parameters (which
+     *       implies that it must be a varargs method as well).
+     *    2. A polymorphic member of type [a1 >: L1 <: U1, ..., an >: Ln <: Un]T is as
+     *       specific as `alt2` of type `tp2` if T is as specific as `tp2` under the
+     *       assumption that for i = 1,...,n each ai is an abstract type name bounded
+     *       from below by Li and from above by Ui.
+     *    3. A member of any other type `tp1` is:
+     *       a. always as specific as a method or a polymorphic method.
+     *       b. as specific as a member of any other type `tp2` if `tp1` is compatible
+     *          with `tp2`.
+     */
+    def isAsSpecific(alt1: TermRef, tp1: Type, alt2: TermRef, tp2: Type): Boolean = trace(i"isAsSpecific $tp1 $tp2", overload) {
+      tp1 match
+        case tp1: MethodType => // (1)
+          tp1.paramInfos.isEmpty && tp2.isInstanceOf[LambdaType]
+          || {
+            if tp1.isVarArgsMethod then
+              tp2.isVarArgsMethod
+              && isApplicableMethodRef(alt2, tp1.paramInfos.map(_.repeatedToSingle), WildcardType, ArgMatch.Compatible)
+            else
+              isApplicableMethodRef(alt2, tp1.paramInfos, WildcardType, ArgMatch.Compatible)
+          }
+        case tp1: PolyType => // (2)
+          inContext(ctx.fresh.setExploreTyperState()) {
+            // Fully define the PolyType parameters so that the infos of the
+            // tparams created below never contain TypeRefs whose underling types
+            // contain uninstantiated TypeVars, this could lead to cycles in
+            // `isSubType` as a TypeVar might get constrained by a TypeRef it's
+            // part of.
+            val tp1Params = tp1.newLikeThis(tp1.paramNames, tp1.paramInfos, defn.AnyType)
+            fullyDefinedType(tp1Params, "type parameters of alternative", alt1.symbol.srcPos)
+
+            val tparams = newTypeParams(alt1.symbol, tp1.paramNames, EmptyFlags, tp1.instantiateParamInfos(_))
+            isAsSpecific(alt1, tp1.instantiate(tparams.map(_.typeRef)), alt2, tp2)
+          }
+        case _ => // (3)
+          tp2 match
+            case tp2: MethodType => true // (3a)
+            case tp2: PolyType if tp2.resultType.isInstanceOf[MethodType] => true // (3a)
+            case tp2: PolyType => // (3b)
+              explore(isAsSpecificValueType(tp1, instantiateWithTypeVars(tp2)))
+            case _ => // 3b)
+              isAsSpecificValueType(tp1, tp2)
+    }
+
+    /** Test whether value type `tp1` is as specific as value type `tp2`.
+     *  Let's abbreviate this to `tp1 <:s tp2`.
+     *  Previously, `<:s` was the same as `<:`. This behavior is still
+     *  available under mode `Mode.OldOverloadingResolution`. The new behavior
+     *  is different, however. Here, `T <:s U` iff
+     *
+     *    flip(T) <: flip(U)
+     *
+     *  where `flip` changes covariant occurrences of contravariant type parameters to
+     *  covariant ones. Intuitively `<:s` means subtyping `<:`, except that all arguments
+     *  to contravariant parameters are compared as if they were covariant. E.g. given class
+     *
+     *     class Cmp[-X]
+     *
+     *  `Cmp[T] <:s Cmp[U]` if `T <: U`. On the other hand, non-variant occurrences
+     *  of parameters are not affected. So `T <: U` would imply `Set[Cmp[U]] <:s Set[Cmp[T]]`,
+     *  as usual, because `Set` is non-variant.
+     *
+     *  This relation might seem strange, but it models closely what happens for methods.
+     *  Indeed, if we integrate the existing rules for methods into `<:s` we have now that
+     *
+     *     (T)R  <:s  (U)R
+     *
+     *  iff
+     *
+     *     T => R  <:s  U => R
+     *
+     *  Also: If a compared type refers to a given or its module class, use
+     *  the intersection of its parent classes instead.
+     */
+    def isAsSpecificValueType(tp1: Type, tp2: Type)(using Context) =
+      if (ctx.mode.is(Mode.OldOverloadingResolution))
+        isCompatible(tp1, tp2)
+      else {
+        val flip = new TypeMap {
+          def apply(t: Type) = t match {
+            case t @ AppliedType(tycon, args) =>
+              def mapArg(arg: Type, tparam: TypeParamInfo) =
+                if (variance > 0 && tparam.paramVarianceSign < 0) defn.FunctionOf(arg :: Nil, defn.UnitType)
+                else arg
+              mapOver(t.derivedAppliedType(tycon, args.zipWithConserve(tycon.typeParams)(mapArg)))
+            case _ => mapOver(t)
+          }
+        }
+        def prepare(tp: Type) = tp.stripTypeVar match {
+          case tp: NamedType if tp.symbol.is(Module) && tp.symbol.sourceModule.is(Given) =>
+            flip(tp.widen.widenToParents)
+          case _ => flip(tp)
+        }
+        (prepare(tp1) relaxed_<:< prepare(tp2)) || viewExists(tp1, tp2)
+      }
+
+    /** Widen the result type of synthetic given methods from the implementation class to the
+     *  type that's implemented. Example
+     *
+     *      given I[X]: T with { ... }
+     *
+     *  This desugars to
+     *
+     *      class I[X] extends T { ... }
+     *      implicit def I[X]: I[X] = new I[X]
+     *
+     *  To compare specificity we should compare with `T`, not with its implementation `I[X]`.
+     *  No such widening is performed for given aliases, which are not synthetic. E.g.
+     *
+     *      given J[X]: T = rhs
+     *
+     *  already has the right result type `T`. Neither is widening performed for given
+     *  objects, since these are anyway taken to be more specific than methods
+     *  (by condition 3a above).
+     */
+    def widenGiven(tp: Type, alt: TermRef): Type = tp match {
+      case mt: MethodType if mt.isImplicitMethod =>
+        mt.derivedLambdaType(mt.paramNames, mt.paramInfos, widenGiven(mt.resultType, alt))
+      case pt: PolyType =>
+        pt.derivedLambdaType(pt.paramNames, pt.paramInfos, widenGiven(pt.resultType, alt))
+      case rt =>
+        if alt.symbol.isCoDefinedGiven(rt.typeSymbol) then tp.widenToParents
+        else tp
+    }
+
+    def compareWithTypes(tp1: Type, tp2: Type) = {
+      val ownerScore = compareOwner(alt1.symbol.maybeOwner, alt2.symbol.maybeOwner)
+      def winsType1 = isAsSpecific(alt1, tp1, alt2, tp2)
+      def winsType2 = isAsSpecific(alt2, tp2, alt1, tp1)
+
+      overload.println(i"compare($alt1, $alt2)? $tp1 $tp2 $ownerScore $winsType1 $winsType2")
+      if (ownerScore == 1)
+        if (winsType1 || !winsType2) 1 else 0
+      else if (ownerScore == -1)
+        if (winsType2 || !winsType1) -1 else 0
+      else if (winsType1)
+        if (winsType2) 0 else 1
+      else
+        if (winsType2) -1 else 0
+    }
+
+    if alt1.symbol.is(ConstructorProxy) && !alt2.symbol.is(ConstructorProxy) then -1
+    else if alt2.symbol.is(ConstructorProxy) && !alt1.symbol.is(ConstructorProxy) then 1
+    else
+      val fullType1 = widenGiven(alt1.widen, alt1)
+      val fullType2 = widenGiven(alt2.widen, alt2)
+      val strippedType1 = stripImplicit(fullType1)
+      val strippedType2 = stripImplicit(fullType2)
+
+      val result = compareWithTypes(strippedType1, strippedType2)
+      if (result != 0) result
+      else if (strippedType1 eq fullType1)
+        if (strippedType2 eq fullType2) 0         // no implicits either side: its' a draw
+        else 1                                    // prefer 1st alternative with no implicits
+      else if (strippedType2 eq fullType2) -1     // prefer 2nd alternative with no implicits
+      else compareWithTypes(fullType1, fullType2) // continue by comparing implicits parameters
+  }
+  end compare
+
+  def narrowMostSpecific(alts: List[TermRef])(using Context): List[TermRef] = {
+    record("narrowMostSpecific")
+    alts match {
+      case Nil => alts
+      case _ :: Nil => alts
+      case alt1 :: alt2 :: Nil =>
+        compare(alt1, alt2) match {
+          case  1 => alt1 :: Nil
+          case -1 => alt2 :: Nil
+          case  0 => alts
+        }
+      case alt :: alts1 =>
+        def survivors(previous: List[TermRef], alts: List[TermRef]): List[TermRef] = alts match {
+          case alt :: alts1 =>
+            compare(previous.head, alt) match {
+              case  1 => survivors(previous, alts1)
+              case -1 => survivors(alt :: previous.tail, alts1)
+              case  0 => survivors(alt :: previous, alts1)
+            }
+          case Nil => previous
+        }
+        val best :: rest = survivors(alt :: Nil, alts1): @unchecked
+        def asGood(alts: List[TermRef]): List[TermRef] = alts match {
+          case alt :: alts1 =>
+            if (compare(alt, best) < 0) asGood(alts1) else alt :: asGood(alts1)
+          case nil =>
+            Nil
+        }
+        best :: asGood(rest)
+    }
+  }
+
+  /** Resolve overloaded alternative `alts`, given expected type `pt`.
+   *  Two trials: First, without implicits or SAM conversions enabled. Then,
+   *  if the first finds no eligible candidates, with implicits and SAM conversions enabled.
+   */
+  def resolveOverloaded(alts: List[TermRef], pt: Type)(using Context): List[TermRef] =
+    record("resolveOverloaded")
+
+    /** Is `alt` a method or polytype whose result type after the first value parameter
+     *  section conforms to the expected type `resultType`? If `resultType`
+     *  is a `IgnoredProto`, pick the underlying type instead.
+     */
+    def resultConforms(altSym: Symbol, altType: Type, resultType: Type)(using Context): Boolean =
+      resultType.revealIgnored match {
+        case resultType: ValueType =>
+          altType.widen match {
+            case tp: PolyType => resultConforms(altSym, instantiateWithTypeVars(tp), resultType)
+            case tp: MethodType => constrainResult(altSym, tp.resultType, resultType)
+            case _ => true
+          }
+        case _ => true
+      }
+
+    /** If the `chosen` alternative has a result type incompatible with the expected result
+     *  type `pt`, run overloading resolution again on all alternatives that do match `pt`.
+     *  If the latter succeeds with a single alternative, return it, otherwise
+     *  fallback to `chosen`.
+     *
+     *  Note this order of events is done for speed. One might be tempted to
+     *  preselect alternatives by result type. But this is slower, because it discriminates
+     *  less. The idea is when searching for a best solution, as is the case in overloading
+     *  resolution, we should first try criteria which are cheap and which have a high
+     *  probability of pruning the search. result type comparisons are neither cheap nor
+     *  do they prune much, on average.
+     */
+    def adaptByResult(chosen: TermRef, alts: List[TermRef]) = pt match {
+      case pt: FunProto if !explore(resultConforms(chosen.symbol, chosen, pt.resultType)) =>
+        val conformingAlts = alts.filterConserve(alt =>
+          (alt ne chosen) && explore(resultConforms(alt.symbol, alt, pt.resultType)))
+        conformingAlts match {
+          case Nil => chosen
+          case alt2 :: Nil => alt2
+          case alts2 =>
+            resolveOverloaded(alts2, pt) match {
+              case alt2 :: Nil => alt2
+              case _ => chosen
+            }
+        }
+      case _ => chosen
+    }
+
+    def resolve(alts: List[TermRef]): List[TermRef] =
+      pt match
+        case pt: FunProto =>
+          if pt.applyKind == ApplyKind.Using then
+            val alts0 = alts.filterConserve(_.widen.stripPoly.isImplicitMethod)
+            if alts0 ne alts then return resolve(alts0)
+          else if alts.exists(_.widen.stripPoly.isContextualMethod) then
+            return resolveMapped(alts, alt => stripImplicit(alt.widen), pt)
+        case _ =>
+
+      var found = withoutMode(Mode.ImplicitsEnabled)(resolveOverloaded1(alts, pt))
+      if found.isEmpty && ctx.mode.is(Mode.ImplicitsEnabled) then
+        found = resolveOverloaded1(alts, pt)
+      found match
+        case alt :: Nil => adaptByResult(alt, alts) :: Nil
+        case _ => found
+    end resolve
+
+    /** Try an apply method, if
+     *   - the result is applied to value arguments and alternative is not a method, or
+     *   - the result is applied to type arguments and alternative is not polymorphic
+     */
+    val tryApply: Type => Boolean = alt => pt match {
+      case pt: FunProto => !alt.widen.stripPoly.isInstanceOf[MethodType]
+      case pt: PolyProto => !alt.widen.isInstanceOf[PolyType]
+      case _ => false
+    }
+
+    /** Replace each alternative by its apply members where necessary */
+    def applyMembers(alt: TermRef): List[TermRef] =
+      if (tryApply(alt)) {
+        val qual = alt.widen match {
+          case pt: PolyType =>
+            wildApprox(pt.resultType)
+          case _ =>
+            alt
+        }
+        qual.member(nme.apply).alternatives.map(TermRef(alt, nme.apply, _))
+      }
+      else alt :: Nil
+
+    /** Fall back from an apply method to its original alternative */
+    def retract(alt: TermRef): TermRef =
+      if (alt.name == nme.apply && !alts.contains(alt))
+        alts.find(_.symbol == alt.prefix.termSymbol).getOrElse(alt)
+      else alt
+
+    if (alts.exists(tryApply)) {
+      val expanded = alts.flatMap(applyMembers)
+      resolve(expanded).map(retract)
+    }
+    else resolve(alts)
+  end resolveOverloaded
+
+  /** This private version of `resolveOverloaded` does the bulk of the work of
+   *  overloading resolution, but does neither result adaptation nor apply insertion.
+   *  It might be called twice from the public `resolveOverloaded` method, once with
+   *  implicits and SAM conversions enabled, and once without.
+   */
+  private def resolveOverloaded1(alts: List[TermRef], pt: Type)(using Context): List[TermRef] =
+    trace(i"resolve over $alts%, %, pt = $pt", typr, show = true) {
+    record(s"resolveOverloaded1", alts.length)
+
+    def isDetermined(alts: List[TermRef]) = alts.isEmpty || alts.tail.isEmpty
+
+    /** The shape of given tree as a type; cannot handle named arguments. */
+    def typeShape(tree: untpd.Tree): Type = tree match {
+      case untpd.Function(args, body) =>
+        defn.FunctionOf(args map Function.const(defn.AnyType), typeShape(body))
+      case Match(EmptyTree, _) =>
+        defn.PartialFunctionClass.typeRef.appliedTo(defn.AnyType :: defn.NothingType :: Nil)
+      case _ =>
+        defn.NothingType
+    }
+
+    /** The shape of given tree as a type; is more expensive than
+     *  typeShape but can can handle named arguments.
+     */
+    def treeShape(tree: untpd.Tree): Tree = tree match {
+      case NamedArg(name, arg) =>
+        val argShape = treeShape(arg)
+        cpy.NamedArg(tree)(name, argShape).withType(argShape.tpe)
+      case _ =>
+        dummyTreeOfType(typeShape(tree))
+    }
+
+    def narrowByTypes(alts: List[TermRef], argTypes: List[Type], resultType: Type): List[TermRef] =
+      alts.filterConserve(isApplicableMethodRef(_, argTypes, resultType, ArgMatch.CompatibleCAP))
+
+    /** Normalization steps before checking arguments:
+     *
+     *                 { expr }   -->   expr
+     *    (x1, ..., xn) => expr   -->   ((x1, ..., xn)) => expr
+     *       if n != 1, no alternative has a corresponding formal parameter that
+     *       is an n-ary function, and at least one alternative has a corresponding
+     *       formal parameter that is a unary function.
+     */
+    def normArg(alts: List[TermRef], arg: untpd.Tree, idx: Int): untpd.Tree = arg match
+      case Block(Nil, expr) if !expr.isEmpty => normArg(alts, expr, idx)
+      case untpd.Function(args: List[untpd.ValDef] @unchecked, body) =>
+
+        // If ref refers to a method whose parameter at index `idx` is a function type,
+        // the arity of that function, otherise -1.
+        def paramCount(ref: TermRef) =
+          val formals = ref.widen.firstParamTypes
+          if formals.length > idx then
+            formals(idx) match
+              case defn.FunctionOf(args, _, _, _) => args.length
+              case _ => -1
+          else -1
+
+        val numArgs = args.length
+        if numArgs != 1
+           && !alts.exists(paramCount(_) == numArgs)
+           && alts.exists(paramCount(_) == 1)
+        then
+          desugar.makeTupledFunction(args, body, isGenericTuple = true)
+            // `isGenericTuple = true` is the safe choice here. It means the i'th tuple
+            // element is selected with `(i)` instead of `_i`, which gives the same code
+            // in the end, but the compilation time and the ascribed type are more involved.
+            // It also means that -Ytest-pickler -Xprint-types fails for sources exercising
+            // the idiom since after pickling the target is known, so _i is used directly.
+        else arg
+      case _ => arg
+    end normArg
+
+    val candidates = pt match {
+      case pt @ FunProto(args, resultType) =>
+        val numArgs = args.length
+        def sizeFits(alt: TermRef): Boolean = alt.widen.stripPoly match {
+          case tp: MethodType =>
+            val ptypes = tp.paramInfos
+            val numParams = ptypes.length
+            def isVarArgs = ptypes.nonEmpty && ptypes.last.isRepeatedParam
+            def numDefaultParams =
+              if alt.symbol.hasDefaultParams then
+                val fn = ref(alt, needLoad = false)
+                ptypes.indices.count(n => !findDefaultGetter(fn, n, testOnly = true).isEmpty)
+              else 0
+            if numParams < numArgs then isVarArgs
+            else if numParams == numArgs then true
+            else
+              val numNecessaryArgs = numParams - numDefaultParams
+              if numNecessaryArgs <= numArgs then true
+              else if numNecessaryArgs == numArgs + 1 then isVarArgs
+              else false
+          case _ =>
+            numArgs == 0
+        }
+
+        def narrowBySize(alts: List[TermRef]): List[TermRef] =
+          alts.filterConserve(sizeFits(_))
+
+        def narrowByShapes(alts: List[TermRef]): List[TermRef] =
+          if args.exists(untpd.isFunctionWithUnknownParamType) then
+            val normArgs = args.mapWithIndexConserve(normArg(alts, _, _))
+            if hasNamedArg(args) then narrowByTrees(alts, normArgs.map(treeShape), resultType)
+            else narrowByTypes(alts, normArgs.map(typeShape), resultType)
+          else
+            alts
+
+        def narrowByTrees(alts: List[TermRef], args: List[Tree], resultType: Type): List[TermRef] =
+          alts.filterConserve(alt =>
+            isApplicableMethodRef(alt, args, resultType, keepConstraint = false, ArgMatch.CompatibleCAP)
+          )
+
+        record("resolveOverloaded.FunProto", alts.length)
+        val alts1 = narrowBySize(alts)
+        overload.println(i"narrowed by size: ${alts1.map(_.symbol.showDcl)}%, %")
+        if isDetermined(alts1) then alts1
+        else
+          record("resolveOverloaded.narrowedBySize", alts1.length)
+          val alts2 = narrowByShapes(alts1)
+          overload.println(i"narrowed by shape: ${alts2.map(_.symbol.showDcl)}%, %")
+          if isDetermined(alts2) then alts2
+          else
+            record("resolveOverloaded.narrowedByShape", alts2.length)
+            pretypeArgs(alts2, pt)
+            narrowByTrees(alts2, pt.typedArgs(normArg(alts2, _, _)), resultType)
+
+      case pt @ PolyProto(targs1, pt1) =>
+        val alts1 = alts.filterConserve(pt.canInstantiate)
+        if isDetermined(alts1) then alts1
+        else
+          def withinBounds(alt: TermRef) = alt.widen match
+            case tp: PolyType =>
+              TypeOps.boundsViolations(targs1, tp.paramInfos, _.substParams(tp, _), NoType).isEmpty
+          val alts2 = alts1.filter(withinBounds)
+          if isDetermined(alts2) then alts2
+          else resolveMapped(alts1, _.widen.appliedTo(targs1.tpes), pt1)
+
+      case defn.FunctionOf(args, resultType, _, _) =>
+        narrowByTypes(alts, args, resultType)
+
+      case pt =>
+        val compat = alts.filterConserve(normalizedCompatible(_, pt, keepConstraint = false))
+        if (compat.isEmpty)
+          /*
+           * the case should not be moved to the enclosing match
+           * since SAM type must be considered only if there are no candidates
+           * For example, the second f should be chosen for the following code:
+           *   def f(x: String): Unit = ???
+           *   def f: java.io.OutputStream = ???
+           *   new java.io.ObjectOutputStream(f)
+           */
+          pt match {
+            case SAMType(mtp) =>
+              narrowByTypes(alts, mtp.paramInfos, mtp.resultType)
+            case _ =>
+              // pick any alternatives that are not methods since these might be convertible
+              // to the expected type, or be used as extension method arguments.
+              val convertible = alts.filterNot(alt =>
+                  normalize(alt, IgnoredProto(pt)).widenSingleton.isInstanceOf[MethodType])
+              if convertible.length == 1 then convertible else compat
+          }
+        else compat
+    }
+
+    /** The type of alternative `alt` after instantiating its first parameter
+     *  clause with `argTypes`. In addition, if the resulting type is a PolyType
+     *  and `typeArgs` matches its parameter list, instantiate the result with `typeArgs`.
+     */
+    def skipParamClause(argTypes: List[Type], typeArgs: List[Type])(alt: TermRef): Type =
+      def skip(tp: Type): Type = tp match {
+        case tp: PolyType =>
+          skip(tp.resultType) match
+            case NoType =>
+              NoType
+            case rt: PolyType if typeArgs.length == rt.paramInfos.length =>
+              tp.derivedLambdaType(resType = rt.instantiate(typeArgs))
+            case rt =>
+              tp.derivedLambdaType(resType = rt).asInstanceOf[PolyType].flatten
+        case tp: MethodType =>
+          tp.instantiate(argTypes)
+        case _ =>
+          NoType
+      }
+      skip(alt.widen)
+
+    def resultIsMethod(tp: Type): Boolean = tp.widen.stripPoly match
+      case tp: MethodType => stripInferrable(tp.resultType).isInstanceOf[MethodType]
+      case _ => false
+
+    record("resolveOverloaded.narrowedApplicable", candidates.length)
+    if pt.unusableForInference then
+      // `pt` might have become erroneous by typing arguments of FunProtos.
+      // If `pt` is erroneous, don't try to go further; report the error in `pt` instead.
+      candidates
+    else
+      val found = narrowMostSpecific(candidates)
+      if found.length <= 1 then found
+      else
+        val deepPt = pt.deepenProto
+        deepPt match
+          case pt @ FunProto(_, PolyProto(targs, resType)) =>
+            // try to narrow further with snd argument list and following type params
+            resolveMapped(candidates,
+              skipParamClause(pt.typedArgs().tpes, targs.tpes), resType)
+          case pt @ FunProto(_, resType: FunOrPolyProto) =>
+            // try to narrow further with snd argument list
+            resolveMapped(candidates,
+              skipParamClause(pt.typedArgs().tpes, Nil), resType)
+          case _ =>
+            // prefer alternatives that need no eta expansion
+            val noCurried = alts.filterConserve(!resultIsMethod(_))
+            val noCurriedCount = noCurried.length
+            if noCurriedCount == 1 then
+              noCurried
+            else if noCurriedCount > 1 && noCurriedCount < alts.length then
+              resolveOverloaded1(noCurried, pt)
+            else
+              // prefer alternatves that match without default parameters
+              val noDefaults = alts.filterConserve(!_.symbol.hasDefaultParams)
+              val noDefaultsCount = noDefaults.length
+              if noDefaultsCount == 1 then
+                noDefaults
+              else if noDefaultsCount > 1 && noDefaultsCount < alts.length then
+                resolveOverloaded1(noDefaults, pt)
+              else if deepPt ne pt then
+                // try again with a deeper known expected type
+                resolveOverloaded1(alts, deepPt)
+              else
+                candidates
+    }
+  end resolveOverloaded1
+
+  /** The largest suffix of `paramss` that has the same first parameter name as `t`,
+   *  plus the number of term parameters in `paramss` that come before that suffix.
+   */
+  def trimParamss(t: Type, paramss: List[List[Symbol]])(using Context): (List[List[Symbol]], Int) = t match
+    case MethodType(Nil) => trimParamss(t.resultType, paramss)
+    case t: MethodOrPoly =>
+      val firstParamName = t.paramNames.head
+      def recur(pss: List[List[Symbol]], skipped: Int): (List[List[Symbol]], Int) =
+        (pss: @unchecked) match
+          case (ps @ (p :: _)) :: pss1 =>
+            if p.name == firstParamName then (pss, skipped)
+            else recur(pss1, if p.name.isTermName then skipped + ps.length else skipped)
+          case Nil =>
+            (pss, skipped)
+      recur(paramss, 0)
+    case _ => (Nil, 0)
+
+  /** Resolve overloading by mapping to a different problem where each alternative's
+   *  type is mapped with `f`, alternatives with non-existing types are dropped, and the
+   *  expected type is `pt`. Map the results back to the original alternatives.
+   */
+  def resolveMapped(alts: List[TermRef], f: TermRef => Type, pt: Type)(using Context): List[TermRef] =
+    val reverseMapping = alts.flatMap { alt =>
+      val t = f(alt)
+      if t.exists then
+        val (trimmed, skipped) = trimParamss(t, alt.symbol.rawParamss)
+        val mappedSym = alt.symbol.asTerm.copy(info = t)
+        mappedSym.rawParamss = trimmed
+        val (pre, totalSkipped) = mappedAltInfo(alt.symbol) match
+          case Some((pre, prevSkipped)) =>
+            mappedSym.removeAnnotation(defn.MappedAlternativeAnnot)
+            (pre, skipped + prevSkipped)
+          case None =>
+            (alt.prefix, skipped)
+        mappedSym.addAnnotation(
+          Annotation(TypeTree(
+            defn.MappedAlternativeAnnot.typeRef.appliedTo(
+              pre, ConstantType(Constant(totalSkipped))))))
+        Some((TermRef(NoPrefix, mappedSym), alt))
+      else
+        None
+    }
+    val mapped = reverseMapping.map(_._1)
+    overload.println(i"resolve mapped: ${mapped.map(_.widen)}%, % with $pt")
+    resolveOverloaded(mapped, pt).map(reverseMapping.toMap)
+
+  /** Try to typecheck any arguments in `pt` that are function values missing a
+   *  parameter type. If the formal parameter types corresponding to a closure argument
+   *  all agree on their argument types, typecheck the argument with an expected
+   *  function or partial function type that contains these argument types,
+   *  The result of the typecheck is stored in `pt`, to be retrieved when its `typedArgs` are selected.
+   *  The benefit of doing this is to allow idioms like this:
+   *
+   *     def map(f: Char => Char): String = ???
+   *     def map[U](f: Char => U): Seq[U] = ???
+   *     map(x => x.toUpper)
+   *
+   *  Without `pretypeArgs` we'd get a "missing parameter type" error for `x`.
+   *  With `pretypeArgs`, we use the `Char => ?` as the expected type of the
+   *  closure `x => x.toUpper`, which makes the code typecheck.
+   */
+  private def pretypeArgs(alts: List[TermRef], pt: FunProto)(using Context): Unit = {
+    def recur(altFormals: List[List[Type]], args: List[untpd.Tree]): Unit = args match {
+      case arg :: args1 if !altFormals.exists(_.isEmpty) =>
+        def isUniform[T](xs: List[T])(p: (T, T) => Boolean) = xs.forall(p(_, xs.head))
+        val formalsForArg: List[Type] = altFormals.map(_.head)
+        def argTypesOfFormal(formal: Type): List[Type] =
+          formal.dealias match {
+            case defn.FunctionOf(args, result, isImplicit, isErased) => args
+            case defn.PartialFunctionOf(arg, result) => arg :: Nil
+            case _ => Nil
+          }
+        val formalParamTypessForArg: List[List[Type]] =
+          formalsForArg.map(argTypesOfFormal)
+        if (formalParamTypessForArg.forall(_.nonEmpty) &&
+            isUniform(formalParamTypessForArg)((x, y) => x.length == y.length)) {
+          val commonParamTypes = formalParamTypessForArg.transpose.map(ps =>
+            // Given definitions above, for i = 1,...,m,
+            //   ps(i) = List(p_i_1, ..., p_i_n)  -- i.e. a column
+            // If all p_i_k's are the same, assume the type as formal parameter
+            // type of the i'th parameter of the closure.
+            if (isUniform(ps)(_ frozen_=:= _)) ps.head
+            else WildcardType)
+          /** Should we generate a partial function for the arg ? */
+          def isPartial = untpd.functionWithUnknownParamType(arg) match
+            case Some(_: untpd.Match) =>
+              formalsForArg.exists(_.isRef(defn.PartialFunctionClass))
+            case _ =>
+              false
+          val commonFormal =
+            if (isPartial) defn.PartialFunctionOf(commonParamTypes.head, WildcardType)
+            else defn.FunctionOf(commonParamTypes, WildcardType)
+          overload.println(i"pretype arg $arg with expected type $commonFormal")
+          if (commonParamTypes.forall(isFullyDefined(_, ForceDegree.flipBottom)))
+            withMode(Mode.ImplicitsEnabled) {
+              // We can cache the adapted argument here because the expected type
+              // is a common type shared by all overloading candidates.
+              pt.cacheArg(arg, pt.typedArg(arg, commonFormal))
+            }
+        }
+        recur(altFormals.map(_.tail), args1)
+      case _ =>
+    }
+    recur(alts.map(_.widen.firstParamTypes), pt.args)
+  }
+
+  private def harmonizeWith[T <: AnyRef](ts: List[T])(tpe: T => Type, adapt: (T, Type) => T)(using Context): List[T] = {
+    def targetClass(ts: List[T], cls: Symbol, intLitSeen: Boolean): Symbol = ts match {
+      case t :: ts1 =>
+        tpe(t).widenTermRefExpr match {
+          case ConstantType(c: Constant) if c.tag == IntTag =>
+            targetClass(ts1, cls, true)
+          case t =>
+            val sym = t.classSymbol
+            if (!sym.isNumericValueClass || cls.exists && cls != sym) NoSymbol
+            else targetClass(ts1, sym, intLitSeen)
+        }
+      case Nil =>
+        if (cls != defn.IntClass && intLitSeen) cls else NoSymbol
+    }
+    val cls = targetClass(ts, NoSymbol, false)
+    if (cls.exists) {
+      def lossOfPrecision(n: Int): Boolean =
+        cls == defn.FloatClass && n.toFloat.toInt != n
+      var canAdapt = true
+      val ts1 = ts.mapConserve { t =>
+        tpe(t).widenTermRefExpr match {
+          case ConstantType(c: Constant) if c.tag == IntTag =>
+            canAdapt &= c.convertTo(cls.typeRef) != null && !lossOfPrecision(c.intValue)
+            if (canAdapt) adapt(t, cls.typeRef) else t
+          case _ => t
+        }
+      }
+      if (canAdapt) ts1 else ts
+    }
+    else ts
+  }
+
+  /** If `trees` all have numeric value types, and they do not have all the same type,
+   *  pick a common numeric supertype and try to convert all constant Int literals to this type.
+   *  If the resulting trees all have the same type, return them instead of the original ones.
+   */
+  def harmonize(trees: List[Tree])(using Context): List[Tree] = {
+    def adaptDeep(tree: Tree, pt: Type): Tree = tree match {
+      case cdef: CaseDef => tpd.cpy.CaseDef(cdef)(body = adaptDeep(cdef.body, pt))
+      case _ => adapt(tree, pt)
+    }
+    if (ctx.isAfterTyper) trees else harmonizeWith(trees)(_.tpe, adaptDeep)
+  }
+
+  /** Apply a transformation `harmonize` on the results of operation `op`,
+   *  unless the expected type `pt` is fully defined.
+   *  If the result is different (wrt eq) from the original results of `op`,
+   *  revert back to the constraint in force before computing `op`.
+   *  This reset is needed because otherwise the original results might
+   *  have added constraints to type parameters which are no longer
+   *  implied after harmonization. No essential constraints are lost by this because
+   *  the result of harmonization will be compared again with the expected type.
+   *  Test cases where this matters are in neg/harmomize.scala and run/weak-conformance.scala.
+   *
+   *  Note: this assumes that the internal typing of the arguments using `op` does
+   *  not leave any constraints, so the only info that is reset is the relationship
+   *  between the argument's types and the expected type. I am not sure this will
+   *  always be the case. If that property does not hold, we risk forgetting constraints
+   *  which could lead to unsoundness.
+   */
+  def harmonic[T](harmonize: List[T] => List[T], pt: Type)(op: => List[T])(using Context): List[T] =
+    if (!isFullyDefined(pt, ForceDegree.none)) {
+      val origConstraint = ctx.typerState.constraint
+      val origElems = op
+      val harmonizedElems = harmonize(origElems)
+      if (harmonizedElems ne origElems) ctx.typerState.constraint = origConstraint
+      harmonizedElems
+    }
+    else op
+
+  /** If all `types` are numeric value types, and they are not all the same type,
+   *  pick a common numeric supertype and widen any constant types in `tpes` to it.
+   *  If the resulting types are all the same, return them instead of the original ones.
+   */
+  private def harmonizeTypes(tpes: List[Type])(using Context): List[Type] =
+    harmonizeWith(tpes)(identity, (tp, pt) => pt)
+
+  /** The typed application
+   *
+   *   <methodRef>(<receiver>)    or
+   *   <methodRef>[<type-args>](<receiver>)
+   *
+   *  where <type-args> comes from `pt` if it is a (possibly ignored) PolyProto.
+   */
+  def extMethodApply(methodRef: untpd.Tree, receiver: Tree, pt: Type)(using Context): Tree = {
+    /** Integrate the type arguments (if any) from `currentPt` into `tree`, and produce
+     *  an expected type that hides the appropriate amount of information through IgnoreProto.
+     */
+    def normalizePt(tree: untpd.Tree, currentPt: Type): (untpd.Tree, Type) = currentPt match
+      // Always reveal expected arguments to guide inference (needed for i9509.scala)
+      case IgnoredProto(ignored: FunOrPolyProto) =>
+        normalizePt(tree, ignored)
+      // Always hide expected member to allow for chained extensions (needed for i6900.scala)
+      case _: SelectionProto =>
+        (tree, IgnoredProto(currentPt))
+      case _ =>
+        (tree, currentPt)
+
+    val (core, pt1) = normalizePt(methodRef, pt)
+    withMode(Mode.SynthesizeExtMethodReceiver) {
+      typed(
+        untpd.Apply(core, untpd.TypedSplice(receiver, isExtensionReceiver = true) :: Nil),
+        pt1, ctx.typerState.ownedVars)
+    }
+  }
+
+  /** Assuming methodRef is a reference to an extension method defined e.g. as
+   *
+   *  extension [T1, T2](using A)(using B, C)(receiver: R)(using D)
+   *    def foo[T3](using E)(f: F): G = ???
+   *
+   *  return the tree representing methodRef partially applied to the receiver
+   *  and all the implicit parameters preceding it (A, B, C)
+   *  with the type parameters of the extension (T1, T2) inferred.
+   *  None is returned if the implicit search fails for any of the leading implicit parameters
+   *  or if the receiver has a wrong type (note that in general the type of the receiver
+   *  might depend on the exact types of the found instances of the proceeding implicits).
+   *  No implicit search is tried for implicits following the receiver or for parameters of the def (D, E).
+   */
+  def tryApplyingExtensionMethod(methodRef: TermRef, receiver: Tree)(using Context): Option[Tree] =
+    // Drop all parameters sections of an extension method following the receiver.
+    // The return type after truncation is not important
+    def truncateExtension(tp: Type)(using Context): Type = tp match
+      case poly: PolyType =>
+        poly.newLikeThis(poly.paramNames, poly.paramInfos, truncateExtension(poly.resType))
+      case meth: MethodType if meth.isContextualMethod =>
+        meth.newLikeThis(meth.paramNames, meth.paramInfos, truncateExtension(meth.resType))
+      case meth: MethodType =>
+        meth.newLikeThis(meth.paramNames, meth.paramInfos, defn.AnyType)
+
+    def replaceCallee(inTree: Tree, replacement: Tree)(using Context): Tree = inTree match
+      case Apply(fun, args) => Apply(replaceCallee(fun, replacement), args)
+      case TypeApply(fun, args) => TypeApply(replaceCallee(fun, replacement), args)
+      case _ => replacement
+
+    val methodRefTree = ref(methodRef, needLoad = false)
+    val truncatedSym = methodRef.symbol.asTerm.copy(info = truncateExtension(methodRef.info))
+    val truncatedRefTree = untpd.TypedSplice(ref(truncatedSym)).withSpan(receiver.span)
+    val newCtx = ctx.fresh.setNewScope.setReporter(new reporting.ThrowingReporter(ctx.reporter))
+
+    try
+      val appliedTree = inContext(newCtx) {
+        // Introducing an auxiliary symbol in a temporary scope.
+        // Entering the symbol indirectly by `newCtx.enter`
+        // could instead add the symbol to the enclosing class
+        // which could break the REPL.
+        newCtx.scope.openForMutations.enter(truncatedSym)
+        newCtx.typer.extMethodApply(truncatedRefTree, receiver, WildcardType)
+      }
+      if appliedTree.tpe.exists && !appliedTree.tpe.isError then
+        Some(replaceCallee(appliedTree, methodRefTree))
+      else
+        None
+    catch
+      case NonFatal(_) => None
+
+  def isApplicableExtensionMethod(methodRef: TermRef, receiverType: Type)(using Context): Boolean =
+    methodRef.symbol.is(ExtensionMethod) && !receiverType.isBottomType &&
+      tryApplyingExtensionMethod(methodRef, nullLiteral.asInstance(receiverType)).nonEmpty
+}
diff --git a/tests/pos-with-compiler-cc/dotc/typer/Checking.scala b/tests/pos-with-compiler-cc/dotc/typer/Checking.scala
new file mode 100644
index 000000000000..2e83a32ae8e4
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/typer/Checking.scala
@@ -0,0 +1,1535 @@
+package dotty.tools
+package dotc
+package typer
+
+import core._
+import ast._
+import Contexts._
+import Types._
+import Flags._
+import Names._
+import StdNames._
+import Symbols._
+import Trees._
+import ProtoTypes._
+import Scopes._
+import CheckRealizable._
+import ErrorReporting.errorTree
+import util.Spans.Span
+import Phases.refchecksPhase
+import Constants.Constant
+
+import util.SrcPos
+import util.Spans.Span
+import rewrites.Rewrites.patch
+import inlines.Inlines
+import transform.SymUtils._
+import transform.ValueClasses._
+import Decorators._
+import ErrorReporting.{err, errorType}
+import config.Printers.{typr, patmatch}
+import NameKinds.DefaultGetterName
+import NameOps._
+import SymDenotations.{NoCompleter, NoDenotation}
+import Applications.unapplyArgs
+import Inferencing.isFullyDefined
+import transform.patmat.SpaceEngine.isIrrefutable
+import config.Feature
+import config.Feature.sourceVersion
+import config.SourceVersion._
+import printing.Formatting.hlAsKeyword
+import transform.TypeUtils.*
+
+import collection.mutable
+import reporting._
+import language.experimental.pureFunctions
+
+object Checking {
+  import tpd._
+
+  /** Add further information for error messages involving applied types if the
+   *  type is inferred:
+   *   1. the full inferred type is a TypeTree node
+   *   2. the applied type causing the error, if different from (1)
+   */
+  private def showInferred(msg: Message, app: Type, tpt: Tree)(using Context): Message =
+    if tpt.isInstanceOf[TypeTree] then
+      def subPart = if app eq tpt.tpe then "" else i" subpart $app of"
+      msg.append(i" in$subPart inferred type ${tpt}")
+        .appendExplanation("\n\nTo fix the problem, provide an explicit type.")
+    else msg
+
+  /** A general checkBounds method that can be used for TypeApply nodes as
+   *  well as for AppliedTypeTree nodes. Also checks that type arguments to
+   *  *-type parameters are fully applied.
+   *  @param tpt  If bounds are checked for an AppliedType, the type tree representing
+   *              or (in case it is inferred) containing the type.
+   *  See TypeOps.boundsViolations for an explanation of the first four parameters.
+   */
+  def checkBounds(args: List[tpd.Tree], boundss: List[TypeBounds],
+    instantiate: (Type, List[Type]) => Type, app: Type = NoType, tpt: Tree = EmptyTree)(using Context): Unit =
+    if ctx.phase != Phases.checkCapturesPhase then
+      args.lazyZip(boundss).foreach { (arg, bound) =>
+        if !bound.isLambdaSub && !arg.tpe.hasSimpleKind then
+          errorTree(arg,
+            showInferred(MissingTypeParameterInTypeApp(arg.tpe), app, tpt))
+      }
+    for (arg, which, bound) <- TypeOps.boundsViolations(args, boundss, instantiate, app) do
+      report.error(
+        showInferred(DoesNotConformToBound(arg.tpe, which, bound), app, tpt),
+        arg.srcPos.focus)
+
+  /** Check that type arguments `args` conform to corresponding bounds in `tl`
+   *  Note: This does not check the bounds of AppliedTypeTrees. These
+   *  are handled by method checkAppliedType below.
+   */
+  def checkBounds(args: List[tpd.Tree], tl: TypeLambda)(using Context): Unit =
+    checkBounds(args, tl.paramInfos, _.substParams(tl, _))
+
+  def checkGoodBounds(sym: Symbol)(using Context): Boolean =
+    val bad = findBadBounds(sym.typeRef)
+    if bad.exists then
+      report.error(em"$sym has possibly conflicting bounds $bad", sym.srcPos)
+    !bad.exists
+
+  /** If `tp` dealiases to a typebounds L..H where not L <:< H
+   *  return the potentially conflicting bounds, otherwise return NoType.
+   */
+  private def findBadBounds(tp: Type)(using Context): Type = tp.dealias match
+    case tp: TypeRef => findBadBounds(tp.info)
+    case tp @ TypeBounds(lo, hi) if !(lo <:< hi) => tp
+    case _ => NoType
+
+  /** Check applied type trees for well-formedness. This means
+   *   - all arguments are within their corresponding bounds
+   *   - if type is a higher-kinded application with wildcard arguments,
+   *     check that it or one of its supertypes can be reduced to a normal application.
+   *     Unreducible applications correspond to general existentials, and we
+   *     cannot handle those.
+   *  @param tree The applied type tree to check
+   *  @param tpt  If `tree` is synthesized from a type in a TypeTree,
+   *              the original TypeTree, or EmptyTree otherwise.
+   */
+  def checkAppliedType(tree: AppliedTypeTree, tpt: Tree = EmptyTree)(using Context): Unit = {
+    val AppliedTypeTree(tycon, args) = tree
+    // If `args` is a list of named arguments, return corresponding type parameters,
+    // otherwise return type parameters unchanged
+    val tparams = tycon.tpe.typeParams
+    val bounds = tparams.map(_.paramInfoAsSeenFrom(tree.tpe).bounds)
+    def instantiate(bound: Type, args: List[Type]) =
+      tparams match
+        case LambdaParam(lam, _) :: _ =>
+          HKTypeLambda.fromParams(tparams, bound).appliedTo(args)
+        case _ =>
+          bound // paramInfoAsSeenFrom already took care of instantiation in this case
+    if !ctx.mode.is(Mode.Pattern)           // no bounds checking in patterns
+       && tycon.symbol != defn.TypeBoxClass // TypeBox types are generated for capture
+                                            // conversion, may contain AnyKind as arguments
+    then
+      checkBounds(args, bounds, instantiate, tree.tpe, tpt)
+
+    def checkWildcardApply(tp: Type): Unit = tp match {
+      case tp @ AppliedType(tycon, _) =>
+        if tp.isUnreducibleWild then
+          report.errorOrMigrationWarning(
+            showInferred(UnreducibleApplication(tycon), tp, tpt),
+            tree.srcPos, from = `3.0`)
+      case _ =>
+    }
+    def checkValidIfApply(using Context): Unit =
+      checkWildcardApply(tycon.tpe.appliedTo(args.map(_.tpe)))
+    withMode(Mode.AllowLambdaWildcardApply)(checkValidIfApply)
+  }
+
+  /** Check all applied type trees in inferred type `tpt` for well-formedness */
+  def checkAppliedTypesIn(tpt: TypeTree)(using Context): Unit =
+    val checker = new TypeTraverser:
+      def traverse(tp: Type) =
+        tp match
+          case AppliedType(tycon, argTypes) =>
+            checkAppliedType(
+              untpd.AppliedTypeTree(TypeTree(tycon), argTypes.map(TypeTree(_)))
+                .withType(tp).withSpan(tpt.span.toSynthetic),
+              tpt)
+          case _ =>
+        traverseChildren(tp)
+    checker.traverse(tpt.tpe)
+
+  def checkNoWildcard(tree: Tree)(using Context): Tree = tree.tpe match {
+    case tpe: TypeBounds => errorTree(tree, "no wildcard type allowed here")
+    case _ => tree
+  }
+
+  /** Check that kind of `arg` has the same outline as the kind of paramBounds.
+   *  E.g. if `paramBounds` has kind * -> *, `arg` must have that kind as well,
+   *  and analogously for all other kinds. This kind checking does not take into account
+   *  variances or bounds. The more detailed kind checking is done as part of checkBounds in PostTyper.
+   *  The purpose of preCheckKind is to do a rough test earlier in Typer,
+   *  in order to prevent scenarios that lead to self application of
+   *  types. Self application needs to be avoided since it can lead to stack overflows.
+   *  Test cases are neg/i2771.scala and neg/i2771b.scala.
+   *  A NoType paramBounds is used as a sign that checking should be suppressed.
+   */
+  def preCheckKind(arg: Tree, paramBounds: Type)(using Context): Tree =
+    if (arg.tpe.widen.isRef(defn.NothingClass) ||
+        !paramBounds.exists ||
+        arg.tpe.hasSameKindAs(paramBounds.bounds.hi)) arg
+    else errorTree(arg, em"Type argument ${arg.tpe} does not have the same kind as its bound $paramBounds")
+
+  def preCheckKinds(args: List[Tree], paramBoundss: List[Type])(using Context): List[Tree] = {
+    val args1 = args.zipWithConserve(paramBoundss)(preCheckKind)
+    args1 ++ args.drop(paramBoundss.length)
+      // add any arguments that do not correspond to a parameter back,
+      // so the wrong number of parameters is reported afterwards.
+  }
+
+  /** Check that `tp` refers to a nonAbstract class
+   *  and that the instance conforms to the self type of the created class.
+   */
+  def checkInstantiable(tp: Type, pos: SrcPos)(using Context): Unit =
+    tp.underlyingClassRef(refinementOK = false) match
+      case tref: TypeRef =>
+        val cls = tref.symbol
+        if (cls.isOneOf(AbstractOrTrait))
+          report.error(CantInstantiateAbstractClassOrTrait(cls, isTrait = cls.is(Trait)), pos)
+        if !cls.is(Module) then
+          // Create a synthetic singleton type instance, and check whether
+          // it conforms to the self type of the class as seen from that instance.
+          val stp = SkolemType(tp)
+          val selfType = cls.declaredSelfTypeAsSeenFrom(stp)
+          if selfType.exists && !(stp <:< selfType) then
+            report.error(DoesNotConformToSelfTypeCantBeInstantiated(tp, selfType), pos)
+      case _ =>
+
+  /** Check that type `tp` is realizable. */
+  def checkRealizable(tp: Type, pos: SrcPos, what: String = "path")(using Context): Unit = {
+    val rstatus = realizability(tp)
+    if (rstatus ne Realizable)
+      report.errorOrMigrationWarning(
+        em"$tp is not a legal $what\nsince it${rstatus.msg}", pos, from = `3.0`)
+  }
+
+  /** Given a parent `parent` of a class `cls`, if `parent` is a trait check that
+   *  the superclass of `cls` derived from the superclass of `parent`.
+   *
+   *  An exception is made if `cls` extends `Any`, and `parent` is `java.io.Serializable`
+   *  or `java.lang.Comparable`. These two classes are treated by Scala as universal
+   *  traits. E.g. the following is OK:
+   *
+   *      ... extends Any with java.io.Serializable
+   *
+   *  The standard library relies on this idiom.
+   */
+  def checkTraitInheritance(parent: Symbol, cls: ClassSymbol, pos: SrcPos)(using Context): Unit =
+    parent match {
+      case parent: ClassSymbol if parent.is(Trait) =>
+        val psuper = parent.superClass
+        val csuper = cls.superClass
+        val ok = csuper.derivesFrom(psuper) ||
+          parent.is(JavaDefined) && csuper == defn.AnyClass &&
+          (parent == defn.JavaSerializableClass || parent == defn.ComparableClass)
+        if (!ok)
+          report.error(em"illegal trait inheritance: super$csuper does not derive from $parent's super$psuper", pos)
+      case _ =>
+    }
+
+  /** A type map which checks that the only cycles in a type are F-bounds
+   *  and that protects all F-bounded references by LazyRefs.
+   */
+  class CheckNonCyclicMap(sym: Symbol, reportErrors: Boolean)(using Context) extends TypeMap {
+
+    /** Set of type references whose info is currently checked */
+    private val locked = mutable.Set[TypeRef]()
+
+    /** Are cycles allowed within nested refinedInfos of currently checked type? */
+    private var nestedCycleOK = false
+
+    /** Are cycles allowed within currently checked type? */
+    private var cycleOK = false
+
+    /** A diagnostic output string that indicates the position of the last
+     *  part of a type bounds checked by checkInfo. Possible choices:
+     *  alias, lower bound, upper bound.
+     */
+    var where: String = ""
+
+    /** The last type top-level type checked when a CyclicReference occurs. */
+    var lastChecked: Type = NoType
+
+    private def checkPart(tp: Type, w: String) =
+      try apply(tp)
+      finally {
+        where = w
+        lastChecked = tp
+      }
+
+    private def checkUpper(tp: Type, w: String) = {
+      val saved = nestedCycleOK
+      nestedCycleOK = true
+      try checkPart(tp, w)
+      finally nestedCycleOK = saved
+    }
+
+    /** Check info `tp` for cycles. Throw CyclicReference for illegal cycles,
+     *  break direct cycle with a LazyRef for legal, F-bounded cycles.
+     */
+    def checkInfo(tp: Type): Type = tp match {
+      case tp @ TypeAlias(alias) =>
+        tp.derivedAlias(checkPart(alias, "alias"))
+      case tp @ MatchAlias(alias) =>
+        tp.derivedAlias(checkUpper(alias, "match"))
+      case tp @ TypeBounds(lo, hi) =>
+        tp.derivedTypeBounds(checkPart(lo, "lower bound"), checkUpper(hi, "upper bound"))
+      case _ =>
+        tp
+    }
+
+    private def apply(tp: Type, cycleOK: Boolean, nestedCycleOK: Boolean): Type = {
+      val savedCycleOK = this.cycleOK
+      val savedNestedCycleOK = this.nestedCycleOK
+      this.cycleOK = cycleOK
+      this.nestedCycleOK = nestedCycleOK
+      try apply(tp)
+      finally {
+        this.cycleOK = savedCycleOK
+        this.nestedCycleOK = savedNestedCycleOK
+      }
+    }
+
+    def apply(tp: Type): Type = tp match {
+      case tp: TermRef =>
+        this(tp.info)
+        mapOver(tp)
+      case tp @ AppliedType(tycon, args) =>
+        tp.derivedAppliedType(this(tycon), args.mapConserve(this(_, nestedCycleOK, nestedCycleOK)))
+      case tp @ RefinedType(parent, name, rinfo) =>
+        tp.derivedRefinedType(this(parent), name, this(rinfo, nestedCycleOK, nestedCycleOK))
+      case tp: RecType =>
+        tp.rebind(this(tp.parent))
+      case tp @ TypeRef(pre, _) =>
+        try {
+          // A prefix is interesting if it might contain (transitively) a reference
+          // to symbol `sym` itself. We only check references with interesting
+          // prefixes for cycles. This pruning is done in order not to force
+          // global symbols when doing the cyclicity check.
+          def isInteresting(prefix: Type): Boolean = prefix.stripTypeVar match {
+            case NoPrefix => true
+            case prefix: ThisType =>
+              sym.owner.isClass && (
+                prefix.cls.isContainedIn(sym.owner)    // sym reachable through outer references
+                || sym.owner.isContainedIn(prefix.cls) // sym reachable through member references
+              )
+            case prefix: NamedType =>
+              (!sym.is(Private) && prefix.derivesFrom(sym.owner)) ||
+              (!prefix.symbol.moduleClass.isStaticOwner && isInteresting(prefix.prefix))
+            case SuperType(thistp, _) => isInteresting(thistp)
+            case AndType(tp1, tp2) => isInteresting(tp1) || isInteresting(tp2)
+            case OrType(tp1, tp2) => isInteresting(tp1) && isInteresting(tp2)
+            case _: RefinedOrRecType | _: AppliedType => true
+            case tp: AnnotatedType => isInteresting(tp.parent)
+            case _ => false
+          }
+
+          if (isInteresting(pre)) {
+            val pre1 = this(pre, false, false)
+            if (locked.contains(tp) || tp.symbol.infoOrCompleter.isInstanceOf[NoCompleter])
+              throw CyclicReference(tp.symbol)
+            locked += tp
+            try if (!tp.symbol.isClass) checkInfo(tp.info)
+            finally locked -= tp
+            tp.withPrefix(pre1)
+          }
+          else tp
+        }
+        catch {
+          case ex: CyclicReference =>
+            report.debuglog(i"cycle detected for $tp, $nestedCycleOK, $cycleOK")
+            if (cycleOK) LazyRef.of(tp)
+            else if (reportErrors) throw ex
+            else tp
+        }
+      case _ => mapOver(tp)
+    }
+  }
+
+  /** Under -Yrequire-targetName, if `sym` has an operator name, check that it has a
+   *  @targetName annotation.
+   */
+  def checkValidOperator(sym: Symbol)(using Context): Unit =
+    if ctx.settings.YrequireTargetName.value then
+      sym.name.toTermName match
+        case name: SimpleName
+        if name.isOperatorName
+          && !name.isSetterName
+          && !name.isConstructorName
+          && !sym.getAnnotation(defn.TargetNameAnnot).isDefined
+          && !sym.is(Synthetic) =>
+          report.warning(
+            i"$sym has an operator name; it should come with an @targetName annotation", sym.srcPos)
+        case _ =>
+
+  /** Check that `info` of symbol `sym` is not cyclic.
+   *  @pre     sym is not yet initialized (i.e. its type is a Completer).
+   *  @return  `info` where every legal F-bounded reference is proctected
+   *                  by a `LazyRef`, or `ErrorType` if a cycle was detected and reported.
+   */
+  def checkNonCyclic(sym: Symbol, info: Type, reportErrors: Boolean)(using Context): Type = {
+    val checker = withMode(Mode.CheckCyclic)(new CheckNonCyclicMap(sym, reportErrors))
+    try checker.checkInfo(info)
+    catch {
+      case ex: CyclicReference =>
+        if (reportErrors)
+          errorType(IllegalCyclicTypeReference(sym, checker.where, checker.lastChecked), sym.srcPos)
+        else info
+    }
+  }
+
+  /** Check that refinement satisfies the following two conditions
+   *  1. No part of it refers to a symbol that's defined in the same refinement
+   *     at a textually later point.
+   *  2. All references to the refinement itself via `this` are followed by
+   *     selections.
+   *  Note: It's not yet clear what exactly we want to allow and what we want to rule out.
+   *  This depends also on firming up the DOT calculus. For the moment we only issue
+   *  deprecated warnings, not errors.
+   */
+  def checkRefinementNonCyclic(refinement: Tree, refineCls: ClassSymbol, seen: mutable.Set[Symbol])
+    (using Context): Unit = {
+    def flag(what: String, tree: Tree) =
+      report.warning(i"$what reference in refinement is deprecated", tree.srcPos)
+    def forwardRef(tree: Tree) = flag("forward", tree)
+    def selfRef(tree: Tree) = flag("self", tree)
+    val checkTree = new TreeAccumulator[Unit] {
+      def checkRef(tree: Tree, sym: Symbol) =
+        if (sym.maybeOwner == refineCls && !seen(sym)) forwardRef(tree)
+      def apply(x: Unit, tree: Tree)(using Context) = tree match {
+        case tree: MemberDef =>
+          foldOver(x, tree)
+          seen += tree.symbol
+        case tree @ Select(This(_), _) =>
+          checkRef(tree, tree.symbol)
+        case tree: RefTree =>
+          checkRef(tree, tree.symbol)
+          foldOver(x, tree)
+        case tree: This =>
+          selfRef(tree)
+        case tree: TypeTree =>
+          val checkType = new TypeAccumulator[Unit] {
+            def apply(x: Unit, tp: Type): Unit = tp match {
+              case tp: NamedType =>
+                checkRef(tree, tp.symbol)
+                tp.prefix match {
+                  case pre: ThisType =>
+                  case pre => foldOver(x, pre)
+                }
+              case tp: ThisType if tp.cls == refineCls =>
+                selfRef(tree)
+              case _ =>
+                foldOver(x, tp)
+            }
+          }
+          checkType((), tree.tpe)
+        case _ =>
+          foldOver(x, tree)
+      }
+    }
+    checkTree((), refinement)
+  }
+
+  /** Check type members inherited from different `parents` of `joint` type for cycles,
+   *  unless a type with the same name already appears in `decls`.
+   *  @return    true iff no cycles were detected
+   */
+  def checkNonCyclicInherited(joint: Type, parents: List[Type], decls: Scope, pos: SrcPos)(using Context): Unit = {
+    // If we don't have more than one parent, then there's nothing to check
+    if (parents.lengthCompare(1) <= 0)
+      return
+
+    def qualifies(sym: Symbol) = sym.name.isTypeName && !sym.is(Private)
+    withMode(Mode.CheckCyclic) {
+      val abstractTypeNames =
+        for (parent <- parents; mbr <- parent.abstractTypeMembers if qualifies(mbr.symbol))
+        yield mbr.name.asTypeName
+
+      for name <- abstractTypeNames do
+        try
+          val mbr = joint.member(name)
+          mbr.info match
+            case bounds: TypeBounds =>
+              !checkNonCyclic(mbr.symbol, bounds, reportErrors = true).isError
+            case _ =>
+              true
+        catch case _: RecursionOverflow | _: CyclicReference =>
+          report.error(em"cyclic reference involving type $name", pos)
+          false
+    }
+  }
+
+  /** Check that symbol's definition is well-formed. */
+  def checkWellFormed(sym: Symbol)(using Context): Unit = {
+    def fail(msg: Message) = report.error(msg, sym.srcPos)
+    def warn(msg: Message) = report.warning(msg, sym.srcPos)
+
+    def checkWithDeferred(flag: FlagSet) =
+      if (sym.isOneOf(flag))
+        fail(AbstractMemberMayNotHaveModifier(sym, flag))
+    def checkNoConflict(flag1: FlagSet, flag2: FlagSet, msg: -> String) =
+      if (sym.isAllOf(flag1 | flag2)) fail(msg.toMessage)
+    def checkCombination(flag1: FlagSet, flag2: FlagSet) =
+      if sym.isAllOf(flag1 | flag2) then
+        fail(i"illegal combination of modifiers: `${flag1.flagsString}` and `${flag2.flagsString}` for: $sym".toMessage)
+    def checkApplicable(flag: Flag, ok: Boolean) =
+      if sym.is(flag, butNot = Synthetic) && !ok then
+        fail(ModifierNotAllowedForDefinition(flag))
+        sym.resetFlag(flag)
+
+    if (sym.is(Inline) &&
+          (  sym.is(ParamAccessor) && sym.owner.isClass
+          || sym.is(TermParam) && !sym.owner.isInlineMethod
+          ))
+      fail(ParamsNoInline(sym.owner))
+    if sym.isInlineMethod && !sym.is(Deferred) && sym.allOverriddenSymbols.nonEmpty then
+      checkInlineOverrideParameters(sym)
+    if (sym.is(Implicit)) {
+      assert(!sym.owner.is(Package), s"top-level implicit $sym should be wrapped by a package after typer")
+      if sym.isType && (!sym.isClass || sym.is(Trait)) then
+        fail(TypesAndTraitsCantBeImplicit())
+    }
+    if sym.is(Transparent) then
+      if sym.isType then
+        if !sym.is(Trait) then fail(em"`transparent` can only be used for traits".toMessage)
+      else
+        if !sym.isInlineMethod then fail(em"`transparent` can only be used for inline methods".toMessage)
+    if (!sym.isClass && sym.is(Abstract))
+      fail(OnlyClassesCanBeAbstract(sym))
+        // note: this is not covered by the next test since terms can be abstract (which is a dual-mode flag)
+        // but they can never be one of ClassOnlyFlags
+    if !sym.isClass && sym.isOneOf(ClassOnlyFlags) then
+      fail(em"only classes can be ${(sym.flags & ClassOnlyFlags).flagsString}".toMessage)
+    if (sym.is(AbsOverride) && !sym.owner.is(Trait))
+      fail(AbstractOverrideOnlyInTraits(sym))
+    if sym.is(Trait) then
+      if sym.is(Final) then
+        fail(TraitsMayNotBeFinal(sym))
+      else if sym.is(Open) then
+        warn(RedundantModifier(Open))
+    if sym.isAllOf(Abstract | Open) then
+      warn(RedundantModifier(Open))
+    if sym.is(Open) && sym.isLocal then
+      warn(RedundantModifier(Open))
+    // Skip ModuleVal since the annotation will also be on the ModuleClass
+    if sym.hasAnnotation(defn.TailrecAnnot) then
+      if !sym.isOneOf(Method | ModuleVal) then
+        fail(TailrecNotApplicable(sym))
+      else if sym.is(Inline) then
+        fail("Inline methods cannot be @tailrec".toMessage)
+    if sym.hasAnnotation(defn.TargetNameAnnot) && sym.isClass && sym.isTopLevelClass then
+      fail(TargetNameOnTopLevelClass(sym))
+    if (sym.hasAnnotation(defn.NativeAnnot)) {
+      if (!sym.is(Deferred))
+        fail(NativeMembersMayNotHaveImplementation(sym))
+      else if(sym.owner.is(Trait))
+        fail(TraitMayNotDefineNativeMethod(sym))
+    }
+    else if (sym.is(Deferred, butNot = Param) && !sym.isType && !sym.isSelfSym) {
+      if (!sym.owner.isClass || sym.owner.is(Module) || sym.owner.isAnonymousClass)
+        fail(OnlyClassesCanHaveDeclaredButUndefinedMembers(sym))
+      checkWithDeferred(Private)
+      checkWithDeferred(Final)
+    }
+    if (sym.isValueClass && sym.is(Trait) && !sym.isRefinementClass)
+      fail(CannotExtendAnyVal(sym))
+    if (sym.isConstructor && !sym.isPrimaryConstructor && sym.owner.is(Trait, butNot = JavaDefined))
+      val addendum = if ctx.settings.Ydebug.value then s" ${sym.owner.flagsString}" else ""
+      fail(s"Traits cannot have secondary constructors$addendum".toMessage)
+    checkApplicable(Inline, sym.isTerm && !sym.isOneOf(Mutable | Module))
+    checkApplicable(Lazy, !sym.isOneOf(Method | Mutable))
+    if (sym.isType && !sym.isOneOf(Deferred | JavaDefined))
+      for (cls <- sym.allOverriddenSymbols.filter(_.isClass)) {
+        fail(CannotHaveSameNameAs(sym, cls, CannotHaveSameNameAs.CannotBeOverridden))
+        sym.setFlag(Private) // break the overriding relationship by making sym Private
+      }
+    checkApplicable(Erased,
+      !sym.isOneOf(MutableOrLazy, butNot = Given) && !sym.isType || sym.isClass)
+    checkCombination(Final, Open)
+    checkCombination(Sealed, Open)
+    checkCombination(Final, Sealed)
+    checkCombination(Private, Protected)
+    checkCombination(Abstract, Override)
+    checkCombination(Private, Override)
+    if sym.isType && !sym.isClass then checkCombination(Private, Opaque)
+    checkCombination(Lazy, Inline)
+    // The issue with `erased inline` is that the erased semantics get lost
+    // as the code is inlined and the reference is removed before the erased usage check.
+    checkCombination(Erased, Inline)
+    checkNoConflict(Lazy, ParamAccessor, s"parameter may not be `lazy`")
+  }
+
+  /** Check for illegal or redundant modifiers on modules. This is done separately
+   *  from checkWellformed, since the original module modifiers don't surivive desugaring
+   */
+  def checkWellFormedModule(mdef: untpd.ModuleDef)(using Context) =
+    val mods = mdef.mods
+    def flagSourcePos(flag: FlagSet) =
+      mods.mods.find(_.flags == flag).getOrElse(mdef).srcPos
+    if mods.is(Abstract) then
+      report.error(ModifierNotAllowedForDefinition(Abstract), flagSourcePos(Abstract))
+    if mods.is(Sealed) then
+      report.error(ModifierNotAllowedForDefinition(Sealed), flagSourcePos(Sealed))
+    if mods.is(Final, butNot = Synthetic) then
+      report.warning(RedundantModifier(Final), flagSourcePos(Final))
+
+  /** Check the type signature of the symbol `M` defined by `tree` does not refer
+   *  to a private type or value which is invisible at a point where `M` is still
+   *  visible.
+   *
+   *  As an exception, we allow references to type aliases if the underlying
+   *  type of the alias is not a leak, and if `sym` is not a type. The rationale
+   *  for this is that the inferred type of a term symbol might contain leaky
+   *  aliases which should be removed (see leak-inferred.scala for an example),
+   *  but a type symbol definition will not contain leaky aliases unless the
+   *  user wrote them, so we can ask the user to change his definition. The more
+   *  practical reason for not transforming types is that `checkNoPrivateLeaks`
+   *  can force a lot of denotations, and this restriction means that we never
+   *  need to run `TypeAssigner#avoidPrivateLeaks` on type symbols when
+   *  unpickling, which avoids some issues related to forcing order.
+   *
+   *  See i997.scala for negative tests, and i1130.scala for a case where it
+   *  matters that we transform leaky aliases away.
+   *
+   *  @return The `info` of `sym`, with problematic aliases expanded away.
+   */
+  def checkNoPrivateLeaks(sym: Symbol)(using Context): Type = {
+    class NotPrivate extends TypeMap {
+      var errors: List[() -> String] = Nil
+      private var inCaptureSet: Boolean = false
+
+      def accessBoundary(sym: Symbol): Symbol =
+        if (sym.is(Private) || !sym.owner.isClass) sym.owner
+        else if (sym.privateWithin.exists) sym.privateWithin
+        else if (sym.is(Package)) sym
+        else accessBoundary(sym.owner)
+
+      val symBoundary = accessBoundary(sym)
+
+      /** Is `other` leaked outside its access boundary ?
+       *  @pre  The signature of `sym` refers to `other`
+       */
+      def isLeaked(other: Symbol) =
+        other.is(Private, butNot = TypeParam)
+        && {
+          val otherBoundary = other.owner
+          val otherLinkedBoundary = otherBoundary.linkedClass
+          !(symBoundary.isContainedIn(otherBoundary) ||
+            otherLinkedBoundary.exists && symBoundary.isContainedIn(otherLinkedBoundary))
+        }
+        && !(inCaptureSet && other.isAllOf(LocalParamAccessor))
+            // class parameters in capture sets are not treated as leaked since in
+            // phase CheckCaptures these are treated as normal vals.
+
+      def apply(tp: Type): Type = tp match {
+        case tp: NamedType =>
+          val prevErrors = errors
+          var tp1 =
+            if (isLeaked(tp.symbol)) {
+              errors =
+                (() => em"non-private ${sym.showLocated} refers to private ${tp.symbol}\nin its type signature ${sym.info}")
+                :: errors
+              tp
+            }
+            else mapOver(tp)
+          if ((errors ne prevErrors) && tp.info.isTypeAlias) {
+            // try to dealias to avoid a leak error
+            val savedErrors = errors
+            errors = prevErrors
+            val tp2 = apply(tp.superType)
+            if (errors eq prevErrors) tp1 = tp2
+            else errors = savedErrors
+          }
+          tp1
+        case tp: ClassInfo =>
+          def transformedParent(tp: Type): Type = tp match {
+            case ref: TypeRef => ref
+            case ref: AppliedType => ref
+            case AnnotatedType(parent, annot) =>
+              AnnotatedType(transformedParent(parent), annot)
+            case _ => defn.ObjectType // can happen if class files are missing
+          }
+          tp.derivedClassInfo(
+            prefix = apply(tp.prefix),
+            declaredParents =
+              tp.declaredParents.map(p => transformedParent(apply(p)))
+            )
+        case tp @ AnnotatedType(underlying, annot)
+        if annot.symbol == defn.RetainsAnnot || annot.symbol == defn.RetainsByNameAnnot =>
+          val underlying1 = this(underlying)
+          val saved = inCaptureSet
+          inCaptureSet = true
+          val annot1 = annot.mapWith(this)
+          inCaptureSet = saved
+          derivedAnnotatedType(tp, underlying1, annot1)
+        case _ =>
+          mapOver(tp)
+      }
+    }
+    val notPrivate = new NotPrivate
+    val info = notPrivate(sym.info)
+    notPrivate.errors.foreach(error => report.errorOrMigrationWarning(error(), sym.srcPos, from = `3.0`))
+    info
+  }
+
+  /** Verify classes extending AnyVal meet the requirements */
+  def checkDerivedValueClass(clazz: Symbol, stats: List[Tree])(using Context): Unit = {
+    def checkValueClassMember(stat: Tree) = stat match {
+      case _: TypeDef if stat.symbol.isClass =>
+        report.error(ValueClassesMayNotDefineInner(clazz, stat.symbol), stat.srcPos)
+      case _: ValDef if !stat.symbol.is(ParamAccessor) =>
+        report.error(ValueClassesMayNotDefineNonParameterField(clazz, stat.symbol), stat.srcPos)
+      case _: DefDef if stat.symbol.isConstructor =>
+        report.error(ValueClassesMayNotDefineASecondaryConstructor(clazz, stat.symbol), stat.srcPos)
+      case _: MemberDef | _: Import | EmptyTree =>
+      // ok
+      case _ =>
+        report.error(ValueClassesMayNotContainInitalization(clazz), stat.srcPos)
+    }
+    if (isDerivedValueClass(clazz)) {
+      if (clazz.is(Trait))
+        report.error(CannotExtendAnyVal(clazz), clazz.srcPos)
+      if (clazz.is(Abstract))
+        report.error(ValueClassesMayNotBeAbstract(clazz), clazz.srcPos)
+      if (!clazz.isStatic)
+        report.error(ValueClassesMayNotBeContainted(clazz), clazz.srcPos)
+      if (isDerivedValueClass(underlyingOfValueClass(clazz.asClass).classSymbol))
+        report.error(ValueClassesMayNotWrapAnotherValueClass(clazz), clazz.srcPos)
+      else {
+        val clParamAccessors = clazz.asClass.paramAccessors.filter { param =>
+          param.isTerm && !param.is(Flags.Accessor)
+        }
+        clParamAccessors match {
+          case param :: params =>
+            if (param.is(Mutable))
+              report.error(ValueClassParameterMayNotBeAVar(clazz, param), param.srcPos)
+            if (param.info.isInstanceOf[ExprType])
+              report.error(ValueClassParameterMayNotBeCallByName(clazz, param), param.srcPos)
+            if (param.is(Erased))
+              report.error("value class first parameter cannot be `erased`", param.srcPos)
+            else
+              for (p <- params if !p.is(Erased))
+                report.error("value class can only have one non `erased` parameter", p.srcPos)
+          case Nil =>
+            report.error(ValueClassNeedsOneValParam(clazz), clazz.srcPos)
+        }
+      }
+      stats.foreach(checkValueClassMember)
+    }
+  }
+
+  /** Check the inline override methods only use inline parameters if they override an inline parameter. */
+  def checkInlineOverrideParameters(sym: Symbol)(using Context): Unit =
+    lazy val params = sym.paramSymss.flatten
+    for
+      sym2 <- sym.allOverriddenSymbols
+      (p1, p2) <- sym.paramSymss.flatten.lazyZip(sym2.paramSymss.flatten)
+      if p1.is(Inline) != p2.is(Inline)
+    do
+      report.error(
+          if p2.is(Inline) then "Cannot override inline parameter with a non-inline parameter"
+          else "Cannot override non-inline parameter with an inline parameter",
+          p1.srcPos)
+
+  def checkValue(tree: Tree)(using Context): Unit =
+    val sym = tree.tpe.termSymbol
+    if sym.isNoValue && !ctx.isJava then
+      report.error(JavaSymbolIsNotAValue(sym), tree.srcPos)
+
+  def checkValue(tree: Tree, proto: Type)(using Context): tree.type =
+    tree match
+      case tree: RefTree
+      if tree.name.isTermName
+         && !proto.isInstanceOf[SelectionProto]
+         && !proto.isInstanceOf[FunOrPolyProto] =>
+        checkValue(tree)
+      case _ =>
+    tree
+
+  /** Check that experimental language imports in `trees`
+   *  are done only in experimental scopes, or in a top-level
+   *  scope with only @experimental definitions.
+   */
+  def checkExperimentalImports(trees: List[Tree])(using Context): Unit =
+
+    def nonExperimentalStat(trees: List[Tree]): Tree = trees match
+      case (_: Import | EmptyTree) :: rest =>
+        nonExperimentalStat(rest)
+      case (tree @ TypeDef(_, impl: Template)) :: rest if tree.symbol.isPackageObject =>
+        nonExperimentalStat(impl.body).orElse(nonExperimentalStat(rest))
+      case (tree: PackageDef) :: rest =>
+        nonExperimentalStat(tree.stats).orElse(nonExperimentalStat(rest))
+      case (tree: MemberDef) :: rest =>
+        if tree.symbol.isExperimental || tree.symbol.is(Synthetic) then
+          nonExperimentalStat(rest)
+        else
+          tree
+      case tree :: rest =>
+        tree
+      case Nil =>
+        EmptyTree
+
+    for case imp @ Import(qual, selectors) <- trees do
+      def isAllowedImport(sel: untpd.ImportSelector) =
+        val name = Feature.experimental(sel.name)
+        name == Feature.scala2macros || name == Feature.erasedDefinitions
+
+      languageImport(qual) match
+        case Some(nme.experimental)
+        if !ctx.owner.isInExperimentalScope && !selectors.forall(isAllowedImport) =>
+          def check(stable: -> String) =
+            Feature.checkExperimentalFeature("features", imp.srcPos,
+              s"\n\nNote: the scope enclosing the import is not considered experimental because it contains the\nnon-experimental $stable")
+          if ctx.owner.is(Package) then
+            // allow top-level experimental imports if all definitions are @experimental
+            nonExperimentalStat(trees) match
+              case EmptyTree =>
+              case tree: MemberDef => check(i"${tree.symbol}")
+              case tree => check(i"expression ${tree}")
+          else Feature.checkExperimentalFeature("features", imp.srcPos)
+        case _ =>
+  end checkExperimentalImports
+}
+
+trait Checking {
+
+  import tpd._
+
+  def checkNonCyclic(sym: Symbol, info: TypeBounds, reportErrors: Boolean)(using Context): Type =
+    Checking.checkNonCyclic(sym, info, reportErrors)
+
+  def checkNonCyclicInherited(joint: Type, parents: List[Type], decls: Scope, pos: SrcPos)(using Context): Unit =
+    Checking.checkNonCyclicInherited(joint, parents, decls, pos)
+
+  /** Check that type `tp` is stable. */
+  def checkStable(tp: Type, pos: SrcPos, kind: String)(using Context): Unit =
+    if !tp.isStable then report.error(NotAPath(tp, kind), pos)
+
+  /** Check that all type members of `tp` have realizable bounds */
+  def checkRealizableBounds(cls: Symbol, pos: SrcPos)(using Context): Unit = {
+    val rstatus = boundsRealizability(cls.thisType)
+    if (rstatus ne Realizable)
+      report.error(ex"$cls cannot be instantiated since it${rstatus.msg}", pos)
+  }
+
+  /** Check that pattern `pat` is irrefutable for scrutinee type `sel.tpe`.
+   *  This means `sel` is either marked @unchecked or `sel.tpe` conforms to the
+   *  pattern's type. If pattern is an UnApply, also check that the extractor is
+   *  irrefutable, and do the check recursively.
+   */
+  def checkIrrefutable(sel: Tree, pat: Tree, isPatDef: Boolean)(using Context): Boolean = {
+    val pt = sel.tpe
+
+    enum Reason:
+      case NonConforming, RefutableExtractor
+
+    def fail(pat: Tree, pt: Type, reason: Reason): Boolean = {
+      import Reason._
+      val message = reason match
+        case NonConforming =>
+          var reportedPt = pt.dropAnnot(defn.UncheckedAnnot)
+          if !pat.tpe.isSingleton then reportedPt = reportedPt.widen
+          val problem = if pat.tpe <:< reportedPt then "is more specialized than" else "does not match"
+          ex"pattern's type ${pat.tpe} $problem the right hand side expression's type $reportedPt"
+        case RefutableExtractor =>
+          val extractor =
+            val UnApply(fn, _, _) = pat: @unchecked
+            tpd.funPart(fn) match
+              case Select(id, _) => id
+              case _ => EmptyTree
+          if extractor.isEmpty then
+            em"pattern binding uses refutable extractor"
+          else
+            em"pattern binding uses refutable extractor `$extractor`"
+
+      val fix =
+        if isPatDef then "adding `: @unchecked` after the expression"
+        else "adding the `case` keyword before the full pattern"
+      val addendum =
+        if isPatDef then "may result in a MatchError at runtime"
+        else "will result in a filtering for expression (using `withFilter`)"
+      val usage = reason match
+        case NonConforming => "the narrowing"
+        case RefutableExtractor => "this usage"
+      val pos =
+        if isPatDef then reason match
+          case NonConforming => sel.srcPos
+          case RefutableExtractor => pat.source.atSpan(pat.span union sel.span)
+        else pat.srcPos
+      def rewriteMsg = Message.rewriteNotice("This patch", `3.2-migration`)
+      report.gradualErrorOrMigrationWarning(
+        em"""$message
+            |
+            |If $usage is intentional, this can be communicated by $fix,
+            |which $addendum.$rewriteMsg""",
+        pos, warnFrom = `3.2`, errorFrom = `future`)
+      false
+    }
+
+    def check(pat: Tree, pt: Type): Boolean = (pt <:< pat.tpe) || fail(pat, pt, Reason.NonConforming)
+
+    def recur(pat: Tree, pt: Type): Boolean =
+      !sourceVersion.isAtLeast(`3.2`)
+      || pt.hasAnnotation(defn.UncheckedAnnot)
+      || {
+        patmatch.println(i"check irrefutable $pat: ${pat.tpe} against $pt")
+        pat match
+          case Bind(_, pat1) =>
+            recur(pat1, pt)
+          case UnApply(fn, _, pats) =>
+            check(pat, pt) &&
+            (isIrrefutable(fn, pats.length) || fail(pat, pt, Reason.RefutableExtractor)) && {
+              val argPts = unapplyArgs(fn.tpe.widen.finalResultType, fn, pats, pat.srcPos)
+              pats.corresponds(argPts)(recur)
+            }
+          case Alternative(pats) =>
+            pats.forall(recur(_, pt))
+          case Typed(arg, tpt) =>
+            check(pat, pt) && recur(arg, pt)
+          case Ident(nme.WILDCARD) =>
+            true
+          case _ =>
+            check(pat, pt)
+        }
+
+    recur(pat, pt)
+  }
+
+  private def checkLegalImportOrExportPath(path: Tree, kind: String)(using Context): Unit = {
+    checkStable(path.tpe, path.srcPos, kind)
+    if (!ctx.isAfterTyper) Checking.checkRealizable(path.tpe, path.srcPos)
+    if !isIdempotentExpr(path) then
+      report.error(em"import prefix is not a pure expression", path.srcPos)
+  }
+
+  /** Check that `path` is a legal prefix for an import clause */
+  def checkLegalImportPath(path: Tree)(using Context): Unit =
+    checkLegalImportOrExportPath(path, "import prefix")
+    languageImport(path) match
+      case Some(prefix) =>
+        val required =
+          if prefix == nme.experimental then defn.LanguageExperimentalModule
+          else if prefix == nme.deprecated then defn.LanguageDeprecatedModule
+          else defn.LanguageModule
+        if path.symbol != required then
+          report.error(em"import looks like a language import, but refers to something else: ${path.symbol.showLocated}", path.srcPos)
+      case None =>
+        val foundClasses = path.tpe.classSymbols
+        if foundClasses.contains(defn.LanguageModule.moduleClass)
+           || foundClasses.contains(defn.LanguageExperimentalModule.moduleClass)
+        then
+          report.error(em"no aliases can be used to refer to a language import", path.srcPos)
+
+  /** Check that `path` is a legal prefix for an export clause */
+  def checkLegalExportPath(path: Tree, selectors: List[untpd.ImportSelector])(using Context): Unit =
+    checkLegalImportOrExportPath(path, "export prefix")
+    if
+      selectors.exists(_.isWildcard)
+      && path.tpe.classSymbol.is(PackageClass)
+    then
+      // we restrict wildcard export from package as incremental compilation does not yet
+      // register a dependency on "all members of a package" - see https://github.com/sbt/zinc/issues/226
+      report.error(
+        em"Implementation restriction: ${path.tpe.classSymbol} is not a valid prefix " +
+          "for a wildcard export, as it is a package.", path.srcPos)
+
+  /** Check that module `sym` does not clash with a class of the same name
+   *  that is concurrently compiled in another source file.
+   */
+  def checkNoModuleClash(sym: Symbol)(using Context): Unit =
+    val effectiveOwner = sym.effectiveOwner
+    if effectiveOwner.is(Package)
+       && effectiveOwner.info.member(sym.name.moduleClassName).symbol.isAbsent()
+    then
+      val conflicting = effectiveOwner.info.member(sym.name.toTypeName).symbol
+      if conflicting.exists then
+        report.error(AlreadyDefined(sym.name, effectiveOwner, conflicting), sym.srcPos)
+
+ /**  Check that `tp` is a class type.
+  *   Also, if `traitReq` is true, check that `tp` is a trait.
+  *   Also, if `stablePrefixReq` is true and phase is not after RefChecks,
+  *   check that class prefix is stable.
+   *  @return  `tp` itself if it is a class or trait ref, ObjectType if not.
+   */
+  def checkClassType(tp: Type, pos: SrcPos, traitReq: Boolean, stablePrefixReq: Boolean)(using Context): Type =
+    tp.underlyingClassRef(refinementOK = false) match {
+      case tref: TypeRef =>
+        if (traitReq && !tref.symbol.is(Trait)) report.error(TraitIsExpected(tref.symbol), pos)
+        if (stablePrefixReq && ctx.phase <= refchecksPhase) checkStable(tref.prefix, pos, "class prefix")
+        tp
+      case _ =>
+        report.error(NotClassType(tp), pos)
+        defn.ObjectType
+    }
+
+  /** If `sym` is an old-style implicit conversion, check that implicit conversions are enabled.
+   *  @pre  sym.is(GivenOrImplicit)
+   */
+  def checkImplicitConversionDefOK(sym: Symbol)(using Context): Unit =
+    if sym.isOldStyleImplicitConversion(directOnly = true) then
+      checkFeature(
+        nme.implicitConversions,
+        i"Definition of implicit conversion $sym",
+        ctx.owner.topLevelClass,
+        sym.srcPos)
+
+  /** If `tree` is an application of a new-style implicit conversion (using the apply
+   *  method of a `scala.Conversion` instance), check that implicit conversions are
+   *  enabled.
+   */
+  def checkImplicitConversionUseOK(tree: Tree)(using Context): Unit =
+    val sym = tree.symbol
+    if sym.name == nme.apply
+       && sym.owner.derivesFrom(defn.ConversionClass)
+       && !sym.info.isErroneous
+    then
+      def conv = methPart(tree) match
+        case Select(qual, _) => qual.symbol.orElse(sym.owner)
+        case _ => sym.owner
+      checkFeature(nme.implicitConversions,
+        i"Use of implicit conversion ${conv.showLocated}", NoSymbol, tree.srcPos)
+
+  private def infixOKSinceFollowedBy(tree: untpd.Tree): Boolean = tree match {
+    case _: untpd.Block | _: untpd.Match => true
+    case _ => false
+  }
+
+  /** Check that `tree` is a valid infix operation. That is, if the
+   *  operator is alphanumeric, it must be declared `infix`.
+   */
+  def checkValidInfix(tree: untpd.InfixOp, meth: Symbol)(using Context): Unit = {
+    tree.op match {
+      case id @ Ident(name: Name) =>
+        name.toTermName match {
+          case name: SimpleName
+          if !untpd.isBackquoted(id) &&
+             !name.isOperatorName &&
+             !meth.isDeclaredInfix &&
+             !meth.maybeOwner.is(Scala2x) &&
+             !infixOKSinceFollowedBy(tree.right) &&
+             sourceVersion.isAtLeast(future) =>
+            val (kind, alternative) =
+              if (ctx.mode.is(Mode.Type))
+                ("type", (n: Name) => s"prefix syntax $n[...]")
+              else if (ctx.mode.is(Mode.Pattern))
+                ("extractor", (n: Name) => s"prefix syntax $n(...)")
+              else
+                ("method", (n: Name) => s"method syntax .$n(...)")
+            def rewriteMsg = Message.rewriteNotice("The latter", options = "-deprecation")
+            report.deprecationWarning(
+              i"""Alphanumeric $kind $name is not declared ${hlAsKeyword("infix")}; it should not be used as infix operator.
+                 |Instead, use ${alternative(name)} or backticked identifier `$name`.$rewriteMsg""",
+              tree.op.srcPos)
+            if (ctx.settings.deprecation.value) {
+              patch(Span(tree.op.span.start, tree.op.span.start), "`")
+              patch(Span(tree.op.span.end, tree.op.span.end), "`")
+            }
+          case _ =>
+        }
+    }
+  }
+
+  /** Issue a feature warning if feature is not enabled */
+  def checkFeature(name: TermName,
+                   description: -> String,
+                   featureUseSite: Symbol,
+                   pos: SrcPos)(using Context): Unit =
+    if !Feature.enabled(name) then
+      report.featureWarning(name.toString, description, featureUseSite, required = false, pos)
+
+  /** Check that `tp` is a class type and that any top-level type arguments in this type
+   *  are feasible, i.e. that their lower bound conforms to their upper bound. If a type
+   *  argument is infeasible, issue and error and continue with upper bound.
+   */
+  def checkFeasibleParent(tp: Type, pos: SrcPos, where: -> String = "")(using Context): Type = {
+    def checkGoodBounds(tp: Type) = tp match {
+      case tp @ TypeBounds(lo, hi) if !(lo <:< hi) =>
+        report.error(ex"no type exists between low bound $lo and high bound $hi$where", pos)
+        TypeBounds(hi, hi)
+      case _ =>
+        tp
+    }
+    tp match {
+      case tp @ AndType(tp1, tp2) =>
+        report.error(s"conflicting type arguments$where", pos)
+        tp1
+      case tp @ AppliedType(tycon, args) =>
+        tp.derivedAppliedType(tycon, args.mapConserve(checkGoodBounds))
+      case tp: RefinedType =>
+        tp.derivedRefinedType(tp.parent, tp.refinedName, checkGoodBounds(tp.refinedInfo))
+      case _ =>
+        tp
+    }
+  }
+
+  /** A hook to exclude selected symbols from double declaration check */
+  def excludeFromDoubleDeclCheck(sym: Symbol)(using Context): Boolean = false
+
+  /** Check that class does not declare same symbol twice */
+  def checkNoDoubleDeclaration(cls: Symbol)(using Context): Unit = {
+    val seen = new mutable.HashMap[Name, List[Symbol]] {
+      override def default(key: Name) = Nil
+    }
+    typr.println(i"check no double declarations $cls")
+
+    def checkDecl(decl: Symbol): Unit = {
+      for (other <- seen(decl.name) if !decl.isAbsent() && !other.isAbsent()) {
+        typr.println(i"conflict? $decl $other")
+        def javaFieldMethodPair =
+          decl.is(JavaDefined) && other.is(JavaDefined) &&
+          decl.is(Method) != other.is(Method)
+        if (decl.matches(other) && !javaFieldMethodPair) {
+          def doubleDefError(decl: Symbol, other: Symbol): Unit =
+            if (!decl.info.isErroneous && !other.info.isErroneous)
+              report.error(DoubleDefinition(decl, other, cls), decl.srcPos)
+          if decl.name.is(DefaultGetterName) && ctx.reporter.errorsReported then
+            () // do nothing; we already have reported an error that overloaded variants cannot have default arguments
+          else if (decl is Synthetic) doubleDefError(other, decl)
+          else doubleDefError(decl, other)
+        }
+        if decl.hasDefaultParams && other.hasDefaultParams then
+          report.error(em"two or more overloaded variants of $decl have default arguments", decl.srcPos)
+          decl.resetFlag(HasDefaultParams)
+      }
+      if (!excludeFromDoubleDeclCheck(decl))
+        seen(decl.name) = decl :: seen(decl.name)
+    }
+
+    cls.info.decls.foreach(checkDecl)
+    cls.info match {
+      case ClassInfo(_, _, _, _, selfSym: Symbol) => checkDecl(selfSym)
+      case _ =>
+    }
+  }
+
+  def checkParentCall(call: Tree, caller: ClassSymbol)(using Context): Unit =
+    if (!ctx.isAfterTyper) {
+      val called = call.tpe.classSymbol
+      if (caller.is(Trait))
+        report.error(i"$caller may not call constructor of $called", call.srcPos)
+      else if (called.is(Trait) && !caller.mixins.contains(called))
+        report.error(i"""$called is already implemented by super${caller.superClass},
+                   |its constructor cannot be called again""", call.srcPos)
+
+      // Check that constructor call is of the form _.<init>(args1)...(argsN).
+      // This guards against calls resulting from inserted implicits or applies.
+      def checkLegalConstructorCall(tree: Tree, encl: Tree, kind: String): Unit = tree match {
+        case Apply(fn, _) => checkLegalConstructorCall(fn, tree, "")
+        case TypeApply(fn, _) => checkLegalConstructorCall(fn, tree, "type ")
+        case Select(_, nme.CONSTRUCTOR) => // ok
+        case _ => report.error(s"too many ${kind}arguments in parent constructor", encl.srcPos)
+      }
+      call match {
+        case Apply(fn, _) => checkLegalConstructorCall(fn, call, "")
+        case _ =>
+      }
+    }
+
+  /** Check that `tpt` does not define a higher-kinded type */
+  def checkSimpleKinded(tpt: Tree)(using Context): Tree =
+    if (!tpt.tpe.hasSimpleKind && !ctx.isJava)
+        // be more lenient with missing type params in Java,
+        // needed to make pos/java-interop/t1196 work.
+      errorTree(tpt, MissingTypeParameterFor(tpt.tpe))
+    else tpt
+
+  /** Verify classes extending AnyVal meet the requirements */
+  def checkDerivedValueClass(clazz: Symbol, stats: List[Tree])(using Context): Unit =
+    Checking.checkDerivedValueClass(clazz, stats)
+
+  /** Given a parent `parent` of a class `cls`, if `parent` is a trait check that
+   *  the superclass of `cls` derived from the superclass of `parent`.
+   *
+   *  An exception is made if `cls` extends `Any`, and `parent` is `java.io.Serializable`
+   *  or `java.lang.Comparable`. These two classes are treated by Scala as universal
+   *  traits. E.g. the following is OK:
+   *
+   *      ... extends Any with java.io.Serializable
+   *
+   *  The standard library relies on this idiom.
+   */
+  def checkTraitInheritance(parent: Symbol, cls: ClassSymbol, pos: SrcPos)(using Context): Unit =
+    parent match {
+      case parent: ClassSymbol if parent.is(Trait) =>
+        val psuper = parent.superClass
+        val csuper = cls.superClass
+        val ok = csuper.derivesFrom(psuper) ||
+          parent.is(JavaDefined) && csuper == defn.AnyClass &&
+          (parent == defn.JavaSerializableClass || parent == defn.ComparableClass)
+        if (!ok)
+          report.error(em"illegal trait inheritance: super$csuper does not derive from $parent's super$psuper", pos)
+      case _ =>
+    }
+
+  /** Check that case classes are not inherited by case classes.
+   */
+  def checkCaseInheritance(parent: Symbol, caseCls: ClassSymbol, pos: SrcPos)(using Context): Unit =
+    parent match {
+      case parent: ClassSymbol =>
+        if (parent.is(Case))
+          report.error(ex"""case $caseCls has case ancestor $parent, but case-to-case inheritance is prohibited.
+                        |To overcome this limitation, use extractors to pattern match on non-leaf nodes.""", pos)
+        else checkCaseInheritance(parent.superClass, caseCls, pos)
+      case _ =>
+    }
+
+  /** Check that method parameter types do not reference their own parameter
+   *  or later parameters in the same parameter section.
+   */
+  def checkNoForwardDependencies(vparams: List[ValDef])(using Context): Unit = vparams match {
+    case vparam :: vparams1 =>
+      val check = new TreeTraverser {
+        def traverse(tree: Tree)(using Context) = tree match {
+          case id: Ident if vparams.exists(_.symbol == id.symbol) =>
+            report.error("illegal forward reference to method parameter", id.srcPos)
+          case _ =>
+            traverseChildren(tree)
+        }
+      }
+      check.traverse(vparam.tpt)
+      checkNoForwardDependencies(vparams1)
+    case Nil =>
+  }
+
+  /** Check that all named types that form part of this type have a denotation.
+   *  Called on inferred (result) types of ValDefs and DefDefs.
+   *  This could fail for types where the member was originally available as part
+   *  of the self type, yet is no longer visible once the `this` has been replaced
+   *  by some other prefix. See neg/i3083.scala
+   */
+  def checkMembersOK(tp: Type, pos: SrcPos)(using Context): Type = {
+    var ok = true
+    val check: Type => Unit = {
+      case ref: NamedType =>
+        val d = try ref.denot catch { case ex: TypeError => NoDenotation }
+        if (!d.exists) {
+          report.error(em"$ref is not defined in inferred type $tp", pos)
+          ok = false
+        }
+      case _ =>
+    }
+    tp.foreachPart(check, StopAt.Static)
+    if (ok) tp else UnspecifiedErrorType
+  }
+
+  /** Check that all non-synthetic references of the form `<ident>` or
+   *  `this.<ident>` in `tree` that refer to a member of `badOwner` are
+   *  `allowed`. Also check that there are no other explicit `this` references
+   *  to `badOwner`.
+   */
+  def checkRefsLegal(tree: tpd.Tree, badOwner: Symbol, allowed: (Name, Symbol) => Boolean, where: String)(using Context): Unit = {
+    val checker = new TreeTraverser {
+      def traverse(t: Tree)(using Context) = {
+        def check(owner: Symbol, checkedSym: Symbol) =
+          if (t.span.isSourceDerived && owner == badOwner)
+            t match {
+              case t: RefTree if allowed(t.name, checkedSym) =>
+              case _ => report.error(i"illegal reference to $checkedSym from $where", t.srcPos)
+            }
+        val sym = t.symbol
+        t match {
+          case Ident(_) | Select(This(_), _) => check(sym.maybeOwner, sym)
+          case This(_) => check(sym, sym)
+          case _ => traverseChildren(t)
+        }
+      }
+    }
+    checker.traverse(tree)
+  }
+
+  /** Check that user-defined (result) type is fully applied */
+  def checkFullyAppliedType(tree: Tree)(using Context): Unit = tree match
+    case TypeBoundsTree(lo, hi, alias) =>
+      checkFullyAppliedType(lo)
+      checkFullyAppliedType(hi)
+      checkFullyAppliedType(alias)
+    case Annotated(arg, annot) =>
+      checkFullyAppliedType(arg)
+    case LambdaTypeTree(_, body) =>
+      checkFullyAppliedType(body)
+    case _: TypeTree =>
+    case _ =>
+      if tree.tpe.typeParams.nonEmpty then
+        val what = if tree.symbol.exists then tree.symbol.show else i"type $tree"
+        report.error(em"$what takes type parameters", tree.srcPos)
+
+  /** Check that we are in an inline context (inside an inline method or in inline code) */
+  def checkInInlineContext(what: String, pos: SrcPos)(using Context): Unit =
+    if !Inlines.inInlineMethod && !ctx.isInlineContext then
+      report.error(em"$what can only be used in an inline method", pos)
+
+  /** Check arguments of compiler-defined annotations */
+  def checkAnnotArgs(tree: Tree)(using Context): tree.type =
+    val cls = Annotations.annotClass(tree)
+    tree match
+      case Apply(tycon, arg :: Nil) if cls == defn.TargetNameAnnot =>
+        arg match
+          case Literal(Constant("")) =>
+            report.error(em"target name cannot be empty", arg.srcPos)
+          case Literal(_) => // ok
+          case _ =>
+            report.error(em"@${cls.name} needs a string literal as argument", arg.srcPos)
+      case _ =>
+    tree
+
+  /** 1. Check that all case classes that extend `scala.reflect.Enum` are `enum` cases
+   *  2. Check that parameterised `enum` cases do not extend java.lang.Enum.
+   *  3. Check that only a static `enum` base class can extend java.lang.Enum.
+   *  4. Check that user does not implement an `ordinal` method in the body of an enum class.
+   */
+  def checkEnum(cdef: untpd.TypeDef, cls: Symbol, firstParent: Symbol)(using Context): Unit = {
+    def existingDef(sym: Symbol, clazz: ClassSymbol)(using Context): Symbol = // adapted from SyntheticMembers
+      val existing = sym.matchingMember(clazz.thisType)
+      if existing != sym && !existing.is(Deferred) then existing else NoSymbol
+    def checkExistingOrdinal(using Context) =
+      val decl = existingDef(defn.Enum_ordinal, cls.asClass)
+      if decl.exists then
+        if decl.owner == cls then
+          report.error(em"the ordinal method of enum $cls can not be defined by the user", decl.srcPos)
+        else
+          report.error(em"enum $cls can not inherit the concrete ordinal method of ${decl.owner}", cdef.srcPos)
+    def isEnumAnonCls =
+      cls.isAnonymousClass
+      && cls.owner.isTerm
+      && (cls.owner.flagsUNSAFE.isAllOf(EnumCase)
+        || ((cls.owner.name eq nme.DOLLAR_NEW) && cls.owner.flagsUNSAFE.isAllOf(Private | Synthetic)))
+    val isJavaEnum = cls.derivesFrom(defn.JavaEnumClass)
+    if isJavaEnum && cdef.mods.isEnumClass && !cls.isStatic then
+      report.error(em"An enum extending java.lang.Enum must be declared in a static scope", cdef.srcPos)
+    if !isEnumAnonCls then
+      if cdef.mods.isEnumCase then
+        if isJavaEnum then
+          report.error(em"paramerized case is not allowed in an enum that extends java.lang.Enum", cdef.srcPos)
+      else if cls.is(Case) || firstParent.is(Enum) then
+        // Since enums are classes and Namer checks that classes don't extend multiple classes, we only check the class
+        // parent.
+        //
+        // this test allows inheriting from `Enum` by hand;
+        // see enum-List-control.scala.
+        report.error(ClassCannotExtendEnum(cls, firstParent), cdef.srcPos)
+    if cls.isEnumClass && !isJavaEnum then
+      checkExistingOrdinal
+  }
+
+  /** Check that the firstParent for an enum case derives from the declaring enum class, if not, adds it as a parent
+   *  after emitting an error.
+   *
+   *  This check will have no effect on simple enum cases as their parents are inferred by the compiler.
+   */
+  def checkEnumParent(cls: Symbol, firstParent: Symbol)(using Context): Unit =
+
+    extension (sym: Symbol) def typeRefApplied(using Context): Type =
+      sym.typeRef.appliedTo(sym.typeParams.map(_.info.loBound))
+
+    def ensureParentDerivesFrom(enumCase: Symbol)(using Context) =
+      val enumCls = enumCase.owner.linkedClass
+      if !firstParent.derivesFrom(enumCls) then
+        report.error(i"enum case does not extend its enum $enumCls", enumCase.srcPos)
+        cls.info match
+          case info: ClassInfo =>
+            cls.info = info.derivedClassInfo(declaredParents = enumCls.typeRefApplied :: info.declaredParents)
+          case _ =>
+
+    val enumCase =
+      if cls.flagsUNSAFE.isAllOf(EnumCase) then cls
+      else if cls.isAnonymousClass && cls.owner.flagsUNSAFE.isAllOf(EnumCase) then cls.owner
+      else NoSymbol
+    if enumCase.exists then
+      ensureParentDerivesFrom(enumCase)
+
+  end checkEnumParent
+
+
+  /** Check that all references coming from enum cases in an enum companion object
+   *  are legal.
+   *  @param  cdef     the enum companion object class
+   *  @param  enumCtx  the context immediately enclosing the corresponding enum
+   */
+  def checkEnumCaseRefsLegal(cdef: TypeDef, enumCtx: Context)(using Context): Unit = {
+
+    def checkEnumCaseOrDefault(stat: Tree, caseCtx: Context) = {
+
+      def check(tree: Tree) = {
+        // allow access to `sym` if a typedIdent just outside the enclosing enum
+        // would have produced the same symbol without errors
+        def allowAccess(name: Name, sym: Symbol): Boolean = {
+          val testCtx = caseCtx.fresh.setNewTyperState()
+          val ref = ctx.typer.typedIdent(untpd.Ident(name).withSpan(stat.span), WildcardType)(using testCtx)
+          ref.symbol == sym && !testCtx.reporter.hasErrors
+        }
+        checkRefsLegal(tree, cdef.symbol, allowAccess, "enum case")
+      }
+
+      if (stat.symbol.isAllOf(EnumCase))
+        stat match {
+          case TypeDef(_, Template(DefDef(_, paramss, _, _), parents, _, _)) =>
+            paramss.foreach(_.foreach(check))
+            parents.foreach(check)
+          case vdef: ValDef =>
+            vdef.rhs match {
+              case Block((clsDef @ TypeDef(_, impl: Template)) :: Nil, _)
+              if clsDef.symbol.isAnonymousClass =>
+                impl.parents.foreach(check)
+              case _ =>
+            }
+          case _ =>
+        }
+      else if (stat.symbol.is(Module) && stat.symbol.linkedClass.isAllOf(EnumCase))
+        stat match {
+          case TypeDef(_, impl: Template) =>
+            for (case (defaultGetter @
+                  DefDef(DefaultGetterName(nme.CONSTRUCTOR, _), _, _, _)) <- impl.body)
+              check(defaultGetter.rhs)
+          case _ =>
+        }
+    }
+
+    cdef.rhs match {
+      case impl: Template =>
+        def isEnumCase(stat: Tree) = stat match {
+          case _: ValDef | _: TypeDef => stat.symbol.isAllOf(EnumCase)
+          case _ => false
+        }
+        val cases =
+          for (stat <- impl.body if isEnumCase(stat))
+          yield untpd.ImportSelector(untpd.Ident(stat.symbol.name.toTermName))
+        val caseImport: Import = Import(ref(cdef.symbol), cases)
+        val caseCtx = enumCtx.importContext(caseImport, caseImport.symbol)
+        for (stat <- impl.body) checkEnumCaseOrDefault(stat, caseCtx)
+      case _ =>
+    }
+  }
+
+  /** check that annotation `annot` is applicable to symbol `sym` */
+  def checkAnnotApplicable(annot: Tree, sym: Symbol)(using Context): Boolean =
+    !ctx.reporter.reportsErrorsFor {
+      val annotCls = Annotations.annotClass(annot)
+      val concreteAnnot = Annotations.ConcreteAnnotation(annot)
+      val pos = annot.srcPos
+      if (annotCls == defn.MainAnnot || concreteAnnot.matches(defn.MainAnnotationClass)) {
+        if (!sym.isRealMethod)
+          report.error(em"main annotation cannot be applied to $sym", pos)
+        if (!sym.owner.is(Module) || !sym.owner.isStatic)
+          report.error(em"$sym cannot be a main method since it cannot be accessed statically", pos)
+      }
+      // TODO: Add more checks here
+    }
+
+  /** Check that symbol's external name does not clash with symbols defined in the same scope */
+  def checkNoTargetNameConflict(stats: List[Tree])(using Context): Unit =
+    var seen = Set[Name]()
+    for stat <- stats do
+      val sym = stat.symbol
+      val tname = sym.targetName
+      if tname != sym.name then
+        val preExisting = ctx.effectiveScope.lookup(tname)
+        if preExisting.exists || seen.contains(tname) then
+          report.error(em"@targetName annotation ${'"'}$tname${'"'} clashes with other definition in same scope", stat.srcPos)
+        if stat.isDef then seen += tname
+
+  def checkMatchable(tp: Type, pos: SrcPos, pattern: Boolean)(using Context): Unit =
+    if !tp.derivesFrom(defn.MatchableClass) && sourceVersion.isAtLeast(`future-migration`) then
+      val kind = if pattern then "pattern selector" else "value"
+      report.warning(MatchableWarning(tp, pattern), pos)
+
+  /** Check that there is an implicit capability to throw a checked exception
+   *  if the saferExceptions feature is turned on. Return that capability is it exists,
+   *  EmptyTree otherwise.
+   */
+  def checkCanThrow(tp: Type, span: Span)(using Context): Tree =
+    if Feature.enabled(Feature.saferExceptions) && tp.isCheckedException then
+      ctx.typer.implicitArgTree(defn.CanThrowClass.typeRef.appliedTo(tp), span)
+    else
+      EmptyTree
+
+  /** Check that catch can generate a good CanThrow exception */
+  def checkCatch(pat: Tree, guard: Tree)(using Context): Unit = pat match
+    case Typed(_: Ident, tpt) if isFullyDefined(tpt.tpe, ForceDegree.none) && guard.isEmpty =>
+      // OK
+    case Bind(_, pat1) =>
+      checkCatch(pat1, guard)
+    case _ =>
+      val req =
+        if guard.isEmpty then "for cases of the form `ex: T` where `T` is fully defined"
+        else "if no pattern guard is given"
+      report.error(
+        em"""Implementation restriction: cannot generate CanThrow capability for this kind of catch.
+            |CanThrow capabilities can only be generated $req.""",
+        pat.srcPos)
+
+  /** Check that tree does not define a context function type */
+  def checkNoContextFunctionType(tree: Tree)(using Context): Unit =
+    def recur(tp: Type): Unit = tp.dealias match
+      case tp: HKTypeLambda => recur(tp.resType)
+      case tp if defn.isContextFunctionType(tp) =>
+        report.error(em"context function type cannot have opaque aliases", tree.srcPos)
+      case _ =>
+    recur(tree.tpe)
+
+  /** (1) Check that every named import selector refers to a type or value member of the
+   *  qualifier type.
+   *  (2) Check that no import selector is renamed more than once.
+   */
+  def checkImportSelectors(qualType: Type, selectors: List[untpd.ImportSelector])(using Context): Unit =
+    val seen = mutable.Set.empty[Name]
+
+    def checkIdent(sel: untpd.ImportSelector): Unit =
+      if sel.name != nme.ERROR
+          && !qualType.member(sel.name).exists
+          && !qualType.member(sel.name.toTypeName).exists
+      then
+        report.error(NotAMember(qualType, sel.name, "value"), sel.imported.srcPos)
+      if seen.contains(sel.name) then
+        report.error(ImportRenamedTwice(sel.imported), sel.imported.srcPos)
+      seen += sel.name
+
+    if !ctx.compilationUnit.isJava then
+      for sel <- selectors do
+        if !sel.isWildcard then checkIdent(sel)
+  end checkImportSelectors
+}
+
+trait ReChecking extends Checking {
+  import tpd._
+  override def checkEnumParent(cls: Symbol, firstParent: Symbol)(using Context): Unit = ()
+  override def checkEnum(cdef: untpd.TypeDef, cls: Symbol, firstParent: Symbol)(using Context): Unit = ()
+  override def checkRefsLegal(tree: tpd.Tree, badOwner: Symbol, allowed: (Name, Symbol) => Boolean, where: String)(using Context): Unit = ()
+  override def checkFullyAppliedType(tree: Tree)(using Context): Unit = ()
+  override def checkEnumCaseRefsLegal(cdef: TypeDef, enumCtx: Context)(using Context): Unit = ()
+  override def checkAnnotApplicable(annot: Tree, sym: Symbol)(using Context): Boolean = true
+  override def checkMatchable(tp: Type, pos: SrcPos, pattern: Boolean)(using Context): Unit = ()
+  override def checkNoModuleClash(sym: Symbol)(using Context) = ()
+  override def checkCanThrow(tp: Type, span: Span)(using Context): Tree = EmptyTree
+  override def checkCatch(pat: Tree, guard: Tree)(using Context): Unit = ()
+  override def checkNoContextFunctionType(tree: Tree)(using Context): Unit = ()
+  override def checkFeature(name: TermName, description: -> String, featureUseSite: Symbol, pos: SrcPos)(using Context): Unit = ()
+}
+
+trait NoChecking extends ReChecking {
+  import tpd._
+  override def checkNonCyclic(sym: Symbol, info: TypeBounds, reportErrors: Boolean)(using Context): Type = info
+  override def checkNonCyclicInherited(joint: Type, parents: List[Type], decls: Scope, pos: SrcPos)(using Context): Unit = ()
+  override def checkStable(tp: Type, pos: SrcPos, kind: String)(using Context): Unit = ()
+  override def checkClassType(tp: Type, pos: SrcPos, traitReq: Boolean, stablePrefixReq: Boolean)(using Context): Type = tp
+  override def checkImplicitConversionDefOK(sym: Symbol)(using Context): Unit = ()
+  override def checkImplicitConversionUseOK(tree: Tree)(using Context): Unit = ()
+  override def checkFeasibleParent(tp: Type, pos: SrcPos, where: -> String = "")(using Context): Type = tp
+  override def checkAnnotArgs(tree: Tree)(using Context): tree.type = tree
+  override def checkNoTargetNameConflict(stats: List[Tree])(using Context): Unit = ()
+  override def checkParentCall(call: Tree, caller: ClassSymbol)(using Context): Unit = ()
+  override def checkSimpleKinded(tpt: Tree)(using Context): Tree = tpt
+  override def checkDerivedValueClass(clazz: Symbol, stats: List[Tree])(using Context): Unit = ()
+  override def checkTraitInheritance(parentSym: Symbol, cls: ClassSymbol, pos: SrcPos)(using Context): Unit = ()
+  override def checkCaseInheritance(parentSym: Symbol, caseCls: ClassSymbol, pos: SrcPos)(using Context): Unit = ()
+  override def checkNoForwardDependencies(vparams: List[ValDef])(using Context): Unit = ()
+  override def checkMembersOK(tp: Type, pos: SrcPos)(using Context): Type = tp
+  override def checkInInlineContext(what: String, pos: SrcPos)(using Context): Unit = ()
+  override def checkValidInfix(tree: untpd.InfixOp, meth: Symbol)(using Context): Unit = ()
+  override def checkImportSelectors(qualType: Type, selectors: List[untpd.ImportSelector])(using Context): Unit = ()
+}
diff --git a/tests/pos-with-compiler-cc/dotc/typer/ConstFold.scala b/tests/pos-with-compiler-cc/dotc/typer/ConstFold.scala
new file mode 100644
index 000000000000..81b1de67b707
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/typer/ConstFold.scala
@@ -0,0 +1,210 @@
+package dotty.tools.dotc
+package typer
+
+import java.lang.ArithmeticException
+
+import ast._
+import core._
+import Symbols._
+import Types._
+import Constants._
+import Names._
+import StdNames._
+import Contexts._
+import transform.TypeUtils._
+
+object ConstFold:
+
+  import tpd._
+
+  private val foldedBinops = Set[Name](
+    nme.ZOR, nme.OR, nme.XOR, nme.ZAND, nme.AND, nme.EQ, nme.NE,
+    nme.LT, nme.GT, nme.LE, nme.GE, nme.LSL, nme.LSR, nme.ASR,
+    nme.ADD, nme.SUB, nme.MUL, nme.DIV, nme.MOD)
+
+  val foldedUnops = Set[Name](
+    nme.UNARY_!, nme.UNARY_~, nme.UNARY_+, nme.UNARY_-)
+
+  def Apply[T <: Apply](tree: T)(using Context): T =
+    tree.fun match
+      case Select(xt, op) if foldedBinops.contains(op) =>
+        xt match
+          case ConstantTree(x) =>
+            tree.args match
+              case yt :: Nil =>
+                yt match
+                  case ConstantTree(y) => tree.withFoldedType(foldBinop(op, x, y))
+                  case _ => tree
+              case _ => tree
+          case _ => tree
+      case TypeApply(Select(qual, nme.getClass_), _)
+      if qual.tpe.widen.isPrimitiveValueType && tree.args.isEmpty =>
+        tree.withFoldedType(Constant(qual.tpe.widen))
+      case _ =>
+        tree
+
+  def Select[T <: Select](tree: T)(using Context): T =
+    if foldedUnops.contains(tree.name) then
+      tree.qualifier match
+        case ConstantTree(x) => tree.withFoldedType(foldUnop(tree.name, x))
+        case _ => tree
+    else tree
+
+  /** If tree is a constant operation, replace with result. */
+  def apply[T <: Tree](tree: T)(using Context): T = tree match
+    case tree: Apply => Apply(tree)
+    case tree: Select => Select(tree)
+    case TypeApply(_, targ :: Nil) if tree.symbol eq defn.Predef_classOf =>
+      tree.withFoldedType(Constant(targ.tpe))
+    case _ => tree
+
+  private object ConstantTree:
+    def unapply(tree: Tree)(using Context): Option[Constant] =
+      tree match
+        case Inlined(_, Nil, expr) => unapply(expr)
+        case Typed(expr, _) => unapply(expr)
+        case Literal(c) if c.tag == Constants.NullTag => Some(c)
+        case _ =>
+          tree.tpe.widenTermRefExpr.normalized.simplified match
+            case ConstantType(c) => Some(c)
+            case _ => None
+
+  extension [T <: Tree](tree: T)(using Context)
+    private def withFoldedType(c: Constant | Null): T =
+      if c == null then tree else tree.withType(ConstantType(c)).asInstanceOf[T]
+
+  private def foldUnop(op: Name, x: Constant): Constant | Null = (op, x.tag) match {
+    case (nme.UNARY_!, BooleanTag) => Constant(!x.booleanValue)
+
+    case (nme.UNARY_~ , IntTag    ) => Constant(~x.intValue)
+    case (nme.UNARY_~ , LongTag   ) => Constant(~x.longValue)
+
+    case (nme.UNARY_+ , IntTag    ) => Constant(x.intValue)
+    case (nme.UNARY_+ , LongTag   ) => Constant(x.longValue)
+    case (nme.UNARY_+ , FloatTag  ) => Constant(x.floatValue)
+    case (nme.UNARY_+ , DoubleTag ) => Constant(x.doubleValue)
+
+    case (nme.UNARY_- , IntTag    ) => Constant(-x.intValue)
+    case (nme.UNARY_- , LongTag   ) => Constant(-x.longValue)
+    case (nme.UNARY_- , FloatTag  ) => Constant(-x.floatValue)
+    case (nme.UNARY_- , DoubleTag ) => Constant(-x.doubleValue)
+
+    case _ => null
+  }
+
+  /** These are local helpers to keep foldBinop from overly taxing the
+   *  optimizer.
+   */
+  private def foldBooleanOp(op: Name, x: Constant, y: Constant): Constant | Null = op match {
+    case nme.ZOR  => Constant(x.booleanValue | y.booleanValue)
+    case nme.OR   => Constant(x.booleanValue | y.booleanValue)
+    case nme.XOR  => Constant(x.booleanValue ^ y.booleanValue)
+    case nme.ZAND => Constant(x.booleanValue & y.booleanValue)
+    case nme.AND  => Constant(x.booleanValue & y.booleanValue)
+    case nme.EQ   => Constant(x.booleanValue == y.booleanValue)
+    case nme.NE   => Constant(x.booleanValue != y.booleanValue)
+    case _ => null
+  }
+  private def foldSubrangeOp(op: Name, x: Constant, y: Constant): Constant | Null = op match {
+    case nme.OR  => Constant(x.intValue | y.intValue)
+    case nme.XOR => Constant(x.intValue ^ y.intValue)
+    case nme.AND => Constant(x.intValue & y.intValue)
+    case nme.LSL => Constant(x.intValue << y.intValue)
+    case nme.LSR => Constant(x.intValue >>> y.intValue)
+    case nme.ASR => Constant(x.intValue >> y.intValue)
+    case nme.EQ  => Constant(x.intValue == y.intValue)
+    case nme.NE  => Constant(x.intValue != y.intValue)
+    case nme.LT  => Constant(x.intValue < y.intValue)
+    case nme.GT  => Constant(x.intValue > y.intValue)
+    case nme.LE  => Constant(x.intValue <= y.intValue)
+    case nme.GE  => Constant(x.intValue >= y.intValue)
+    case nme.ADD => Constant(x.intValue + y.intValue)
+    case nme.SUB => Constant(x.intValue - y.intValue)
+    case nme.MUL => Constant(x.intValue * y.intValue)
+    case nme.DIV => Constant(x.intValue / y.intValue)
+    case nme.MOD => Constant(x.intValue % y.intValue)
+    case _ => null
+  }
+  private def foldLongOp(op: Name, x: Constant, y: Constant): Constant | Null = op match {
+    case nme.OR  => Constant(x.longValue | y.longValue)
+    case nme.XOR => Constant(x.longValue ^ y.longValue)
+    case nme.AND => Constant(x.longValue & y.longValue)
+    case nme.LSL => if (x.tag <= IntTag) Constant(x.intValue << y.longValue.toInt) else Constant(x.longValue << y.longValue)
+    case nme.LSR => if (x.tag <= IntTag) Constant(x.intValue >>> y.longValue.toInt) else Constant(x.longValue >>> y.longValue)
+    case nme.ASR => if (x.tag <= IntTag) Constant(x.intValue >> y.longValue.toInt) else Constant(x.longValue >> y.longValue)
+    case nme.EQ  => Constant(x.longValue == y.longValue)
+    case nme.NE  => Constant(x.longValue != y.longValue)
+    case nme.LT  => Constant(x.longValue < y.longValue)
+    case nme.GT  => Constant(x.longValue > y.longValue)
+    case nme.LE  => Constant(x.longValue <= y.longValue)
+    case nme.GE  => Constant(x.longValue >= y.longValue)
+    case nme.ADD => Constant(x.longValue + y.longValue)
+    case nme.SUB => Constant(x.longValue - y.longValue)
+    case nme.MUL => Constant(x.longValue * y.longValue)
+    case nme.DIV => Constant(x.longValue / y.longValue)
+    case nme.MOD => Constant(x.longValue % y.longValue)
+    case _ => null
+  }
+  private def foldFloatOp(op: Name, x: Constant, y: Constant): Constant | Null = op match {
+    case nme.EQ  => Constant(x.floatValue == y.floatValue)
+    case nme.NE  => Constant(x.floatValue != y.floatValue)
+    case nme.LT  => Constant(x.floatValue < y.floatValue)
+    case nme.GT  => Constant(x.floatValue > y.floatValue)
+    case nme.LE  => Constant(x.floatValue <= y.floatValue)
+    case nme.GE  => Constant(x.floatValue >= y.floatValue)
+    case nme.ADD => Constant(x.floatValue + y.floatValue)
+    case nme.SUB => Constant(x.floatValue - y.floatValue)
+    case nme.MUL => Constant(x.floatValue * y.floatValue)
+    case nme.DIV => Constant(x.floatValue / y.floatValue)
+    case nme.MOD => Constant(x.floatValue % y.floatValue)
+    case _ => null
+  }
+  private def foldDoubleOp(op: Name, x: Constant, y: Constant): Constant | Null = op match {
+    case nme.EQ  => Constant(x.doubleValue == y.doubleValue)
+    case nme.NE  => Constant(x.doubleValue != y.doubleValue)
+    case nme.LT  => Constant(x.doubleValue < y.doubleValue)
+    case nme.GT  => Constant(x.doubleValue > y.doubleValue)
+    case nme.LE  => Constant(x.doubleValue <= y.doubleValue)
+    case nme.GE  => Constant(x.doubleValue >= y.doubleValue)
+    case nme.ADD => Constant(x.doubleValue + y.doubleValue)
+    case nme.SUB => Constant(x.doubleValue - y.doubleValue)
+    case nme.MUL => Constant(x.doubleValue * y.doubleValue)
+    case nme.DIV => Constant(x.doubleValue / y.doubleValue)
+    case nme.MOD => Constant(x.doubleValue % y.doubleValue)
+    case _ => null
+  }
+  private def foldStringOp(op: Name, x: Constant, y: Constant): Constant | Null = op match {
+    case nme.ADD => Constant(x.stringValue + y.stringValue)
+    case nme.EQ  => Constant(x.stringValue == y.stringValue)
+    case nme.NE  => Constant(x.stringValue != y.stringValue)
+    case _ => null
+  }
+
+  private def foldNullOp(op: Name, x: Constant, y: Constant): Constant | Null=
+    assert(x.tag == NullTag || y.tag == NullTag)
+    op match
+      case nme.EQ => Constant(x.tag == y.tag)
+      case nme.NE => Constant(x.tag != y.tag)
+      case _ => null
+
+  private def foldBinop(op: Name, x: Constant, y: Constant): Constant | Null =
+    val optag =
+      if (x.tag == y.tag) x.tag
+      else if (x.isNumeric && y.isNumeric) math.max(x.tag, y.tag)
+      else if (x.tag == NullTag || y.tag == NullTag) NullTag
+      else NoTag
+
+    try optag match
+      case  BooleanTag                            => foldBooleanOp(op, x, y)
+      case  ByteTag | ShortTag | CharTag | IntTag => foldSubrangeOp(op, x, y)
+      case  LongTag                               => foldLongOp(op, x, y)
+      case  FloatTag                              => foldFloatOp(op, x, y)
+      case  DoubleTag                             => foldDoubleOp(op, x, y)
+      case  StringTag                             => foldStringOp(op, x, y)
+      case  NullTag                               => foldNullOp(op, x, y)
+      case  _                                     => null
+      catch case ex: ArithmeticException => null // the code will crash at runtime,
+                                                 // but that is better than the
+                                                 // compiler itself crashing
+  end foldBinop
+end ConstFold
diff --git a/tests/pos-with-compiler-cc/dotc/typer/CrossVersionChecks.scala b/tests/pos-with-compiler-cc/dotc/typer/CrossVersionChecks.scala
new file mode 100644
index 000000000000..00b037a4e259
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/typer/CrossVersionChecks.scala
@@ -0,0 +1,199 @@
+package dotty.tools
+package dotc
+package transform
+
+import core.*
+import Symbols.*, Types.*, Contexts.*, Flags.*, SymUtils.*, Decorators.*, reporting.*
+import util.SrcPos
+import config.{ScalaVersion, NoScalaVersion, Feature, ScalaRelease}
+import MegaPhase.MiniPhase
+import scala.util.{Failure, Success}
+import ast.tpd
+
+class CrossVersionChecks extends MiniPhase:
+  import tpd.*
+  import CrossVersionChecks.*
+
+  override def phaseName: String = CrossVersionChecks.name
+
+  override def description: String = CrossVersionChecks.description
+
+  override def runsAfterGroupsOf: Set[String] = Set(FirstTransform.name)
+    // We assume all type trees except TypeTree have been eliminated
+
+  // Note: if a symbol has both @deprecated and @migration annotations and both
+  // warnings are enabled, only the first one checked here will be emitted.
+  // I assume that's a consequence of some code trying to avoid noise by suppressing
+  // warnings after the first, but I think it'd be better if we didn't have to
+  // arbitrarily choose one as more important than the other.
+  private def checkUndesiredProperties(sym: Symbol, pos: SrcPos)(using Context): Unit =
+    checkDeprecated(sym, pos)
+    checkExperimentalRef(sym, pos)
+
+    val xMigrationValue = ctx.settings.Xmigration.value
+    if xMigrationValue != NoScalaVersion then
+      checkMigration(sym, pos, xMigrationValue)
+  end checkUndesiredProperties
+
+  /** If @deprecated is present, and the point of reference is not enclosed
+   * in either a deprecated member or a scala bridge method, issue a warning.
+   */
+  private def checkDeprecated(sym: Symbol, pos: SrcPos)(using Context): Unit =
+
+    /** is the owner an enum or its companion and also the owner of sym */
+    def isEnumOwner(owner: Symbol)(using Context) =
+      // pre: sym is an enumcase
+      if owner.isEnumClass then owner.companionClass eq sym.owner
+      else if owner.is(ModuleClass) && owner.companionClass.isEnumClass then owner eq sym.owner
+      else false
+
+    def isDeprecatedOrEnum(owner: Symbol)(using Context) =
+      // pre: sym is an enumcase
+      owner.isDeprecated
+      || isEnumOwner(owner)
+
+    /**Scan the chain of outer declaring scopes from the current context
+     * a deprecation warning will be skipped if one the following holds
+     * for a given declaring scope:
+     * - the symbol associated with the scope is also deprecated.
+     * - if and only if `sym` is an enum case, the scope is either
+     *   a module that declares `sym`, or the companion class of the
+     *   module that declares `sym`.
+     */
+    def skipWarning(using Context) =
+      ctx.owner.ownersIterator.exists(if sym.isEnumCase then isDeprecatedOrEnum else _.isDeprecated)
+
+    for annot <- sym.getAnnotation(defn.DeprecatedAnnot) do
+      if !skipWarning then
+        val msg = annot.argumentConstant(0).map(": " + _.stringValue).getOrElse("")
+        val since = annot.argumentConstant(1).map(" since " + _.stringValue).getOrElse("")
+        report.deprecationWarning(s"${sym.showLocated} is deprecated${since}${msg}", pos)
+
+  private def checkExperimentalSignature(sym: Symbol, pos: SrcPos)(using Context): Unit =
+    class Checker extends TypeTraverser:
+      def traverse(tp: Type): Unit =
+        if tp.typeSymbol.isExperimental then
+          Feature.checkExperimentalDef(tp.typeSymbol, pos)
+        else
+          traverseChildren(tp)
+    if !sym.isInExperimentalScope then
+      new Checker().traverse(sym.info)
+
+  private def checkExperimentalAnnots(sym: Symbol)(using Context): Unit =
+    if !sym.isInExperimentalScope then
+      for annot <- sym.annotations if annot.symbol.isExperimental do
+        Feature.checkExperimentalDef(annot.symbol, annot.tree)
+
+  /** If @migration is present (indicating that the symbol has changed semantics between versions),
+   *  emit a warning.
+   */
+  private def checkMigration(sym: Symbol, pos: SrcPos, xMigrationValue: ScalaVersion)(using Context): Unit =
+    for annot <- sym.getAnnotation(defn.MigrationAnnot) do
+      val migrationVersion = ScalaVersion.parse(annot.argumentConstant(1).get.stringValue)
+      migrationVersion match
+        case Success(symVersion) if xMigrationValue < symVersion =>
+          val msg = annot.argumentConstant(0).get.stringValue
+          report.warning(SymbolChangedSemanticsInVersion(sym, symVersion, msg), pos)
+        case Failure(ex) =>
+          report.warning(SymbolHasUnparsableVersionNumber(sym, ex.getMessage.nn), pos)
+        case _ =>
+
+  /** Check that a deprecated val or def does not override a
+   *  concrete, non-deprecated method.  If it does, then
+   *  deprecation is meaningless.
+   */
+  private def checkDeprecatedOvers(tree: Tree)(using Context): Unit = {
+    val symbol = tree.symbol
+    if (symbol.isDeprecated) {
+      val concrOvers =
+        symbol.allOverriddenSymbols.filter(sym =>
+          !sym.isDeprecated && !sym.is(Deferred))
+      if (!concrOvers.isEmpty)
+        report.deprecationWarning(
+          symbol.toString + " overrides concrete, non-deprecated symbol(s):" +
+            concrOvers.map(_.name).mkString("    ", ", ", ""), tree.srcPos)
+    }
+  }
+
+  /** Check that classes extending experimental classes or nested in experimental classes have the @experimental annotation. */
+  private def checkExperimentalInheritance(cls: ClassSymbol)(using Context): Unit =
+    if !cls.isAnonymousClass && !cls.isInExperimentalScope then
+      cls.info.parents.find(_.typeSymbol.isExperimental) match
+        case Some(parent) =>
+          report.error(em"extension of experimental ${parent.typeSymbol} must have @experimental annotation", cls.srcPos)
+        case _ =>
+  end checkExperimentalInheritance
+
+  override def transformValDef(tree: ValDef)(using Context): ValDef =
+    checkDeprecatedOvers(tree)
+    checkExperimentalAnnots(tree.symbol)
+    checkExperimentalSignature(tree.symbol, tree)
+    tree
+
+  override def transformDefDef(tree: DefDef)(using Context): DefDef =
+    checkDeprecatedOvers(tree)
+    checkExperimentalAnnots(tree.symbol)
+    checkExperimentalSignature(tree.symbol, tree)
+    tree
+
+  override def transformTemplate(tree: Template)(using Context): Tree =
+    val cls = ctx.owner.asClass
+    checkExperimentalInheritance(cls)
+    checkExperimentalAnnots(cls)
+    tree
+
+  override def transformIdent(tree: Ident)(using Context): Ident = {
+    checkUndesiredProperties(tree.symbol, tree.srcPos)
+    tree
+  }
+
+  override def transformSelect(tree: Select)(using Context): Select = {
+    checkUndesiredProperties(tree.symbol, tree.srcPos)
+    tree
+  }
+
+  override def transformNew(tree: New)(using Context): New = {
+    checkUndesiredProperties(tree.tpe.typeSymbol, tree.srcPos)
+    tree
+  }
+
+  override def transformTypeTree(tree: TypeTree)(using Context): TypeTree = {
+    val tpe = tree.tpe
+    tpe.foreachPart {
+      case TypeRef(_, sym: Symbol)  =>
+        checkDeprecated(sym, tree.srcPos)
+        checkExperimentalRef(sym, tree.srcPos)
+      case TermRef(_, sym: Symbol)  =>
+        checkDeprecated(sym, tree.srcPos)
+        checkExperimentalRef(sym, tree.srcPos)
+      case _ =>
+    }
+    tree
+  }
+
+  override def transformTypeDef(tree: TypeDef)(using Context): TypeDef = {
+    checkExperimentalAnnots(tree.symbol)
+    tree
+  }
+
+  override def transformOther(tree: Tree)(using Context): Tree = tree match
+    case tree: Import =>
+      tree.foreachSubTree {
+        case t: RefTree => checkUndesiredProperties(t.symbol, t.srcPos)
+        case _ =>
+      }
+      tree
+    case _ => tree
+
+end CrossVersionChecks
+
+object CrossVersionChecks:
+  val name: String = "crossVersionChecks"
+  val description: String = "check issues related to deprecated and experimental"
+
+  /** Check that a reference to an experimental definition with symbol `sym` is only
+   *  used in an experimental scope
+   */
+  def checkExperimentalRef(sym: Symbol, pos: SrcPos)(using Context): Unit =
+    if sym.isExperimental && !ctx.owner.isInExperimentalScope then
+      Feature.checkExperimentalDef(sym, pos)
diff --git a/tests/pos-with-compiler-cc/dotc/typer/Deriving.scala b/tests/pos-with-compiler-cc/dotc/typer/Deriving.scala
new file mode 100644
index 000000000000..d2165a5ca8c5
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/typer/Deriving.scala
@@ -0,0 +1,312 @@
+package dotty.tools
+package dotc
+package typer
+
+import core._
+import ast._
+import ast.Trees._
+import StdNames._
+import Contexts._, Symbols._, Types._, SymDenotations._, Names._, NameOps._, Flags._, Decorators._
+import ProtoTypes._, ContextOps._
+import util.Spans._
+import util.SrcPos
+import collection.mutable
+import ErrorReporting.errorTree
+
+/** A typer mixin that implements type class derivation functionality */
+trait Deriving {
+  this: Typer =>
+
+  /** A helper class to derive type class instances for one class or object
+   *  @param  cls      The class symbol of the class or object with a `derives` clause
+   *  @param  codePos  The default position that should be given to generic
+   *                   synthesized infrastructure code that is not connected with a
+   *                   `derives` instance.
+   */
+  class Deriver(cls: ClassSymbol, codePos: SrcPos)(using Context) {
+
+    /** A buffer for synthesized symbols for type class instances */
+    private var synthetics = new mutable.ListBuffer[Symbol]
+
+    /** A version of Type#underlyingClassRef that works also for higher-kinded types */
+    private def underlyingClassRef(tp: Type): Type = tp match {
+      case tp: TypeRef if tp.symbol.isClass => tp
+      case tp: TypeRef if tp.symbol.isAbstractType => NoType
+      case tp: TermRef => NoType
+      case tp: TypeProxy => underlyingClassRef(tp.superType)
+      case _ => NoType
+    }
+
+    /** Enter type class instance with given name and info in current scope, provided
+     *  an instance with the same name does not exist already.
+     *  @param  reportErrors  Report an error if an instance with the same name exists already
+     */
+    private def addDerivedInstance(clsName: Name, info: Type, pos: SrcPos): Unit = {
+      val instanceName = "derived$".concat(clsName)
+      if (ctx.denotNamed(instanceName).exists)
+        report.error(i"duplicate type class derivation for $clsName", pos)
+      else
+        // If we set the Synthetic flag here widenGiven will widen too far and the
+        // derived instance will have too low a priority to be selected over a freshly
+        // derived instance at the summoning site.
+        val flags = if info.isInstanceOf[MethodOrPoly] then GivenMethod else Given | Lazy
+        synthetics +=
+          newSymbol(ctx.owner, instanceName, flags, info, coord = pos.span)
+            .entered
+    }
+
+    /** Check derived type tree `derived` for the following well-formedness conditions:
+     *  (1) It must be a class type with a stable prefix (@see checkClassTypeWithStablePrefix)
+     *
+     *  (2) It must belong to one of the following three categories:
+     *      (a) a single parameter type class with a parameter which matches the kind of
+     *          the deriving ADT
+     *      (b) a single parameter type class with a parameter of kind * and an ADT with
+     *          one or more type parameter of kind *
+     *      (c) the CanEqual type class
+     *
+     *      See detailed descriptions in deriveSingleParameter and deriveCanEqual below.
+     *
+     *  If it passes the checks, enter a type class instance for it in the current scope.
+     *
+     *  See test run/typeclass-derivation2, run/poly-kinded-derives and pos/derive-eq
+     *  for examples that spell out what would be generated.
+     *
+     *  Note that the name of the derived method contains the name in the derives clause, not
+     *  the underlying class name. This allows one to disambiguate derivations of type classes
+     *  that have the same name but different prefixes through selective aliasing.
+     */
+    private def processDerivedInstance(derived: untpd.Tree): Unit = {
+      val originalTypeClassType = typedAheadType(derived, AnyTypeConstructorProto).tpe
+      val underlyingClassType = underlyingClassRef(originalTypeClassType)
+      val typeClassType = checkClassType(
+          underlyingClassType.orElse(originalTypeClassType),
+          derived.srcPos, traitReq = false, stablePrefixReq = true)
+      val typeClass = typeClassType.classSymbol
+      val typeClassParams = typeClass.typeParams
+      val typeClassArity = typeClassParams.length
+
+      def sameParamKinds(xs: List[ParamInfo], ys: List[ParamInfo]): Boolean =
+        xs.corresponds(ys)((x, y) => x.paramInfo.hasSameKindAs(y.paramInfo))
+
+      def cannotBeUnified =
+        report.error(i"${cls.name} cannot be unified with the type argument of ${typeClass.name}", derived.srcPos)
+
+      def addInstance(derivedParams: List[TypeSymbol], evidenceParamInfos: List[List[Type]], instanceTypes: List[Type]): Unit = {
+        val resultType = typeClassType.appliedTo(instanceTypes)
+        val monoInfo =
+          if evidenceParamInfos.isEmpty then resultType
+          else ImplicitMethodType(evidenceParamInfos.map(typeClassType.appliedTo), resultType)
+        val derivedInfo =
+          if derivedParams.isEmpty then monoInfo
+          else PolyType.fromParams(derivedParams, monoInfo)
+        addDerivedInstance(originalTypeClassType.typeSymbol.name, derivedInfo, derived.srcPos)
+      }
+
+      def deriveSingleParameter: Unit = {
+        // Single parameter type classes ... (a) and (b) above
+        //
+        // (a) ADT and type class parameters overlap on the right and have the
+        //     same kinds at the overlap.
+        //
+        //     Examples:
+        //
+        //     Type class: TC[F[T, U]]
+        //
+        //     ADT: C[A, B, C, D]         (C, D have same kinds as T, U)
+        //
+        //          given derived$TC[a, b]: TC[[t, u] =>> C[a, b, t, u]]
+        //
+        //     ADT: C[A, B, C]            (B, C have same kinds at T, U)
+        //
+        //          given derived$TC   [a]: TC[[t, u] =>>    C[a, t, u]]
+        //
+        //     ADT: C[A, B]               (A, B have same kinds at T, U)
+        //
+        //          given derived$TC      : TC[              C         ]  // a "natural" instance
+        //
+        //     ADT: C[A]                  (A has same kind as U)
+        //
+        //          given derived$TC      : TC[[t, u] =>>    C[      u]]
+        //
+        // (b) The type class and all ADT type parameters are of kind *
+        //
+        //     In this case the ADT has at least one type parameter of kind *,
+        //     otherwise it would already have been covered as a "natural" case
+        //     for a type class of the form F[_].
+        //
+        //     The derived instance has a type parameter and a given for
+        //     each of the type parameters of the ADT,
+        //
+        //     Example:
+        //
+        //     Type class: TC[T]
+        //
+        //     ADT: C[A, B, C]
+        //
+        //          given derived$TC[a, b, c] given TC[a], TC[b], TC[c]: TC[a, b, c]
+        //
+        //     This, like the derivation for CanEqual, is a special case of the
+        //     earlier more general multi-parameter type class model for which
+        //     the heuristic is typically a good one.
+
+        val typeClassParamType = typeClassParams.head.info
+        val typeClassParamInfos = typeClassParamType.typeParams
+        val instanceArity = typeClassParamInfos.length
+        val clsType = cls.typeRef
+        val clsParams = cls.typeParams
+        val clsParamInfos = clsType.typeParams
+        val clsArity = clsParamInfos.length
+        val alignedClsParamInfos = clsParamInfos.takeRight(instanceArity)
+        val alignedTypeClassParamInfos = typeClassParamInfos.takeRight(alignedClsParamInfos.length)
+
+
+        if ((instanceArity == clsArity || instanceArity > 0) && sameParamKinds(alignedClsParamInfos, alignedTypeClassParamInfos)) {
+          // case (a) ... see description above
+          val derivedParams = clsParams.dropRight(instanceArity)
+          val instanceType =
+            if (instanceArity == clsArity) clsType.EtaExpand(clsParams)
+            else {
+              val derivedParamTypes = derivedParams.map(_.typeRef)
+
+              HKTypeLambda(typeClassParamInfos.map(_.paramName))(
+                tl => typeClassParamInfos.map(_.paramInfo.bounds),
+                tl => clsType.appliedTo(derivedParamTypes ++ tl.paramRefs.takeRight(clsArity)))
+            }
+
+          addInstance(derivedParams, Nil, List(instanceType))
+        }
+        else if (instanceArity == 0 && !clsParams.exists(_.info.isLambdaSub)) {
+          // case (b) ... see description above
+          val instanceType = clsType.appliedTo(clsParams.map(_.typeRef))
+          val evidenceParamInfos = clsParams.map(param => List(param.typeRef))
+          addInstance(clsParams, evidenceParamInfos, List(instanceType))
+        }
+        else
+          cannotBeUnified
+      }
+
+      def deriveCanEqual: Unit = {
+        // Specific derives rules for the CanEqual type class ... (c) above
+        //
+        // This has been extracted from the earlier more general multi-parameter
+        // type class model. Modulo the assumptions below, the implied semantics
+        // are reasonable defaults.
+        //
+        // Assumptions:
+        // 1. Type params of the deriving class correspond to all and only
+        // elements of the deriving class which are relevant to equality (but:
+        // type params could be phantom, or the deriving class might have an
+        // element of a non-CanEqual type non-parametrically).
+        //
+        // 2. Type params of kinds other than * can be assumed to be irrelevant to
+        // the derivation (but: eg. Foo[F[_]](fi: F[Int])).
+        //
+        // Are they reasonable? They cover some important cases (eg. Tuples of all
+        // arities). derives CanEqual is opt-in, so if the semantics don't match those
+        // appropriate for the deriving class the author of that class can provide
+        // their own instance in the normal way. That being so, the question turns
+        // on whether there are enough types which fit these semantics for the
+        // feature to pay its way.
+
+        // Procedure:
+        // We construct a two column matrix of the deriving class type parameters
+        // and the CanEqual type class parameters.
+        //
+        // Rows: parameters of the deriving class
+        // Columns: parameters of the CanEqual type class (L/R)
+        //
+        // Running example: type class: class CanEqual[L, R], deriving class: class A[T, U, V]
+        // clsParamss =
+        //     T_L  T_R
+        //     U_L  U_R
+        //     V_L  V_R
+        val clsParamss: List[List[TypeSymbol]] = cls.typeParams.map { tparam =>
+          typeClassParams.map(tcparam =>
+            tparam.copy(name = s"${tparam.name}_$$_${tcparam.name}".toTypeName)
+              .asInstanceOf[TypeSymbol])
+        }
+        // Retain only rows with L/R params of kind * which CanEqual can be applied to.
+        // No pairwise evidence will be required for params of other kinds.
+        val firstKindedParamss = clsParamss.filter {
+          case param :: _ => !param.info.isLambdaSub
+          case _ => false
+        }
+
+        // The types of the required evidence parameters. In the running example:
+        // CanEqual[T_L, T_R], CanEqual[U_L, U_R], CanEqual[V_L, V_R]
+        val evidenceParamInfos =
+          for (row <- firstKindedParamss)
+          yield row.map(_.typeRef)
+
+        // The class instances in the result type. Running example:
+        //   A[T_L, U_L, V_L], A[T_R, U_R, V_R]
+        val instanceTypes =
+          for (n <- List.range(0, typeClassArity))
+          yield cls.typeRef.appliedTo(clsParamss.map(row => row(n).typeRef))
+
+        // CanEqual[A[T_L, U_L, V_L], A[T_R, U_R, V_R]]
+        addInstance(clsParamss.flatten, evidenceParamInfos, instanceTypes)
+      }
+
+      if (typeClassArity == 1) deriveSingleParameter
+      else if (typeClass == defn.CanEqualClass) deriveCanEqual
+      else if (typeClassArity == 0)
+        report.error(i"type ${typeClass.name} in derives clause of ${cls.name} has no type parameters", derived.srcPos)
+      else
+        cannotBeUnified
+    }
+
+    /** Create symbols for derived instances and infrastructure,
+     *  append them to `synthetics` buffer, and enter them into class scope.
+     *  Also, add generic instances if needed.
+     */
+    def enterDerived(derived: List[untpd.Tree]) =
+      derived.foreach(processDerivedInstance(_))
+
+    /** The synthesized type class instance definitions */
+    def syntheticDefs: List[tpd.Tree] = {
+      import tpd._
+
+      /** The type class instance definition with symbol `sym` */
+      def typeclassInstance(sym: Symbol)(using Context): List[List[tpd.Tree]] => tpd.Tree =
+        (paramRefss: List[List[tpd.Tree]]) =>
+          val (tparamRefs, vparamRefss) = splitArgs(paramRefss)
+          val tparamTypes = tparamRefs.tpes
+          val tparams = tparamTypes.map(_.typeSymbol.asType)
+          val vparams = if (vparamRefss.isEmpty) Nil else vparamRefss.head.map(_.symbol.asTerm)
+          tparams.foreach(ctx.enter(_))
+          vparams.foreach(ctx.enter(_))
+          def instantiated(info: Type): Type = info match {
+            case info: PolyType => instantiated(info.instantiate(tparamTypes))
+            case info: MethodType => info.instantiate(vparams.map(_.termRef))
+            case info => info.widenExpr
+          }
+          def companionRef(tp: Type): TermRef = tp match {
+            case tp @ TypeRef(prefix, _) if tp.symbol.isClass =>
+              prefix.select(tp.symbol.companionModule).asInstanceOf[TermRef]
+            case tp: TypeProxy =>
+              companionRef(tp.superType)
+          }
+          val resultType = instantiated(sym.info)
+          val companion = companionRef(resultType)
+          val module = untpd.ref(companion).withSpan(sym.span)
+          val rhs = untpd.Select(module, nme.derived)
+          if companion.termSymbol.exists then typed(rhs, resultType)
+          else errorTree(rhs, em"$resultType cannot be derived since ${resultType.typeSymbol} has no companion object")
+      end typeclassInstance
+
+      def syntheticDef(sym: Symbol): Tree = inContext(ctx.fresh.setOwner(sym).setNewScope) {
+        if sym.is(Method) then tpd.DefDef(sym.asTerm, typeclassInstance(sym))
+        else tpd.ValDef(sym.asTerm, typeclassInstance(sym)(Nil))
+      }
+
+      synthetics.map(syntheticDef).toList
+    }
+
+    def finalize(stat: tpd.TypeDef): tpd.Tree = {
+      val templ @ Template(_, _, _, _) = stat.rhs: @unchecked
+      tpd.cpy.TypeDef(stat)(rhs = tpd.cpy.Template(templ)(body = templ.body ++ syntheticDefs))
+    }
+  }
+}
diff --git a/tests/pos-with-compiler-cc/dotc/typer/Docstrings.scala b/tests/pos-with-compiler-cc/dotc/typer/Docstrings.scala
new file mode 100644
index 000000000000..5fefd355d7d8
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/typer/Docstrings.scala
@@ -0,0 +1,67 @@
+package dotty.tools
+package dotc
+package typer
+
+import core._
+import Contexts._, Symbols._, Decorators._, Comments.{_, given}
+import ast.tpd
+
+object Docstrings {
+
+  /**
+   * Expands or cooks the documentation for `sym` in class `owner`.
+   * The expanded comment will directly replace the original comment in the doc context.
+   *
+   * The expansion registers `@define` sections, and will replace `@inheritdoc` and variable
+   * occurrences in the comments.
+   *
+   * If the doc comments contain `@usecase` sections, they will be typed.
+   *
+   * @param sym   The symbol for which the comment is being cooked.
+   * @param owner The class for which comments are being cooked.
+   */
+  def cookComment(sym: Symbol, owner: Symbol)(using Context): Option[Comment] =
+    ctx.docCtx.flatMap { docCtx =>
+      expand(sym, owner)(using ctx)(using docCtx)
+    }
+
+  private def expand(sym: Symbol, owner: Symbol)(using Context)(using docCtx: ContextDocstrings): Option[Comment] =
+    docCtx.docstring(sym).flatMap {
+      case cmt if cmt.isExpanded =>
+        Some(cmt)
+      case _ =>
+        expandComment(sym).map { expanded =>
+          val typedUsecases = expanded.usecases.map { usecase =>
+            ctx.typer.enterSymbol(ctx.typer.createSymbol(usecase.untpdCode))
+            ctx.typer.typedStats(usecase.untpdCode :: Nil, owner)._1 match {
+              case List(df: tpd.DefDef) =>
+                usecase.typed(df)
+              case _ =>
+                report.error("`@usecase` was not a valid definition", ctx.source.atSpan(usecase.codePos))
+                usecase
+            }
+          }
+
+          val commentWithUsecases = expanded.copy(usecases = typedUsecases)
+          docCtx.addDocstring(sym, Some(commentWithUsecases))
+          commentWithUsecases
+        }
+    }
+
+  private def expandComment(sym: Symbol, owner: Symbol, comment: Comment)(using Context)(using docCtx: ContextDocstrings): Comment = {
+    val tplExp = docCtx.templateExpander
+    tplExp.defineVariables(sym)
+    val newComment = comment.expand(tplExp.expandedDocComment(sym, owner, _))
+    docCtx.addDocstring(sym, Some(newComment))
+    newComment
+  }
+
+  private def expandComment(sym: Symbol)(using Context)(using docCtx: ContextDocstrings): Option[Comment] =
+    if (sym eq NoSymbol) None
+    else
+      for {
+        cmt <- docCtx.docstring(sym) if !cmt.isExpanded
+        _ = expandComment(sym.owner)
+      }
+      yield expandComment(sym, sym.owner, cmt)
+}
diff --git a/tests/pos-with-compiler-cc/dotc/typer/Dynamic.scala b/tests/pos-with-compiler-cc/dotc/typer/Dynamic.scala
new file mode 100644
index 000000000000..1630ce31e4c6
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/typer/Dynamic.scala
@@ -0,0 +1,249 @@
+package dotty.tools
+package dotc
+package typer
+
+import dotty.tools.dotc.ast.Trees._
+import dotty.tools.dotc.ast.tpd
+import dotty.tools.dotc.ast.untpd
+import dotty.tools.dotc.core.Constants.Constant
+import dotty.tools.dotc.core.Contexts._
+import dotty.tools.dotc.core.Names.{Name, TermName}
+import dotty.tools.dotc.core.StdNames._
+import dotty.tools.dotc.core.Types._
+import dotty.tools.dotc.core.Decorators._
+import dotty.tools.dotc.core.TypeErasure
+import util.Spans._
+import core.Symbols._
+import ErrorReporting._
+import reporting._
+
+object Dynamic {
+  private def isDynamicMethod(name: Name): Boolean =
+    name == nme.applyDynamic || name == nme.selectDynamic || name == nme.updateDynamic || name == nme.applyDynamicNamed
+
+  /** Is `tree` a reference over `Dynamic` that should be expanded to a
+   *  dyanmic `applyDynamic`, `selectDynamic`, `updateDynamic`, or `applyDynamicNamed` call?
+   */
+  def isDynamicExpansion(tree: untpd.RefTree)(using Context): Boolean =
+    isDynamicMethod(tree.name)
+    || tree.match
+          case Select(Apply(fun: untpd.RefTree, _), nme.apply)
+          if defn.isContextFunctionClass(fun.symbol.owner) =>
+            isDynamicExpansion(fun)
+          case Select(qual, nme.apply) =>
+            isDynamicMethod(qual.symbol.name) && tree.span.isSynthetic
+          case _ => false
+}
+
+object DynamicUnapply {
+  def unapply(tree: tpd.Tree): Option[List[tpd.Tree]] = tree match
+    case TypeApply(Select(qual, name), _) if name == nme.asInstanceOfPM =>
+      unapply(qual)
+    case Apply(Apply(Select(selectable, fname), Literal(Constant(name)) :: ctag :: Nil), _ :: implicits)
+    if fname == nme.applyDynamic && (name == "unapply" || name == "unapplySeq") =>
+      Some(selectable :: ctag :: implicits)
+    case _ =>
+      None
+}
+
+/** Handles programmable member selections of `Dynamic` instances and values
+ *  with structural types. Two functionalities:
+ *
+ * 1. Translates selection that does not typecheck according to the scala.Dynamic rules:
+ *    foo.bar(baz) = quux                   ~~> foo.selectDynamic(bar).update(baz, quux)
+ *    foo.bar = baz                         ~~> foo.updateDynamic("bar")(baz)
+ *    foo.bar(x = bazX, y = bazY, baz, ...) ~~> foo.applyDynamicNamed("bar")(("x", bazX), ("y", bazY), ("", baz), ...)
+ *    foo.bar(baz0, baz1, ...)              ~~> foo.applyDynamic(bar)(baz0, baz1, ...)
+ *    foo.bar                               ~~> foo.selectDynamic(bar)
+ *
+ *  The first matching rule of is applied.
+ *
+ * 2. Translates member selections on structural types to calls of `selectDynamic`
+ *    or `applyDynamic` on a `Selectable` instance. @See handleStructural.
+ *
+ */
+trait Dynamic {
+  self: Typer & Applications =>
+
+  import Dynamic._
+  import tpd._
+
+  /** Translate selection that does not typecheck according to the normal rules into a applyDynamic/applyDynamicNamed.
+   *    foo.bar(baz0, baz1, ...)                       ~~> foo.applyDynamic(bar)(baz0, baz1, ...)
+   *    foo.bar[T0, ...](baz0, baz1, ...)              ~~> foo.applyDynamic[T0, ...](bar)(baz0, baz1, ...)
+   *    foo.bar(x = bazX, y = bazY, baz, ...)          ~~> foo.applyDynamicNamed("bar")(("x", bazX), ("y", bazY), ("", baz), ...)
+   *    foo.bar[T0, ...](x = bazX, y = bazY, baz, ...) ~~> foo.applyDynamicNamed[T0, ...]("bar")(("x", bazX), ("y", bazY), ("", baz), ...)
+   */
+  def typedDynamicApply(tree: untpd.Apply, isInsertedApply: Boolean, pt: Type)(using Context): Tree = {
+    def typedDynamicApply(qual: untpd.Tree, name: Name, selSpan: Span, targs: List[untpd.Tree]): Tree = {
+      def isNamedArg(arg: untpd.Tree): Boolean = arg match { case NamedArg(_, _) => true; case _ => false }
+      val args = tree.args
+      val dynName = if (args.exists(isNamedArg)) nme.applyDynamicNamed else nme.applyDynamic
+      if (dynName == nme.applyDynamicNamed && untpd.isWildcardStarArgList(args))
+        errorTree(tree, "applyDynamicNamed does not support passing a vararg parameter")
+      else {
+        def namedArgTuple(name: String, arg: untpd.Tree) = untpd.Tuple(List(Literal(Constant(name)), arg))
+        def namedArgs = args.map {
+          case NamedArg(argName, arg) => namedArgTuple(argName.toString, arg)
+          case arg => namedArgTuple("", arg)
+        }
+        val args1 = if (dynName == nme.applyDynamic) args else namedArgs
+        typedApply(untpd.Apply(coreDynamic(qual, dynName, name, selSpan, targs), args1), pt)
+      }
+    }
+
+    if (isInsertedApply) {
+      tree.fun match {
+        case TypeApply(fun, targs) =>
+          typedDynamicApply(fun, nme.apply, fun.span, targs)
+        case fun =>
+          typedDynamicApply(fun, nme.apply, fun.span, Nil)
+      }
+    } else {
+      tree.fun match {
+        case sel @ Select(qual, name) if !isDynamicMethod(name) =>
+          typedDynamicApply(qual, name, sel.span, Nil)
+        case TypeApply(sel @ Select(qual, name), targs) if !isDynamicMethod(name) =>
+          typedDynamicApply(qual, name, sel.span, targs)
+        case _ =>
+          errorTree(tree, em"Dynamic insertion not applicable")
+      }
+    }
+  }
+
+  /** Translate selection that does not typecheck according to the normal rules into a selectDynamic.
+   *    foo.bar          ~~> foo.selectDynamic(bar)
+   *    foo.bar[T0, ...] ~~> foo.selectDynamic[T0, ...](bar)
+   *
+   *  Note: inner part of translation foo.bar(baz) = quux ~~> foo.selectDynamic(bar).update(baz, quux) is achieved
+   *  through an existing transformation of in typedAssign [foo.bar(baz) = quux ~~> foo.bar.update(baz, quux)].
+   */
+  def typedDynamicSelect(tree: untpd.Select, targs: List[untpd.Tree], pt: Type)(using Context): Tree =
+    typedApply(coreDynamic(tree.qualifier, nme.selectDynamic, tree.name, tree.span, targs), pt)
+
+  /** Translate selection that does not typecheck according to the normal rules into a updateDynamic.
+   *    foo.bar = baz ~~> foo.updateDynamic(bar)(baz)
+   */
+  def typedDynamicAssign(tree: untpd.Assign, pt: Type)(using Context): Tree = {
+    def typedDynamicAssign(qual: untpd.Tree, name: Name, selSpan: Span, targs: List[untpd.Tree]): Tree =
+      typedApply(untpd.Apply(coreDynamic(qual, nme.updateDynamic, name, selSpan, targs), tree.rhs), pt)
+    tree.lhs match {
+      case sel @ Select(qual, name) if !isDynamicMethod(name) =>
+        typedDynamicAssign(qual, name, sel.span, Nil)
+      case TypeApply(sel @ Select(qual, name), targs) if !isDynamicMethod(name) =>
+        typedDynamicAssign(qual, name, sel.span, targs)
+      case _ =>
+        errorTree(tree, ReassignmentToVal(tree.lhs.symbol.name))
+    }
+  }
+
+  private def coreDynamic(qual: untpd.Tree, dynName: Name, name: Name, selSpan: Span, targs: List[untpd.Tree])(using Context): untpd.Apply = {
+    val select = untpd.Select(qual, dynName).withSpan(selSpan)
+    val selectWithTypes =
+      if (targs.isEmpty) select
+      else untpd.TypeApply(select, targs)
+    untpd.Apply(selectWithTypes, Literal(Constant(name.toString)))
+  }
+
+  /** Handle reflection-based dispatch for members of structural types.
+   *
+   *  Given `x.a`, where `x` is of (widened) type `T` (a value type or a nullary method type),
+   *  and `x.a` is of type `U`, map `x.a` to the equivalent of:
+   *
+   *  ```scala
+   *  x1.selectDynamic("a").asInstanceOf[U]
+   *  ```
+   *  where `x1` is `x` adapted to `Selectable`.
+   *
+   *  Given `x.a(a11, ..., a1n)...(aN1, ..., aNn)`, where `x.a` is of (widened) type
+   *  `(T11, ..., T1n)...(TN1, ..., TNn): R`, it is desugared to:
+   *
+   *  ```scala
+   *  x1.applyDynamic("a")(a11, ..., a1n, ..., aN1, ..., aNn)
+   *    .asInstanceOf[R]
+   *  ```
+   *  If this call resolves to an `applyDynamic` method that takes a `Class[?]*` as second
+   *  parameter, we further rewrite this call to
+   *  scala```
+   *  x1.applyDynamic("a", c11, ..., c1n, ..., cN1, ... cNn)
+   *                  (a11, ..., a1n, ..., aN1, ..., aNn)
+   *    .asInstanceOf[R]
+   *  ```
+   *  where c11, ..., cNn are the classOf constants representing the erasures of T11, ..., TNn.
+   *
+   *  It's an error if U is neither a value nor a method type, or a dependent method
+   *  type
+   */
+  def handleStructural(tree: Tree)(using Context): Tree = {
+    val fun @ Select(qual, name) = funPart(tree): @unchecked
+    val vargss = termArgss(tree)
+
+    def structuralCall(selectorName: TermName, classOfs: => List[Tree]) = {
+      val selectable = adapt(qual, defn.SelectableClass.typeRef)
+
+      // ($qual: Selectable).$selectorName("$name")
+      val base =
+        untpd.Apply(
+          untpd.TypedSplice(selectable.select(selectorName)).withSpan(fun.span),
+          (Literal(Constant(name.encode.toString)) :: Nil).map(untpd.TypedSplice(_)))
+
+      val scall =
+        if (vargss.isEmpty) base
+        else untpd.Apply(base, vargss.flatten.map(untpd.TypedSplice(_)))
+
+      // If function is an `applyDynamic` that takes a Class* parameter,
+      // add `classOfs`.
+      def addClassOfs(tree: Tree): Tree = tree match
+        case Apply(fn: Apply, args) =>
+          cpy.Apply(tree)(addClassOfs(fn), args)
+        case Apply(fn @ Select(_, nme.applyDynamic), nameArg :: _ :: Nil) =>
+          fn.tpe.widen match
+            case mt: MethodType => mt.paramInfos match
+              case _ :: classOfsParam :: Nil
+              if classOfsParam.isRepeatedParam
+                 && classOfsParam.argInfos.head.isRef(defn.ClassClass) =>
+                  val jlClassType = defn.ClassClass.typeRef.appliedTo(TypeBounds.empty)
+                  cpy.Apply(tree)(fn,
+                    nameArg :: seqToRepeated(SeqLiteral(classOfs, TypeTree(jlClassType))) :: Nil)
+              case _ => tree
+            case other => tree
+        case _ => tree
+      addClassOfs(typed(scall))
+    }
+
+    def fail(reason: String): Tree =
+      errorTree(tree, em"Structural access not allowed on method $name because it $reason")
+
+    fun.tpe.widen match {
+      case tpe: ValueType =>
+        structuralCall(nme.selectDynamic, Nil).cast(tpe)
+
+      case tpe: MethodType =>
+        def isDependentMethod(tpe: Type): Boolean = tpe match {
+          case tpe: MethodType =>
+            tpe.isParamDependent ||
+            tpe.isResultDependent ||
+            isDependentMethod(tpe.resultType)
+          case _ =>
+            false
+        }
+
+        if (isDependentMethod(tpe))
+          fail(i"has a method type with inter-parameter dependencies")
+        else {
+          def classOfs =
+            if tpe.paramInfoss.nestedExists(!TypeErasure.hasStableErasure(_)) then
+              fail(i"has a parameter type with an unstable erasure") :: Nil
+            else
+              TypeErasure.erasure(tpe).asInstanceOf[MethodType].paramInfos.map(clsOf(_))
+          structuralCall(nme.applyDynamic, classOfs).cast(tpe.finalResultType)
+        }
+
+      // (@allanrenucci) I think everything below is dead code
+      case _: PolyType =>
+        fail("is polymorphic")
+      case tpe =>
+        fail(i"has an unsupported type: $tpe")
+    }
+  }
+}
diff --git a/tests/pos-with-compiler-cc/dotc/typer/ErrorReporting.scala b/tests/pos-with-compiler-cc/dotc/typer/ErrorReporting.scala
new file mode 100644
index 000000000000..06ca1a3072f4
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/typer/ErrorReporting.scala
@@ -0,0 +1,456 @@
+package dotty.tools
+package dotc
+package typer
+
+import ast._
+import core._
+import Types._, ProtoTypes._, Contexts._, Decorators._, Denotations._, Symbols._
+import Implicits._, Flags._, Constants.Constant
+import Trees._
+import NameOps._
+import util.SrcPos
+import config.Feature
+import java.util.regex.Matcher.quoteReplacement
+import reporting._
+import collection.mutable
+
+import scala.util.matching.Regex
+import language.experimental.pureFunctions
+
+object ErrorReporting {
+
+  import tpd._
+
+  def errorTree(tree: untpd.Tree, msg: Message, pos: SrcPos)(using Context): tpd.Tree =
+    tree.withType(errorType(msg, pos))
+
+  def errorTree(tree: untpd.Tree, msg: Message)(using Context): tpd.Tree =
+    errorTree(tree, msg, tree.srcPos)
+
+  def errorTree(tree: untpd.Tree, msg: -> String)(using Context): tpd.Tree =
+    errorTree(tree, msg.toMessage)
+
+  def errorTree(tree: untpd.Tree, msg: TypeError, pos: SrcPos)(using Context): tpd.Tree =
+    tree.withType(errorType(msg, pos))
+
+  def errorType(msg: Message, pos: SrcPos)(using Context): ErrorType = {
+    report.error(msg, pos)
+    ErrorType(msg)
+  }
+
+  def errorType(msg: -> String, pos: SrcPos)(using Context): ErrorType =
+    errorType(msg.toMessage, pos)
+
+  def errorType(ex: TypeError, pos: SrcPos)(using Context): ErrorType = {
+    report.error(ex, pos)
+    ErrorType(ex.toMessage)
+  }
+
+  def wrongNumberOfTypeArgs(fntpe: Type, expectedArgs: List[ParamInfo], actual: List[untpd.Tree], pos: SrcPos)(using Context): ErrorType =
+    errorType(WrongNumberOfTypeArgs(fntpe, expectedArgs, actual), pos)
+
+  def missingArgs(tree: Tree, mt: Type)(using Context): Unit =
+    val meth = err.exprStr(methPart(tree))
+    mt match
+      case mt: MethodType if mt.paramNames.isEmpty =>
+        report.error(MissingEmptyArgumentList(meth), tree.srcPos)
+      case _ =>
+        report.error(em"missing arguments for $meth", tree.srcPos)
+
+  def matchReductionAddendum(tps: Type*)(using Context): String =
+    val collectMatchTrace = new TypeAccumulator[String]:
+      def apply(s: String, tp: Type): String =
+        if s.nonEmpty then s
+        else tp match
+          case tp: AppliedType if tp.isMatchAlias => MatchTypeTrace.record(tp.tryNormalize)
+          case tp: MatchType => MatchTypeTrace.record(tp.tryNormalize)
+          case _ => foldOver(s, tp)
+    tps.foldLeft("")(collectMatchTrace.apply) // !cc! .apply needed since otherwise box conversion gets confused
+
+  class Errors(using Context) {
+
+    /** An explanatory note to be added to error messages
+     *  when there's a problem with abstract var defs */
+    def abstractVarMessage(sym: Symbol): String =
+      if (sym.underlyingSymbol.is(Mutable))
+        "\n(Note that variables need to be initialized to be defined)"
+      else ""
+
+    /** Reveal arguments in FunProtos that are proteted by an IgnoredProto but were
+     *  revealed during type inference. This gives clearer error messages for overloading
+     *  resolution errors that need to show argument lists after the first. We do not
+     *  reveal other kinds of ignored prototypes since these might be misleading because
+     *  there might be a possible implicit conversion on the result.
+     */
+    def revealDeepenedArgs(tp: Type): Type = tp match
+      case tp @ IgnoredProto(deepTp: FunProto) if tp.wasDeepened => deepTp
+      case _ => tp
+
+    def expectedTypeStr(tp: Type): String = tp match {
+      case tp: PolyProto =>
+        em"type arguments [${tp.targs.tpes}%, %] and ${expectedTypeStr(revealDeepenedArgs(tp.resultType))}"
+      case tp: FunProto =>
+        def argStr(tp: FunProto): String =
+          val result = revealDeepenedArgs(tp.resultType) match {
+            case restp: FunProto => argStr(restp)
+            case _: WildcardType | _: IgnoredProto => ""
+            case tp => em" and expected result type $tp"
+          }
+          em"(${tp.typedArgs().tpes}%, %)$result"
+        s"arguments ${argStr(tp)}"
+      case _ =>
+        em"expected type $tp"
+    }
+
+    def anonymousTypeMemberStr(tpe: Type): String = {
+      val kind = tpe match {
+        case _: TypeBounds => "type with bounds"
+        case _: MethodOrPoly => "method"
+        case _ => "value of type"
+      }
+      em"$kind $tpe"
+    }
+
+    def overloadedAltsStr(alts: List[SingleDenotation]): String =
+      em"overloaded alternatives of ${denotStr(alts.head)} with types\n" +
+      em" ${alts map (_.info)}%\n %"
+
+    def denotStr(denot: Denotation): String =
+      if (denot.isOverloaded) overloadedAltsStr(denot.alternatives)
+      else if (denot.symbol.exists) denot.symbol.showLocated
+      else anonymousTypeMemberStr(denot.info)
+
+    def refStr(tp: Type): String = tp match {
+      case tp: NamedType =>
+        if tp.denot.symbol.exists then tp.denot.symbol.showLocated
+        else
+          val kind = tp.info match
+            case _: MethodOrPoly | _: ExprType => "method"
+            case _ => if tp.isType then "type" else "value"
+          s"$kind ${tp.name}"
+      case _ => anonymousTypeMemberStr(tp)
+    }
+
+    def exprStr(tree: Tree): String = refStr(tree.tpe)
+
+    def takesNoParamsStr(tree: Tree, kind: String): String =
+      if (tree.tpe.widen.exists)
+        i"${exprStr(tree)} does not take ${kind}parameters"
+      else {
+        i"undefined: $tree # ${tree.uniqueId}: ${tree.tpe.toString} at ${ctx.phase}"
+      }
+
+    def patternConstrStr(tree: Tree): String = ???
+
+    def typeMismatch(tree: Tree, pt: Type, implicitFailure: SearchFailureType = NoMatchingImplicits): Tree = {
+      val normTp = normalize(tree.tpe, pt)
+      val normPt = normalize(pt, pt)
+
+      def contextFunctionCount(tp: Type): Int = tp.stripped match
+        case defn.ContextFunctionType(_, restp, _) => 1 + contextFunctionCount(restp)
+        case _ => 0
+      def strippedTpCount = contextFunctionCount(tree.tpe) - contextFunctionCount(normTp)
+      def strippedPtCount = contextFunctionCount(pt) - contextFunctionCount(normPt)
+
+      val (treeTp, expectedTp) =
+        if normTp <:< normPt || strippedTpCount != strippedPtCount
+        then (tree.tpe, pt)
+        else (normTp, normPt)
+        // use normalized types if that also shows an error, and both sides stripped
+        // the same number of context functions. Use original types otherwise.
+
+      def missingElse = tree match
+        case If(_, _, elsep @ Literal(Constant(()))) if elsep.span.isSynthetic =>
+          "\nMaybe you are missing an else part for the conditional?"
+        case _ => ""
+
+      errorTree(tree, TypeMismatch(treeTp, expectedTp, Some(tree), implicitFailure.whyNoConversion, missingElse))
+    }
+
+    /** A subtype log explaining why `found` does not conform to `expected` */
+    def whyNoMatchStr(found: Type, expected: Type): String =
+      val header =
+        i"""I tried to show that
+          |  $found
+          |conforms to
+          |  $expected
+          |but the comparison trace ended with `false`:
+          |"""
+      val c = ctx.typerState.constraint
+      val constraintText =
+        if c.domainLambdas.isEmpty then
+          "the empty constraint"
+        else
+          i"""a constraint with:
+             |$c"""
+      i"""${TypeComparer.explained(_.isSubType(found, expected), header)}
+         |
+         |The tests were made under $constraintText"""
+
+    def whyFailedStr(fail: FailedExtension) =
+      i"""    failed with
+         |
+         |${fail.whyFailed.message.indented(8)}"""
+
+    def selectErrorAddendum
+      (tree: untpd.RefTree, qual1: Tree, qualType: Type, suggestImports: Type => String, foundWithoutNull: Boolean = false)
+      (using Context): String =
+
+      val attempts = mutable.ListBuffer[(Tree, String)]()
+      val nested = mutable.ListBuffer[NestedFailure]()
+      for
+        failures <- qual1.getAttachment(Typer.HiddenSearchFailure)
+        failure <- failures
+      do
+        failure.reason match
+          case fail: NestedFailure => nested += fail
+          case fail: FailedExtension => attempts += ((failure.tree, whyFailedStr(fail)))
+          case fail: Implicits.NoMatchingImplicits => // do nothing
+          case _ => attempts += ((failure.tree, ""))
+      if foundWithoutNull then
+        i""".
+          |Since explicit-nulls is enabled, the selection is rejected because
+          |${qualType.widen} could be null at runtime.
+          |If you want to select ${tree.name} without checking for a null value,
+          |insert a .nn before .${tree.name} or import scala.language.unsafeNulls."""
+      else if qualType.derivesFrom(defn.DynamicClass) then
+        "\npossible cause: maybe a wrong Dynamic method signature?"
+      else if attempts.nonEmpty then
+        val attemptStrings =
+          attempts.toList
+            .map((tree, whyFailed) => (tree.showIndented(4), whyFailed))
+            .distinctBy(_._1)
+            .map((treeStr, whyFailed) =>
+              i"""
+                 |    $treeStr$whyFailed""")
+        val extMethods =
+          if attemptStrings.length > 1 then "Extension methods were"
+          else "An extension method was"
+        i""".
+           |$extMethods tried, but could not be fully constructed:
+           |$attemptStrings%\n%"""
+      else if nested.nonEmpty then
+        i""".
+           |Extension methods were tried, but the search failed with:
+           |
+           |${nested.head.explanation.indented(4)}"""
+      else if tree.hasAttachment(desugar.MultiLineInfix) then
+        i""".
+           |Note that `${tree.name}` is treated as an infix operator in Scala 3.
+           |If you do not want that, insert a `;` or empty line in front
+           |or drop any spaces behind the operator."""
+      else if qualType.isExactlyNothing then
+        ""
+      else
+        val add = suggestImports(
+          ViewProto(qualType.widen,
+            SelectionProto(tree.name, WildcardType, NoViewsAllowed, privateOK = false)))
+        if add.isEmpty then ""
+        else ", but could be made available as an extension method." ++ add
+    end selectErrorAddendum
+  }
+
+  def substitutableTypeSymbolsInScope(sym: Symbol)(using Context): List[Symbol] =
+    sym.ownersIterator.takeWhile(!_.is(Flags.Package)).flatMap { ownerSym =>
+      ownerSym.paramSymss.flatten.filter(_.isType) ++
+      ownerSym.typeRef.nonClassTypeMembers.map(_.symbol)
+    }.toList
+
+  def dependentStr =
+    """Term-dependent types are experimental,
+      |they must be enabled with a `experimental.dependent` language import or setting""".stripMargin
+
+  def err(using Context): Errors = new Errors
+}
+
+class ImplicitSearchError(
+  arg: tpd.Tree,
+  pt: Type,
+  where: String,
+  paramSymWithMethodCallTree: Option[(Symbol, tpd.Tree)] = None,
+  ignoredInstanceNormalImport: -> Option[SearchSuccess],
+  importSuggestionAddendum: -> String
+)(using ctx: Context) {
+
+  def missingArgMsg = arg.tpe match {
+    case ambi: AmbiguousImplicits =>
+      (ambi.alt1, ambi.alt2) match {
+        case (alt @ AmbiguousImplicitMsg(msg), _) =>
+          userDefinedAmbiguousImplicitMsg(alt, msg)
+        case (_, alt @ AmbiguousImplicitMsg(msg)) =>
+          userDefinedAmbiguousImplicitMsg(alt, msg)
+        case _ =>
+          defaultAmbiguousImplicitMsg(ambi)
+      }
+    case ambi @ TooUnspecific(target) =>
+      ex"""No implicit search was attempted${location("for")}
+          |since the expected type $target is not specific enough"""
+    case _ =>
+      val shortMessage = userDefinedImplicitNotFoundParamMessage
+        .orElse(userDefinedImplicitNotFoundTypeMessage)
+        .getOrElse(defaultImplicitNotFoundMessage)
+      formatMsg(shortMessage)()
+      ++ hiddenImplicitsAddendum
+      ++ ErrorReporting.matchReductionAddendum(pt)
+  }
+
+  private def formatMsg(shortForm: String)(headline: String = shortForm) = arg match
+    case arg: Trees.SearchFailureIdent[?] =>
+      arg.tpe match
+        case _: NoMatchingImplicits => headline
+        case tpe: SearchFailureType =>
+          i"$headline. ${tpe.explanation}"
+        case _ => headline
+    case _ =>
+      arg.tpe match
+        case tpe: SearchFailureType =>
+          val original = arg match
+            case Inlined(call, _, _) => call
+            case _ => arg
+          i"""$headline.
+            |I found:
+            |
+            |    ${original.show.replace("\n", "\n    ")}
+            |
+            |But ${tpe.explanation}."""
+        case _ => headline
+
+  /** Format `raw` implicitNotFound or implicitAmbiguous argument, replacing
+   *  all occurrences of `${X}` where `X` is in `paramNames` with the
+   *  corresponding shown type in `args`.
+   */
+  private def userDefinedErrorString(raw: String, paramNames: List[String], args: List[Type]): String = {
+    def translate(name: String): Option[String] = {
+      val idx = paramNames.indexOf(name)
+      if (idx >= 0) Some(ex"${args(idx)}") else None
+    }
+
+    """\$\{\s*([^}\s]+)\s*\}""".r.replaceAllIn(raw, (_: Regex.Match) match {
+      case Regex.Groups(v) => quoteReplacement(translate(v).getOrElse("")).nn
+    })
+  }
+
+  /** Extract a user defined error message from a symbol `sym`
+   *  with an annotation matching the given class symbol `cls`.
+   */
+  private def userDefinedMsg(sym: Symbol, cls: Symbol) = for {
+    ann <- sym.getAnnotation(cls)
+    msg <- ann.argumentConstantString(0)
+  } yield msg
+
+  private def location(preposition: String) = if (where.isEmpty) "" else s" $preposition $where"
+
+  private def defaultAmbiguousImplicitMsg(ambi: AmbiguousImplicits) =
+    s"Ambiguous given instances: ${ambi.explanation}${location("of")}"
+
+  private def defaultImplicitNotFoundMessage =
+    ex"No given instance of type $pt was found${location("for")}"
+
+  /** Construct a custom error message given an ambiguous implicit
+   *  candidate `alt` and a user defined message `raw`.
+   */
+  private def userDefinedAmbiguousImplicitMsg(alt: SearchSuccess, raw: String) = {
+    val params = alt.ref.underlying match {
+      case p: PolyType => p.paramNames.map(_.toString)
+      case _           => Nil
+    }
+    def resolveTypes(targs: List[tpd.Tree])(using Context) =
+      targs.map(a => Inferencing.fullyDefinedType(a.tpe, "type argument", a.srcPos))
+
+    // We can extract type arguments from:
+    //   - a function call:
+    //     @implicitAmbiguous("msg A=${A}")
+    //     implicit def f[A](): String = ...
+    //     implicitly[String] // found: f[Any]()
+    //
+    //   - an eta-expanded function:
+    //     @implicitAmbiguous("msg A=${A}")
+    //     implicit def f[A](x: Int): String = ...
+    //     implicitly[Int => String] // found: x => f[Any](x)
+
+    val call = tpd.closureBody(alt.tree) // the tree itself if not a closure
+    val targs = tpd.typeArgss(call).flatten
+    val args = resolveTypes(targs)(using ctx.fresh.setTyperState(alt.tstate))
+    userDefinedErrorString(raw, params, args)
+  }
+
+  /** @param rawMsg           Message template with variables, e.g. "Variable A is ${A}"
+   *  @param sym              Symbol of the annotated type or of the method whose parameter was annotated
+   *  @param substituteType   Function substituting specific types for abstract types associated with variables, e.g A -> Int
+   */
+  private def formatAnnotationMessage(rawMsg: String, sym: Symbol, substituteType: Type => Type): String = {
+    val substitutableTypesSymbols = ErrorReporting.substitutableTypeSymbolsInScope(sym)
+
+    userDefinedErrorString(
+      rawMsg,
+      paramNames = substitutableTypesSymbols.map(_.name.unexpandedName.toString),
+      args = substitutableTypesSymbols.map(_.typeRef).map(substituteType)
+    )
+  }
+
+  /** Extracting the message from a method parameter, e.g. in
+   *
+   *  trait Foo
+   *
+   *  def foo(implicit @annotation.implicitNotFound("Foo is missing") foo: Foo): Any = ???
+   */
+  private def userDefinedImplicitNotFoundParamMessage: Option[String] = paramSymWithMethodCallTree.flatMap { (sym, applTree) =>
+    userDefinedMsg(sym, defn.ImplicitNotFoundAnnot).map { rawMsg =>
+      val fn = tpd.funPart(applTree)
+      val targs = tpd.typeArgss(applTree).flatten
+      val methodOwner = fn.symbol.owner
+      val methodOwnerType = tpd.qualifier(fn).tpe
+      val methodTypeParams = fn.symbol.paramSymss.flatten.filter(_.isType)
+      val methodTypeArgs = targs.map(_.tpe)
+      val substituteType = (_: Type).asSeenFrom(methodOwnerType, methodOwner).subst(methodTypeParams, methodTypeArgs)
+      formatAnnotationMessage(rawMsg, sym.owner, substituteType)
+    }
+  }
+
+  /** Extracting the message from a type, e.g. in
+   *
+   *  @annotation.implicitNotFound("Foo is missing")
+   *  trait Foo
+   *
+   *  def foo(implicit foo: Foo): Any = ???
+   */
+  private def userDefinedImplicitNotFoundTypeMessage: Option[String] =
+    def recur(tp: Type): Option[String] = tp match
+      case tp: TypeRef =>
+        val sym = tp.symbol
+        userDefinedImplicitNotFoundTypeMessage(sym).orElse(recur(tp.info))
+      case tp: ClassInfo =>
+        tp.baseClasses.iterator
+          .map(userDefinedImplicitNotFoundTypeMessage)
+          .find(_.isDefined).flatten
+      case tp: TypeProxy =>
+        recur(tp.superType)
+      case tp: AndType =>
+        recur(tp.tp1).orElse(recur(tp.tp2))
+      case _ =>
+        None
+    recur(pt)
+
+  private def userDefinedImplicitNotFoundTypeMessage(sym: Symbol): Option[String] =
+    for
+      rawMsg <- userDefinedMsg(sym, defn.ImplicitNotFoundAnnot)
+      if Feature.migrateTo3 || sym != defn.Function1
+        // Don't inherit "No implicit view available..." message if subtypes of Function1 are not treated as implicit conversions anymore
+    yield
+      val substituteType = (_: Type).asSeenFrom(pt, sym)
+      formatAnnotationMessage(rawMsg, sym, substituteType)
+
+  private def hiddenImplicitsAddendum: String =
+    def hiddenImplicitNote(s: SearchSuccess) =
+      em"\n\nNote: ${s.ref.symbol.showLocated} was not considered because it was not imported with `import given`."
+
+    val normalImports = ignoredInstanceNormalImport.map(hiddenImplicitNote)
+
+    normalImports.getOrElse(importSuggestionAddendum)
+  end hiddenImplicitsAddendum
+
+  private object AmbiguousImplicitMsg {
+    def unapply(search: SearchSuccess): Option[String] =
+      userDefinedMsg(search.ref.symbol, defn.ImplicitAmbiguousAnnot)
+  }
+}
diff --git a/tests/pos-with-compiler-cc/dotc/typer/EtaExpansion.scala b/tests/pos-with-compiler-cc/dotc/typer/EtaExpansion.scala
new file mode 100644
index 000000000000..46725f0fa6b2
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/typer/EtaExpansion.scala
@@ -0,0 +1,293 @@
+package dotty.tools
+package dotc
+package typer
+
+import core._
+import ast.{Trees, untpd, tpd}
+import Contexts._
+import Types._
+import Flags._
+import Symbols._
+import Names._
+import NameKinds.UniqueName
+import util.Spans._
+import util.Property
+import collection.mutable
+import Trees._
+
+/** A class that handles argument lifting. Argument lifting is needed in the following
+ *  scenarios:
+ *   - eta expansion
+ *   - applications with default arguments
+ *   - applications with out-of-order named arguments
+ *  Lifting generally lifts impure expressions only, except in the case of possible
+ *  default arguments, where we lift also complex pure expressions, since in that case
+ *  arguments can be duplicated as arguments to default argument methods.
+ */
+abstract class Lifter {
+  import tpd._
+
+  /** Test indicating `expr` does not need lifting */
+  def noLift(expr: Tree)(using Context): Boolean
+
+  /** The corresponding lifter for pass-by-name arguments */
+  protected def exprLifter: Lifter = NoLift
+
+  /** The flags of a lifted definition */
+  protected def liftedFlags: FlagSet = EmptyFlags
+
+  /** The tree of a lifted definition */
+  protected def liftedDef(sym: TermSymbol, rhs: Tree)(using Context): MemberDef = ValDef(sym, rhs)
+
+  /** Is lifting performed on erased terms? */
+  protected def isErased = false
+
+  private def lift(defs: mutable.ListBuffer[Tree], expr: Tree, prefix: TermName = EmptyTermName)(using Context): Tree =
+    if (noLift(expr)) expr
+    else {
+      val name = UniqueName.fresh(prefix)
+      // don't instantiate here, as the type params could be further constrained, see tests/pos/pickleinf.scala
+      var liftedType = expr.tpe.widen.deskolemized
+      if (liftedFlags.is(Method)) liftedType = ExprType(liftedType)
+      val lifted = newSymbol(ctx.owner, name, liftedFlags | Synthetic, liftedType, coord = spanCoord(expr.span),
+        // Lifted definitions will be added to a local block, so they need to be
+        // at a higher nesting level to prevent leaks. See tests/pos/i15174.scala
+        nestingLevel = ctx.nestingLevel + 1)
+      defs += liftedDef(lifted, expr)
+        .withSpan(expr.span)
+        .changeNonLocalOwners(lifted)
+        .setDefTree
+      ref(lifted.termRef).withSpan(expr.span.focus)
+    }
+
+  /** Lift out common part of lhs tree taking part in an operator assignment such as
+   *
+   *     lhs += expr
+   */
+  def liftAssigned(defs: mutable.ListBuffer[Tree], tree: Tree)(using Context): Tree = tree match {
+    case Apply(MaybePoly(fn @ Select(pre, name), targs), args) =>
+      cpy.Apply(tree)(
+        cpy.Select(fn)(
+          lift(defs, pre), name).appliedToTypeTrees(targs),
+          liftArgs(defs, fn.tpe, args))
+    case Select(pre, name) =>
+      cpy.Select(tree)(lift(defs, pre), name)
+    case _ =>
+      tree
+  }
+
+  /** Lift a function argument, stripping any NamedArg wrapper */
+  private def liftArg(defs: mutable.ListBuffer[Tree], arg: Tree, prefix: TermName = EmptyTermName)(using Context): Tree =
+    arg match {
+      case arg @ NamedArg(name, arg1) => cpy.NamedArg(arg)(name, lift(defs, arg1, prefix))
+      case arg => lift(defs, arg, prefix)
+    }
+
+  /** Lift arguments that are not-idempotent into ValDefs in buffer `defs`
+   *  and replace by the idents of so created ValDefs.
+   */
+  def liftArgs(defs: mutable.ListBuffer[Tree], methRef: Type, args: List[Tree])(using Context): List[Tree] =
+    methRef.widen match {
+      case mt: MethodType =>
+        args.lazyZip(mt.paramNames).lazyZip(mt.paramInfos).map { (arg, name, tp) =>
+          if tp.hasAnnotation(defn.InlineParamAnnot) then arg
+          else
+            val lifter = if (tp.isInstanceOf[ExprType]) exprLifter else this
+            lifter.liftArg(defs, arg, if (name.firstPart contains '$') EmptyTermName else name)
+        }
+      case _ =>
+        args.mapConserve(liftArg(defs, _))
+    }
+
+  /** Lift out function prefix and all arguments from application
+   *
+   *     pre.f(arg1, ..., argN)   becomes
+   *
+   *     val x0 = pre
+   *     val x1 = arg1
+   *     ...
+   *     val xN = argN
+   *     x0.f(x1, ..., xN)
+   *
+   *  But leave pure expressions alone.
+   *
+   */
+  def liftApp(defs: mutable.ListBuffer[Tree], tree: Tree)(using Context): Tree = tree match {
+    case Apply(fn, args) =>
+      val fn1 = liftApp(defs, fn)
+      val args1 = liftArgs(defs, fn.tpe, args)
+      if isErased then untpd.cpy.Apply(tree)(fn1, args1).withType(tree.tpe) // application may be partial
+      else cpy.Apply(tree)(fn1, args1)
+    case TypeApply(fn, targs) =>
+      cpy.TypeApply(tree)(liftApp(defs, fn), targs)
+    case Select(pre, name) if isPureRef(tree) =>
+      cpy.Select(tree)(liftPrefix(defs, pre), name)
+    case Block(stats, expr) =>
+      liftApp(defs ++= stats, expr)
+    case New(tpt) =>
+      tree
+    case _ =>
+      lift(defs, tree)
+  }
+
+  /** Lift prefix `pre` of an application `pre.f(...)` to
+   *
+   *     val x0 = pre
+   *     x0.f(...)
+   *
+   *  unless `pre` is idempotent.
+   */
+  def liftPrefix(defs: mutable.ListBuffer[Tree], tree: Tree)(using Context): Tree =
+    if (isIdempotentExpr(tree)) tree else lift(defs, tree)
+}
+
+/** No lifting at all */
+object NoLift extends Lifter {
+  def noLift(expr: tpd.Tree)(using Context): Boolean = true
+}
+
+/** Lift all impure arguments */
+class LiftImpure extends Lifter {
+  def noLift(expr: tpd.Tree)(using Context): Boolean = tpd.isPureExpr(expr)
+}
+object LiftImpure extends LiftImpure
+
+/** Lift all impure or complex arguments */
+class LiftComplex extends Lifter {
+  def noLift(expr: tpd.Tree)(using Context): Boolean = tpd.isPurePath(expr)
+  override def exprLifter: Lifter = LiftToDefs
+}
+object LiftComplex extends LiftComplex
+
+/** Lift impure + lift the prefixes */
+object LiftCoverage extends LiftImpure {
+
+  // Property indicating whether we're currently lifting the arguments of an application
+  private val LiftingArgs = new Property.Key[Boolean]
+
+  private inline def liftingArgs(using Context): Boolean =
+    ctx.property(LiftingArgs).contains(true)
+
+  private def liftingArgsContext(using Context): Context =
+    ctx.fresh.setProperty(LiftingArgs, true)
+
+  /** Variant of `noLift` for the arguments of applications.
+   *  To produce the right coverage information (especially in case of exceptions), we must lift:
+   *  - all the applications, except the erased ones
+   *  - all the impure arguments
+   *
+   * There's no need to lift the other arguments.
+   */
+  private def noLiftArg(arg: tpd.Tree)(using Context): Boolean =
+    arg match
+      case a: tpd.Apply => a.symbol.is(Erased) // don't lift erased applications, but lift all others
+      case tpd.Block(stats, expr) => stats.forall(noLiftArg) && noLiftArg(expr)
+      case tpd.Inlined(_, bindings, expr) => noLiftArg(expr)
+      case tpd.Typed(expr, _) => noLiftArg(expr)
+      case _ => super.noLift(arg)
+
+  override def noLift(expr: tpd.Tree)(using Context) =
+    if liftingArgs then noLiftArg(expr) else super.noLift(expr)
+
+  def liftForCoverage(defs: mutable.ListBuffer[tpd.Tree], tree: tpd.Apply)(using Context) = {
+    val liftedFun = liftApp(defs, tree.fun)
+    val liftedArgs = liftArgs(defs, tree.fun.tpe, tree.args)(using liftingArgsContext)
+    tpd.cpy.Apply(tree)(liftedFun, liftedArgs)
+  }
+}
+
+object LiftErased extends LiftComplex:
+  override def isErased = true
+
+/** Lift all impure or complex arguments to `def`s */
+object LiftToDefs extends LiftComplex {
+  override def liftedFlags: FlagSet = Method
+  override def liftedDef(sym: TermSymbol, rhs: tpd.Tree)(using Context): tpd.DefDef = tpd.DefDef(sym, rhs)
+}
+
+/** Lifter for eta expansion */
+object EtaExpansion extends LiftImpure {
+  import tpd._
+
+  /** Eta-expanding a tree means converting a method reference to a function value.
+   *  @param    tree       The tree to expand
+   *  @param    mt         The type of the method reference
+   *  @param    xarity     The arity of the expected function type
+   *  and assume the lifted application of `tree` (@see liftApp) is
+   *
+   *         { val xs = es; expr }
+   *
+   *  The result of the eta-expansion is either (1)
+   *
+   *         { val xs = es; (x1, ..., xn) => expr(x1, ..., xn) }
+   *
+   *  or (2)
+   *
+   *         { val xs = es; (x1: T1, ..., xn: Tn) => expr(x1, ..., xn) }
+   *
+   *  or (3)
+   *
+   *         { val xs = es; (x1: T1, ..., xn: Tn) => expr(x1, ..., xn) _ }
+   *
+   *  where `T1, ..., Tn` are the paremeter types of the expanded method.
+   *  If `expr` has implicit function type, the arguments are passed with `given`.
+   *  E.g. for (1):
+   *
+   *      { val xs = es; (x1, ..., xn) => expr(using x1, ..., xn) }
+   *
+   *  Case (3) applies if the method is curried, i.e. its result type is again a method
+   *  type. Case (2) applies if the expected arity of the function type `xarity` differs
+   *  from the number of parameters in `mt`. Case (1) applies if `mt` is uncurried
+   *  and its number of parameters equals `xarity`. In this case we can always infer
+   *  the parameter types later from the callee even if parameter types could not be
+   *  inferred from the expected type. Hence, we lose nothing by omitting parameter types
+   *  in the eta expansion. On the other hand omitting these parameters keeps the possibility
+   *  open that different parameters are inferred from the expected type, so we keep
+   *  more options open.
+   *
+   *  In each case, the result is an untyped tree, with `es` and `expr` as typed splices.
+   *
+   *    F[V](x) ==> (x => F[X])
+   *
+   *  Note: We allow eta expanding a method with a call by name parameter like
+   *
+   *    def m(x: => T): T
+   *
+   *  to a value of type (=> T) => T. This type cannot be written in source, since
+   *  by-name types => T are not legal argument types.
+   *
+   *  It would be simpler to not allow to eta expand by-name methods. That was the rule
+   *  initially, but at some point, the rule was dropped. Enforcing the restriction again
+   *  now would break existing code. Allowing by-name parameters in function types seems to
+   *  be OK. After elimByName they are all converted to regular function types anyway.
+   *  But see comment on the `ExprType` case in function `prune` in class `ConstraintHandling`.
+   */
+  def etaExpand(tree: Tree, mt: MethodType, xarity: Int)(using Context): untpd.Tree = {
+    import untpd._
+    assert(!ctx.isAfterTyper || (ctx.phase eq ctx.base.inliningPhase), ctx.phase)
+    val defs = new mutable.ListBuffer[tpd.Tree]
+    val lifted: Tree = TypedSplice(liftApp(defs, tree))
+    val isLastApplication = mt.resultType match {
+      case rt: MethodType => rt.isImplicitMethod
+      case _ => true
+    }
+    val paramTypes: List[Tree] =
+      if (isLastApplication && mt.paramInfos.length == xarity) mt.paramInfos map (_ => TypeTree())
+      else mt.paramInfos map TypeTree
+    var paramFlag = SyntheticParam
+    if (mt.isContextualMethod) paramFlag |= Given
+    else if (mt.isImplicitMethod) paramFlag |= Implicit
+    val params = mt.paramNames.lazyZip(paramTypes).map((name, tpe) =>
+      ValDef(name, tpe, EmptyTree).withFlags(paramFlag).withSpan(tree.span.startPos))
+    var ids: List[Tree] = mt.paramNames map (name => Ident(name).withSpan(tree.span.startPos))
+    if (mt.paramInfos.nonEmpty && mt.paramInfos.last.isRepeatedParam)
+      ids = ids.init :+ repeated(ids.last)
+    val body = Apply(lifted, ids)
+    if (mt.isContextualMethod) body.setApplyKind(ApplyKind.Using)
+    val fn =
+      if (mt.isContextualMethod) new untpd.FunctionWithMods(params, body, Modifiers(Given))
+      else if (mt.isImplicitMethod) new untpd.FunctionWithMods(params, body, Modifiers(Implicit))
+      else untpd.Function(params, body)
+    if (defs.nonEmpty) untpd.Block(defs.toList map (untpd.TypedSplice(_)), fn) else fn
+  }
+}
diff --git a/tests/pos-with-compiler-cc/dotc/typer/Implicits.scala b/tests/pos-with-compiler-cc/dotc/typer/Implicits.scala
new file mode 100644
index 000000000000..fcf75a14f9d8
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/typer/Implicits.scala
@@ -0,0 +1,1916 @@
+package dotty.tools
+package dotc
+package typer
+
+import backend.sjs.JSDefinitions
+import core._
+import ast.{TreeTypeMap, untpd, tpd}
+import util.Spans._
+import util.Stats.{record, monitored}
+import printing.{Showable, Printer}
+import printing.Texts._
+import Contexts._
+import Types._
+import Flags._
+import Mode.ImplicitsEnabled
+import NameKinds.{LazyImplicitName, EvidenceParamName}
+import Symbols._
+import Types._
+import Decorators._
+import Names._
+import StdNames._
+import ProtoTypes._
+import ErrorReporting._
+import Inferencing.{fullyDefinedType, isFullyDefined}
+import Scopes.newScope
+import transform.TypeUtils._
+import Hashable._
+import util.{EqHashMap, Stats}
+import config.{Config, Feature}
+import Feature.migrateTo3
+import config.Printers.{implicits, implicitsDetailed}
+import collection.mutable
+import reporting._
+import annotation.tailrec
+
+import scala.annotation.internal.sharable
+import scala.annotation.threadUnsafe
+
+/** Implicit resolution */
+object Implicits:
+  import tpd._
+
+  /** An implicit definition `implicitRef` that is visible under a different name, `alias`.
+   *  Gets generated if an implicit ref is imported via a renaming import.
+   */
+  class RenamedImplicitRef(val underlyingRef: TermRef, val alias: TermName) extends ImplicitRef {
+    def implicitName(using Context): TermName = alias
+  }
+
+  /** Both search candidates and successes are references with a specific nesting level. */
+  sealed trait RefAndLevel {
+    def ref: TermRef
+    def level: Int
+  }
+
+  /** An eligible implicit candidate, consisting of an implicit reference and a nesting level */
+  case class Candidate(implicitRef: ImplicitRef, kind: Candidate.Kind, level: Int) extends RefAndLevel {
+    def ref: TermRef = implicitRef.underlyingRef
+
+    def isExtension = (kind & Candidate.Extension) != 0
+    def isConversion = (kind & Candidate.Conversion) != 0
+  }
+  object Candidate {
+    type Kind = Int
+    inline val None = 0
+    inline val Value = 1
+    inline val Conversion = 2
+    inline val Extension = 4
+  }
+
+  /** If `expected` is a selection prototype, does `tp` have an extension
+   *  method with the selecting name? False otherwise.
+   */
+  def hasExtMethod(tp: Type, expected: Type)(using Context) = expected match
+    case selProto @ SelectionProto(selName: TermName, _, _, _) =>
+      tp.memberBasedOnFlags(selName, required = ExtensionMethod).exists
+    case _ =>
+      false
+
+  def strictEquality(using Context): Boolean =
+    ctx.mode.is(Mode.StrictEquality) || Feature.enabled(nme.strictEquality)
+
+
+  /** A common base class of contextual implicits and of-type implicits which
+   *  represents a set of references to implicit definitions.
+   */
+  abstract class ImplicitRefs(initctx: Context) {
+    val irefCtx =
+      if (initctx eq NoContext) initctx else initctx.retractMode(Mode.ImplicitsEnabled)
+    protected given Context = irefCtx
+
+    /** The nesting level of this context. Non-zero only in ContextialImplicits */
+    def level: Int = 0
+
+    /** The implicit references */
+    def refs: List[ImplicitRef]
+
+    /** If comes from an implicit scope of a type, the companion objects making
+     *  up that implicit scope, otherwise the empty set.
+     */
+    def companionRefs: TermRefSet = TermRefSet.empty
+
+    private var mySingletonClass: ClassSymbol | Null = null
+
+    /** Widen type so that it is neither a singleton type nor a type that inherits from scala.Singleton. */
+    private def widenSingleton(tp: Type)(using Context): Type = {
+      if (mySingletonClass == null) mySingletonClass = defn.SingletonClass
+      val wtp = tp.widenSingleton
+      if (wtp.derivesFrom(mySingletonClass.uncheckedNN)) defn.AnyType else wtp
+    }
+
+    protected def isAccessible(ref: TermRef)(using Context): Boolean
+
+    /** Return those references in `refs` that are compatible with type `pt`. */
+    protected def filterMatching(pt: Type)(using Context): List[Candidate] = {
+      record("filterMatching")
+
+      val considerExtension = pt match
+        case ViewProto(_, _: SelectionProto) => true
+        case _ => false
+
+      def candidateKind(ref: TermRef)(using Context): Candidate.Kind = { /*trace(i"candidateKind $ref $pt")*/
+
+        def viewCandidateKind(tpw: Type, argType: Type, resType: Type): Candidate.Kind = {
+
+          def methodCandidateKind(mt: MethodType, approx: Boolean) =
+            if (mt.isImplicitMethod)
+              viewCandidateKind(normalize(mt, pt), argType, resType)
+            else if (mt.paramInfos.lengthCompare(1) == 0 && {
+                  var formal = widenSingleton(mt.paramInfos.head)
+                  if (approx) formal = wildApprox(formal)
+                  explore(argType relaxed_<:< formal.widenExpr)
+                })
+              Candidate.Conversion
+            else
+              Candidate.None
+
+          tpw match {
+            case mt: MethodType =>
+              methodCandidateKind(mt, approx = false)
+            case poly: PolyType =>
+              // We do not need to call ProtoTypes#constrained on `poly` because
+              // `candidateKind` is always called with mode TypevarsMissContext enabled.
+              poly.resultType match {
+                case mt: MethodType =>
+                  methodCandidateKind(mt, approx = true)
+                case rtp =>
+                  viewCandidateKind(wildApprox(rtp), argType, resType)
+              }
+            case tpw: TermRef => // can't discard overloaded refs
+              Candidate.Conversion
+              | (if considerExtension then Candidate.Extension else Candidate.None)
+            case tpw =>
+              // Only direct instances of Function1 and direct or indirect instances of <:< are eligible as views.
+              // However, Predef.$conforms is not eligible, because it is a no-op.
+              //
+              // In principle, it would be cleanest if only implicit methods qualified
+              // as implicit conversions. We could achieve that by having standard conversions like
+              // this in Predef:
+              //
+              //    implicit def convertIfConforms[A, B](x: A)(implicit ev: A <:< B): B = ev(a)
+              //    implicit def convertIfConverter[A, B](x: A)(implicit ev: Conversion[A, B]): B = ev(a)
+              //
+              // (Once `<:<` inherits from `Conversion` we only need the 2nd one.)
+              // But clauses like this currently slow down implicit search a lot, because
+              // they are eligible for all pairs of types, and therefore are tried too often.
+              // We emulate instead these conversions directly in the search.
+              // The reason for leaving out `Predef_conforms` is that we know it adds
+              // nothing since it only relates subtype with supertype.
+              //
+              // We keep the old behavior under -source 3.0-migration.
+              val isFunctionInS2 =
+                migrateTo3
+                && tpw.derivesFrom(defn.Function1)
+                && ref.symbol != defn.Predef_conforms
+              val isImplicitConversion = tpw.derivesFrom(defn.ConversionClass)
+              // An implementation of <:< counts as a view
+              val isConforms = tpw.derivesFrom(defn.SubTypeClass)
+              val conversionKind =
+                if (isFunctionInS2 || isImplicitConversion || isConforms) Candidate.Conversion
+                else Candidate.None
+              val extensionKind =
+                if considerExtension && hasExtMethod(tpw, resType) then Candidate.Extension
+                else Candidate.None
+              conversionKind | extensionKind
+          }
+        }
+
+        def valueTypeCandidateKind(tpw: Type): Candidate.Kind = tpw.stripPoly match {
+          case tpw: MethodType =>
+            if (tpw.isImplicitMethod) Candidate.Value else Candidate.None
+          case _ =>
+            Candidate.Value
+        }
+
+        /** Widen singleton arguments of implicit conversions to their underlying type.
+         *  This is necessary so that they can be found eligible for the argument type.
+         *  Note that we always take the underlying type of a singleton type as the argument
+         *  type, so that we get a reasonable implicit cache hit ratio.
+         */
+        def adjustSingletonArg(tp: Type): Type = tp.widenSingleton match
+          case tp: PolyType =>
+            val res = adjustSingletonArg(tp.resType)
+            if res eq tp.resType then tp else tp.derivedLambdaType(resType = res)
+          case tp: MethodType =>
+            tp.derivedLambdaType(paramInfos = tp.paramInfos.mapConserve(widenSingleton))
+          case _ =>
+            tp.baseType(defn.ConversionClass) match
+              case app @ AppliedType(tycon, from :: rest) =>
+                val wideFrom = from.widenSingleton
+                if wideFrom ne from then app.derivedAppliedType(tycon, wideFrom :: rest)
+                else tp
+              case _ => tp
+
+        var ckind =
+          if !isAccessible(ref) then
+            Candidate.None
+          else pt match {
+            case pt: ViewProto =>
+              viewCandidateKind(ref.widen, pt.argType, pt.resType)
+            case _: ValueTypeOrProto =>
+              if (defn.isFunctionType(pt)) Candidate.Value
+              else valueTypeCandidateKind(ref.widen)
+            case _ =>
+              Candidate.Value
+          }
+
+        if (ckind == Candidate.None)
+          record("discarded eligible")
+        else {
+          val ptNorm = normalize(pt, pt) // `pt` could be implicit function types, check i2749
+          val refAdjusted =
+            if (pt.isInstanceOf[ViewProto]) adjustSingletonArg(ref)
+            else ref
+          val refNorm = normalize(refAdjusted, pt)
+          Stats.record("eligible check matches")
+          if (!NoViewsAllowed.isCompatible(refNorm, ptNorm))
+            ckind = Candidate.None
+        }
+        ckind
+      }
+
+
+      if refs.isEmpty && (!considerExtension || companionRefs.isEmpty) then
+        Nil
+      else
+        val candidates = new mutable.ListBuffer[Candidate]
+        def tryCandidate(extensionOnly: Boolean)(ref: ImplicitRef) =
+          var ckind = exploreInFreshCtx { (ctx: FreshContext) ?=>
+            ctx.setMode(ctx.mode &~ Mode.SafeNulls | Mode.TypevarsMissContext)
+            candidateKind(ref.underlyingRef)
+          }
+          if extensionOnly then ckind &= Candidate.Extension
+          if ckind != Candidate.None then
+            candidates += Candidate(ref, ckind, level)
+
+        if considerExtension then
+          companionRefs.foreach(tryCandidate(extensionOnly = true))
+        if refs.nonEmpty then
+          refs.foreach(tryCandidate(extensionOnly = false))
+        candidates.toList
+    }
+  }
+
+  /** The implicit references coming from the implicit scope of a type.
+   *  @param tp              the type determining the implicit scope
+   *  @param companionRefs   the companion objects in the implicit scope.
+   */
+  class OfTypeImplicits(tp: Type, override val companionRefs: TermRefSet)(initctx: Context) extends ImplicitRefs(initctx) {
+    implicits.println(i"implicit scope of type $tp = ${companionRefs.showAsList}%, %")
+    @threadUnsafe lazy val refs: List[ImplicitRef] = {
+      val buf = new mutable.ListBuffer[TermRef]
+      for (companion <- companionRefs) buf ++= companion.implicitMembers
+      buf.toList
+    }
+
+    /** The candidates that are eligible for expected type `tp` */
+    @threadUnsafe lazy val eligible: List[Candidate] =
+      trace(i"eligible($tp), companions = ${companionRefs.showAsList}%, %", implicitsDetailed, show = true) {
+        if (refs.nonEmpty && monitored) record(s"check eligible refs in tpe", refs.length)
+        filterMatching(tp)
+      }
+
+    override def isAccessible(ref: TermRef)(using Context): Boolean =
+      ref.symbol.exists
+
+    override def toString: String =
+      i"OfTypeImplicits($tp), companions = ${companionRefs.showAsList}%, %; refs = $refs%, %."
+  }
+
+  /** The implicit references coming from the context.
+   *  @param refs      the implicit references made visible by the current context.
+   *                   Note: The name of the reference might be different from the name of its symbol.
+   *                   In the case of a renaming import a => b, the name of the reference is the renamed
+   *                   name, b, whereas the name of the symbol is the original name, a.
+   *  @param outerCtx  the next outer context that makes visible further implicits
+   */
+  class ContextualImplicits(
+      val refs: List[ImplicitRef],
+      val outerImplicits: ContextualImplicits | Null,
+      isImport: Boolean)(initctx: Context) extends ImplicitRefs(initctx) {
+    private val eligibleCache = EqHashMap[Type, List[Candidate]]()
+
+    /** The level increases if current context has a different owner or scope than
+     *  the context of the next-outer ImplicitRefs. This is however disabled under
+     *  Scala2 mode, since we do not want to change the implicit disambiguation then.
+     */
+    override val level: Int =
+      def isSameOwner = irefCtx.owner eq outerImplicits.uncheckedNN.irefCtx.owner
+      def isSameScope = irefCtx.scope eq outerImplicits.uncheckedNN.irefCtx.scope
+      def isLazyImplicit = refs.head.implicitName.is(LazyImplicitName)
+
+      if outerImplicits == null then 1
+      else if migrateTo3(using irefCtx)
+              || isSameOwner && (isImport || isSameScope && !isLazyImplicit)
+      then outerImplicits.uncheckedNN.level
+      else outerImplicits.uncheckedNN.level + 1
+    end level
+
+    /** Is this the outermost implicits? This is the case if it either the implicits
+     *  of NoContext, or the last one before it.
+     */
+    private def isOuterMost = {
+      val finalImplicits = NoContext.implicits
+      (this eq finalImplicits) || (outerImplicits eqn finalImplicits)
+    }
+
+    private def combineEligibles(ownEligible: List[Candidate], outerEligible: List[Candidate]): List[Candidate] =
+      if ownEligible.isEmpty then outerEligible
+      else if outerEligible.isEmpty then ownEligible
+      else
+        val shadowed = ownEligible.map(_.ref.implicitName).toSet
+        ownEligible ::: outerEligible.filterConserve(cand => !shadowed.contains(cand.ref.implicitName))
+
+    def uncachedEligible(tp: Type)(using Context): List[Candidate] =
+      Stats.record("uncached eligible")
+      if monitored then record(s"check uncached eligible refs in irefCtx", refs.length)
+      val ownEligible = filterMatching(tp)
+      if isOuterMost then ownEligible
+      else combineEligibles(ownEligible, outerImplicits.nn.uncachedEligible(tp))
+
+    /** The implicit references that are eligible for type `tp`. */
+    def eligible(tp: Type): List[Candidate] =
+      if (tp.hash == NotCached)
+        Stats.record(i"compute eligible not cached ${tp.getClass}")
+        Stats.record("compute eligible not cached")
+        computeEligible(tp)
+      else {
+        val eligibles = eligibleCache.lookup(tp)
+        if (eligibles != null) {
+          Stats.record("cached eligible")
+          eligibles
+        }
+        else if (irefCtx eq NoContext) Nil
+        else {
+          Stats.record(i"compute eligible cached")
+          val result = computeEligible(tp)
+          eligibleCache(tp) = result
+          result
+        }
+      }
+
+    private def computeEligible(tp: Type): List[Candidate] = /*>|>*/ trace(i"computeEligible $tp in $refs%, %", implicitsDetailed) /*<|<*/ {
+      if (monitored) record(s"check eligible refs in irefCtx", refs.length)
+      val ownEligible = filterMatching(tp)
+      if isOuterMost then ownEligible
+      else combineEligibles(ownEligible, outerImplicits.nn.eligible(tp))
+    }
+
+    override def isAccessible(ref: TermRef)(using Context): Boolean =
+      ref.symbol.isAccessibleFrom(ref.prefix)
+
+    override def toString: String = {
+      val own = i"(implicits: $refs%, %)"
+      if (isOuterMost) own else own + "\n " + outerImplicits
+    }
+
+    /** This context, or a copy, ensuring root import from symbol `root`
+     *  is not present in outer implicits.
+     */
+    def exclude(root: Symbol): ContextualImplicits =
+      if (this == NoContext.implicits) this
+      else {
+        val outerExcluded = outerImplicits.nn exclude root
+        if (irefCtx.importInfo.nn.site.termSymbol == root) outerExcluded
+        else if (outerExcluded eqn outerImplicits) this
+        else new ContextualImplicits(refs, outerExcluded, isImport)(irefCtx)
+      }
+  }
+
+  /** The result of an implicit search */
+  sealed abstract class SearchResult extends Showable {
+    def tree: Tree
+    def toText(printer: Printer): Text = printer.toText(this)
+    def recoverWith(other: SearchFailure => SearchResult): SearchResult = this match {
+      case _: SearchSuccess => this
+      case fail: SearchFailure => other(fail)
+    }
+    def isSuccess: Boolean = isInstanceOf[SearchSuccess]
+  }
+
+  /** A successful search
+   *  @param tree        The typed tree that needs to be inserted
+   *  @param ref         The implicit reference that succeeded
+   *  @param level       The level where the reference was found
+   *  @param isExtension Whether the result is an extension method application
+   *  @param tstate The typer state to be committed if this alternative is chosen
+   */
+  case class SearchSuccess(tree: Tree, ref: TermRef, level: Int, isExtension: Boolean = false)(val tstate: TyperState, val gstate: GadtConstraint)
+  extends SearchResult with RefAndLevel with Showable
+
+  /** A failed search */
+  case class SearchFailure(tree: Tree) extends SearchResult {
+    final def isAmbiguous: Boolean = tree.tpe.isInstanceOf[AmbiguousImplicits | TooUnspecific]
+    final def reason: SearchFailureType = tree.tpe.asInstanceOf[SearchFailureType]
+  }
+
+  object SearchFailure {
+    def apply(tpe: SearchFailureType, span: Span)(using Context): SearchFailure = {
+      val id = tpe match
+        case tpe: (AmbiguousImplicits | TooUnspecific) =>
+          untpd.SearchFailureIdent(nme.AMBIGUOUS, s"/* ambiguous: ${tpe.explanation} */")
+        case _ =>
+          untpd.SearchFailureIdent(nme.MISSING, "/* missing */")
+      SearchFailure(id.withTypeUnchecked(tpe).withSpan(span))
+    }
+  }
+
+  abstract class SearchFailureType extends ErrorType {
+    def expectedType: Type
+    def argument: Tree
+
+    /** A "massaging" function for displayed types to give better info in error diagnostics */
+    def clarify(tp: Type)(using Context): Type = tp
+
+    final protected def qualify(using Context): String = expectedType match {
+      case SelectionProto(name, mproto, _, _) if !argument.isEmpty =>
+        em"provide an extension method `$name` on ${argument.tpe}"
+      case NoType =>
+        if (argument.isEmpty) em"match expected type"
+        else em"convert from ${argument.tpe} to expected type"
+      case _ =>
+        if (argument.isEmpty) em"match type ${clarify(expectedType)}"
+        else em"convert from ${argument.tpe} to ${clarify(expectedType)}"
+    }
+
+    /** An explanation of the cause of the failure as a string */
+    def explanation(using Context): String
+
+    def msg(using Context): Message = explanation.toMessage
+
+    /** If search was for an implicit conversion, a note describing the failure
+     *  in more detail - this is either empty or starts with a '\n'
+     */
+    def whyNoConversion(using Context): String = ""
+  }
+
+  class NoMatchingImplicits(val expectedType: Type, val argument: Tree, constraint: Constraint = OrderingConstraint.empty)
+  extends SearchFailureType {
+
+    /** Replace all type parameters in constraint by their bounds, to make it clearer
+     *  what was expected
+     */
+    override def clarify(tp: Type)(using Context): Type =
+      val ctx1 = ctx.fresh.setExploreTyperState()
+      ctx1.typerState.constraint = constraint
+      inContext(ctx1) {
+        val map = new TypeMap:
+          def apply(t: Type): Type = t match
+            case t: TypeParamRef =>
+              constraint.entry(t) match
+                case NoType | _: TypeBounds => t
+                case t1 => t1
+            case t: TypeVar =>
+              t.instanceOpt.orElse(apply(t.origin))
+            case _ =>
+              mapOver(t)
+
+          override def mapArgs(args: List[Type], tparams: List[ParamInfo]) =
+            args.mapConserve {
+              case t: TypeParamRef =>
+                constraint.entry(t) match
+                  case bounds: TypeBounds => TypeComparer.fullBounds(t)
+                  case _ => this(t)
+              case t => this(t)
+            }
+        end map
+        map(tp)
+      }
+
+    def explanation(using Context): String =
+      em"no implicit values were found that $qualify"
+    override def toString = s"NoMatchingImplicits($expectedType, $argument)"
+  }
+
+  @sharable object NoMatchingImplicits extends NoMatchingImplicits(NoType, EmptyTree, OrderingConstraint.empty)
+
+  @sharable val NoMatchingImplicitsFailure: SearchFailure =
+    SearchFailure(NoMatchingImplicits, NoSpan)(using NoContext)
+
+  @sharable object ImplicitSearchTooLarge extends NoMatchingImplicits(NoType, EmptyTree, OrderingConstraint.empty)
+
+  @sharable val ImplicitSearchTooLargeFailure: SearchFailure =
+    SearchFailure(ImplicitSearchTooLarge, NoSpan)(using NoContext)
+
+  /** A failure value indicating that an implicit search for a conversion was not tried */
+  case class TooUnspecific(target: Type) extends NoMatchingImplicits(NoType, EmptyTree, OrderingConstraint.empty):
+    override def whyNoConversion(using Context): String =
+      i"""
+         |Note that implicit conversions were not tried because the result of an implicit conversion
+         |must be more specific than $target"""
+    override def explanation(using Context) =
+      i"""${super.explanation}.
+         |The expected type $target is not specific enough, so no search was attempted"""
+    override def toString = s"TooUnspecific"
+
+  /** An ambiguous implicits failure */
+  class AmbiguousImplicits(val alt1: SearchSuccess, val alt2: SearchSuccess, val expectedType: Type, val argument: Tree) extends SearchFailureType {
+    def explanation(using Context): String =
+      var str1 = err.refStr(alt1.ref)
+      var str2 = err.refStr(alt2.ref)
+      if str1 == str2 then
+        str1 = ctx.printer.toTextRef(alt1.ref).show
+        str2 = ctx.printer.toTextRef(alt2.ref).show
+      em"both $str1 and $str2 $qualify"
+    override def whyNoConversion(using Context): String =
+      if !argument.isEmpty && argument.tpe.widen.isRef(defn.NothingClass) then
+        ""
+      else
+        val what = if (expectedType.isInstanceOf[SelectionProto]) "extension methods" else "conversions"
+        i"""
+           |Note that implicit $what cannot be applied because they are ambiguous;
+           |$explanation"""
+  }
+
+  class MismatchedImplicit(ref: TermRef,
+                           val expectedType: Type,
+                           val argument: Tree) extends SearchFailureType {
+    def explanation(using Context): String =
+      em"${err.refStr(ref)} does not $qualify"
+  }
+
+  class DivergingImplicit(ref: TermRef,
+                          val expectedType: Type,
+                          val argument: Tree) extends SearchFailureType {
+    def explanation(using Context): String =
+      em"${err.refStr(ref)} produces a diverging implicit search when trying to $qualify"
+  }
+
+  /** A search failure type for attempted ill-typed extension method calls */
+  class FailedExtension(extApp: Tree, val expectedType: Type, val whyFailed: Message) extends SearchFailureType:
+    def argument = EmptyTree
+    def explanation(using Context) = em"$extApp does not $qualify"
+
+   /** A search failure type for aborted searches of extension methods, typically
+    *  because of a cyclic reference or similar.
+    */
+  class NestedFailure(_msg: Message, val expectedType: Type) extends SearchFailureType:
+    def argument = EmptyTree
+    override def msg(using Context) = _msg
+    def explanation(using Context) = msg.toString
+
+  /** A search failure type for failed synthesis of terms for special types */
+  class SynthesisFailure(reasons: List[String], val expectedType: Type) extends SearchFailureType:
+    def argument = EmptyTree
+
+    private def formatReasons =
+      if reasons.length > 1 then
+        reasons.mkString("\n\t* ", "\n\t* ", "")
+      else
+        reasons.mkString
+
+    def explanation(using Context) = em"Failed to synthesize an instance of type ${clarify(expectedType)}: ${formatReasons}"
+
+end Implicits
+
+import Implicits._
+
+/** Info relating to implicits that is kept for one run */
+trait ImplicitRunInfo:
+  self: Run =>
+
+  private val implicitScopeCache = util.EqHashMap[Type, OfTypeImplicits]()
+
+  private def isExcluded(sym: Symbol) =
+    if migrateTo3 then false else sym.is(Package) || sym.isPackageObject
+
+  /** Is `sym` an anchor type for which givens may exist? Anchor types are classes,
+    *  opaque type aliases, match aliases and abstract types, but not type parameters
+    *  or package objects.
+    */
+  private def isAnchor(sym: Symbol) =
+    sym.isClass && !isExcluded(sym)
+    || sym.isOpaqueAlias
+    || sym.is(Deferred, butNot = Param)
+    || sym.info.isInstanceOf[MatchAlias]
+
+  private def computeIScope(rootTp: Type): OfTypeImplicits =
+
+    object collectParts extends TypeTraverser:
+
+      private var parts: mutable.LinkedHashSet[Type] = _
+      private val partSeen = util.HashSet[Type]()
+
+      def traverse(t: Type) =
+        if partSeen.contains(t) then ()
+        else if implicitScopeCache.contains(t) then parts += t
+        else
+          partSeen += t
+          t.dealias match
+            case t: TypeRef =>
+              if isAnchor(t.symbol) then
+                parts += t
+                traverse(t.prefix)
+              else
+                traverse(t.underlying)
+            case t: TermRef =>
+              if !isExcluded(t.symbol) then
+                traverse(t.info)
+                traverse(t.prefix)
+            case t: ThisType if t.cls.is(Module) && t.cls.isStaticOwner =>
+              traverse(t.cls.sourceModule.termRef)
+            case t: ConstantType =>
+              traverse(t.underlying)
+            case t: TypeParamRef =>
+              assert(!ctx.typerState.constraint.contains(t), i"`wildApprox` failed to remove uninstantiated $t")
+              traverse(t.underlying)
+            case t: TermParamRef =>
+              traverse(t.underlying)
+            case t: TypeLambda =>
+              for p <- t.paramRefs do partSeen += p
+              traverseChildren(t)
+            case t =>
+              traverseChildren(t)
+
+      def apply(tp: Type): collection.Set[Type] =
+        parts = mutable.LinkedHashSet()
+        partSeen.clear()
+        traverse(tp)
+        parts
+    end collectParts
+
+    val seen = util.HashSet[Type]()
+    val incomplete = util.HashSet[Type]()
+
+    def collectCompanions(tp: Type, parts: collection.Set[Type]): TermRefSet =
+      val companions = new TermRefSet
+
+      def iscopeRefs(t: Type): TermRefSet =
+        implicitScopeCache.lookup(t) match
+          case is: OfTypeImplicits =>
+            is.companionRefs
+          case null =>
+            if seen.contains(t) then
+              incomplete += tp // all references for `t` will be accounted for in `seen` so we return `EmptySet`.
+              TermRefSet.empty        // on the other hand, the refs of `tp` are now inaccurate, so `tp` is marked incomplete.
+            else
+              seen += t
+              val is = recur(t)
+              if !implicitScopeCache.contains(t) then incomplete += tp
+              is.companionRefs
+      end iscopeRefs
+
+      def addCompanion(pre: Type, companion: Symbol) =
+        if companion.exists && !companion.isAbsent() then
+          companions += TermRef(pre, companion)
+
+      def addCompanions(t: Type) = implicitScopeCache.lookup(t) match
+        case iscope: OfTypeImplicits =>
+          companions ++= iscope.companionRefs
+        case null => t match
+          case t: TypeRef =>
+            val sym = t.symbol
+            val pre = t.prefix
+            addPath(pre)
+            addCompanion(pre,
+              if sym.isClass then sym.companionModule
+              else pre.member(sym.name.toTermName)
+                .suchThat(companion => companion.is(Module) && companion.owner == sym.owner)
+                .symbol)
+
+            // The companion of `js.|` defines an implicit conversions from
+            // `A | Unit` to `js.UndefOrOps[A]`. To keep this conversion in scope
+            // in Scala 3, where we re-interpret `js.|` as a real union, we inject
+            // it in the scope of `Unit`.
+            if t.isRef(defn.UnitClass) && ctx.settings.scalajs.value then
+              companions += JSDefinitions.jsdefn.UnionOpsModuleRef
+
+            if sym.isClass then
+              for p <- t.parents do companions ++= iscopeRefs(p)
+            else
+              companions ++= iscopeRefs(t.underlying)
+      end addCompanions
+
+      def addPath(pre: Type): Unit = pre.dealias match
+        case pre: ThisType if pre.cls.is(Module) && pre.cls.isStaticOwner =>
+          addPath(pre.cls.sourceModule.termRef)
+        case pre: TermRef if !isExcluded(pre.symbol) =>
+          pre.info match
+            case info: SingletonType =>
+              addPath(info)
+            case info: TypeRef if info.symbol.is(Module) =>
+              addCompanion(info.prefix, info.symbol.sourceModule)
+              addPath(info.prefix)
+            case _ =>
+              companions += pre
+              addPath(pre.prefix)
+        case _ =>
+
+      parts.foreach(addCompanions)
+      companions
+    end collectCompanions
+
+    def recur(tp: Type): OfTypeImplicits =
+      val parts = collectParts(tp)
+      val companions = collectCompanions(tp, parts)
+      val result = OfTypeImplicits(tp, companions)(runContext)
+      if Config.cacheImplicitScopes
+        && tp.hash != NotCached
+        && (tp eq rootTp)              // first type traversed is always cached
+           || !incomplete.contains(tp) // other types are cached if they are not incomplete
+      then implicitScopeCache(tp) = result
+      result
+
+    record(i"computeIScope")
+    recur(rootTp)
+  end computeIScope
+
+  /** The implicit scope of a type `tp`, which is specified by the following definitions.
+   *
+   *  A reference is an _anchor_ if it refers to an object, a class, a trait, an
+   *  abstract type, an opaque type alias, or a match type alias. References to
+   *  packages and package objects are anchors only under -source:3.0-migration.
+   *
+   *  The _anchors_ of a type `T` is a set of references defined as follows:
+   *
+   *   - If `T` is a reference to an anchor, `T` itself plus, if `T` is of the form
+   *     `P#A`, the anchors of `P`.
+   *   - If `T` is an alias of `U`, the anchors of `U`.
+   *   - If `T` is a reference to a type parameter, the union of the anchors of both of its bounds.
+   *   - If `T` is a singleton reference, the anchors of its underlying type, plus,
+   *     if `T` is of the form `(P#x).type`, the anchors of `P`.
+   *   - If `T` is the this-type of a static object, the anchors of a term reference to that object.
+   *   - If `T` is some other type, the union of the anchors of each constituent type of `T`.
+   *
+   *  The _implicit scope_ of a type `tp` is the smallest set S of term references (i.e. TermRefs)
+   *  such that
+   *
+   *   - If `T` is a reference to a class, S includes a reference to the companion object
+   *     of the class, if it exists, as well as the implicit scopes of all of `T`'s parent classes.
+   *   - If `T` is a reference to an object, S includes `T` itself as well as
+   *     the implicit scopes of all of `T`'s parent classes.
+   *   - If `T` is a reference to an opaque type alias named `A`, S includes
+   *     a reference to an object `A` defined in the same scope as the type, if it exists,
+   *     as well as the implicit scope of `T`'s underlying type or bounds.
+   *   - If `T` is a reference to an an abstract type or match type alias named `A`,
+   *     S includes a reference to an object `A` defined in the same scope as the type,
+   *     if it exists, as well as the implicit scopes of `T`'s lower and upper bound,
+   *     if present.
+   *   - If `T` is a reference to an anchor of the form `p.A` then S also includes
+   *     all term references on the path `p`.
+   *   - If `T` is some other type, S includes the implicit scopes of all anchors of `T`.
+   */
+  def implicitScope(tp: Type)(using Context): OfTypeImplicits =
+    implicitScopeCache.lookup(tp) match
+      case is: OfTypeImplicits =>
+        record("implicitScope cache hit")
+        is
+      case null =>
+        record(i"implicitScope")
+        val liftToAnchors = new TypeMap:
+          override def stopAt = StopAt.Static
+          private val seen = util.HashSet[Type]()
+
+          def applyToUnderlying(t: TypeProxy) =
+            if seen.contains(t) then
+              WildcardType
+            else
+              seen += t
+              t.superType match
+                case TypeBounds(lo, hi) =>
+                  if lo.isBottomTypeAfterErasure then apply(hi)
+                  else AndType.make(apply(lo), apply(hi))
+                case u => apply(u)
+
+          def apply(t: Type) = t.dealias match
+            case t: TypeRef =>
+              if t.symbol.isClass || isAnchor(t.symbol) then t else applyToUnderlying(t)
+            case t: TypeVar => apply(t.underlying)
+            case t: ParamRef => applyToUnderlying(t)
+            case t: ConstantType => apply(t.underlying)
+            case t => mapOver(t)
+        end liftToAnchors
+        val liftedTp = liftToAnchors(tp)
+        if liftedTp eq tp then
+          record(i"implicitScope unlifted")
+          computeIScope(tp)
+        else
+          record("implicitScope lifted")
+          val liftedIScope = implicitScopeCache.getOrElse(liftedTp, computeIScope(liftedTp))
+          val result = OfTypeImplicits(tp, liftedIScope.companionRefs)(runContext)
+          implicitScopeCache(tp) = result
+          result
+  end implicitScope
+
+  protected def reset(): Unit =
+    implicitScopeCache.clear()
+end ImplicitRunInfo
+
+/** The implicit resolution part of type checking */
+trait Implicits:
+  self: Typer =>
+
+  import tpd._
+
+  override def viewExists(from: Type, to: Type)(using Context): Boolean =
+       !from.isError
+    && !to.isError
+    && !ctx.isAfterTyper
+    && ctx.mode.is(Mode.ImplicitsEnabled)
+    && from.isValueType
+    && (  from.isValueSubType(to)
+       || inferView(dummyTreeOfType(from), to)
+            (using ctx.fresh.addMode(Mode.ImplicitExploration).setExploreTyperState()).isSuccess
+          // TODO: investigate why we can't TyperState#test here
+       )
+
+  /** Find an implicit conversion to apply to given tree `from` so that the
+   *  result is compatible with type `to`.
+   */
+  def inferView(from: Tree, to: Type)(using Context): SearchResult = {
+    record("inferView")
+    if !ctx.mode.is(Mode.ImplicitsEnabled) || from.isInstanceOf[Super] then
+      NoMatchingImplicitsFailure
+    else {
+      def adjust(to: Type) = to.stripTypeVar.widenExpr match {
+        case SelectionProto(name, memberProto, compat, true) =>
+          SelectionProto(name, memberProto, compat, privateOK = false)
+        case tp => tp
+      }
+
+      def isOldStyleFunctionConversion(tpe: Type): Boolean =
+        tpe match {
+          case PolyType(_, resType) => isOldStyleFunctionConversion(resType)
+          case _ => tpe.derivesFrom(defn.FunctionSymbol(1)) && !tpe.derivesFrom(defn.ConversionClass) && !tpe.derivesFrom(defn.SubTypeClass)
+        }
+
+      try
+        val inferred = inferImplicit(adjust(to), from, from.span)
+
+        inferred match {
+          case SearchSuccess(_, ref, _, false) if isOldStyleFunctionConversion(ref.underlying) =>
+            report.migrationWarning(
+              i"The conversion ${ref} will not be applied implicitly here in Scala 3 because only implicit methods and instances of Conversion class will continue to work as implicit views.",
+              from
+            )
+          case _ =>
+        }
+
+        inferred
+      catch {
+        case ex: AssertionError =>
+          implicits.println(s"view $from ==> $to")
+          implicits.println(ctx.typerState.constraint.show)
+          implicits.println(TypeComparer.explained(_.isSubType(from.tpe, to)))
+          throw ex
+      }
+    }
+  }
+
+  private var synthesizer: Synthesizer | Null = null
+
+  /** Find an implicit argument for parameter `formal`.
+   *  Return a failure as a SearchFailureType in the type of the returned tree.
+   */
+  def inferImplicitArg(formal: Type, span: Span)(using Context): Tree =
+    inferImplicit(formal, EmptyTree, span) match
+      case SearchSuccess(arg, _, _, _) => arg
+      case fail @ SearchFailure(failed) =>
+        if fail.isAmbiguous then failed
+        else
+          if synthesizer == null then synthesizer = Synthesizer(this)
+          val (tree, errors) = synthesizer.uncheckedNN.tryAll(formal, span)
+          if errors.nonEmpty then
+            SearchFailure(new SynthesisFailure(errors, formal), span).tree
+          else
+            tree.orElse(failed)
+
+
+  /** Search an implicit argument and report error if not found */
+  def implicitArgTree(formal: Type, span: Span)(using Context): Tree = {
+    val arg = inferImplicitArg(formal, span)
+    if (arg.tpe.isInstanceOf[SearchFailureType])
+      report.error(missingArgMsg(arg, formal, ""), ctx.source.atSpan(span))
+    arg
+  }
+
+  /** @param arg                          Tree representing a failed result of implicit search
+   *  @param pt                           Type for which an implicit value was searched
+   *  @param where                        Description of where the search was performed. Might be empty
+   *  @param paramSymWithMethodCallTree   Symbol of the parameter for which the implicit was searched and tree of the method call that triggered the implicit search
+   */
+  def missingArgMsg(
+    arg: Tree,
+    pt: Type,
+    where: String,
+    paramSymWithMethodCallTree: Option[(Symbol, Tree)] = None
+  )(using Context): String = {
+    def findHiddenImplicitsCtx(c: Context): Context =
+      if c == NoContext then c
+      else c.freshOver(findHiddenImplicitsCtx(c.outer)).addMode(Mode.FindHiddenImplicits)
+
+    def ignoredInstanceNormalImport = arg.tpe match
+      case fail: SearchFailureType =>
+        if (fail.expectedType eq pt) || isFullyDefined(fail.expectedType, ForceDegree.none) then
+          inferImplicit(fail.expectedType, fail.argument, arg.span)(
+            using findHiddenImplicitsCtx(ctx)) match {
+            case s: SearchSuccess => Some(s)
+            case f: SearchFailure =>
+              f.reason match {
+                case ambi: AmbiguousImplicits => Some(ambi.alt1)
+                case r => None
+              }
+          }
+        else
+          // It's unsafe to search for parts of the expected type if they are not fully defined,
+          // since these come with nested contexts that are lost at this point. See #7249 for an
+          // example where searching for a nested type causes an infinite loop.
+          None
+
+    val error = new ImplicitSearchError(arg, pt, where, paramSymWithMethodCallTree, ignoredInstanceNormalImport, importSuggestionAddendum(pt))
+    error.missingArgMsg
+  }
+
+  /** A string indicating the formal parameter corresponding to a  missing argument */
+  def implicitParamString(paramName: TermName, methodStr: String, tree: Tree)(using Context): String =
+    tree match {
+      case Select(qual, nme.apply) if defn.isFunctionType(qual.tpe.widen) =>
+        val qt = qual.tpe.widen
+        val qt1 = qt.dealiasKeepAnnots
+        def addendum = if (qt1 eq qt) "" else (i"\nThe required type is an alias of: $qt1")
+        em"parameter of ${qual.tpe.widen}$addendum"
+      case _ =>
+        em"${ if paramName.is(EvidenceParamName) then "an implicit parameter"
+              else s"parameter $paramName" } of $methodStr"
+    }
+
+  /** A CanEqual[T, U] instance is assumed
+   *   - if one of T, U is an error type, or
+   *   - if one of T, U is a subtype of the lifted version of the other,
+   *     unless strict equality is set.
+   */
+  def assumedCanEqual(ltp: Type, rtp: Type)(using Context) = {
+    // Map all non-opaque abstract types to their upper bound.
+    // This is done to check whether such types might plausibly be comparable to each other.
+    val lift = new TypeMap {
+      def apply(t: Type): Type = t match {
+        case t: TypeRef =>
+          t.info match {
+            case TypeBounds(lo, hi) if lo.ne(hi) && !t.symbol.is(Opaque) => apply(hi)
+            case _ => t
+          }
+        case t: SingletonType =>
+          apply(t.widen)
+        case t: RefinedType =>
+          apply(t.parent)
+        case t: LazyRef =>
+          t
+        case _ =>
+          if (variance > 0) mapOver(t) else t
+      }
+    }
+
+    ltp.isError
+    || rtp.isError
+    || !strictEquality && (ltp <:< lift(rtp) || rtp <:< lift(ltp))
+  }
+
+  /** Check that equality tests between types `ltp` and `rtp` make sense */
+  def checkCanEqual(ltp: Type, rtp: Type, span: Span)(using Context): Unit =
+    if (!ctx.isAfterTyper && !assumedCanEqual(ltp, rtp)) {
+      val res = implicitArgTree(defn.CanEqualClass.typeRef.appliedTo(ltp, rtp), span)
+      implicits.println(i"CanEqual witness found for $ltp / $rtp: $res: ${res.tpe}")
+    }
+
+  object hasSkolem extends TreeAccumulator[Boolean]:
+    def apply(x: Boolean, tree: Tree)(using Context): Boolean =
+      x || {
+        tree match
+          case tree: Ident => tree.symbol.isSkolem
+          case Select(qual, _) => apply(x, qual)
+          case Apply(fn, _) => apply(x, fn)
+          case TypeApply(fn, _) => apply(x, fn)
+          case _: This => false
+          case _ => foldOver(x, tree)
+      }
+
+  /** Find an implicit parameter or conversion.
+   *  @param pt              The expected type of the parameter or conversion.
+   *  @param argument        If an implicit conversion is searched, the argument to which
+   *                         it should be applied, EmptyTree otherwise.
+   *  @param span            The position where errors should be reported.
+   */
+  def inferImplicit(pt: Type, argument: Tree, span: Span)(using Context): SearchResult =
+    trace(s"search implicit ${pt.show}, arg = ${argument.show}: ${argument.tpe.show}", implicits, show = true) {
+      record("inferImplicit")
+      assert(ctx.phase.allowsImplicitSearch,
+        if (argument.isEmpty) i"missing implicit parameter of type $pt after typer at phase ${ctx.phase.phaseName}"
+        else i"type error: ${argument.tpe} does not conform to $pt${err.whyNoMatchStr(argument.tpe, pt)}")
+
+      if pt.unusableForInference
+         || !argument.isEmpty && argument.tpe.unusableForInference
+      then return NoMatchingImplicitsFailure
+
+      val result0 =
+        // If we are searching implicits when resolving an import symbol, start the search
+        // in the first enclosing context that does not have the same scope and owner as the current
+        // context. Without that precaution, an eligible implicit in the current scope
+        // would cause a cyclic reference error (if the import is named) or cause a
+        // spurious import skip (if the import is a wildcard import). See i12802 for a test case.
+        var searchCtx = ctx
+        if ctx.owner.isImport then
+          while
+            searchCtx = searchCtx.outer
+            (searchCtx.scope eq ctx.scope) && (searchCtx.owner eq ctx.owner.owner)
+          do ()
+
+        try ImplicitSearch(pt, argument, span)(using searchCtx).bestImplicit
+        catch case ce: CyclicReference =>
+          ce.inImplicitSearch = true
+          throw ce
+      end result0
+
+      val result =
+        result0 match {
+          case result: SearchSuccess =>
+            if result.tstate ne ctx.typerState then
+              result.tstate.commit()
+            if result.gstate ne ctx.gadt then
+              ctx.gadt.restore(result.gstate)
+            if hasSkolem(false, result.tree) then
+              report.error(SkolemInInferred(result.tree, pt, argument), ctx.source.atSpan(span))
+            implicits.println(i"success: $result")
+            implicits.println(i"committing ${result.tstate.constraint} yielding ${ctx.typerState.constraint} in ${ctx.typerState}")
+            result
+          case result: SearchFailure if result.isAmbiguous =>
+            val deepPt = pt.deepenProto
+            if (deepPt ne pt) inferImplicit(deepPt, argument, span)
+            else if (migrateTo3 && !ctx.mode.is(Mode.OldOverloadingResolution))
+              withMode(Mode.OldOverloadingResolution)(inferImplicit(pt, argument, span)) match {
+                case altResult: SearchSuccess =>
+                  report.migrationWarning(
+                    s"According to new implicit resolution rules, this will be ambiguous:\n${result.reason.explanation}",
+                    ctx.source.atSpan(span))
+                  altResult
+                case _ =>
+                  result
+              }
+            else result
+          case NoMatchingImplicitsFailure =>
+            SearchFailure(new NoMatchingImplicits(pt, argument, ctx.typerState.constraint), span)
+          case _ =>
+            result0
+        }
+      // If we are at the outermost implicit search then emit the implicit dictionary, if any.
+      ctx.searchHistory.emitDictionary(span, result)
+    }
+
+  /** Try to typecheck an implicit reference */
+  def typedImplicit(cand: Candidate, pt: Type, argument: Tree, span: Span)(using Context): SearchResult =  trace(i"typed implicit ${cand.ref}, pt = $pt, implicitsEnabled == ${ctx.mode is ImplicitsEnabled}", implicits, show = true) {
+    if ctx.run.nn.isCancelled then NoMatchingImplicitsFailure
+    else
+      record("typedImplicit")
+      val ref = cand.ref
+      val generated: Tree = tpd.ref(ref).withSpan(span.startPos)
+      val locked = ctx.typerState.ownedVars
+      val adapted =
+        if argument.isEmpty then
+          if defn.isContextFunctionType(pt) then
+            // need to go through typed, to build the context closure
+            typed(untpd.TypedSplice(generated), pt, locked)
+          else
+            // otherwise we can skip typing and go directly to adapt
+            adapt(generated, pt.widenExpr, locked)
+        else {
+          def untpdGenerated = untpd.TypedSplice(generated)
+          def producesConversion(info: Type): Boolean = info match
+            case info: PolyType => producesConversion(info.resType)
+            case info: MethodType if info.isImplicitMethod => producesConversion(info.resType)
+            case _ => info.derivesFrom(defn.ConversionClass)
+          def tryConversion(using Context) = {
+            val untpdConv =
+              if ref.symbol.is(Given) && producesConversion(ref.symbol.info) then
+                untpd.Select(
+                  untpd.TypedSplice(
+                    adapt(generated,
+                      defn.ConversionClass.typeRef.appliedTo(argument.tpe, pt),
+                      locked)),
+                  nme.apply)
+              else untpdGenerated
+            typed(
+              untpd.Apply(untpdConv, untpd.TypedSplice(argument) :: Nil),
+              pt, locked)
+          }
+          pt match
+            case selProto @ SelectionProto(selName: TermName, mbrType, _, _) =>
+
+              def tryExtension(using Context) =
+                extMethodApply(untpd.Select(untpdGenerated, selName), argument, mbrType)
+
+              def tryConversionForSelection(using Context) =
+                val converted = tryConversion
+                if !ctx.reporter.hasErrors && !selProto.isMatchedBy(converted.tpe) then
+                  // this check is needed since adapting relative to a `SelectionProto` can succeed
+                  // even if the term is not a subtype of the `SelectionProto`
+                  err.typeMismatch(converted, selProto)
+                converted
+
+              if cand.isExtension && cand.isConversion then
+                val extensionCtx, conversionCtx = ctx.fresh.setNewTyperState()
+                val extensionResult = tryExtension(using extensionCtx)
+                val conversionResult = tryConversionForSelection(using conversionCtx)
+                if !extensionCtx.reporter.hasErrors then
+                  extensionCtx.typerState.commit()
+                  if !conversionCtx.reporter.hasErrors then
+                    report.error(em"ambiguous implicit: $generated is eligible both as an implicit conversion and as an extension method container")
+                  extensionResult
+                else
+                  conversionCtx.typerState.commit()
+                  conversionResult
+              else if cand.isExtension then tryExtension
+              else tryConversionForSelection
+            case _ =>
+              tryConversion
+        }
+      if ctx.reporter.hasErrors
+         || !cand.ref.symbol.isAccessibleFrom(cand.ref.prefix)
+      then
+        ctx.reporter.removeBufferedMessages
+        adapted.tpe match {
+          case _: SearchFailureType => SearchFailure(adapted)
+          case error: PreviousErrorType if !adapted.symbol.isAccessibleFrom(cand.ref.prefix) =>
+            SearchFailure(adapted.withType(new NestedFailure(error.msg, pt)))
+          case _ =>
+            // Special case for `$conforms` and `<:<.refl`. Showing them to the users brings
+            // no value, so we instead report a `NoMatchingImplicitsFailure`
+            if (adapted.symbol == defn.Predef_conforms || adapted.symbol == defn.SubType_refl)
+              NoMatchingImplicitsFailure
+            else
+              SearchFailure(adapted.withType(new MismatchedImplicit(ref, pt, argument)))
+        }
+      else
+        SearchSuccess(adapted, ref, cand.level, cand.isExtension)(ctx.typerState, ctx.gadt)
+    }
+
+  /** An implicit search; parameters as in `inferImplicit` */
+  class ImplicitSearch(protected val pt: Type, protected val argument: Tree, span: Span)(using Context):
+    assert(argument.isEmpty || argument.tpe.isValueType || argument.tpe.isInstanceOf[ExprType],
+        em"found: $argument: ${argument.tpe}, expected: $pt")
+
+    private def nestedContext() =
+      ctx.fresh.setMode(ctx.mode &~ Mode.ImplicitsEnabled)
+
+    private def isCoherent = pt.isRef(defn.CanEqualClass)
+
+    private val wideProto = pt.widenExpr
+
+    private val srcPos = ctx.source.atSpan(span)
+
+    /** The expected type where parameters and uninstantiated typevars are replaced by wildcard types */
+    private val wildProto: Type =
+      if argument.isEmpty then wildApprox(pt)
+      else ViewProto(wildApprox(argument.tpe.widen.normalized), wildApprox(pt))
+        // Not clear whether we need to drop the `.widen` here. All tests pass with it in place, though.
+
+    private val isNotGiven: Boolean = wildProto.classSymbol == defn.NotGivenClass
+
+    private def searchTooLarge(): Boolean = ctx.searchHistory match
+      case root: SearchRoot =>
+        root.nestedSearches = 1
+        false
+      case h =>
+        val limit = ctx.settings.XimplicitSearchLimit.value
+        val nestedSearches = h.root.nestedSearches
+        val result = nestedSearches > limit
+        if result then
+          var c = ctx
+          while c.outer.typer eq ctx.typer do c = c.outer
+          report.warning(ImplicitSearchTooLargeWarning(limit, h.openSearchPairs), srcPos)(using c)
+        else
+          h.root.nestedSearches = nestedSearches + 1
+        result
+
+    /** Try to type-check implicit reference, after checking that this is not
+      * a diverging search
+      */
+    def tryImplicit(cand: Candidate, contextual: Boolean): SearchResult =
+      if checkDivergence(cand) then
+        SearchFailure(new DivergingImplicit(cand.ref, wideProto, argument), span)
+      else if searchTooLarge() then
+        ImplicitSearchTooLargeFailure
+      else
+        val history = ctx.searchHistory.nest(cand, pt)
+        val typingCtx =
+          nestedContext().setNewTyperState().setFreshGADTBounds.setSearchHistory(history)
+        val result = typedImplicit(cand, pt, argument, span)(using typingCtx)
+        result match
+          case res: SearchSuccess =>
+            ctx.searchHistory.defineBynameImplicit(wideProto, res)
+          case _ =>
+            // Since the search failed, the local typerstate will be discarded
+            // without being committed, but type variables local to that state
+            // might still appear in an error message, so we run `gc()` here to
+            // make sure we don't forget their instantiation. This leads to more
+            // precise error messages in tests/neg/missing-implicit3.check and
+            // tests/neg/implicitSearch.check
+            typingCtx.typerState.gc()
+            result
+
+    /** Search a list of eligible implicit references */
+    private def searchImplicit(eligible: List[Candidate], contextual: Boolean): SearchResult =
+
+      /** Compare `alt1` with `alt2` to determine which one should be chosen.
+       *
+       *  @return  a number > 0   if `alt1` is preferred over `alt2`
+       *           a number < 0   if `alt2` is preferred over `alt1`
+       *           0              if neither alternative is preferred over the other
+       */
+      def compareAlternatives(alt1: RefAndLevel, alt2: RefAndLevel): Int =
+        if alt1.ref eq alt2.ref then 0
+        else if alt1.level != alt2.level then alt1.level - alt2.level
+        else explore(compare(alt1.ref, alt2.ref))(using nestedContext())
+
+      /** If `alt1` is also a search success, try to disambiguate as follows:
+       *    - If alt2 is preferred over alt1, pick alt2, otherwise return an
+       *      ambiguous implicits error.
+       */
+      def disambiguate(alt1: SearchResult, alt2: SearchSuccess) = alt1 match
+        case alt1: SearchSuccess =>
+          var diff = compareAlternatives(alt1, alt2)
+          assert(diff <= 0)   // diff > 0 candidates should already have been eliminated in `rank`
+          if diff == 0 && alt1.isExtension && alt2.isExtension then
+            // Fall back: if both results are extension method applications,
+            // compare the extension methods instead of their wrappers.
+            def stripExtension(alt: SearchSuccess) = methPart(stripApply(alt.tree)).tpe
+            (stripExtension(alt1), stripExtension(alt2)) match
+              case (ref1: TermRef, ref2: TermRef) =>
+                // ref1 and ref2 might refer to type variables owned by
+                // alt1.tstate and alt2.tstate respectively, to compare the
+                // alternatives correctly we need a TyperState that includes
+                // constraints from both sides, see
+                // tests/*/extension-specificity2.scala for test cases.
+                val constraintsIn1 = alt1.tstate.constraint ne ctx.typerState.constraint
+                val constraintsIn2 = alt2.tstate.constraint ne ctx.typerState.constraint
+                def exploreState(alt: SearchSuccess): TyperState =
+                  alt.tstate.fresh(committable = false)
+                val comparisonState =
+                  if constraintsIn1 && constraintsIn2 then
+                    exploreState(alt1).mergeConstraintWith(alt2.tstate)
+                  else if constraintsIn1 then
+                    exploreState(alt1)
+                  else if constraintsIn2 then
+                    exploreState(alt2)
+                  else
+                    ctx.typerState
+
+                diff = inContext(ctx.withTyperState(comparisonState)) {
+                  compare(ref1, ref2)
+                }
+              case _ =>
+          if diff < 0 then alt2
+          else if diff > 0 then alt1
+          else SearchFailure(new AmbiguousImplicits(alt1, alt2, pt, argument), span)
+        case _: SearchFailure => alt2
+
+      /** Try to find a best matching implicit term among all the candidates in `pending`.
+       *  @param pending   The list of candidates that remain to be tested
+       *  @param found     The result obtained from previously tried candidates
+       *  @param rfailures A list of all failures from previously tried candidates in reverse order
+       *
+       *  The scheme is to try candidates one-by-one. If a trial is successful:
+       *   - if the query term is a `Not[T]` treat it a failure,
+       *   - otherwise, if a previous search was also successful, handle the ambiguity
+       *     in `disambiguate`,
+       *   - otherwise, continue the search with all candidates that are not strictly
+       *     worse than the successful candidate.
+       *  If a trial failed:
+       *    - if the query term is a `Not[T]` treat it as a success,
+       *    - otherwise, if the failure is an ambiguity, try to heal it (see `healAmbiguous`)
+       *      and return an ambiguous error otherwise. However, under Scala2 mode this is
+       *      treated as a simple failure, with a warning that semantics will change.
+       *    - otherwise add the failure to `rfailures` and continue testing the other candidates.
+       */
+      def rank(pending: List[Candidate], found: SearchResult, rfailures: List[SearchFailure]): SearchResult =
+        pending match {
+          case cand :: remaining =>
+            /** To recover from an ambiguous implicit failure, we need to find a pending
+             *  candidate that is strictly better than the failed candidate(s).
+             *  If no such candidate is found, we propagate the ambiguity.
+             */
+            def healAmbiguous(fail: SearchFailure, betterThanFailed: Candidate => Boolean) =
+              val newPending = remaining.filter(betterThanFailed)
+              rank(newPending, fail, Nil).recoverWith(_ => fail)
+
+            negateIfNot(tryImplicit(cand, contextual)) match {
+              case fail: SearchFailure =>
+                if fail eq ImplicitSearchTooLargeFailure then
+                  fail
+                else if (fail.isAmbiguous)
+                  if migrateTo3 then
+                    val result = rank(remaining, found, NoMatchingImplicitsFailure :: rfailures)
+                    if (result.isSuccess)
+                      warnAmbiguousNegation(fail.reason.asInstanceOf[AmbiguousImplicits])
+                    result
+                  else
+                    // The ambiguity happened in a nested search: to recover we
+                    // need a candidate better than `cand`
+                    healAmbiguous(fail, newCand =>
+                      compareAlternatives(newCand, cand) > 0)
+                else rank(remaining, found, fail :: rfailures)
+              case best: SearchSuccess =>
+                if (ctx.mode.is(Mode.ImplicitExploration) || isCoherent)
+                  best
+                else disambiguate(found, best) match {
+                  case retained: SearchSuccess =>
+                    val newPending =
+                      if (retained eq found) || remaining.isEmpty then remaining
+                      else remaining.filterConserve(cand =>
+                        compareAlternatives(retained, cand) <= 0)
+                    rank(newPending, retained, rfailures)
+                  case fail: SearchFailure =>
+                    // The ambiguity happened in the current search: to recover we
+                    // need a candidate better than the two ambiguous alternatives.
+                    val ambi = fail.reason.asInstanceOf[AmbiguousImplicits]
+                    healAmbiguous(fail, newCand =>
+                      compareAlternatives(newCand, ambi.alt1) > 0 &&
+                      compareAlternatives(newCand, ambi.alt2) > 0)
+                }
+            }
+          case nil =>
+            if (rfailures.isEmpty) found
+            else found.recoverWith(_ => rfailures.reverse.maxBy(_.tree.treeSize))
+        }
+
+      def negateIfNot(result: SearchResult) =
+        if (isNotGiven)
+          result match {
+            case _: SearchFailure =>
+              SearchSuccess(ref(defn.NotGiven_value), defn.NotGiven_value.termRef, 0)(
+                ctx.typerState.fresh().setCommittable(true),
+                ctx.gadt
+              )
+            case _: SearchSuccess =>
+              NoMatchingImplicitsFailure
+          }
+        else result
+
+      def warnAmbiguousNegation(ambi: AmbiguousImplicits) =
+        report.migrationWarning(
+          i"""Ambiguous implicits ${ambi.alt1.ref.symbol.showLocated} and ${ambi.alt2.ref.symbol.showLocated}
+             |seem to be used to implement a local failure in order to negate an implicit search.
+             |According to the new implicit resolution rules this is no longer possible;
+             |the search will fail with a global ambiguity error instead.
+             |
+             |Consider using the scala.util.NotGiven class to implement similar functionality.""",
+             srcPos)
+
+      /** Compare the length of the baseClasses of two symbols (except for objects,
+       *  where we use the length of the companion class instead if it's bigger).
+       *
+       *  This relation is meant to approximate `Applications#compareOwner` while also
+       *  inducing a total ordering: `compareOwner` returns `0` for unrelated symbols
+       *  and therefore only induces a partial ordering, meaning it cannot be used
+       *  as a sorting function (see `java.util.Comparator#compare`).
+       */
+      def compareBaseClassesLength(sym1: Symbol, sym2: Symbol): Int =
+        def len(sym: Symbol) =
+          if sym.is(ModuleClass) && sym.companionClass.exists then
+            Math.max(sym.asClass.baseClassesLength, sym.companionClass.asClass.baseClassesLength)
+          else if sym.isClass then
+            sym.asClass.baseClassesLength
+          else
+            0
+        len(sym1) - len(sym2)
+
+      /** A relation that influences the order in which eligible implicits are tried.
+       *
+       *  We prefer (in order of importance)
+       *   1. more deeply nested definitions
+       *   2. definitions with fewer implicit parameters
+       *   3. definitions whose owner has more parents (see `compareBaseClassesLength`)
+       *  The reason for (2) is that we want to fail fast if the search type
+       *  is underconstrained. So we look for "small" goals first, because that
+       *  will give an ambiguity quickly.
+       */
+      def compareEligibles(e1: Candidate, e2: Candidate): Int =
+        if e1 eq e2 then return 0
+        val cmpLevel = e1.level - e2.level
+        if cmpLevel != 0 then return -cmpLevel // 1.
+        val sym1 = e1.ref.symbol
+        val sym2 = e2.ref.symbol
+        val arity1 = sym1.info.firstParamTypes.length
+        val arity2 = sym2.info.firstParamTypes.length
+        val cmpArity = arity1 - arity2
+        if cmpArity != 0 then return cmpArity // 2.
+        val cmpBcs = compareBaseClassesLength(sym1.owner, sym2.owner)
+        -cmpBcs // 3.
+
+      /** Check if `ord` respects the contract of `Ordering`.
+       *
+       *  More precisely, we check that its `compare` method respects the invariants listed
+       *  in https://docs.oracle.com/javase/8/docs/api/java/util/Comparator.html#compare-T-T-
+       */
+      def validateOrdering(ord: Ordering[Candidate]): Unit =
+        for
+          x <- eligible
+          y <- eligible
+          cmpXY = Integer.signum(ord.compare(x, y))
+          cmpYX = Integer.signum(ord.compare(y, x))
+          z <- eligible
+          cmpXZ = Integer.signum(ord.compare(x, z))
+          cmpYZ = Integer.signum(ord.compare(y, z))
+        do
+          def reportViolation(msg: String): Unit =
+            Console.err.println(s"Internal error: comparison function violated ${msg.stripMargin}")
+          def showCandidate(c: Candidate): String =
+            s"$c (${c.ref.symbol.showLocated})"
+
+          if cmpXY != -cmpYX then
+            reportViolation(
+              s"""signum(cmp(x, y)) == -signum(cmp(y, x)) given:
+                 |x = ${showCandidate(x)}
+                 |y = ${showCandidate(y)}
+                 |cmpXY = $cmpXY
+                 |cmpYX = $cmpYX""")
+          if cmpXY != 0 && cmpXY == cmpYZ && cmpXZ != cmpXY then
+            reportViolation(
+              s"""transitivity given:
+                 |x = ${showCandidate(x)}
+                 |y = ${showCandidate(y)}
+                 |z = ${showCandidate(z)}
+                 |cmpXY = $cmpXY
+                 |cmpXZ = $cmpXZ
+                 |cmpYZ = $cmpYZ""")
+          if cmpXY == 0 && cmpXZ != cmpYZ then
+            reportViolation(
+              s"""cmp(x, y) == 0 implies that signum(cmp(x, z)) == signum(cmp(y, z)) given:
+                 |x = ${showCandidate(x)}
+                 |y = ${showCandidate(y)}
+                 |z = ${showCandidate(z)}
+                 |cmpXY = $cmpXY
+                 |cmpXZ = $cmpXZ
+                 |cmpYZ = $cmpYZ""")
+      end validateOrdering
+
+      /** Sort list of implicit references according to `compareEligibles`.
+       *  This is just an optimization that aims at reducing the average
+       *  number of candidates to be tested.
+       */
+      def sort(eligible: List[Candidate]) = eligible match
+        case Nil => eligible
+        case e1 :: Nil => eligible
+        case e1 :: e2 :: Nil =>
+          if compareEligibles(e2, e1) < 0 then e2 :: e1 :: Nil
+          else eligible
+        case _ =>
+          val ord: Ordering[Candidate] = (a, b) => compareEligibles(a, b)
+          try eligible.sorted(using ord)
+          catch case ex: IllegalArgumentException =>
+            // This exception being thrown probably means that our comparison
+            // function is broken, check if that's the case
+            validateOrdering(ord)
+            throw ex
+
+      rank(sort(eligible), NoMatchingImplicitsFailure, Nil)
+    end searchImplicit
+
+    def isUnderSpecifiedArgument(tp: Type): Boolean =
+      tp.isRef(defn.NothingClass) || tp.isRef(defn.NullClass) || (tp eq NoPrefix)
+
+    private def isUnderspecified(tp: Type): Boolean = tp.stripTypeVar match
+      case tp: WildcardType =>
+        !tp.optBounds.exists || isUnderspecified(tp.optBounds.hiBound)
+      case tp: ViewProto =>
+        isUnderspecified(tp.resType)
+        || tp.resType.isRef(defn.UnitClass)
+        || isUnderSpecifiedArgument(tp.argType.widen)
+      case _ =>
+        tp.isAny || tp.isAnyRef
+
+    private def searchImplicit(contextual: Boolean): SearchResult =
+      if isUnderspecified(wildProto) then
+        SearchFailure(TooUnspecific(pt), span)
+      else
+        val eligible =
+          if contextual then
+            if ctx.gadt.isNarrowing then
+              withoutMode(Mode.ImplicitsEnabled) {
+                ctx.implicits.uncachedEligible(wildProto)
+              }
+            else ctx.implicits.eligible(wildProto)
+          else implicitScope(wildProto).eligible
+        searchImplicit(eligible, contextual) match
+          case result: SearchSuccess =>
+            result
+          case failure: SearchFailure =>
+            failure.reason match
+              case _: AmbiguousImplicits => failure
+              case reason =>
+                if contextual then
+                  searchImplicit(contextual = false).recoverWith {
+                    failure2 => failure2.reason match
+                      case _: AmbiguousImplicits => failure2
+                      case _ =>
+                        reason match
+                          case (_: DivergingImplicit) => failure
+                          case _ => List(failure, failure2).maxBy(_.tree.treeSize)
+                  }
+                else failure
+    end searchImplicit
+
+    /** Find a unique best implicit reference */
+    def bestImplicit: SearchResult =
+      // Before searching for contextual or implicit scope candidates we first check if
+      // there is an under construction or already constructed term with which we can tie
+      // the knot.
+      //
+      // Since any suitable term found is defined as part of this search it will always be
+      // effectively in a more inner context than any other definition provided by
+      // explicit definitions. Consequently these terms have the highest priority and no
+      // other candidates need to be considered.
+      recursiveRef match
+        case ref: TermRef =>
+          SearchSuccess(tpd.ref(ref).withSpan(span.startPos), ref, 0)(ctx.typerState, ctx.gadt)
+        case _ =>
+          searchImplicit(contextual = true)
+    end bestImplicit
+
+    def implicitScope(tp: Type): OfTypeImplicits = ctx.run.nn.implicitScope(tp)
+
+    /** All available implicits, without ranking */
+    def allImplicits: Set[SearchSuccess] = {
+      val contextuals = ctx.implicits.eligible(wildProto).map(tryImplicit(_, contextual = true))
+      val inscope = implicitScope(wildProto).eligible.map(tryImplicit(_, contextual = false))
+      (contextuals.toSet ++ inscope).collect {
+        case success: SearchSuccess => success
+      }
+    }
+
+    /** Fields needed for divergence checking */
+    @threadUnsafe lazy val ptCoveringSet = wideProto.coveringSet
+    @threadUnsafe lazy val ptSize = wideProto.typeSize
+    @threadUnsafe lazy val wildPt = wildApprox(wideProto)
+
+    /**
+    * Check if the supplied candidate implicit and target type indicate a diverging
+    * implicit search.
+    *
+    * @param cand The candidate implicit to be explored.
+    * @param pt   The target type for the above candidate.
+    * @result     True if this candidate/pt are divergent, false otherwise.
+    */
+    def checkDivergence(cand: Candidate): Boolean =
+      // For full details of the algorithm see the SIP:
+      //   https://docs.scala-lang.org/sips/byname-implicits.html
+      Stats.record("checkDivergence")
+
+      // Unless we are able to tie a recursive knot, we report divergence if there is an
+      // open implicit using the same candidate implicit definition which has a type which
+      // is larger (see `typeSize`) and is constructed using the same set of types and type
+      // constructors (see `coveringSet`).
+      //
+      // We are able to tie a recursive knot if there is compatible term already under
+      // construction which is separated from this context by at least one by name argument
+      // as we ascend the chain of open implicits to the outermost search context.
+
+      @tailrec
+      def loop(history: SearchHistory, belowByname: Boolean): Boolean =
+        history match
+          case prev @ OpenSearch(cand1, tp, outer) =>
+            if cand1.ref eq cand.ref then
+              lazy val wildTp = wildApprox(tp.widenExpr)
+              if belowByname && (wildTp <:< wildPt) then
+                fullyDefinedType(tp, "by-name implicit parameter", srcPos)
+                false
+              else if prev.typeSize > ptSize || prev.coveringSet != ptCoveringSet then
+                loop(outer, tp.isByName || belowByname)
+              else
+                prev.typeSize < ptSize
+                || wildTp =:= wildPt
+                || loop(outer, tp.isByName || belowByname)
+            else loop(outer, tp.isByName || belowByname)
+          case _ => false
+
+      loop(ctx.searchHistory, pt.isByName)
+    end checkDivergence
+
+    /**
+     * Return the reference, if any, to a term under construction or already constructed in
+     * the current search history corresponding to the supplied target type.
+     *
+     * A term is eligible if its type is a subtype of the target type and either it has
+     * already been constructed and is present in the current implicit dictionary, or it is
+     * currently under construction and is separated from the current search context by at
+     * least one by name argument position.
+     *
+     * Note that because any suitable term found is defined as part of this search it will
+     * always be effectively in a more inner context than any other definition provided by
+     * explicit definitions. Consequently these terms have the highest priority and no other
+     * candidates need to be considered.
+     *
+     * @param pt  The target type being searched for.
+     * @result    The corresponding dictionary reference if any, NoType otherwise.
+     */
+    def recursiveRef: Type =
+      val found = ctx.searchHistory.refBynameImplicit(wideProto)
+      if found.exists then
+        found
+      else if !ctx.searchHistory.byname && !pt.isByName then
+        NoType // No recursion unless at least one open implicit is by name ...
+      else
+        // We are able to tie a recursive knot if there is compatible term already under
+        // construction which is separated from this context by at least one by name
+        // argument as we ascend the chain of open implicits to the outermost search
+        // context.
+        @tailrec
+        def loop(history: SearchHistory, belowByname: Boolean): Type =
+          history match
+            case OpenSearch(cand, tp, outer) =>
+              if (belowByname || tp.isByName) && tp.widenExpr <:< wideProto then tp
+              else loop(outer, belowByname || tp.isByName)
+            case _ => NoType
+
+        loop(ctx.searchHistory, pt.isByName) match
+          case NoType => NoType
+          case tp => ctx.searchHistory.linkBynameImplicit(tp.widenExpr)
+    end recursiveRef
+  end ImplicitSearch
+end Implicits
+
+/**
+ * Records the history of currently open implicit searches.
+ *
+ * A search history maintains a list of open implicit searches (`openSearchPairs`) a shortcut flag
+ * indicating whether any of these are by name (`byname`) and a reference to the root
+ * search history (`root`) which in turn maintains a possibly empty dictionary of
+ * recursive implicit terms constructed during this search.
+ *
+ * A search history provides operations to create a nested search history, check for
+ * divergence, enter by name references and definitions in the implicit dictionary, lookup
+ * recursive references and emit a complete implicit dictionary when the outermost search
+ * is complete.
+ */
+abstract class SearchHistory extends caps.Pure:
+  val root: SearchRoot
+  /** Does this search history contain any by name implicit arguments. */
+  val byname: Boolean
+  def openSearchPairs: List[(Candidate, Type)]
+
+  /**
+   * Create the state for a nested implicit search.
+   * @param cand The candidate implicit to be explored.
+   * @param pt   The target type for the above candidate.
+   * @result     The nested history.
+   */
+  def nest(cand: Candidate, pt: Type)(using Context): OpenSearch = OpenSearch(cand, pt, this)
+
+  // The following are delegated to the root of this search history.
+  def linkBynameImplicit(tpe: Type)(using Context): TermRef =
+    root.linkBynameImplicit(tpe)
+  def refBynameImplicit(tpe: Type)(using Context): Type =
+    root.refBynameImplicit(tpe)
+  def defineBynameImplicit(tpe: Type, result: SearchSuccess)(using Context): SearchResult =
+    root.defineBynameImplicit(tpe, result)
+
+  // This is NOOP unless at the root of this search history.
+  def emitDictionary(span: Span, result: SearchResult)(using Context): SearchResult = result
+
+  override def toString: String = s"SearchHistory(open = $openSearchPairs, byname = $byname)"
+end SearchHistory
+
+case class OpenSearch(cand: Candidate, pt: Type, outer: SearchHistory)(using Context) extends SearchHistory:
+  val root = outer.root
+  val byname = outer.byname || pt.isByName
+  def openSearchPairs = (cand, pt) :: outer.openSearchPairs
+
+  // The typeSize and coveringSet of the current search.
+  // Note: It is important to cache size and covering sets since types
+  // in search histories can contain type variables that can be instantiated
+  // by nested implicit searches, thus leading to types in search histories
+  // that grow larger the deeper the search gets. This can mask divergence.
+  // An example is in neg/9504.scala
+  lazy val typeSize = pt.typeSize
+  lazy val coveringSet = pt.coveringSet
+end OpenSearch
+
+/**
+ * The state corresponding to the outermost context of an implicit searcch.
+ */
+final class SearchRoot extends SearchHistory:
+  val root = this
+  val byname = false
+  def openSearchPairs = Nil
+
+  /** How many expressions were constructed so far in the current toplevel implicit search?
+   */
+  var nestedSearches: Int = 0
+
+  /** The dictionary of recursive implicit types and corresponding terms for this search. */
+  var myImplicitDictionary: mutable.Map[Type, (TermRef, tpd.Tree)] | Null = null
+  private def implicitDictionary =
+    if myImplicitDictionary == null then
+      myImplicitDictionary = mutable.Map.empty[Type, (TermRef, tpd.Tree)]
+    myImplicitDictionary.uncheckedNN
+
+  /**
+   * Link a reference to an under-construction implicit for the provided type to its
+   * defining occurrence via the implicit dictionary, creating a dictionary entry for this
+   * type if one does not yet exist.
+   *
+   * @param tpe  The type to link.
+   * @result     The TermRef of the corresponding dictionary entry.
+   */
+  override def linkBynameImplicit(tpe: Type)(using Context): TermRef =
+    implicitDictionary.get(tpe) match {
+      case Some((ref, _)) => ref
+      case None =>
+        val lazyImplicit = newLazyImplicit(tpe)
+        val ref = lazyImplicit.termRef
+        implicitDictionary.put(tpe, (ref, tpd.EmptyTree))
+        ref
+    }
+
+  /**
+   * Look up an implicit dictionary entry by type.
+   *
+   * If present yield the TermRef corresponding to the eventual dictionary entry,
+   * otherwise NoType.
+   *
+   * @param tpe The type to look up.
+   * @result    The corresponding TermRef, or NoType if none.
+   */
+  override def refBynameImplicit(tpe: Type)(using Context): Type =
+    implicitDictionary.get(tpe) match
+      case Some((tp, _)) => tp
+      case None => NoType
+
+  /**
+   * Define a pending dictionary entry if any.
+   *
+   * If the provided type corresponds to an under-construction by name implicit, then use
+   * the tree contained in the provided SearchSuccess as its definition, returning an
+   * updated result referring to dictionary entry. Otherwise return the SearchSuccess
+   * unchanged.
+   *
+   * @param  tpe    The type for which the entry is to be defined
+   * @param  result The SearchSuccess corresponding to tpe
+   * @result        A SearchResult referring to the newly created dictionary entry if tpe
+   *                is an under-construction by name implicit, the provided result otherwise.
+   */
+  override def defineBynameImplicit(tpe: Type, result: SearchSuccess)(using Context): SearchResult =
+    implicitDictionary.get(tpe) match {
+      case Some((ref, _)) =>
+        implicitDictionary.put(tpe, (ref, result.tree))
+        SearchSuccess(tpd.ref(ref).withSpan(result.tree.span), result.ref, result.level)(result.tstate, result.gstate)
+      case None => result
+    }
+
+  /**
+   * Emit the implicit dictionary at the completion of an implicit search.
+   *
+   * @param span   The position at which the search is elaborated.
+   * @param result The result of the search prior to substitution of recursive references.
+   * @result       The elaborated result, comprising the implicit dictionary and a result tree
+   *               substituted with references into the dictionary.
+   */
+  override def emitDictionary(span: Span, result: SearchResult)(using Context): SearchResult =
+    if (myImplicitDictionary == null || implicitDictionary.isEmpty) result
+    else
+      result match {
+        case failure: SearchFailure => failure
+        case success: SearchSuccess =>
+          import tpd._
+
+          // We might have accumulated dictionary entries for by name implicit arguments
+          // which are not in fact used recursively either directly in the outermost result
+          // term, or indirectly via other dictionary entries. We prune these out, recursively
+          // eliminating entries until all remaining entries are at least transtively referred
+          // to in the outermost result term.
+          @tailrec
+          def prune(trees: List[Tree], pending: List[(TermRef, Tree)], acc: List[(TermRef, Tree)]): List[(TermRef, Tree)] = pending match {
+            case Nil => acc
+            case ps =>
+              val (in, out) = ps.partition {
+                case (vref, rhs) =>
+                  trees.exists(_.existsSubTree {
+                    case id: Ident => id.symbol == vref.symbol
+                    case _ => false
+                  })
+              }
+              if (in.isEmpty) acc
+              else prune(in.map(_._2) ++ trees, out, in ++ acc)
+          }
+
+          val pruned = prune(List(success.tree), implicitDictionary.map(_._2).toList, Nil)
+          myImplicitDictionary = null
+          if (pruned.isEmpty) result
+          else if (pruned.exists(_._2 == EmptyTree)) NoMatchingImplicitsFailure
+          else {
+            // If there are any dictionary entries remaining after pruning, construct a dictionary
+            // class of the form,
+            //
+            // class <dictionary> {
+            //   val $_lazy_implicit_$0 = ...
+            //   ...
+            //   val $_lazy_implicit_$n = ...
+            // }
+            //
+            // Where the RHSs of the $_lazy_implicit_$n are the terms used to populate the dictionary
+            // via defineByNameImplicit.
+            //
+            // The returned search result is then of the form,
+            //
+            // {
+            //   class <dictionary> { ... }
+            //   val $_lazy_implicit_$nn = new <dictionary>
+            //   result.tree // with dictionary references substituted in
+            // }
+
+            val parents = List(defn.ObjectType, defn.SerializableType)
+            val classSym = newNormalizedClassSymbol(ctx.owner, LazyImplicitName.fresh().toTypeName, Synthetic | Final, parents, coord = span)
+            val vsyms = pruned.map(_._1.symbol)
+            val nsyms = vsyms.map(vsym => newSymbol(classSym, vsym.name, EmptyFlags, vsym.info, coord = span).entered)
+            val vsymMap = (vsyms zip nsyms).toMap
+
+            val rhss = pruned.map(_._2)
+            // Substitute dictionary references into dictionary entry RHSs
+            val rhsMap = new TreeTypeMap(treeMap = {
+              case id: Ident if vsymMap.contains(id.symbol) =>
+                tpd.ref(vsymMap(id.symbol))(using ctx.withSource(id.source)).withSpan(id.span)
+              case tree => tree
+            })
+            val nrhss = rhss.map(rhsMap(_))
+
+            val vdefs = (nsyms zip nrhss) map {
+              case (nsym, nrhs) => ValDef(nsym.asTerm, nrhs.changeNonLocalOwners(nsym))
+            }
+
+            val constr = newConstructor(classSym, Synthetic, Nil, Nil).entered
+            val classDef = ClassDef(classSym, DefDef(constr), vdefs)
+
+            val valSym = newLazyImplicit(classSym.typeRef, span)
+            val inst = ValDef(valSym, New(classSym.typeRef, Nil))
+
+            // Substitute dictionary references into outermost result term.
+            val resMap = new TreeTypeMap(treeMap = {
+              case id: Ident if vsymMap.contains(id.symbol) =>
+                Select(tpd.ref(valSym), id.name)
+              case tree => tree
+            })
+
+            val res = resMap(success.tree)
+
+            val blk = Block(classDef :: inst :: Nil, res).withSpan(span)
+
+            success.copy(tree = blk)(success.tstate, success.gstate)
+          }
+      }
+end SearchRoot
+
+/** A set of term references where equality is =:= */
+sealed class TermRefSet(using Context):
+  private val elems = new java.util.LinkedHashMap[TermSymbol, Type | List[Type]]
+
+  def isEmpty = elems.size == 0
+
+  def += (ref: TermRef): Unit =
+    val pre = ref.prefix
+    if ref.symbol.exists then
+      val sym = ref.symbol.asTerm
+      elems.get(sym) match
+        case null =>
+          elems.put(sym, pre)
+        case prefix: Type =>
+          if !(prefix =:= pre) then elems.put(sym, pre :: prefix :: Nil)
+        case prefixes: List[Type] =>
+          if !prefixes.exists(_ =:= pre) then elems.put(sym, pre :: prefixes)
+
+  def ++= (that: TermRefSet): Unit =
+    if !that.isEmpty then that.foreach(+=)
+
+  def foreach[U](f: TermRef => U): Unit =
+    def handle(sym: TermSymbol | Null, prefixes: Type | List[Type] | Null): Unit =
+      // We cannot use `.nn` here due to inference issue.
+      val prefixes0: Type | List[Type] = prefixes.uncheckedNN
+      prefixes0 match
+        case prefix: Type => f(TermRef(prefix, sym.uncheckedNN))
+        case prefixes: List[Type] => prefixes.foreach(pre => f(TermRef(pre, sym.uncheckedNN)))
+    elems.forEach(handle.asInstanceOf)
+      // !cc! cast is needed to circumvent problematic interaction of box and Java wildcards
+
+  // used only for debugging
+  def showAsList: List[TermRef] = {
+    val buffer = new mutable.ListBuffer[TermRef]
+    foreach(tr => buffer += tr)
+    buffer.toList
+  }
+
+  override def toString = showAsList.toString
+
+object TermRefSet:
+
+  @sharable val empty = new TermRefSet(using NoContext):
+    override def += (ref: TermRef): Unit = throw UnsupportedOperationException("+=")
+
+end TermRefSet
diff --git a/tests/pos-with-compiler-cc/dotc/typer/ImportInfo.scala b/tests/pos-with-compiler-cc/dotc/typer/ImportInfo.scala
new file mode 100644
index 000000000000..3cc88fa323b9
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/typer/ImportInfo.scala
@@ -0,0 +1,229 @@
+package dotty.tools
+package dotc
+package typer
+
+import ast.{tpd, untpd}
+import core._
+import printing.{Printer, Showable}
+import util.SimpleIdentityMap
+import Symbols._, Names._, Types._, Contexts._, StdNames._, Flags._
+import Implicits.RenamedImplicitRef
+import StdNames.nme
+import printing.Texts.Text
+import NameKinds.QualifiedName
+import language.experimental.pureFunctions
+
+object ImportInfo {
+
+  case class RootRef(refFn: () => TermRef, isPredef: Boolean = false)
+
+  /** The import info for a root import */
+  def rootImport(ref: RootRef)(using Context): ImportInfo =
+    var selectors =
+      untpd.ImportSelector(untpd.Ident(nme.WILDCARD))  // import all normal members...
+      :: untpd.ImportSelector(untpd.Ident(nme.EMPTY))  // ... and also all given members
+      :: Nil
+    if ref.isPredef then                               // do not import any2stringadd
+      selectors = untpd.ImportSelector(untpd.Ident(nme.any2stringadd), untpd.Ident(nme.WILDCARD))
+        :: selectors
+
+    def sym(using Context) =
+      val expr = tpd.Ident(ref.refFn()) // refFn must be called in the context of ImportInfo.sym
+      tpd.Import(expr, selectors).symbol
+
+    ImportInfo(sym, selectors, untpd.EmptyTree, isRootImport = true)
+
+  extension (c: Context)
+    def withRootImports(rootRefs: List[RootRef])(using Context): Context =
+      rootRefs.foldLeft(c)((ctx, ref) => ctx.fresh.setImportInfo(rootImport(ref)))
+
+    def withRootImports: Context =
+      given Context = c
+      c.withRootImports(defn.rootImportFns)
+}
+
+/** Info relating to an import clause
+ *  @param   symf          A function that computes the import symbol defined by the clause
+ *  @param   selectors     The selector clauses
+ *  @param   qualifier     The import qualifier, or EmptyTree for root imports.
+ *                         Defined for all explicit imports from ident or select nodes.
+ *  @param   isRootImport  true if this is one of the implicit imports of scala, java.lang,
+ *                         scala.Predef in the start context, false otherwise.
+ */
+class ImportInfo(symf: Context ?-> Symbol,
+                 val selectors: List[untpd.ImportSelector],
+                 val qualifier: untpd.Tree,
+                 val isRootImport: Boolean = false) extends Showable, caps.Pure {
+
+  private def symNameOpt = qualifier match {
+    case ref: untpd.RefTree => Some(ref.name.asTermName)
+    case _                  => None
+  }
+
+  def importSym(using Context): Symbol = {
+    if (mySym == null) {
+      mySym = symf
+      assert(mySym != null)
+    }
+    mySym.uncheckedNN
+  }
+  private var mySym: Symbol | Null = _
+
+  /** The (TermRef) type of the qualifier of the import clause */
+  def site(using Context): Type = importSym.info match {
+    case ImportType(expr) => expr.tpe
+    case _ => NoType
+  }
+
+  /** The names that are excluded from any wildcard import */
+  def excluded: Set[TermName] = { ensureInitialized(); myExcluded.nn }
+
+  /** A mapping from original to renamed names */
+  def forwardMapping: SimpleIdentityMap[TermName, TermName] = { ensureInitialized(); myForwardMapping.nn }
+
+  /** A mapping from renamed to original names */
+  def reverseMapping: SimpleIdentityMap[TermName, TermName] = { ensureInitialized(); myReverseMapping.nn }
+
+  /** Does the import clause contain wildcard selectors (both `_` and `given` count)? */
+  def isWildcardImport: Boolean = { ensureInitialized(); myWildcardImport }
+
+  /** Does the import clause have at least one `given` selector? */
+  def isGivenImport: Boolean = { ensureInitialized(); myGivenImport }
+
+  private var myExcluded: Set[TermName] | Null = null
+  private var myForwardMapping: SimpleIdentityMap[TermName, TermName] | Null = null
+  private var myReverseMapping: SimpleIdentityMap[TermName, TermName] | Null = null
+  private var myWildcardImport: Boolean = false
+  private var myGivenImport: Boolean = false
+  private var myWildcardBound: Type = NoType
+  private var myGivenBound: Type = NoType
+
+  /** Compute info relating to the selector list */
+  private def ensureInitialized(): Unit = if myExcluded == null then
+    myExcluded = Set()
+    myForwardMapping = SimpleIdentityMap.empty
+    myReverseMapping = SimpleIdentityMap.empty
+    for sel <- selectors do
+      if sel.isWildcard then
+        myWildcardImport = true
+        if sel.isGiven then myGivenImport = true
+      else
+        if sel.rename != sel.name then
+          myExcluded = myExcluded.nn + sel.name
+        if sel.rename != nme.WILDCARD then
+          myForwardMapping = myForwardMapping.uncheckedNN.updated(sel.name, sel.rename)
+          myReverseMapping = myReverseMapping.uncheckedNN.updated(sel.rename, sel.name)
+
+  /** The upper bound for `given` wildcards, or `Nothing` if there are none */
+  def givenBound(using Context) =
+    if !myGivenBound.exists then
+      myGivenBound = ctx.typer.importBound(selectors, isGiven = true)
+    myGivenBound
+
+  /** The upper bound for `_` wildcards, or `Nothing` if there are none */
+  def wildcardBound(using Context) =
+    if !myWildcardBound.exists then
+      myWildcardBound = ctx.typer.importBound(selectors, isGiven = false)
+    myWildcardBound
+
+  /** The implicit references imported by this import clause */
+  def importedImplicits(using Context): List[ImplicitRef] =
+    val pre = site
+    if isWildcardImport then
+      pre.implicitMembers.flatMap { ref =>
+        val name = ref.name.toTermName
+        if excluded.contains(name) then Nil
+        else
+          val renamed = forwardMapping(ref.name)
+          if renamed == null then // not explicitly named
+            val isEligible =
+              isGivenImport                             // a given import pulls in implicits and givens
+              || ctx.mode.is(Mode.FindHiddenImplicits)  // consider both implicits and givens for error reporting
+              || ref.symbol.is(Implicit)                // a wildcard `_` import only pulls in implicits
+            val bound = if isGivenImport then givenBound else wildcardBound
+            if isEligible && ref.denot.asSingleDenotation.matchesImportBound(bound) then ref :: Nil
+            else Nil
+          else if renamed == ref.name then ref :: Nil
+          else RenamedImplicitRef(ref, renamed) :: Nil
+      }
+    else
+      for
+        renamed <- reverseMapping.keys
+        denot <- pre.member(reverseMapping(renamed).nn).altsWith(_.isOneOf(GivenOrImplicitVal))
+      yield
+        val original = reverseMapping(renamed).nn
+        val ref = TermRef(pre, original, denot)
+        if renamed == original then ref
+        else RenamedImplicitRef(ref, renamed)
+
+  /** The root import symbol hidden by this symbol, or NoSymbol if no such symbol is hidden.
+   *  Note: this computation needs to work even for un-initialized import infos, and
+   *  is not allowed to force initialization.
+   *
+   *  TODO: Once we have fully bootstrapped, I would prefer if we expressed
+   *  unimport with an `override` modifier, and generalized it to all imports.
+   *  I believe this would be more transparent than the current set of conditions. E.g.
+   *
+   *      override import Predef.{any2stringAdd => _, StringAdd => _, _} // disables String +
+   *      override import java.lang.{}                                   // disables all imports
+   */
+  def unimported(using Context): Symbol =
+    if myUnimported == null then
+      lazy val sym = site.termSymbol
+      def maybeShadowsRoot = symNameOpt match
+        case Some(symName) => defn.ShadowableImportNames.contains(symName)
+        case None => false
+      myUnimported =
+        if maybeShadowsRoot && defn.rootImportTypes.exists(_.symbol == sym) then sym
+        else NoSymbol
+      assert(myUnimported != null)
+    myUnimported.uncheckedNN
+
+  private val isLanguageImport: Boolean = untpd.languageImport(qualifier).isDefined
+
+  private var myUnimported: Symbol | Null = _
+
+  private var featureCache: SimpleIdentityMap[TermName, java.lang.Boolean] = SimpleIdentityMap.empty
+
+  /** Does this import clause enable or disable `feature`?
+   *  @param  feature   See featureImported for a description
+   *  @return Some(true)  if `feature` is imported
+   *          Some(false) if `feature` is excluded
+   *          None        if `feature` is not mentioned, or this is not a language import
+   */
+  def mentionsFeature(feature: TermName)(using Context): Option[Boolean] =
+    def test(prefix: TermName, feature: TermName): Option[Boolean] =
+      untpd.languageImport(qualifier) match
+        case Some(`prefix`) =>
+          if forwardMapping.contains(feature) then Some(true)
+          else if excluded.contains(feature) then Some(false)
+          else None
+        case _ => None
+    feature match
+      case QualifiedName(prefix, name) => test(prefix, name)
+      case _ => test(EmptyTermName, feature)
+
+  /** Does this import clause or a preceding import clause enable `feature`?
+   *
+   *  @param  feature  a possibly quailified name, e.g.
+   *                      strictEquality
+   *                      experimental.genericNumberLiterals
+   *
+   *  An excluded feature such as `strictEquality => _` in a language import
+   *  means that preceding imports are not considered and the feature is not imported.
+   */
+  def featureImported(feature: TermName)(using Context): Boolean =
+    if !featureCache.contains(feature) then
+      featureCache = featureCache.updated(feature,
+        mentionsFeature(feature) match
+          case Some(bv) => bv
+          case None =>
+            var c = ctx.outer
+            while c.importInfo eqn ctx.importInfo do c = c.outer
+            val cinfo = c.importInfo
+            (cinfo != null) && cinfo.featureImported(feature)(using c)
+      )
+    featureCache(feature).nn
+
+  def toText(printer: Printer): Text = printer.toText(this)
+}
diff --git a/tests/pos-with-compiler-cc/dotc/typer/ImportSuggestions.scala b/tests/pos-with-compiler-cc/dotc/typer/ImportSuggestions.scala
new file mode 100644
index 000000000000..a9b53f0783bd
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/typer/ImportSuggestions.scala
@@ -0,0 +1,357 @@
+package dotty.tools
+package dotc
+package typer
+
+import backend.sjs.JSDefinitions
+import core._
+import Contexts._, Types._, Symbols._, Names._, Decorators._, ProtoTypes._
+import Flags._, SymDenotations._
+import NameKinds.FlatName
+import StdNames._
+import config.Printers.{implicits, implicitsDetailed}
+import ast.{untpd, tpd}
+import Implicits.{hasExtMethod, Candidate}
+import java.util.{Timer, TimerTask}
+import collection.mutable
+import scala.util.control.NonFatal
+
+/** This trait defines the method `importSuggestionAddendum` that adds an addendum
+ *  to error messages suggesting additional imports.
+ */
+trait ImportSuggestions:
+  this: Typer =>
+
+  /** The maximal number of suggested imports to make */
+  inline val MaxSuggestions = 10
+
+  import tpd._
+
+  /** Timeout to test a single implicit value as a suggestion, in ms */
+  private inline val testOneImplicitTimeOut = 500
+
+  /** A list of TermRefs referring to the roots where suggestions for
+   *  imports of givens or extension methods that might fix a type error
+   *  are searched.
+   *
+   *  These roots are the smallest set of objects and packages that includes
+   *
+   *   - any object that is a defined in an enclosing scope,
+   *   - any object that is a member of an enclosing class,
+   *   - any enclosing package (including the root package),
+   *   - any object that is a member of a searched object or package,
+   *   - any object or package from which something is imported in an enclosing scope,
+   *   - any package that is nested in a searched package, provided
+   *     the package was accessed in some way previously.
+   *
+   *  Excluded from the root set are:
+   *
+   *   - Objects that contain `$`s in their name. These have to
+   *     be omitted since they might be inner Java class files which
+   *     cannot be read by the ClassfileParser without crashing.
+   *   - Any members of static parts of Java classes.
+   *   - Any members of the empty package. These should be
+   *     skipped since the empty package often contains unrelated junk files
+   *     that should not be used for suggestions.
+   *   - Any members of the java or java.lang packages. These are
+   *     skipped as an optimization, since they won't contain implicits anyway.
+   */
+  private def suggestionRoots(using Context) =
+    val seen = mutable.Set[TermRef]()
+
+    def lookInside(root: Symbol)(using Context): Boolean =
+      explore {
+        if root.is(Package) then root.isTerm && root.isCompleted
+        else !root.name.is(FlatName)
+          && !root.name.lastPart.contains('$')
+          && root.is(ModuleVal, butNot = JavaDefined)
+          // The implicits in `scalajs.js.|` are implementation details and shouldn't be suggested
+          && !(root.name == nme.raw.BAR && ctx.settings.scalajs.value && root == JSDefinitions.jsdefn.PseudoUnionModule)
+      }
+
+    def nestedRoots(site: Type)(using Context): List[Symbol] =
+      val seenNames = mutable.Set[Name]()
+      site.baseClasses.flatMap { bc =>
+        bc.info.decls.filter { dcl =>
+          lookInside(dcl)
+          && !seenNames.contains(dcl.name)
+          && { seenNames += dcl.name; true }
+        }
+      }
+
+    def rootsStrictlyIn(ref: Type)(using Context): List[TermRef] =
+      val site = ref.widen
+      val refSym = site.typeSymbol
+      val nested =
+        if refSym.is(Package) then
+          if refSym == defn.EmptyPackageClass       // Don't search the empty package
+              || refSym == defn.JavaPackageClass     // As an optimization, don't search java...
+              || refSym == defn.JavaLangPackageClass // ... or java.lang.
+          then Nil
+          else refSym.info.decls.filter(lookInside)
+        else if refSym.infoOrCompleter.isInstanceOf[StubInfo] then
+          Nil // Don't chase roots that do not exist
+        else
+          if !refSym.is(Touched) then
+            refSym.ensureCompleted() // JavaDefined is reliably known only after completion
+          if refSym.is(JavaDefined) then Nil
+          else nestedRoots(site)
+      nested
+        .map(mbr => TermRef(ref, mbr.asTerm))
+        .flatMap(rootsIn)
+        .toList
+
+    def rootsIn(ref: TermRef)(using Context): List[TermRef] =
+      if seen.contains(ref) then Nil
+      else
+        implicitsDetailed.println(i"search for suggestions in ${ref.symbol.fullName}")
+        seen += ref
+        ref :: rootsStrictlyIn(ref)
+
+    def rootsOnPath(tp: Type)(using Context): List[TermRef] = tp match
+      case ref: TermRef => rootsIn(ref) ::: rootsOnPath(ref.prefix)
+      case _ => Nil
+
+    def recur(using Context): List[TermRef] =
+      if ctx.owner.exists then
+        val defined =
+          if ctx.owner.isClass then
+            if ctx.owner eq ctx.outer.owner then Nil
+            else rootsStrictlyIn(ctx.owner.thisType)
+          else
+            if ctx.scope eq ctx.outer.scope then Nil
+            else ctx.scope
+              .filter(lookInside(_))
+              .flatMap(sym => rootsIn(sym.termRef))
+        val imported =
+          if ctx.importInfo eqn ctx.outer.importInfo then Nil
+          else ctx.importInfo.nn.importSym.info match
+            case ImportType(expr) => rootsOnPath(expr.tpe)
+            case _ => Nil
+        defined ++ imported ++ recur(using ctx.outer)
+      else Nil
+
+    recur
+  end suggestionRoots
+
+  /** Given an expected type `pt`, return two lists of TermRefs:
+   *
+   *   1. The _fully matching_ given instances that can be completed
+   *      to a full synthesized given term that matches the expected type `pt`.
+   *
+   *   2. The _head matching_ given instances, that conform to the
+   *      expected type `pt`, ignoring any dependent implicit arguments.
+   *
+   *   If there are no fully matching given instances under (1), and `pt` is
+   *   a view prototype of a selection of the form `T ?=>? { name: ... }`,
+   *   return instead a list of all possible references to extension methods named
+   *   `name` that are applicable to `T`.
+   */
+  private def importSuggestions(pt: Type)(using Context): (List[TermRef], List[TermRef]) =
+    val timer = new Timer()
+    val allotted = ctx.run.nn.importSuggestionBudget
+    if allotted <= 1 then return (Nil, Nil)
+    implicits.println(i"looking for import suggestions, timeout = ${allotted}ms")
+    val start = System.currentTimeMillis()
+    val deadLine = start + allotted
+
+    // Candidates that are already available without explicit import because they
+    // are already provided by the context (imported or inherited) or because they
+    // are in the implicit scope of `pt`.
+    val alreadyAvailableCandidates: Set[Symbol] = {
+      val wildProto = wildApprox(pt)
+      val contextualCandidates = ctx.implicits.eligible(wildProto)
+      val implicitScopeCandidates = ctx.run.nn.implicitScope(wildProto).eligible
+      val allCandidates = contextualCandidates ++ implicitScopeCandidates
+      allCandidates.map(_.implicitRef.underlyingRef.symbol).toSet
+    }
+
+    def testContext(): Context =
+      ctx.fresh.retractMode(Mode.ImplicitsEnabled).setExploreTyperState()
+
+    /** Test whether the head of a given instance matches the expected type `pt`,
+     *  ignoring any dependent implicit arguments.
+     */
+    def shallowTest(ref: TermRef): Boolean =
+      System.currentTimeMillis < deadLine
+      && inContext(testContext()) {
+        def test(pt: Type): Boolean = pt match
+          case ViewProto(argType, OrType(rt1, rt2)) =>
+            // Union types do not constrain results, since comparison with a union
+            // type on the right might lose information. See ProtoTypes.disregardProto.
+            // To regain precision, test both sides separately.
+            test(ViewProto(argType, rt1)) || test(ViewProto(argType, rt2))
+          case pt: ViewProto =>
+            pt.isMatchedBy(ref)
+          case _ =>
+            normalize(ref, pt) <:< pt
+        test(pt)
+      }
+
+    /** Test whether a full given term can be synthesized that matches
+     *  the expected type `pt`.
+     */
+    def deepTest(ref: TermRef): Boolean =
+      System.currentTimeMillis < deadLine
+      && {
+        val task = new TimerTask:
+          def run() =
+            println(i"Cancelling test of $ref when making suggestions for error in ${ctx.source}")
+            ctx.run.nn.isCancelled = true
+        val span = ctx.owner.srcPos.span
+        val (expectedType, argument, kind) = pt match
+          case ViewProto(argType, resType) =>
+            (resType,
+             untpd.Ident(ref.name).withSpan(span).withType(argType),
+             if hasExtMethod(ref, resType) then Candidate.Extension
+             else Candidate.Conversion)
+          case _ =>
+            (pt, EmptyTree, Candidate.Value)
+        val candidate = Candidate(ref, kind, 0)
+        try
+          timer.schedule(task, testOneImplicitTimeOut)
+          typedImplicit(candidate, expectedType, argument, span)(
+            using testContext()).isSuccess
+        finally
+          val run = ctx.run.nn
+          if task.cancel() then // timer task has not run yet
+            assert(!run.isCancelled)
+          else
+            while !run.isCancelled do () // wait until timer task has run to completion
+            run.isCancelled = false
+      }
+    end deepTest
+
+    /** Optionally, an extension method reference `site.name` that is
+     *  applicable to `argType`.
+     */
+    def extensionMethod(site: TermRef, name: TermName, argType: Type): Option[TermRef] =
+      site.member(name)
+        .alternatives
+        .map(mbr => TermRef(site, mbr.symbol))
+        .filter(ref => ctx.typer.isApplicableExtensionMethod(ref, argType))
+        .headOption
+
+    try
+      val roots = suggestionRoots
+        .filterNot(root => defn.rootImportTypes.exists(_.symbol == root.symbol))
+          // don't suggest things that are imported by default
+
+      def extensionImports = pt match
+        case ViewProto(argType, SelectionProto(name: TermName, _, _, _)) =>
+          roots.flatMap(extensionMethod(_, name, argType))
+        case _ =>
+          Nil
+
+      roots
+        .flatMap(_.implicitMembers.filter { ref =>
+          !alreadyAvailableCandidates(ref.symbol) && shallowTest(ref)
+        })
+          // filter whether the head of the implicit can match
+        .partition(deepTest)
+          // partition into full matches and head matches
+        match
+          case (Nil, partials) => (extensionImports, partials)
+          case givenImports => givenImports
+    catch case NonFatal(ex) =>
+      if ctx.settings.Ydebug.value then
+        println("caught exception when searching for suggestions")
+        ex.printStackTrace()
+      (Nil, Nil)
+    finally
+      timer.cancel()
+      reduceTimeBudget(((System.currentTimeMillis() - start) min Int.MaxValue).toInt)
+  end importSuggestions
+
+  /** Reduce next timeout for import suggestions by the amount of time it took
+   *  for current search, but but never less than to half of the previous budget.
+   */
+  private def reduceTimeBudget(used: Int)(using Context) =
+    val run = ctx.run.nn
+    run.importSuggestionBudget =
+      (run.importSuggestionBudget - used) max (run.importSuggestionBudget / 2)
+
+  /** The `ref` parts of this list of pairs, discarding subsequent elements that
+   *  have the same String part. Elements are sorted by their String parts.
+   */
+  extension (refs: List[(TermRef, String)]) def distinctRefs(using Context): List[TermRef] =
+    val buf = new mutable.ListBuffer[TermRef]
+    var last = ""
+    for (ref, str) <- refs do
+      if last != str then
+        buf += ref
+        last = str
+    buf.toList
+
+  /** The best `n` references in `refs`, according to `compare`
+   *  `compare` is a partial order. If there's a tie, we take elements
+   *  in the order thy appear in the list.
+   */
+  extension (refs: List[TermRef]) def best(n: Int)(using Context): List[TermRef] =
+    val top = new Array[TermRef](n)
+    var filled = 0
+    val rest = new mutable.ListBuffer[TermRef]
+    val noImplicitsCtx = ctx.retractMode(Mode.ImplicitsEnabled)
+    for ref <- refs do
+      var i = 0
+      var diff = 0
+      while i < filled && diff == 0 do
+        diff = compare(ref, top(i))(using noImplicitsCtx)
+        if diff > 0 then
+          rest += top(i)
+          top(i) = ref
+        i += 1
+      end while
+      if diff == 0 && filled < n then
+        top(filled) = ref
+        filled += 1
+      else if diff <= 0 then
+        rest += ref
+    end for
+    val remaining =
+      if filled < n && rest.nonEmpty then rest.toList.best(n - filled)
+      else Nil
+    top.take(filled).toList ++ remaining
+  //end best  TODO: re-enable with new syntax
+
+  /** An addendum to an error message where the error might be fixed
+   *  by some implicit value of type `pt` that is however not found.
+   *  The addendum suggests given imports that might fix the problem.
+   *  If there's nothing to suggest, an empty string is returned.
+   */
+  override def importSuggestionAddendum(pt: Type)(using Context): String =
+    if ctx.phase == Phases.checkCapturesPhase then
+      return "" // it's too late then to look for implicits
+    val (fullMatches, headMatches) =
+      importSuggestions(pt)(using ctx.fresh.setExploreTyperState())
+    implicits.println(i"suggestions for $pt in ${ctx.owner} = ($fullMatches%, %, $headMatches%, %)")
+    val (suggestedRefs, help) =
+      if fullMatches.nonEmpty then (fullMatches, "fix")
+      else (headMatches, "make progress towards fixing")
+    def importString(ref: TermRef): String =
+      val imported =
+        if ref.symbol.is(ExtensionMethod) then
+          s"${ctx.printer.toTextPrefix(ref.prefix).show}${ref.symbol.name}"
+        else
+          ctx.printer.toTextRef(ref).show
+      s"  import $imported"
+    val suggestions = suggestedRefs
+      .zip(suggestedRefs.map(importString))
+      .filter((ref, str) => str.contains('.')) // must be a real import with `.`
+      .sortBy(_._2)         // sort first alphabetically for stability
+      .distinctRefs         // TermRefs might be different but generate the same strings
+      .best(MaxSuggestions) // take MaxSuggestions best references according to specificity
+      .map(importString)
+    if suggestions.isEmpty then ""
+    else
+      val fix =
+        if suggestions.tail.isEmpty then "The following import"
+        else "One of the following imports"
+      i"""
+         |
+         |$fix might $help the problem:
+         |
+         |$suggestions%\n%
+         |
+         |"""
+  end importSuggestionAddendum
+end ImportSuggestions
diff --git a/tests/pos-with-compiler-cc/dotc/typer/Inferencing.scala b/tests/pos-with-compiler-cc/dotc/typer/Inferencing.scala
new file mode 100644
index 000000000000..27b83e025cf9
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/typer/Inferencing.scala
@@ -0,0 +1,750 @@
+package dotty.tools
+package dotc
+package typer
+
+import core._
+import ast._
+import Contexts._, Types._, Flags._, Symbols._
+import ProtoTypes._
+import NameKinds.{AvoidNameKind, UniqueName}
+import util.Spans._
+import util.{Stats, SimpleIdentityMap, SrcPos}
+import Decorators._
+import config.Printers.{gadts, typr}
+import annotation.tailrec
+import reporting._
+import collection.mutable
+
+import scala.annotation.internal.sharable
+
+object Inferencing {
+
+  import tpd._
+
+  /** Is type fully defined, meaning the type does not contain wildcard types
+   *  or uninstantiated type variables. As a side effect, this will minimize
+   *  any uninstantiated type variables, according to the given force degree,
+   *  but only if the overall result of `isFullyDefined` is `true`.
+   *  Variables that are successfully minimized do not count as uninstantiated.
+   */
+  def isFullyDefined(tp: Type, force: ForceDegree.Value)(using Context): Boolean = {
+    val nestedCtx = ctx.fresh.setNewTyperState()
+    val result = new IsFullyDefinedAccumulator(force)(using nestedCtx).process(tp)
+    if (result) nestedCtx.typerState.commit()
+    result
+  }
+
+  /** Try to fully define `tp`. Return whether constraint has changed.
+   *  Any changed constraint is kept.
+   */
+  def canDefineFurther(tp: Type)(using Context): Boolean =
+    val prevConstraint = ctx.typerState.constraint
+    isFullyDefined(tp, force = ForceDegree.failBottom)
+    && (ctx.typerState.constraint ne prevConstraint)
+
+  /** The fully defined type, where all type variables are forced.
+   *  Throws an error if type contains wildcards.
+   */
+  def fullyDefinedType(tp: Type, what: String, pos: SrcPos)(using Context): Type =
+    try
+      if isFullyDefined(tp, ForceDegree.all) then tp
+      else throw new Error(i"internal error: type of $what $tp is not fully defined, pos = $pos")
+    catch case ex: RecursionOverflow =>
+      report.error(ex, pos)
+      UnspecifiedErrorType
+
+  /** Instantiate selected type variables `tvars` in type `tp` in a special mode:
+   *   1. If a type variable is constrained from below (i.e. constraint bound != given lower bound)
+   *      it is minimized.
+   *   2. Otherwise, if the type variable is constrained from above, it is maximized.
+   *   3. Otherwise, if the type variable has a lower bound != Nothing, it is minimized.
+   *   4. Otherwise, if the type variable has an upper bound != Any, it is maximized.
+   *  If none of (1) - (4) applies, the type variable is left uninstantiated.
+   *  The method is called to instantiate type variables before an implicit search.
+   */
+  def instantiateSelected(tp: Type, tvars: List[Type])(using Context): Unit =
+    if (tvars.nonEmpty)
+      IsFullyDefinedAccumulator(
+        ForceDegree.Value(tvars.contains, IfBottom.flip), minimizeSelected = true
+      ).process(tp)
+
+  /** Instantiate any type variables in `tp` whose bounds contain a reference to
+   *  one of the parameters in `paramss`.
+   */
+  def instantiateDependent(tp: Type, paramss: List[List[Symbol]])(using Context): Unit = {
+    val dependentVars = new TypeAccumulator[Set[TypeVar]] {
+      def apply(tvars: Set[TypeVar], tp: Type) = tp match {
+        case tp: TypeVar
+        if !tp.isInstantiated &&
+            TypeComparer.bounds(tp.origin)
+              .namedPartsWith(ref => paramss.exists(_.contains(ref.symbol)))
+              .nonEmpty =>
+          tvars + tp
+        case _ =>
+          foldOver(tvars, tp)
+      }
+    }
+    val depVars = dependentVars(Set(), tp)
+    if (depVars.nonEmpty) instantiateSelected(tp, depVars.toList)
+  }
+
+  /** If `tp` is top-level type variable with a lower bound in the current constraint,
+   *  instantiate it from below. We also look for TypeVars in other places where
+   *  their instantiation could uncover new type members. However that search is best
+   *  effort only. It might miss type variables that appear in structures involving
+   *  alias types and type projections.
+   *  @param applied  Test is done in a `tryInsertImplicitOnQualifier` application.
+   *                  In this case, we always try to instantiate TypeVars in type arguments.
+   *                  If `applied` is false, we only try that in arguments that may affect
+   *                  the result type.
+   */
+  def couldInstantiateTypeVar(tp: Type, applied: Boolean = false)(using Context): Boolean = tp.dealias match
+    case tvar: TypeVar
+    if !tvar.isInstantiated
+       && ctx.typerState.constraint.contains(tvar)
+       && tvar.hasLowerBound =>
+      tvar.instantiate(fromBelow = true)
+      true
+    case AppliedType(tycon, args) =>
+      // The argument in `args` that may potentially appear directly as result
+      // and thereby influence the members of this type
+      def argsInResult: List[Type] = tycon.stripTypeVar match
+        case tycon: TypeRef =>
+          tycon.info match
+            case MatchAlias(_) => args
+            case TypeBounds(_, upper: TypeLambda) =>
+              upper.resultType match
+                case ref: TypeParamRef if ref.binder == upper =>
+                  args.lazyZip(upper.paramRefs).collect {
+                    case (arg, pref) if pref eq ref => arg
+                  }.toList
+                case _ => Nil
+            case _ => Nil
+        case _ => Nil
+      couldInstantiateTypeVar(tycon, applied)
+      || (if applied then args else argsInResult).exists(couldInstantiateTypeVar(_, applied))
+    case RefinedType(parent, _, _) =>
+      couldInstantiateTypeVar(parent, applied)
+    case tp: AndOrType =>
+      couldInstantiateTypeVar(tp.tp1, applied) || couldInstantiateTypeVar(tp.tp2, applied)
+    case tp: AnnotatedType =>
+      couldInstantiateTypeVar(tp.parent, applied)
+    case _ =>
+      false
+
+  /** The accumulator which forces type variables using the policy encoded in `force`
+   *  and returns whether the type is fully defined. The direction in which
+   *  a type variable is instantiated is determined as follows:
+   *   1. T is minimized if the constraint over T is only from below (i.e.
+   *      constrained lower bound != given lower bound and
+   *      constrained upper bound == given upper bound).
+   *   2. T is maximized if the constraint over T is only from above (i.e.
+   *      constrained upper bound != given upper bound and
+   *      constrained lower bound == given lower bound).
+   *
+   *  If (1) and (2) do not apply, and minimizeSelected is set:
+   *   3. T is minimized if it has a lower bound (different from Nothing) in the
+   *      current constraint (the bound might come from T's declaration).
+   *   4. Otherwise, T is maximized if it has an upper bound (different from Any)
+   *      in the currented constraint (the bound might come from T's declaration).
+   *   5. Otherwise, T is not instantiated at all.
+
+   *  If (1) and (2) do not apply, and minimizeSelected is not set:
+   *   6: T is maximized if it appears only contravariantly in the given type,
+   *      or if forceDegree is `flipBottom` and T has no lower bound different from Nothing.
+   *   7. Otherwise, T is minimized.
+   *
+   *  The instantiation for (6) and (7) is done in two phases:
+   *  1st Phase: Try to instantiate minimizable type variables to
+   *  their lower bound. Record whether successful.
+   *  2nd Phase: If first phase was successful, instantiate all remaining type variables
+   *  to their upper bound.
+   */
+  private class IsFullyDefinedAccumulator(force: ForceDegree.Value, minimizeSelected: Boolean = false)
+    (using Context) extends TypeAccumulator[Boolean] {
+
+    private def instantiate(tvar: TypeVar, fromBelow: Boolean): Type = {
+      val inst = tvar.instantiate(fromBelow)
+      typr.println(i"forced instantiation of ${tvar.origin} = $inst")
+      inst
+    }
+
+    private var toMaximize: List[TypeVar] = Nil
+
+    def apply(x: Boolean, tp: Type): Boolean =
+      try tp.dealias match
+        case _: WildcardType | _: ProtoType =>
+          false
+        case tvar: TypeVar if !tvar.isInstantiated =>
+          force.appliesTo(tvar)
+          && ctx.typerState.constraint.contains(tvar)
+          && {
+            val direction = instDirection(tvar.origin)
+            if minimizeSelected then
+              if direction <= 0 && tvar.hasLowerBound then
+                instantiate(tvar, fromBelow = true)
+              else if direction >= 0 && tvar.hasUpperBound then
+                instantiate(tvar, fromBelow = false)
+              // else hold off instantiating unbounded unconstrained variable
+            else if direction != 0 then
+              instantiate(tvar, fromBelow = direction < 0)
+            else if variance >= 0 && (force.ifBottom == IfBottom.ok || tvar.hasLowerBound) then
+              instantiate(tvar, fromBelow = true)
+            else if variance >= 0 && force.ifBottom == IfBottom.fail then
+              return false
+            else
+              toMaximize = tvar :: toMaximize
+            foldOver(x, tvar)
+          }
+        case tp =>
+          reporting.trace(s"IFT $tp") {
+            foldOver(x, tp)
+          }
+      catch case ex: Throwable =>
+        handleRecursive("check fully defined", tp.show, ex)
+
+    def process(tp: Type): Boolean =
+      // Maximize type vars in the order they were visited before */
+      def maximize(tvars: List[TypeVar]): Unit = tvars match
+        case tvar :: tvars1 =>
+          maximize(tvars1)
+          if !tvar.isInstantiated then
+            instantiate(tvar, fromBelow = false)
+        case nil =>
+      apply(true, tp)
+      && (
+        toMaximize.isEmpty
+        || { maximize(toMaximize)
+             toMaximize = Nil       // Do another round since the maximixing instances
+             process(tp)            // might have type uninstantiated variables themselves.
+           }
+      )
+  }
+
+  def approximateGADT(tp: Type)(using Context): Type = {
+    val map = new ApproximateGadtAccumulator
+    val res = map(tp)
+    assert(!map.failed)
+    res
+  }
+
+  /** Approximates a type to get rid of as many GADT-constrained abstract types as possible. */
+  private class ApproximateGadtAccumulator(using Context) extends TypeMap {
+
+    var failed = false
+
+    /** GADT approximation proceeds differently from type variable approximation.
+      *
+      * Essentially, what we're doing is we're inferring a type ascription that
+      * will remove as many GADT-constrained types as possible. This means that
+      * we want to approximate type T to type S in such a way that no matter how
+      * GADT-constrained types are instantiated, T <: S. In other words, the
+      * relationship _necessarily_ must hold.
+      *
+      * We accomplish that by:
+      *   - replacing covariant occurences with upper GADT bound
+      *   - replacing contravariant occurences with lower GADT bound
+      *   - leaving invariant occurences alone
+      *
+      * Examples:
+      *   - If we have GADT cstr A <: Int, then for all A <: Int, Option[A] <: Option[Int].
+      *     Therefore, we can approximate Option[A] ~~ Option[Int].
+      *   - If we have A >: S <: T, then for all such A, A => A <: S => T. This
+      *     illustrates that it's fine to differently approximate different
+      *     occurences of same type.
+      *   - If we have A <: Int and F <: [A] => Option[A] (note the invariance),
+      *     then we should approximate F[A] ~~ Option[A]. That is, we should
+      *     respect the invariance of the type constructor.
+      *   - If we have A <: Option[B] and B <: Int, we approximate A ~~
+      *     Option[B]. That is, we don't recurse into already approximated
+      *     types. Since GADT approximation is (for now) only used for member
+      *     selection, this behaviour is expected, as nested types cannot affect
+      *     member selection (note that given/extension lookup doesn't need GADT
+      *     approx, see gadt-approximation-interaction.scala).
+      */
+    def apply(tp: Type): Type = tp.dealias match {
+      case tp @ TypeRef(qual, nme) if variance != 0
+                                   && ctx.gadt.contains(tp.symbol)
+                                   =>
+        val sym = tp.symbol
+        val res = ctx.gadt.approximation(sym, fromBelow = variance < 0)
+        gadts.println(i"approximated $tp  ~~  $res")
+        res
+
+      case _: WildcardType | _: ProtoType =>
+        failed = true
+        NoType
+
+      case tp =>
+        mapOver(tp)
+    }
+
+    def process(tp: Type): Type = {
+      apply(tp)
+    }
+  }
+
+  /** For all type parameters occurring in `tp`:
+   *  If the bounds of `tp` in the current constraint are equal wrt =:=,
+   *  instantiate the type parameter to the lower bound's approximation
+   *  (approximation because of possible F-bounds).
+   */
+  def replaceSingletons(tp: Type)(using Context): Unit = {
+    val tr = new TypeTraverser {
+      def traverse(tp: Type): Unit = {
+        tp match {
+          case param: TypeParamRef =>
+            val constraint = accCtx.typerState.constraint
+            constraint.entry(param) match {
+              case TypeBounds(lo, hi)
+              if (hi frozen_<:< lo) =>
+                val inst = TypeComparer.approximation(param, fromBelow = true)
+                typr.println(i"replace singleton $param := $inst")
+                accCtx.typerState.constraint = constraint.replace(param, inst)
+              case _ =>
+            }
+          case _ =>
+        }
+        traverseChildren(tp)
+      }
+    }
+    tr.traverse(tp)
+  }
+
+  /** If `tree` has a type lambda type, infer its type parameters by comparing with expected type `pt` */
+  def inferTypeParams(tree: Tree, pt: Type)(using Context): Tree = tree.tpe match {
+    case tl: TypeLambda =>
+      val (tl1, tvars) = constrained(tl, tree)
+      var tree1 = AppliedTypeTree(tree.withType(tl1), tvars)
+      tree1.tpe <:< pt
+      fullyDefinedType(tree1.tpe, "template parent", tree.srcPos)
+      tree1
+    case _ =>
+      tree
+  }
+
+  def isSkolemFree(tp: Type)(using Context): Boolean =
+    !tp.existsPart(_.isInstanceOf[SkolemType])
+
+  /** The list of uninstantiated type variables bound by some prefix of type `T` which
+   *  occur in at least one formal parameter type of a prefix application.
+   *  Considered prefixes are:
+   *    - The function `f` of an application node `f(e1, .., en)`
+   *    - The function `f` of a type application node `f[T1, ..., Tn]`
+   *    - The prefix `p` of a selection `p.f`.
+   *    - The result expression `e` of a block `{s1; .. sn; e}`.
+   */
+  def tvarsInParams(tree: Tree, locked: TypeVars)(using Context): List[TypeVar] = {
+    @tailrec def boundVars(tree: Tree, acc: List[TypeVar]): List[TypeVar] = tree match {
+      case Apply(fn, _) => boundVars(fn, acc)
+      case TypeApply(fn, targs) =>
+        val tvars = targs.filter(_.isInstanceOf[InferredTypeTree]).tpes.collect {
+          case tvar: TypeVar
+          if !tvar.isInstantiated &&
+             ctx.typerState.ownedVars.contains(tvar) &&
+             !locked.contains(tvar) => tvar
+        }
+        boundVars(fn, acc ::: tvars)
+      case Select(pre, _) => boundVars(pre, acc)
+      case Block(_, expr) => boundVars(expr, acc)
+      case _ => acc
+    }
+    @tailrec def occurring(tree: Tree, toTest: List[TypeVar], acc: List[TypeVar]): List[TypeVar] =
+      if (toTest.isEmpty) acc
+      else tree match {
+        case Apply(fn, _) =>
+          fn.tpe.widen match {
+            case mtp: MethodType =>
+              val (occ, nocc) = toTest.partition(tvar => mtp.paramInfos.exists(tvar.occursIn))
+              occurring(fn, nocc, occ ::: acc)
+            case _ =>
+              occurring(fn, toTest, acc)
+          }
+        case TypeApply(fn, targs) => occurring(fn, toTest, acc)
+        case Select(pre, _) => occurring(pre, toTest, acc)
+        case Block(_, expr) => occurring(expr, toTest, acc)
+        case _ => acc
+      }
+    occurring(tree, boundVars(tree, Nil), Nil)
+  }
+
+  /** The instantiation direction for given poly param computed
+   *  from the constraint:
+   *  @return   1 (maximize) if constraint is uniformly from above,
+   *           -1 (minimize) if constraint is uniformly from below,
+   *            0 if unconstrained, or constraint is from below and above.
+   */
+  private def instDirection(param: TypeParamRef)(using Context): Int = {
+    val constrained = TypeComparer.fullBounds(param)
+    val original = param.binder.paramInfos(param.paramNum)
+    val cmp = TypeComparer
+    val approxBelow =
+      if (!cmp.isSubTypeWhenFrozen(constrained.lo, original.lo)) 1 else 0
+    val approxAbove =
+      if (!cmp.isSubTypeWhenFrozen(original.hi, constrained.hi)) 1 else 0
+    approxAbove - approxBelow
+  }
+
+  /** Following type aliases and stripping refinements and annotations, if one arrives at a
+   *  class type reference where the class has a companion module, a reference to
+   *  that companion module. Otherwise NoType
+   */
+  def companionRef(tp: Type)(using Context): Type =
+    tp.underlyingClassRef(refinementOK = true) match {
+      case tp: TypeRef =>
+        val companion = tp.classSymbol.companionModule
+        if (companion.exists)
+          companion.termRef.asSeenFrom(tp.prefix, companion.owner)
+        else NoType
+      case _ => NoType
+    }
+
+  /** Instantiate undetermined type variables so that type `tp` is maximized.
+   *  @return   The list of type symbols that were created
+   *            to instantiate undetermined type variables that occur non-variantly
+   */
+  def maximizeType(tp: Type, span: Span)(using Context): List[Symbol] = {
+    Stats.record("maximizeType")
+    val vs = variances(tp)
+    val patternBindings = new mutable.ListBuffer[(Symbol, TypeParamRef)]
+    val gadtBounds = ctx.gadt.symbols.map(ctx.gadt.bounds(_).nn)
+    vs foreachBinding { (tvar, v) =>
+      if !tvar.isInstantiated then
+        // if the tvar is covariant/contravariant (v == 1/-1, respectively) in the input type tp
+        // then it is safe to instantiate if it doesn't occur in any of the GADT bounds.
+        // Eg neg/i14983 the C in Node[+C] occurs in GADT bound X >: List[C] so maximising to Node[Any] is unsound
+        // Eg pos/precise-pattern-type the T in Tree[-T] doesn't occur in any GADT bound so can maximise to Tree[Type]
+        val safeToInstantiate = v != 0 && gadtBounds.forall(!tvar.occursIn(_))
+        if safeToInstantiate then tvar.instantiate(fromBelow = v == -1)
+        else {
+          val bounds = TypeComparer.fullBounds(tvar.origin)
+          if bounds.hi <:< bounds.lo || bounds.hi.classSymbol.is(Final) then
+            tvar.instantiate(fromBelow = false)
+          else {
+            // We do not add the created symbols to GADT constraint immediately, since they may have inter-dependencies.
+            // Instead, we simultaneously add them later on.
+            val wildCard = newPatternBoundSymbol(UniqueName.fresh(tvar.origin.paramName), bounds, span, addToGadt = false)
+            tvar.instantiateWith(wildCard.typeRef)
+            patternBindings += ((wildCard, tvar.origin))
+          }
+        }
+    }
+    val res = patternBindings.toList.map { (boundSym, _) =>
+      // substitute bounds of pattern bound variables to deal with possible F-bounds
+      for (wildCard, param) <- patternBindings do
+        boundSym.info = boundSym.info.substParam(param, wildCard.typeRef)
+      boundSym
+    }
+
+    // We add the created symbols to GADT constraint here.
+    if (res.nonEmpty) ctx.gadt.addToConstraint(res)
+    res
+  }
+
+  type VarianceMap = SimpleIdentityMap[TypeVar, Integer]
+
+  /** All occurrences of type vars in `tp` that satisfy predicate
+   *  `include` mapped to their variances (-1/0/1) in both `tp` and
+   *  `pt.finalResultType`, where
+   *  -1 means: only contravariant occurrences
+   *  +1 means: only covariant occurrences
+   *  0 means: mixed or non-variant occurrences
+   *
+   *  We need to take the occurences in `pt` into account because a type
+   *  variable created when typing the current tree might only appear in the
+   *  bounds of a type variable in the expected type, for example when
+   *  `ConstraintHandling#legalBound` creates type variables when approximating
+   *  a bound.
+   *
+   *  Note: We intentionally use a relaxed version of variance here,
+   *  where the variance does not change under a prefix of a named type
+   *  (the strict version makes prefixes invariant). This turns out to be
+   *  better for type inference. In a nutshell, if a type variable occurs
+   *  like this:
+   *
+   *     (U? >: x.type) # T
+   *
+   *  we want to instantiate U to x.type right away. No need to wait further.
+   */
+  private def variances(tp: Type, pt: Type = WildcardType)(using Context): VarianceMap = {
+    Stats.record("variances")
+    val constraint = ctx.typerState.constraint
+
+    object accu extends TypeAccumulator[VarianceMap] {
+      def setVariance(v: Int) = variance = v
+      def apply(vmap: VarianceMap, t: Type): VarianceMap = t match {
+        case t: TypeVar
+        if !t.isInstantiated && accCtx.typerState.constraint.contains(t) =>
+          val v = vmap(t)
+          if (v == null) vmap.updated(t, variance)
+          else if (v == variance || v == 0) vmap
+          else vmap.updated(t, 0)
+        case _ =>
+          foldOver(vmap, t)
+      }
+    }
+
+    /** Include in `vmap` type variables occurring in the constraints of type variables
+     *  already in `vmap`. Specifically:
+     *   - if `tvar` is covariant in `vmap`, include all variables in its lower bound
+     *     (because they influence the minimal solution of `tvar`),
+     *   - if `tvar` is contravariant in `vmap`, include all variables in its upper bound
+     *     at flipped variances (because they influence the maximal solution of `tvar`),
+     *   - if `tvar` is nonvariant in `vmap`, include all variables in its upper and lower
+     *     bounds as non-variant.
+     *  Do this in a fixpoint iteration until `vmap` stabilizes.
+     */
+    def propagate(vmap: VarianceMap): VarianceMap = {
+      var vmap1 = vmap
+      def traverse(tp: Type) = { vmap1 = accu(vmap1, tp) }
+      vmap.foreachBinding { (tvar, v) =>
+        val param = tvar.origin
+        constraint.entry(param) match
+          case TypeBounds(lo, hi) =>
+            accu.setVariance(v)
+            if v >= 0 then
+              traverse(lo)
+              constraint.lower(param).foreach(p => traverse(constraint.typeVarOfParam(p)))
+            if v <= 0 then
+              traverse(hi)
+              constraint.upper(param).foreach(p => traverse(constraint.typeVarOfParam(p)))
+          case _ =>
+      }
+      if (vmap1 eq vmap) vmap else propagate(vmap1)
+    }
+
+    propagate(accu(accu(SimpleIdentityMap.empty, tp), pt.finalResultType))
+  }
+
+  /** Run the transformation after dealiasing but return the original type if it was a no-op. */
+  private def derivedOnDealias(tp: Type)(transform: Type => Type)(using Context) = {
+    val dealiased = tp.dealias
+    val transformed = transform(dealiased)
+    if transformed eq dealiased then tp // return the original type, not the result of dealiasing
+    else transformed
+  }
+
+  /** Replace every top-level occurrence of a wildcard type argument by
+   *  a fresh skolem type. The skolem types are of the form $i.CAP, where
+   *  $i is a skolem of type `scala.internal.TypeBox`, and `CAP` is its
+   *  type member. See the documentation of `TypeBox` for a rationale why we do this.
+   */
+  def captureWildcards(tp: Type)(using Context): Type = derivedOnDealias(tp) {
+    case tp @ AppliedType(tycon, args) if tp.hasWildcardArg =>
+      val tparams = tycon.typeParamSymbols
+      val args1 = args.zipWithConserve(tparams.map(_.paramInfo.substApprox(tparams, args))) {
+        case (TypeBounds(lo, hi), bounds) =>
+          val skolem = SkolemType(defn.TypeBoxClass.typeRef.appliedTo(lo | bounds.loBound, hi & bounds.hiBound))
+          TypeRef(skolem, defn.TypeBox_CAP)
+        case (arg, _) =>
+          arg
+      }
+      if tparams.isEmpty then tp else tp.derivedAppliedType(tycon, args1)
+    case tp: AndOrType => tp.derivedAndOrType(captureWildcards(tp.tp1), captureWildcards(tp.tp2))
+    case tp: RefinedType => tp.derivedRefinedType(captureWildcards(tp.parent), tp.refinedName, tp.refinedInfo)
+    case tp: RecType => tp.derivedRecType(captureWildcards(tp.parent))
+    case tp: LazyRef => captureWildcards(tp.ref)
+    case tp: AnnotatedType => tp.derivedAnnotatedType(captureWildcards(tp.parent), tp.annot)
+    case _ => tp
+  }
+}
+
+trait Inferencing { this: Typer =>
+  import Inferencing._
+  import tpd._
+
+  /** Interpolate undetermined type variables in the widened type of this tree.
+   *  @param tree    the tree whose type is interpolated
+   *  @param pt      the expected result type
+   *  @param locked  the set of type variables of the current typer state that cannot be interpolated
+   *                 at the present time
+   *  Eligible for interpolation are all type variables owned by the current typerstate
+   *  that are not in `locked` and whose `nestingLevel` is `>= ctx.nestingLevel`.
+   *  Type variables occurring co- (respectively, contra-) variantly in the tree type
+   *  or expected type are minimized (respectvely, maximized). Non occurring type variables are minimized if they
+   *  have a lower bound different from Nothing, maximized otherwise. Type variables appearing
+   *  non-variantly in the type are left untouched.
+   *
+   *  Note that even type variables that do not appear directly in a type, can occur with
+   *  some variance in the type, because of the constraints. E.g if `X` occurs co-variantly in `T`
+   *  and we have a constraint
+   *
+   *      Y <: X
+   *
+   *  Then `Y` also occurs co-variantly in `T` because it needs to be minimized in order to constrain
+   *  `T` the least. See `variances` for more detail.
+   */
+  def interpolateTypeVars(tree: Tree, pt: Type, locked: TypeVars)(using Context): tree.type = {
+    val state = ctx.typerState
+
+    // Note that some variables in `locked` might not be in `state.ownedVars`
+    // anymore if they've been garbage-collected, so we can't use
+    // `state.ownedVars.size > locked.size` as an early check to avoid computing
+    // `qualifying`.
+
+    val ownedVars = state.ownedVars
+    if ((ownedVars ne locked) && !ownedVars.isEmpty) {
+      val qualifying = ownedVars -- locked
+      if (!qualifying.isEmpty) {
+        typr.println(i"interpolate $tree: ${tree.tpe.widen} in $state, pt = $pt, owned vars = ${state.ownedVars.toList}%, %, qualifying = ${qualifying.toList}%, %, previous = ${locked.toList}%, % / ${state.constraint}")
+        val resultAlreadyConstrained =
+          tree.isInstanceOf[Apply] || tree.tpe.isInstanceOf[MethodOrPoly]
+        if (!resultAlreadyConstrained)
+          constrainResult(tree.symbol, tree.tpe, pt)
+            // This is needed because it could establish singleton type upper bounds. See i2998.scala.
+
+        val tp = tree.tpe.widen
+        val vs = variances(tp, pt)
+
+        // Avoid interpolating variables occurring in tree's type if typerstate has unreported errors.
+        // Reason: The errors might reflect unsatisfiable constraints. In that
+        // case interpolating without taking account the constraints risks producing
+        // nonsensical types that then in turn produce incomprehensible errors.
+        // An example is in neg/i1240.scala. Without the condition in the next code line
+        // we get for
+        //
+        //      val y: List[List[String]] = List(List(1))
+        //
+        //     i1430.scala:5: error: type mismatch:
+        //     found   : Int(1)
+        //     required: Nothing
+        //     val y: List[List[String]] = List(List(1))
+        //                                           ^
+        // With the condition, we get the much more sensical:
+        //
+        //     i1430.scala:5: error: type mismatch:
+        //     found   : Int(1)
+        //     required: String
+        //     val y: List[List[String]] = List(List(1))
+        if state.reporter.hasUnreportedErrors then return tree
+
+        def constraint = state.constraint
+        type InstantiateQueue = mutable.ListBuffer[(TypeVar, Boolean)]
+        val toInstantiate = new InstantiateQueue
+        for tvar <- qualifying do
+          if !tvar.isInstantiated && constraint.contains(tvar) && tvar.nestingLevel >= ctx.nestingLevel then
+            constrainIfDependentParamRef(tvar, tree)
+            // Needs to be checked again, since previous interpolations could already have
+            // instantiated `tvar` through unification.
+            val v = vs(tvar)
+            if v == null then
+              // Even though `tvar` is non-occurring in `v`, the specific
+              // instantiation we pick still matters because `tvar` might appear
+              // in the bounds of a non-`qualifying` type variable in the
+              // constraint.
+              // In particular, if `tvar` was created as the upper or lower
+              // bound of an existing variable by `LevelAvoidMap`, we
+              // instantiate it in the direction corresponding to the
+              // original variable which might be further constrained later.
+              // Otherwise, we simply rely on `hasLowerBound`.
+              val name = tvar.origin.paramName
+              val fromBelow =
+                name.is(AvoidNameKind.UpperBound) ||
+                !name.is(AvoidNameKind.LowerBound) && tvar.hasLowerBound
+              typr.println(i"interpolate non-occurring $tvar in $state in $tree: $tp, fromBelow = $fromBelow, $constraint")
+              toInstantiate += ((tvar, fromBelow))
+            else if v.intValue != 0 then
+              typr.println(i"interpolate $tvar in $state in $tree: $tp, fromBelow = ${v.intValue == 1}, $constraint")
+              toInstantiate += ((tvar, v.intValue == 1))
+            else comparing(cmp =>
+              if !cmp.levelOK(tvar.nestingLevel, ctx.nestingLevel) then
+                // Invariant: The type of a tree whose enclosing scope is level
+                // N only contains type variables of level <= N.
+                typr.println(i"instantiate nonvariant $tvar of level ${tvar.nestingLevel} to a type variable of level <= ${ctx.nestingLevel}, $constraint")
+                cmp.atLevel(ctx.nestingLevel, tvar.origin)
+              else
+                typr.println(i"no interpolation for nonvariant $tvar in $state")
+            )
+
+        /** Instantiate all type variables in `buf` in the indicated directions.
+         *  If a type variable A is instantiated from below, and there is another
+         *  type variable B in `buf` that is known to be smaller than A, wait and
+         *  instantiate all other type variables before trying to instantiate A again.
+         *  Dually, wait instantiating a type variable from above as long as it has
+         *  upper bounds in `buf`.
+         *
+         *  This is done to avoid loss of precision when forming unions. An example
+         *  is in i7558.scala:
+         *
+         *      type Tr[+V1, +O1 <: V1]
+         *      extension [V2, O2 <: V2](tr: Tr[V2, O2]) def sl: Tr[V2, O2] = ???
+         *      def as[V3, O3 <: V3](tr: Tr[V3, O3]) : Tr[V3, O3] = tr.sl
+         *
+         *   Here we interpolate at some point V2 and O2 given the constraint
+         *
+         *      V2 >: V3, O2 >: O3, O2 <: V2
+         *
+         *   where O3 and V3 are type refs with O3 <: V3.
+         *   If we interpolate V2 first to V3 | O2, the widenUnion algorithm will
+         *   instantiate O2 to V3, leading to the final constraint
+         *
+         *      V2 := V3, O2 := V3
+         *
+         *   But if we instantiate O2 first to O3, and V2 next to V3, we get the
+         *   more flexible instantiation
+         *
+         *      V2 := V3, O2 := O3
+         */
+        def doInstantiate(buf: InstantiateQueue): Unit =
+          if buf.nonEmpty then
+            val suspended = new InstantiateQueue
+            while buf.nonEmpty do
+              val first @ (tvar, fromBelow) = buf.head
+              buf.dropInPlace(1)
+              if !tvar.isInstantiated then
+                val suspend = buf.exists{ (following, _) =>
+                  if fromBelow then
+                    constraint.isLess(following.origin, tvar.origin)
+                  else
+                    constraint.isLess(tvar.origin, following.origin)
+                }
+                if suspend then suspended += first else tvar.instantiate(fromBelow)
+              end if
+            end while
+            doInstantiate(suspended)
+        end doInstantiate
+        doInstantiate(toInstantiate)
+      }
+    }
+    tree
+  }
+
+  /** If `tvar` represents a parameter of a dependent method type in the current `call`
+   *  approximate it from below with the type of the actual argument. Skolemize that
+   *  type if necessary to make it a Singleton.
+   */
+  private def constrainIfDependentParamRef(tvar: TypeVar, call: Tree)(using Context): Unit =
+    if tvar.origin.paramName.is(NameKinds.DepParamName) then
+      representedParamRef(tvar.origin) match
+        case ref: TermParamRef =>
+          def findArg(tree: Tree)(using Context): Tree = tree match
+            case Apply(fn, args) =>
+              if fn.tpe.widen eq ref.binder then
+                if ref.paramNum < args.length then args(ref.paramNum)
+                else EmptyTree
+              else findArg(fn)
+            case TypeApply(fn, _) => findArg(fn)
+            case Block(_, expr) => findArg(expr)
+            case Inlined(_, _, expr) => findArg(expr)
+            case _ => EmptyTree
+
+          val arg = findArg(call)
+          if !arg.isEmpty then
+            var argType = arg.tpe.widenIfUnstable
+            if !argType.isSingleton then argType = SkolemType(argType)
+            argType <:< tvar
+        case _ =>
+  end constrainIfDependentParamRef
+}
+
+/** An enumeration controlling the degree of forcing in "is-dully-defined" checks. */
+@sharable object ForceDegree {
+  class Value(val appliesTo: TypeVar => Boolean, val ifBottom: IfBottom)
+  val none: Value = new Value(_ => false, IfBottom.ok)
+  val all: Value = new Value(_ => true, IfBottom.ok)
+  val failBottom: Value = new Value(_ => true, IfBottom.fail)
+  val flipBottom: Value = new Value(_ => true, IfBottom.flip)
+}
+
+enum IfBottom:
+  case ok, fail, flip
diff --git a/tests/pos-with-compiler-cc/dotc/typer/JavaChecks.scala b/tests/pos-with-compiler-cc/dotc/typer/JavaChecks.scala
new file mode 100644
index 000000000000..89caf5e1c474
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/typer/JavaChecks.scala
@@ -0,0 +1,26 @@
+package dotty.tools.dotc
+package typer
+
+import core.Contexts._
+import ast.tpd._
+
+/** PostTyper doesn't run on java sources,
+ *  but some checks still need to be applied.
+ */
+object JavaChecks {
+  /** Check the bounds of AppliedTypeTrees. */
+  private object AppliedTypeChecker extends TreeTraverser {
+    def traverse(tree: Tree)(using Context): Unit = tree match
+      case tpt: TypeTree =>
+        Checking.checkAppliedTypesIn(tpt)
+      case tree: AppliedTypeTree =>
+        Checking.checkAppliedType(tree)
+      case _ =>
+        traverseChildren(tree)
+  }
+
+  /** Scan a tree and check it. */
+  def check(tree: Tree)(using Context): Unit =
+    report.debuglog("checking type bounds in " + ctx.compilationUnit.source.name)
+    AppliedTypeChecker.traverse(tree)
+}
diff --git a/tests/pos-with-compiler-cc/dotc/typer/Namer.scala b/tests/pos-with-compiler-cc/dotc/typer/Namer.scala
new file mode 100644
index 000000000000..ad8d0e50d348
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/typer/Namer.scala
@@ -0,0 +1,1912 @@
+package dotty.tools
+package dotc
+package typer
+
+import core._
+import ast._
+import Trees._, StdNames._, Scopes._, Denotations._, NamerOps._, ContextOps._
+import Contexts._, Symbols._, Types._, SymDenotations._, Names._, NameOps._, Flags._
+import Decorators._, Comments.{_, given}
+import NameKinds.DefaultGetterName
+import ast.desugar, ast.desugar._
+import ProtoTypes._
+import util.Spans._
+import util.Property
+import collection.mutable
+import tpd.tpes
+import Variances.alwaysInvariant
+import config.{Config, Feature}
+import config.Printers.typr
+import inlines.{Inlines, PrepareInlineable}
+import parsing.JavaParsers.JavaParser
+import parsing.Parsers.Parser
+import Annotations._
+import Inferencing._
+import transform.ValueClasses._
+import transform.TypeUtils._
+import transform.SymUtils._
+import TypeErasure.erasure
+import reporting._
+import config.Feature.sourceVersion
+import config.SourceVersion._
+
+
+/** This class creates symbols from definitions and imports and gives them
+ *  lazy types.
+ *
+ *  Timeline:
+ *
+ *  During enter, trees are expanded as necessary, populating the expandedTree map.
+ *  Symbols are created, and the symOfTree map is set up.
+ *
+ *  Symbol completion causes some trees to be already typechecked and typedTree
+ *  entries are created to associate the typed trees with the untyped expanded originals.
+ *
+ *  During typer, original trees are first expanded using expandedTree. For each
+ *  expanded member definition or import we extract and remove the corresponding symbol
+ *  from the symOfTree map and complete it. We then consult the typedTree map to see
+ *  whether a typed tree exists already. If yes, the typed tree is returned as result.
+ *  Otherwise, we proceed with regular type checking.
+ *
+ *  The scheme is designed to allow sharing of nodes, as long as each duplicate appears
+ *  in a different method.
+ */
+class Namer { typer: Typer =>
+
+  import untpd._
+
+  val TypedAhead      : Property.Key[tpd.Tree]            = new Property.Key
+  val ExpandedTree    : Property.Key[untpd.Tree]          = new Property.Key
+  val ExportForwarders: Property.Key[List[tpd.MemberDef]] = new Property.Key
+  val SymOfTree       : Property.Key[Symbol]              = new Property.Key
+  val AttachedDeriver : Property.Key[Deriver]             = new Property.Key
+    // was `val Deriver`, but that gave shadowing problems with constructor proxies
+
+  /** A partial map from unexpanded member and pattern defs and to their expansions.
+   *  Populated during enterSyms, emptied during typer.
+   */
+  //lazy val expandedTree = new mutable.AnyRefMap[DefTree, Tree]
+  /*{
+    override def default(tree: DefTree) = tree // can't have defaults on AnyRefMaps :-(
+  }*/
+
+  /** A map from expanded MemberDef, PatDef or Import trees to their symbols.
+   *  Populated during enterSyms, emptied at the point a typed tree
+   *  with the same symbol is created (this can be when the symbol is completed
+   *  or at the latest when the tree is typechecked.
+   */
+  //lazy val symOfTree = new mutable.AnyRefMap[Tree, Symbol]
+
+  /** A map from expanded trees to their typed versions.
+   *  Populated when trees are typechecked during completion (using method typedAhead).
+   */
+  // lazy val typedTree = new mutable.AnyRefMap[Tree, tpd.Tree]
+
+  /** A map from method symbols to nested typers.
+   *  Populated when methods are completed. Emptied when they are typechecked.
+   *  The nested typer contains new versions of the four maps above including this
+   *  one, so that trees that are shared between different DefDefs can be independently
+   *  used as indices. It also contains a scope that contains nested parameters.
+   */
+  lazy val nestedTyper: mutable.AnyRefMap[Symbol, Typer] = new mutable.AnyRefMap
+
+  /** We are entering symbols coming from a SourceLoader */
+  private var lateCompile = false
+
+  /** The symbol of the given expanded tree. */
+  def symbolOfTree(tree: Tree)(using Context): Symbol = {
+    val xtree = expanded(tree)
+    xtree.getAttachment(TypedAhead) match {
+      case Some(ttree) => ttree.symbol
+      case none =>
+        xtree.getAttachment(SymOfTree) match
+          case Some(sym) => sym
+          case _ => throw IllegalArgumentException(i"$xtree does not have a symbol")
+    }
+  }
+
+  def hasDefinedSymbol(tree: Tree)(using Context): Boolean =
+    val xtree = expanded(tree)
+    xtree.hasAttachment(TypedAhead) || xtree.hasAttachment(SymOfTree)
+
+  /** The enclosing class with given name; error if none exists */
+  def enclosingClassNamed(name: TypeName, span: Span)(using Context): Symbol =
+    if (name.isEmpty) NoSymbol
+    else {
+      val cls = ctx.owner.enclosingClassNamed(name)
+      if (!cls.exists)
+        report.error(UnknownNamedEnclosingClassOrObject(name), ctx.source.atSpan(span))
+      cls
+    }
+
+  /** Record `sym` as the symbol defined by `tree` */
+  def recordSym(sym: Symbol, tree: Tree)(using Context): Symbol = {
+    for (refs <- tree.removeAttachment(References); ref <- refs) ref.watching(sym)
+    tree.pushAttachment(SymOfTree, sym)
+    sym
+  }
+
+  /** Check that a new definition with given name and privacy status
+   *  in current context would not conflict with existing currently
+   *  compiled definitions.
+   *  The logic here is very subtle and fragile due to the fact that
+   *  we are not allowed to force anything.
+   */
+  def checkNoConflict(name: Name, isPrivate: Boolean, span: Span)(using Context): Name =
+    val owner = ctx.owner
+    var conflictsDetected = false
+
+    def conflict(conflicting: Symbol) =
+      val other =
+        if conflicting.is(ConstructorProxy) then conflicting.companionClass
+        else conflicting
+      report.error(AlreadyDefined(name, owner, other), ctx.source.atSpan(span))
+      conflictsDetected = true
+
+    def checkNoConflictIn(owner: Symbol) =
+      val preExisting = owner.unforcedDecls.lookup(name)
+      if (preExisting.isDefinedInCurrentRun || preExisting.lastKnownDenotation.is(Package))
+          && (!preExisting.lastKnownDenotation.is(Private) || preExisting.owner.is(Package))
+          && (!preExisting.lastKnownDenotation.isPackageObject
+              || preExisting.associatedFile != ctx.source.file)
+              // isDefinedInCurrentRun does not work correctly for package objects, because
+              // package objects are updated to the new run earlier than normal classes, everytime
+              // some member of the enclosing package is accessed. Therefore, we use another
+              // test: conflict if package objects have the same name but come from different
+              // sources. See i9252.
+      then conflict(preExisting)
+
+    def pkgObjs(pkg: Symbol) =
+      pkg.denot.asInstanceOf[PackageClassDenotation].packageObjs.map(_.symbol)
+
+    if owner.is(PackageClass) then
+      checkNoConflictIn(owner)
+      for pkgObj <- pkgObjs(owner) do
+        checkNoConflictIn(pkgObj)
+    else
+      def preExisting = ctx.effectiveScope.lookup(name)
+      if (!owner.isClass || name.isTypeName) && preExisting.exists then
+        conflict(preExisting)
+      else if owner.isPackageObject && !isPrivate && name != nme.CONSTRUCTOR then
+        checkNoConflictIn(owner.owner)
+        for pkgObj <- pkgObjs(owner.owner) if pkgObj != owner do
+          checkNoConflictIn(pkgObj)
+
+    if conflictsDetected then name.freshened else name
+  end checkNoConflict
+
+  /** If this tree is a member def or an import, create a symbol of it
+   *  and store in symOfTree map.
+   */
+  def createSymbol(tree: Tree)(using Context): Symbol = {
+
+    def privateWithinClass(mods: Modifiers) =
+      enclosingClassNamed(mods.privateWithin, tree.span)
+
+    /** Check that flags are OK for symbol. This is done early to avoid
+     *  catastrophic failure when we create a TermSymbol with TypeFlags, or vice versa.
+     *  A more complete check is done in checkWellFormed.
+     *  Also, speculatively add a Local flag to private members that can be Local if
+     *  referred to exclusively from their owner's this-type. The Local flag is retracted in
+     *  `isAccessibleFrom` if the access not from such a this-type.
+     */
+    def checkFlags(flags: FlagSet) =
+      if (flags.isEmpty) flags
+      else {
+        val (ok, adapted, kind) = tree match {
+          case tree: TypeDef => (flags.isTypeFlags, flags.toTypeFlags, "type")
+          case _ => (flags.isTermFlags, flags.toTermFlags, "value")
+        }
+        def canBeLocal = tree match
+          case tree: MemberDef => SymDenotations.canBeLocal(tree.name, flags)
+          case _ => false
+        if !ok then
+          report.error(i"modifier(s) `${flags.flagsString}` incompatible with $kind definition", tree.srcPos)
+        if adapted.is(Private) && canBeLocal then adapted | Local else adapted
+      }
+
+    /** Add moduleClass/sourceModule to completer if it is for a module val or class */
+    def adjustIfModule(completer: LazyType, tree: MemberDef) =
+      if (tree.mods.is(Module)) adjustModuleCompleter(completer, tree.name)
+      else completer
+
+    typr.println(i"creating symbol for $tree in ${ctx.mode}")
+
+    /** Create new symbol or redefine existing symbol under lateCompile. */
+    def createOrRefine[S <: Symbol](
+        tree: MemberDef, name: Name, flags: FlagSet, owner: Symbol, infoFn: S => Type,
+        symFn: (FlagSet, S => Type, Symbol) => S): Symbol = {
+      val prev =
+        if (lateCompile && ctx.owner.is(Package)) ctx.effectiveScope.lookup(name)
+        else NoSymbol
+
+      var flags1 = flags
+      var privateWithin = privateWithinClass(tree.mods)
+      val effectiveOwner = owner.skipWeakOwner
+      if (flags.is(Private) && effectiveOwner.is(Package)) {
+        // If effective owner is a package p, widen private to private[p]
+        flags1 = flags1 &~ PrivateLocal
+        privateWithin = effectiveOwner
+      }
+
+      val sym =
+        if (prev.exists) {
+          prev.flags = flags1
+          prev.info = infoFn(prev.asInstanceOf[S])
+          prev.setPrivateWithin(privateWithin)
+          prev
+        }
+        else symFn(flags1, infoFn, privateWithin)
+      recordSym(sym, tree)
+    }
+
+    tree match {
+      case tree: TypeDef if tree.isClassDef =>
+        val flags = checkFlags(tree.mods.flags)
+        val name = checkNoConflict(tree.name, flags.is(Private), tree.span).asTypeName
+        val cls =
+          createOrRefine[ClassSymbol](tree, name, flags, ctx.owner,
+            cls => adjustIfModule(new ClassCompleter(cls, tree)(ctx), tree),
+            newClassSymbol(ctx.owner, name, _, _, _, tree.nameSpan, ctx.source.file))
+        cls.completer.asInstanceOf[ClassCompleter].init()
+        cls
+      case tree: MemberDef =>
+        var flags = checkFlags(tree.mods.flags)
+        val name = checkNoConflict(tree.name, flags.is(Private), tree.span)
+        tree match
+          case tree: ValOrDefDef =>
+            if tree.isInstanceOf[ValDef] && !flags.is(Param) && name.endsWith("_=") then
+              report.error("Names of vals or vars may not end in `_=`", tree.namePos)
+            if tree.unforcedRhs == EmptyTree
+               && !flags.isOneOf(TermParamOrAccessor)
+               && !tree.name.isConstructorName
+            then
+              flags |= Deferred
+            if (tree.isInstanceOf[DefDef]) flags |= Method
+            else if flags.isAllOf(EnumValue) && ctx.owner.isStaticOwner then flags |= JavaStatic
+          case tree: TypeDef =>
+            def analyzeRHS(rhs: Tree): Unit = rhs match
+              case _: TypeBoundsTree | _: MatchTypeTree =>
+                flags |= Deferred // Typedefs with Match rhs classify as abstract
+              case LambdaTypeTree(_, body) =>
+                analyzeRHS(body)
+              case _ =>
+                if rhs.isEmpty || flags.is(Opaque) then flags |= Deferred
+            analyzeRHS(tree.rhs)
+
+        // to complete a constructor, move one context further out -- this
+        // is the context enclosing the class. Note that the context in which a
+        // constructor is recorded and the context in which it is completed are
+        // different: The former must have the class as owner (because the
+        // constructor is owned by the class), the latter must not (because
+        // constructor parameters are interpreted as if they are outside the class).
+        // Don't do this for Java constructors because they need to see the import
+        // of the companion object, and it is not necessary for them because they
+        // have no implementation.
+        val cctx = if (tree.name == nme.CONSTRUCTOR && !flags.is(JavaDefined)) ctx.outer else ctx
+
+        val completer = tree match
+          case tree: TypeDef => TypeDefCompleter(tree)(cctx)
+          case _ => Completer(tree)(cctx)
+        val info = adjustIfModule(completer, tree)
+        createOrRefine[Symbol](tree, name, flags, ctx.owner, _ => info,
+          (fs, _, pwithin) => newSymbol(ctx.owner, name, fs, info, pwithin, tree.nameSpan))
+      case tree: Import =>
+        recordSym(newImportSymbol(ctx.owner, Completer(tree)(ctx), tree.span), tree)
+      case _ =>
+        NoSymbol
+    }
+  }
+
+   /** If `sym` exists, enter it in effective scope. Check that
+    *  package members are not entered twice in the same run.
+    */
+  def enterSymbol(sym: Symbol)(using Context): Unit =
+    // We do not enter Scala 2 macros defined in Scala 3 as they have an equivalent Scala 3 inline method.
+    if sym.exists && !sym.isScala2MacroInScala3 then
+      typr.println(s"entered: $sym in ${ctx.owner}")
+      ctx.enter(sym)
+
+  /** Create package if it does not yet exist. */
+  private def createPackageSymbol(pid: RefTree)(using Context): Symbol = {
+    val pkgOwner = pid match {
+      case Ident(_) => if (ctx.owner eq defn.EmptyPackageClass) defn.RootClass else ctx.owner
+      case Select(qual: RefTree, _) => createPackageSymbol(qual).moduleClass
+    }
+    val existing = pkgOwner.info.decls.lookup(pid.name)
+
+    if (existing.is(Package) && (pkgOwner eq existing.owner)) {
+      existing.moduleClass.denot match {
+        case d: PackageClassDenotation =>
+          // Remove existing members coming from a previous compilation of this file,
+          // they are obsolete.
+          d.unlinkFromFile(ctx.source.file)
+        case _ =>
+      }
+      existing
+    }
+    else {
+      /** If there's already an existing type, then the package is a dup of this type */
+      val existingType = pkgOwner.info.decls.lookup(pid.name.toTypeName)
+      if (existingType.exists) {
+        report.error(PkgDuplicateSymbol(existingType), pid.srcPos)
+        newCompletePackageSymbol(pkgOwner, (pid.name ++ "$_error_").toTermName).entered
+      }
+      else newCompletePackageSymbol(pkgOwner, pid.name.asTermName).entered
+    }
+  }
+
+  /** Expand tree and store in `expandedTree` */
+  def expand(tree: Tree)(using Context): Unit = {
+    def record(expanded: Tree) =
+      if (expanded `ne` tree) {
+        typr.println(i"Expansion: $tree expands to $expanded")
+        tree.pushAttachment(ExpandedTree, expanded)
+      }
+    tree match {
+      case tree: DefTree    => record(desugar.defTree(tree))
+      case tree: PackageDef => record(desugar.packageDef(tree))
+      case tree: ExtMethods => record(desugar.extMethods(tree))
+      case _                =>
+    }
+  }
+
+  /** The expanded version of this tree, or tree itself if not expanded */
+  def expanded(tree: Tree)(using Context): Tree = tree match {
+    case _: DefTree | _: PackageDef | _: ExtMethods => tree.attachmentOrElse(ExpandedTree, tree)
+    case _ => tree
+  }
+
+  /** For all class definitions `stat` in `xstats`: If the companion class is
+    * not also defined in `xstats`, invalidate it by setting its info to
+    * NoType.
+    */
+  def invalidateCompanions(pkg: Symbol, xstats: List[untpd.Tree])(using Context): Unit = {
+    val definedNames = xstats collect { case stat: NameTree => stat.name }
+    def invalidate(name: TypeName) =
+      if (!(definedNames contains name)) {
+        val member = pkg.info.decl(name).asSymDenotation
+        if (member.isClass && !(member.is(Package))) member.markAbsent()
+      }
+    xstats foreach {
+      case stat: TypeDef if stat.isClassDef =>
+        invalidate(stat.name.moduleClassName)
+      case _ =>
+    }
+  }
+
+  /** Expand tree and create top-level symbols for statement and enter them into symbol table */
+  def index(stat: Tree)(using Context): Context = {
+    expand(stat)
+    indexExpanded(stat)
+  }
+
+  /** Create top-level symbols for all statements in the expansion of this statement and
+   *  enter them into symbol table
+   */
+  def indexExpanded(origStat: Tree)(using Context): Context = {
+    def recur(stat: Tree): Context = stat match {
+      case pcl: PackageDef =>
+        val pkg = createPackageSymbol(pcl.pid)
+        index(pcl.stats)(using ctx.fresh.setOwner(pkg.moduleClass))
+        invalidateCompanions(pkg, Trees.flatten(pcl.stats map expanded))
+        setDocstring(pkg, stat)
+        ctx
+      case imp: Import =>
+        ctx.importContext(imp, createSymbol(imp))
+      case mdef: DefTree =>
+        val sym = createSymbol(mdef)
+        enterSymbol(sym)
+        setDocstring(sym, origStat)
+        addEnumConstants(mdef, sym)
+        ctx
+      case stats: Thicket =>
+        stats.toList.foreach(recur)
+        ctx
+      case _ =>
+        ctx
+    }
+    recur(expanded(origStat))
+  }
+
+  /** Determines whether this field holds an enum constant. */
+  def isEnumConstant(vd: ValDef)(using Context): Boolean =
+    vd.mods.isAllOf(JavaEnumValue)
+
+  /** Ensure that the first type in a list of parent types Ps points to a non-trait class.
+   *  If that's not already the case, add one. The added class type CT is determined as follows.
+   *  First, let C be the unique class such that
+   *  - there is a parent P_i such that P_i derives from C, and
+   *  - for every class D: If some parent P_j, j <= i derives from D, then C derives from D.
+   *  Then, let CT be the smallest type which
+   *  - has C as its class symbol, and
+   *  - for all parents P_i: If P_i derives from C then P_i <:< CT.
+   *
+   * Tweak: It could be that at the point where the method is called, some superclass
+   * is still missing its parents. Parents are set to Nil when completion starts and are
+   * set to the actual parents later. If a superclass completes a subclass in one
+   * of its parents, the parents of the superclass or some intervening class might
+   * not yet be set. This situation can be detected by asking for the baseType of Any -
+   * if that type does not exist, one of the base classes of this class misses its parents.
+   * If this situation arises, the computation of the superclass might be imprecise.
+   * For instance, in i12722.scala, the superclass of `IPersonalCoinOps` is computed
+   * as `Object`, where `JsObject` would be correct. The problem cannot be solved locally,
+   * but we detect the situaton and mark the superclass with a `@ProvisionalSuperClass`
+   * annotation in this case. When typechecking the class, we then run ensureFirstIsClass
+   * again and possibly improve the computed super class.
+   * An alternatiev fix would compute superclasses at typer instead at completion. But
+   * that breaks too many invariants. For instance, we rely on correct @Child annotations
+   * after completion, and these in turn need the superclass.
+   */
+  def ensureFirstIsClass(cls: ClassSymbol, parents: List[Type])(using Context): List[Type] =
+
+    def realClassParent(sym: Symbol): ClassSymbol =
+      if !sym.isClass then defn.ObjectClass
+      else if !sym.is(Trait) then sym.asClass
+      else sym.info.parents match
+        case parentRef :: _ => realClassParent(parentRef.typeSymbol)
+        case nil => defn.ObjectClass
+
+    def improve(candidate: ClassSymbol, parent: Type): ClassSymbol =
+      val pcls = realClassParent(parent.classSymbol)
+      if (pcls derivesFrom candidate) pcls else candidate
+
+    parents match
+      case p :: _ if p.classSymbol.isRealClass => parents
+      case _ =>
+        val pcls = parents.foldLeft(defn.ObjectClass)(improve)
+        typr.println(i"ensure first is class $parents%, % --> ${parents map (_ baseType pcls)}%, %")
+        val bases = parents.map(_.baseType(pcls))
+        var first = TypeComparer.glb(defn.ObjectType :: bases)
+        val isProvisional = parents.exists(!_.baseType(defn.AnyClass).exists)
+        if isProvisional then
+          typr.println(i"provisional superclass $first for $cls")
+          first = AnnotatedType(first, Annotation(defn.ProvisionalSuperClassAnnot))
+        checkFeasibleParent(first, cls.srcPos, em" in inferred superclass $first") :: parents
+  end ensureFirstIsClass
+
+  /** Add child annotation for `child` to annotations of `cls`. The annotation
+   *  is added at the correct insertion point, so that Child annotations appear
+   *  in reverse order of their start positions.
+   *  @pre `child` must have a position.
+   */
+  final def addChild(cls: Symbol, child: Symbol)(using Context): Unit = {
+    val childStart = if (child.span.exists) child.span.start else -1
+    def insertInto(annots: List[Annotation]): List[Annotation] =
+      annots.find(_.symbol == defn.ChildAnnot) match {
+        case Some(Annotation.Child(other)) if other.span.exists && childStart <= other.span.start =>
+          if (child == other)
+            annots // can happen if a class has several inaccessible children
+          else {
+            assert(childStart != other.span.start || child.source != other.source, i"duplicate child annotation $child / $other")
+            val (prefix, otherAnnot :: rest) = annots.span(_.symbol != defn.ChildAnnot): @unchecked
+            prefix ::: otherAnnot :: insertInto(rest)
+          }
+        case _ =>
+          Annotation.Child(child, cls.span.startPos) :: annots
+      }
+    cls.annotations = insertInto(cls.annotations)
+  }
+
+  /** Add java enum constants */
+  def addEnumConstants(mdef: DefTree, sym: Symbol)(using Context): Unit = mdef match {
+    case vdef: ValDef if (isEnumConstant(vdef)) =>
+      val enumClass = sym.owner.linkedClass
+      if (!enumClass.is(Sealed)) enumClass.setFlag(Flags.AbstractSealed)
+      addChild(enumClass, sym)
+    case _ =>
+  }
+
+  def setDocstring(sym: Symbol, tree: Tree)(using Context): Unit = tree match {
+    case t: MemberDef if t.rawComment.isDefined =>
+      ctx.docCtx.foreach(_.addDocstring(sym, t.rawComment))
+    case t: ExtMethods =>
+      for meth <- t.methods.find(_.span.point == sym.span.point) do
+        setDocstring(sym, meth)
+    case _ => ()
+  }
+
+  /** Create top-level symbols for statements and enter them into symbol table
+   *  @return A context that reflects all imports in `stats`.
+   */
+  def index(stats: List[Tree])(using Context): Context = {
+
+    // module name -> (stat, moduleCls | moduleVal)
+    val moduleClsDef = mutable.Map[TypeName, (Tree, TypeDef)]()
+    val moduleValDef = mutable.Map[TermName, (Tree, ValDef)]()
+
+    /** Remove the subtree `tree` from the expanded tree of `mdef` */
+    def removeInExpanded(mdef: Tree, tree: Tree): Unit = {
+      val Thicket(trees) = expanded(mdef): @unchecked
+      mdef.putAttachment(ExpandedTree, Thicket(trees.filter(_ != tree)))
+    }
+
+    /** Transfer all references to `from` to `to` */
+    def transferReferences(from: ValDef, to: ValDef): Unit = {
+      val fromRefs = from.removeAttachment(References).getOrElse(Nil)
+      val toRefs = to.removeAttachment(References).getOrElse(Nil)
+      to.putAttachment(References, fromRefs ++ toRefs)
+    }
+
+    /** Merge the module class `modCls` in the expanded tree of `mdef` with the
+     *  body and derived clause of the synthetic module class `fromCls`.
+     */
+    def mergeModuleClass(mdef: Tree, modCls: TypeDef, fromCls: TypeDef): TypeDef = {
+      var res: TypeDef | Null = null
+      val Thicket(trees) = expanded(mdef): @unchecked
+      val merged = trees.map { tree =>
+        if (tree == modCls) {
+          val fromTempl = fromCls.rhs.asInstanceOf[Template]
+          val modTempl = modCls.rhs.asInstanceOf[Template]
+          res = cpy.TypeDef(modCls)(
+            rhs = cpy.Template(modTempl)(
+              derived = if (fromTempl.derived.nonEmpty) fromTempl.derived else modTempl.derived,
+              body = fromTempl.body ++ modTempl.body))
+          if (fromTempl.derived.nonEmpty) {
+            if (modTempl.derived.nonEmpty)
+              report.error(em"a class and its companion cannot both have `derives` clauses", mdef.srcPos)
+            // `res` is inside a closure, so the flow-typing doesn't work here.
+            res.uncheckedNN.putAttachment(desugar.DerivingCompanion, fromTempl.srcPos.startPos)
+          }
+          res.uncheckedNN
+        }
+        else tree
+      }
+
+      mdef.putAttachment(ExpandedTree, Thicket(merged))
+
+      res.nn
+    }
+
+    /** Merge `fromCls` of `fromStat` into `toCls` of `toStat`
+     *  if the former is synthetic and the latter not.
+     *
+     *  Note:
+     *    1. `fromStat` and `toStat` could be the same stat
+     *    2. `fromCls` and `toCls` are necessarily different
+     */
+    def mergeIfSynthetic(fromStat: Tree, fromCls: TypeDef, toStat: Tree, toCls: TypeDef): Unit =
+      if (fromCls.mods.is(Synthetic) && !toCls.mods.is(Synthetic)) {
+        removeInExpanded(fromStat, fromCls)
+        val mcls = mergeModuleClass(toStat, toCls, fromCls)
+        mcls.setMods(toCls.mods)
+        moduleClsDef(fromCls.name) = (toStat, mcls)
+      }
+
+    /** Merge the definitions of a synthetic companion generated by a case class
+     *  and the real companion, if both exist.
+     */
+    def mergeCompanionDefs() = {
+      def valid(mdef: MemberDef): Boolean = mdef.mods.is(Module, butNot = Package)
+
+      for (stat <- stats)
+        expanded(stat) match {
+          case Thicket(trees) => // companion object always expands to thickets
+            trees.map {
+              case mcls @ TypeDef(name, impl: Template) if valid(mcls) =>
+                (moduleClsDef.get(name): @unchecked) match {
+                  case Some((stat1, mcls1@TypeDef(_, impl1: Template))) =>
+                    mergeIfSynthetic(stat, mcls, stat1, mcls1)
+                    mergeIfSynthetic(stat1, mcls1, stat, mcls)
+                  case None =>
+                    moduleClsDef(name) = (stat, mcls)
+                }
+
+              case vdef @ ValDef(name, _, _) if valid(vdef) =>
+                moduleValDef.get(name) match {
+                  case Some((stat1, vdef1)) =>
+                    if (vdef.mods.is(Synthetic) && !vdef1.mods.is(Synthetic)) {
+                      transferReferences(vdef, vdef1)
+                      removeInExpanded(stat, vdef)
+                    }
+                    else if (!vdef.mods.is(Synthetic) && vdef1.mods.is(Synthetic)) {
+                      transferReferences(vdef1, vdef)
+                      removeInExpanded(stat1, vdef1)
+                      moduleValDef(name) = (stat, vdef)
+                    }
+                    else {
+                      // double definition of objects or case classes, handled elsewhere
+                    }
+                  case None =>
+                    moduleValDef(name) = (stat, vdef)
+                }
+
+              case _ =>
+            }
+          case _ =>
+        }
+    }
+
+    val classDef  = mutable.Map[TypeName, TypeDef]()
+    val moduleDef = mutable.Map[TypeName, TypeDef]()
+
+    /** Create links between companion object and companion class.
+     *  Populate `moduleDef` and `classDef` as a side effect.
+     */
+    def createCompanionLinks()(using Context): Unit = {
+
+      def updateCache(cdef: TypeDef): Unit =
+        if (cdef.isClassDef && !cdef.mods.is(Package))
+          if (cdef.mods.is(ModuleClass)) moduleDef(cdef.name) = cdef
+          else classDef(cdef.name) = cdef
+
+      def createLinks(classTree: TypeDef, moduleTree: TypeDef)(using Context) = {
+        val claz = ctx.effectiveScope.lookup(classTree.name)
+        val modl = ctx.effectiveScope.lookup(moduleTree.name)
+        modl.registerCompanion(claz)
+        claz.registerCompanion(modl)
+      }
+
+      for (stat <- stats)
+        expanded(stat) match {
+          case cdef : TypeDef => updateCache(cdef)
+          case Thicket(trees) =>
+            trees.map {
+              case cdef: TypeDef => updateCache(cdef)
+              case _ =>
+            }
+          case _ =>
+        }
+
+      for (cdef @ TypeDef(name, _) <- classDef.values)
+        moduleDef.getOrElse(name.moduleClassName, EmptyTree) match {
+          case t: TypeDef =>
+            createLinks(cdef, t)
+          case EmptyTree =>
+        }
+    }
+
+    /** If a top-level object or class has no companion in the current run, we
+     *  enter a dummy companion (`denot.isAbsent` returns true) or constructor
+     *  proxy in scope. This ensures that we never use a companion from a previous
+     *  run or from thenclass path. See tests/pos/false-companion for an example
+     *  where this matters.
+     *  Also: We add constructor proxies for classes in some local scope, i.e.
+     *  that are not members of other classes. Constructor proxies for member
+     *  classes are added in addConstructorProxies.
+     */
+    def addAbsentCompanions()(using Context): Unit =
+      if ctx.owner.isTerm then
+        for case cdef @ TypeDef(className, _) <- classDef.values do
+          val classSym = ctx.effectiveScope.lookup(className)
+          val moduleName = className.toTermName
+          if needsConstructorProxies(classSym) && ctx.effectiveScope.lookupEntry(moduleName) == null then
+            enterSymbol(classConstructorCompanion(classSym.asClass))
+      else if ctx.owner.is(PackageClass) then
+        for case cdef @ TypeDef(moduleName, _) <- moduleDef.values do
+          val moduleSym = ctx.effectiveScope.lookup(moduleName)
+          if moduleSym.isDefinedInCurrentRun then
+            val className = moduleName.stripModuleClassSuffix.toTypeName
+            val classSym = ctx.effectiveScope.lookup(className)
+            if !classSym.isDefinedInCurrentRun then
+              val absentClassSymbol = newClassSymbol(ctx.owner, className, EmptyFlags, _ => NoType)
+              enterSymbol(absentClassSymbol)
+
+        for case cdef @ TypeDef(className, _) <- classDef.values do
+          val classSym = ctx.effectiveScope.lookup(className.encode)
+          if classSym.isDefinedInCurrentRun then
+            val moduleName = className.toTermName
+            val companionVals = ctx.effectiveScope.lookupAll(moduleName.encode)
+            if companionVals.isEmpty && needsConstructorProxies(classSym) then
+              enterSymbol(classConstructorCompanion(classSym.asClass))
+            else
+              for moduleSym <- companionVals do
+                if moduleSym.is(Module) && !moduleSym.isDefinedInCurrentRun then
+                  val companion =
+                    if needsConstructorProxies(classSym) then
+                      classConstructorCompanion(classSym.asClass)
+                    else newModuleSymbol(
+                      ctx.owner, moduleName, EmptyFlags, EmptyFlags, (_, _) => NoType)
+                  enterSymbol(companion)
+    end addAbsentCompanions
+
+    stats.foreach(expand)
+    mergeCompanionDefs()
+    val ctxWithStats = stats.foldLeft(ctx)((ctx, stat) => indexExpanded(stat)(using ctx))
+    inContext(ctxWithStats) {
+      createCompanionLinks()
+      addAbsentCompanions()
+    }
+    ctxWithStats
+  }
+
+  /** Parse the source and index symbols in the compilation unit's untpdTree
+   *  while asserting the `lateCompile` flag. This will cause any old
+   *  top-level symbol with the same fully qualified name as a newly created
+   *  symbol to be replaced.
+   *
+   *  Will call the callback with an implementation of type checking
+   *  That will set the tpdTree and root tree for the compilation unit.
+   */
+  def lateEnterUnit(typeCheckCB: (() => Unit) => Unit)(using Context) =
+    val unit = ctx.compilationUnit
+
+    /** Index symbols in unit.untpdTree with lateCompile flag = true */
+    def lateEnter()(using Context): Context =
+      val saved = lateCompile
+      lateCompile = true
+      try index(unit.untpdTree :: Nil) finally lateCompile = saved
+
+    /** Set the tpdTree and root tree of the compilation unit */
+    def lateTypeCheck()(using Context) =
+      unit.tpdTree = typer.typedExpr(unit.untpdTree)
+      val phase = new transform.SetRootTree()
+      phase.run
+
+    unit.untpdTree =
+      if (unit.isJava) new JavaParser(unit.source).parse()
+      else new Parser(unit.source).parse()
+
+    atPhase(Phases.typerPhase) {
+      inContext(PrepareInlineable.initContext(ctx)) {
+        // inline body annotations are set in namer, capturing the current context
+        // we need to prepare the context for inlining.
+        lateEnter()
+        typeCheckCB { () =>
+          lateTypeCheck()
+        }
+      }
+    }
+  end lateEnterUnit
+
+  /** The type bound on wildcard imports of an import list, with special values
+   *    Nothing  if no wildcard imports of this kind exist
+   *    Any      if there are unbounded wildcard imports of this kind
+   */
+  def importBound(sels: List[untpd.ImportSelector], isGiven: Boolean)(using Context): Type =
+    sels.foldLeft(defn.NothingType: Type) { (bound, sel) =>
+      if sel.isWildcard && sel.isGiven == isGiven then
+        if sel.bound.isEmpty then defn.AnyType
+        else bound | typedAheadType(sel.bound).tpe
+      else bound
+    }
+
+  def missingType(sym: Symbol, modifier: String)(using Context): Unit = {
+    report.error(s"${modifier}type of implicit definition needs to be given explicitly", sym.srcPos)
+    sym.resetFlag(GivenOrImplicit)
+  }
+
+  /** The completer of a symbol defined by a member def or import (except ClassSymbols) */
+  class Completer(val original: Tree)(ictx: Context) extends LazyType with SymbolLoaders.SecondCompleter {
+
+    protected def localContext(owner: Symbol): FreshContext = ctx.fresh.setOwner(owner).setTree(original)
+
+    /** The context with which this completer was created */
+    given creationContext: Context = ictx
+
+    // make sure testing contexts are not captured by completers
+    assert(!ictx.reporter.isInstanceOf[ExploringReporter])
+
+    protected def typeSig(sym: Symbol): Type = original match
+      case original: ValDef =>
+        if (sym.is(Module)) moduleValSig(sym)
+        else valOrDefDefSig(original, sym, Nil, identity)(using localContext(sym).setNewScope)
+      case original: DefDef =>
+        val typer1 = ctx.typer.newLikeThis(ctx.nestingLevel + 1)
+        nestedTyper(sym) = typer1
+        typer1.defDefSig(original, sym, this)(using localContext(sym).setTyper(typer1))
+      case imp: Import =>
+        try
+          val expr1 = typedImportQualifier(imp, typedAheadExpr(_, _)(using ctx.withOwner(sym)))
+          ImportType(expr1)
+        catch case ex: CyclicReference =>
+          typr.println(s"error while completing ${imp.expr}")
+          throw ex
+
+    final override def complete(denot: SymDenotation)(using Context): Unit = {
+      if (Config.showCompletions && ctx.typerState != creationContext.typerState) {
+        def levels(c: Context): Int =
+          if (c.typerState eq creationContext.typerState) 0
+          else if (c.outer.typerState == c.typerState) levels(c.outer)
+          else levels(c.outer) + 1
+        println(s"!!!completing ${denot.symbol.showLocated} in buried typerState, gap = ${levels(ctx)}")
+      }
+      val creationRunId = creationContext.runId
+      if ctx.runId > creationRunId then
+        assert(ctx.mode.is(Mode.Interactive), s"completing $denot in wrong run ${ctx.runId}, was created in $creationRunId")
+        denot.info = UnspecifiedErrorType
+      else
+        try
+          completeInCreationContext(denot)
+          if (denot.isCompleted) registerIfChild(denot)
+        catch
+          case ex: CompilationUnit.SuspendException =>
+            val completer = SuspendCompleter()
+            denot.info = completer
+            completer.complete(denot)
+    }
+
+    private var completedTypeParamSyms: List[TypeSymbol] | Null = null
+
+    def setCompletedTypeParams(tparams: List[TypeSymbol]) =
+      completedTypeParamSyms = tparams
+
+    override def completerTypeParams(sym: Symbol)(using Context): List[TypeSymbol] =
+      if completedTypeParamSyms != null then completedTypeParamSyms.uncheckedNN
+      else Nil
+
+    protected def addAnnotations(sym: Symbol): Unit = original match {
+      case original: untpd.MemberDef =>
+        lazy val annotCtx = annotContext(original, sym)
+        for (annotTree <- original.mods.annotations) {
+          val cls = typedAheadAnnotationClass(annotTree)(using annotCtx)
+          if (cls eq sym)
+            report.error("An annotation class cannot be annotated with iself", annotTree.srcPos)
+          else {
+            val ann = Annotation.deferred(cls)(typedAheadAnnotation(annotTree)(using annotCtx))
+            sym.addAnnotation(ann)
+          }
+        }
+      case _ =>
+    }
+
+    private def addInlineInfo(sym: Symbol) = original match {
+      case original: untpd.DefDef if sym.isInlineMethod =>
+        def rhsToInline(using Context): tpd.Tree =
+          if !original.symbol.exists && !hasDefinedSymbol(original) then
+            throw
+              if sym.isCompleted then Inlines.MissingInlineInfo()
+              else CyclicReference(sym)
+          val mdef = typedAheadExpr(original).asInstanceOf[tpd.DefDef]
+          PrepareInlineable.wrapRHS(original, mdef.tpt, mdef.rhs)
+        PrepareInlineable.registerInlineInfo(sym, rhsToInline)(using localContext(sym))
+      case _ =>
+    }
+
+    /** Invalidate `denot` by overwriting its info with `NoType` if
+     *  `denot` is a compiler generated case class method that clashes
+     *  with a user-defined method in the same scope with a matching type.
+     */
+    private def invalidateIfClashingSynthetic(denot: SymDenotation): Unit =
+
+      def isCaseClassOrCompanion(owner: Symbol) =
+        owner.isClass && {
+          if (owner.is(Module)) owner.linkedClass.is(CaseClass)
+          else owner.is(CaseClass)
+        }
+
+      def definesMember =
+        denot.owner.info.decls.lookupAll(denot.name).exists(alt =>
+          alt != denot.symbol && alt.info.matchesLoosely(denot.info))
+
+      def inheritsConcreteMember =
+        denot.owner.asClass.info.parents.exists(parent =>
+          parent.member(denot.name).hasAltWith(sd =>
+            !sd.symbol.is(Deferred) && sd.matches(denot)))
+
+      val isClashingSynthetic =
+        denot.is(Synthetic, butNot = ConstructorProxy)
+        && desugar.isRetractableCaseClassMethodName(denot.name)
+        && isCaseClassOrCompanion(denot.owner)
+        && (definesMember || inheritsConcreteMember)
+
+      if isClashingSynthetic then
+        typr.println(i"invalidating clashing $denot in ${denot.owner}")
+        denot.markAbsent()
+    end invalidateIfClashingSynthetic
+
+    /** If completed symbol is an enum value or a named class, register it as a child
+     *  in all direct parent classes which are sealed.
+     */
+    def registerIfChild(denot: SymDenotation)(using Context): Unit = {
+      val sym = denot.symbol
+
+      def register(child: Symbol, parentCls: ClassSymbol) = {
+        if (parentCls.is(Sealed))
+          if ((child.isInaccessibleChildOf(parentCls) || child.isAnonymousClass) && !sym.hasAnonymousChild)
+            addChild(parentCls, parentCls)
+          else if (!parentCls.is(ChildrenQueried))
+            addChild(parentCls, child)
+          else
+            report.error(em"""children of $parentCls were already queried before $sym was discovered.
+                          |As a remedy, you could move $sym on the same nesting level as $parentCls.""",
+                      child.srcPos)
+      }
+
+      if denot.isClass && !sym.isEnumAnonymClass && !sym.isRefinementClass then
+        val child = if (denot.is(Module)) denot.sourceModule else denot.symbol
+        denot.info.parents.foreach { parent => register(child, parent.classSymbol.asClass) }
+      else if denot.is(CaseVal, butNot = MethodOrModule) then
+        assert(denot.is(Enum), denot)
+        denot.info.classSymbols.foreach { parent => register(denot.symbol, parent) }
+      end if
+    }
+
+    /** Intentionally left without `implicit ctx` parameter. We need
+     *  to pick up the context at the point where the completer was created.
+     */
+    def completeInCreationContext(denot: SymDenotation): Unit = {
+      val sym = denot.symbol
+      addAnnotations(sym)
+      addInlineInfo(sym)
+      denot.info = typeSig(sym)
+      invalidateIfClashingSynthetic(denot)
+      Checking.checkWellFormed(sym)
+      denot.info = avoidPrivateLeaks(sym)
+    }
+  }
+
+  class TypeDefCompleter(original: TypeDef)(ictx: Context)
+  extends Completer(original)(ictx) with TypeParamsCompleter {
+    private var myTypeParams: List[TypeSymbol] | Null = null
+    private var nestedCtx: Context | Null = null
+    assert(!original.isClassDef)
+
+    /** If completion of the owner of the to be completed symbol has not yet started,
+     *  complete the owner first and check again. This prevents cyclic references
+     *  where we need to copmplete a type parameter that has an owner that is not
+     *  yet completed. Test case is pos/i10967.scala.
+     */
+    override def needsCompletion(symd: SymDenotation)(using Context): Boolean =
+      val owner = symd.owner
+      !owner.exists
+      || owner.is(Touched)
+      || {
+        owner.ensureCompleted()
+        !symd.isCompleted
+      }
+
+    override def completerTypeParams(sym: Symbol)(using Context): List[TypeSymbol] =
+      if myTypeParams == null then
+        //println(i"completing type params of $sym in ${sym.owner}")
+        nestedCtx = localContext(sym).setNewScope
+        given Context = nestedCtx.uncheckedNN
+
+        def typeParamTrees(tdef: Tree): List[TypeDef] = tdef match
+          case TypeDef(_, original) =>
+            original match
+              case LambdaTypeTree(tparams, _) => tparams
+              case original: DerivedFromParamTree => typeParamTrees(original.watched)
+              case _ => Nil
+          case _ => Nil
+
+        val tparams = typeParamTrees(original)
+        index(tparams)
+        myTypeParams = tparams.map(symbolOfTree(_).asType)
+        for param <- tparams do typedAheadExpr(param)
+      end if
+      myTypeParams.uncheckedNN
+    end completerTypeParams
+
+    override final def typeSig(sym: Symbol): Type =
+      val tparamSyms = completerTypeParams(sym)(using ictx)
+      given ctx: Context = nestedCtx.nn
+
+      def abstracted(tp: TypeBounds): TypeBounds =
+        HKTypeLambda.boundsFromParams(tparamSyms, tp)
+
+      val dummyInfo1 = abstracted(TypeBounds.empty)
+      sym.info = dummyInfo1
+      sym.setFlag(Provisional)
+        // Temporarily set info of defined type T to ` >: Nothing <: Any.
+        // This is done to avoid cyclic reference errors for F-bounds.
+        // This is subtle: `sym` has now an empty TypeBounds, but is not automatically
+        // made an abstract type. If it had been made an abstract type, it would count as an
+        // abstract type of its enclosing class, which might make that class an invalid
+        // prefix. I verified this would lead to an error when compiling io.ClassPath.
+        // A distilled version is in pos/prefix.scala.
+        //
+        // The scheme critically relies on an implementation detail of isRef, which
+        // inspects a TypeRef's info, instead of simply dealiasing alias types.
+
+      val isDerived = original.rhs.isInstanceOf[untpd.DerivedTypeTree]
+      val rhs = original.rhs match {
+        case LambdaTypeTree(_, body) => body
+        case rhs => rhs
+      }
+
+      // For match types: approximate with upper bound while evaluating the rhs.
+      val dummyInfo2 = rhs match {
+        case MatchTypeTree(bound, _, _) if !bound.isEmpty =>
+          abstracted(TypeBounds.upper(typedAheadType(bound).tpe))
+        case _ =>
+          dummyInfo1
+      }
+      sym.info = dummyInfo2
+
+      // Treat the parameters of an upper type lambda bound on the RHS as non-variant.
+      // E.g.   type F <: [X] =>> G   and   type F[X] <: G
+      // are treated alike.
+      def addVariances(tp: Type): Type = tp match
+        case tp: TypeBounds =>
+          def recur(tp: Type): Type = tp match
+            case tp: HKTypeLambda if !tp.isDeclaredVarianceLambda =>
+              val tp1 = tp.withVariances(tp.paramNames.map(alwaysInvariant))
+              tp1.derivedLambdaType(resType = recur(tp1.resType))
+            case tp => tp
+          tp.derivedTypeBounds(tp.lo, recur(tp.hi))
+        case _ =>
+          tp
+
+      val rhs1 = typedAheadType(rhs)
+      val rhsBodyType: TypeBounds = addVariances(rhs1.tpe).toBounds
+      val unsafeInfo = if (isDerived) rhsBodyType else abstracted(rhsBodyType)
+
+      def opaqueToBounds(info: Type): Type =
+        if sym.isOpaqueAlias then
+          if info.typeParams.nonEmpty && info.hkResult.typeParams.nonEmpty then
+            report.error(em"opaque type alias cannot have multiple type parameter lists", rhs.srcPos)
+          sym.opaqueToBounds(info, rhs1, tparamSyms)
+        else
+          info
+
+      if (isDerived) sym.info = unsafeInfo
+      else {
+        sym.info = NoCompleter
+        sym.info = opaqueToBounds(checkNonCyclic(sym, unsafeInfo, reportErrors = true))
+      }
+      if sym.isOpaqueAlias then sym.typeRef.recomputeDenot() // make sure we see the new bounds from now on
+      sym.resetFlag(Provisional)
+
+      // Here we pay the price for the cavalier setting info to TypeBounds.empty above.
+      // We need to compensate by reloading the denotation of references that might
+      // still contain the TypeBounds.empty. If we do not do this, stdlib factories
+      // fail with a bounds error in PostTyper.
+      def ensureUpToDate(tref: TypeRef, outdated: Type) =
+        if (tref.info == outdated && sym.info != outdated) tref.recomputeDenot()
+      ensureUpToDate(sym.typeRef, dummyInfo1)
+      if (dummyInfo2 `ne` dummyInfo1) ensureUpToDate(sym.typeRef, dummyInfo2)
+
+      sym.info
+    end typeSig
+  }
+
+  class ClassCompleter(cls: ClassSymbol, original: TypeDef)(ictx: Context) extends Completer(original)(ictx) {
+    withDecls(newScope(using ictx))
+
+    protected implicit val completerCtx: Context = localContext(cls)
+
+    private var localCtx: Context = _
+
+    /** info to be used temporarily while completing the class, to avoid cyclic references. */
+    private var tempInfo: TempClassInfo | Null = null
+
+    val TypeDef(name, impl @ Template(constr, _, self, _)) = original: @unchecked
+
+    private val (params, rest): (List[Tree], List[Tree]) = impl.body.span {
+      case td: TypeDef => td.mods.is(Param)
+      case vd: ValDef => vd.mods.is(ParamAccessor)
+      case _ => false
+    }
+
+    def init(): Context = index(params)
+
+    /** The forwarders defined by export `exp`
+     *  @param  pathMethod  If it exists, the symbol referenced by the path of an export
+     *                      in an extension clause. That symbol is always a companion
+     *                      extension method.
+     */
+    private def exportForwarders(exp: Export, pathMethod: Symbol)(using Context): List[tpd.MemberDef] =
+      val buf = new mutable.ListBuffer[tpd.MemberDef]
+      val Export(expr, selectors) = exp
+      if expr.isEmpty then
+        report.error(em"Export selector must have prefix and `.`", exp.srcPos)
+        return Nil
+
+      val (path, pathType) =
+        if pathMethod.exists then
+          val path = typedAhead(expr, _.withType(pathMethod.termRef))
+          (path, pathMethod.info.finalResultType)
+        else
+          val path = typedAheadExpr(expr, AnySelectionProto)
+          checkLegalExportPath(path, selectors)
+          (path, path.tpe)
+      lazy val wildcardBound = importBound(selectors, isGiven = false)
+      lazy val givenBound = importBound(selectors, isGiven = true)
+
+      val targets = mutable.Set[Name]()
+      def canForward(mbr: SingleDenotation, alias: TermName): CanForward = {
+        import CanForward.*
+        val sym = mbr.symbol
+        if !sym.isAccessibleFrom(pathType) then
+          No("is not accessible")
+        else if sym.isConstructor || sym.is(ModuleClass) || sym.is(Bridge) || sym.is(ConstructorProxy) || sym.isAllOf(JavaModule) then
+          Skip
+        else if cls.derivesFrom(sym.owner) && (sym.owner == cls || !sym.is(Deferred)) then
+          No(i"is already a member of $cls")
+        else if pathMethod.exists && mbr.isType then
+          No("is a type, so it cannot be exported as extension method")
+        else if pathMethod.exists && sym.is(ExtensionMethod) then
+          No("is already an extension method, cannot be exported into another one")
+        else if targets.contains(alias) then
+          No(i"clashes with another export in the same export clause")
+        else if sym.is(Override) then
+          sym.allOverriddenSymbols.find(
+            other => cls.derivesFrom(other.owner) && !other.is(Deferred)
+          ) match
+              case Some(other) => No(i"overrides ${other.showLocated}, which is already a member of $cls")
+              case None => Yes
+        else
+          Yes
+      }
+
+      def foreachDefaultGetterOf(sym: TermSymbol, op: TermSymbol => Unit): Unit =
+        var n = 0
+        for params <- sym.paramSymss; param <- params do
+          if param.isTerm then
+            if param.is(HasDefault) then
+              val getterName = DefaultGetterName(sym.name, n)
+              val getter = pathType.member(DefaultGetterName(sym.name, n)).symbol
+              assert(getter.exists, i"$path does not have a default getter named $getterName")
+              op(getter.asTerm)
+            n += 1
+
+      /** Add a forwarder with name `alias` or its type name equivalent to `mbr`,
+        *  provided `mbr` is accessible and of the right implicit/non-implicit kind.
+        */
+      def addForwarder(alias: TermName, mbr: SingleDenotation, span: Span): Unit =
+
+        def adaptForwarderParams(acc: List[List[tpd.Tree]], tp: Type, prefss: List[List[tpd.Tree]])
+          : List[List[tpd.Tree]] = tp match
+            case mt: MethodType
+            if mt.paramInfos.nonEmpty && mt.paramInfos.last.isRepeatedParam =>
+              // Note: in this branch we use the assumptions
+              // that `prefss.head` corresponds to `mt.paramInfos` and
+              // that `prefss.tail` corresponds to `mt.resType`
+              val init :+ vararg = prefss.head: @unchecked
+              val prefs = init :+ ctx.typeAssigner.seqToRepeated(vararg)
+              adaptForwarderParams(prefs :: acc, mt.resType, prefss.tail)
+            case mt: MethodOrPoly =>
+              adaptForwarderParams(prefss.head :: acc, mt.resultType, prefss.tail)
+            case _ =>
+              acc.reverse ::: prefss
+
+        if canForward(mbr, alias) == CanForward.Yes then
+          val sym = mbr.symbol
+          val hasDefaults = sym.hasDefaultParams // compute here to ensure HasDefaultParams and NoDefaultParams flags are set
+          val forwarder =
+            if mbr.isType then
+              val forwarderName = checkNoConflict(alias.toTypeName, isPrivate = false, span)
+              var target = pathType.select(sym)
+              if target.typeParams.nonEmpty then
+                target = target.EtaExpand(target.typeParams)
+              newSymbol(
+                cls, forwarderName,
+                Exported | Final,
+                TypeAlias(target),
+                coord = span)
+              // Note: This will always create unparameterzied aliases. So even if the original type is
+              // a parameterized class, say `C[X]` the alias will read `type C = d.C`. We currently do
+              // allow such type aliases. If we forbid them at some point (requiring the referred type to be
+              // fully applied), we'd have to change the scheme here as well.
+            else
+              def refersToPrivate(tp: Type): Boolean = tp match
+                case tp: TermRef => tp.termSymbol.is(Private) || refersToPrivate(tp.prefix)
+                case _ => false
+              val (maybeStable, mbrInfo) =
+                if sym.isStableMember
+                    && sym.isPublic
+                    && pathType.isStable
+                    && !refersToPrivate(pathType)
+                then
+                  (StableRealizable, ExprType(pathType.select(sym)))
+                else
+                  def addPathMethodParams(pathType: Type, info: Type): Type =
+                    def defines(pt: Type, pname: Name): Boolean = pt match
+                      case pt: MethodOrPoly =>
+                        pt.paramNames.contains(pname) || defines(pt.resType, pname)
+                      case _ =>
+                        false
+                    def avoidNameClashes(info: Type): Type = info match
+                      case info: MethodOrPoly =>
+                        info.derivedLambdaType(
+                          paramNames = info.paramNames.mapConserve {
+                            pname => if defines(pathType, pname) then pname.freshened else pname
+                          },
+                          resType = avoidNameClashes(info.resType))
+                      case info =>
+                        info
+                    def wrap(pt: Type, info: Type): Type = pt match
+                      case pt: MethodOrPoly =>
+                        pt.derivedLambdaType(resType = wrap(pt.resType, info))
+                      case _ =>
+                        info
+                    wrap(pathType, avoidNameClashes(info))
+
+                  val mbrInfo =
+                    if pathMethod.exists
+                    then addPathMethodParams(pathMethod.info, mbr.info.widenExpr)
+                    else mbr.info.ensureMethodic
+                  (EmptyFlags, mbrInfo)
+              var flagMask = RetainedExportFlags
+              if sym.isTerm then flagMask |= HasDefaultParams | NoDefaultParams
+              var mbrFlags = Exported | Method | Final | maybeStable | sym.flags & flagMask
+              if sym.is(ExtensionMethod) || pathMethod.exists then
+                mbrFlags |= ExtensionMethod
+              val forwarderName = checkNoConflict(alias, isPrivate = false, span)
+              newSymbol(cls, forwarderName, mbrFlags, mbrInfo, coord = span)
+
+          forwarder.info = avoidPrivateLeaks(forwarder)
+          forwarder.addAnnotations(sym.annotations.filterConserve(_.symbol != defn.BodyAnnot))
+
+          if forwarder.isType then
+            buf += tpd.TypeDef(forwarder.asType).withSpan(span)
+          else
+            import tpd._
+            def extensionParamsCount(pt: Type): Int = pt match
+              case pt: MethodOrPoly => 1 + extensionParamsCount(pt.resType)
+              case _ => 0
+            val ddef = tpd.DefDef(forwarder.asTerm, prefss => {
+              val (pathRefss, methRefss) = prefss.splitAt(extensionParamsCount(path.tpe.widen))
+              val ref = path.appliedToArgss(pathRefss).select(sym.asTerm)
+              ref.appliedToArgss(adaptForwarderParams(Nil, sym.info, methRefss))
+                .etaExpandCFT(using ctx.withOwner(forwarder))
+            })
+            if forwarder.isInlineMethod then
+              PrepareInlineable.registerInlineInfo(forwarder, ddef.rhs)
+            buf += ddef.withSpan(span)
+            if hasDefaults then
+              foreachDefaultGetterOf(sym.asTerm,
+                getter => addForwarder(
+                  getter.name.asTermName, getter.asSeenFrom(path.tpe), span))
+      end addForwarder
+
+      def addForwardersNamed(name: TermName, alias: TermName, span: Span): Unit =
+        val size = buf.size
+        val mbrs = List(name, name.toTypeName).flatMap(pathType.member(_).alternatives)
+        mbrs.foreach(addForwarder(alias, _, span))
+        if buf.size == size then
+          val reason = mbrs.map(canForward(_, alias)).collect {
+            case CanForward.No(whyNot) => i"\n$path.$name cannot be exported because it $whyNot"
+          }.headOption.getOrElse("")
+          report.error(i"""no eligible member $name at $path$reason""", ctx.source.atSpan(span))
+        else
+          targets += alias
+
+      def addWildcardForwardersNamed(name: TermName, span: Span): Unit =
+        List(name, name.toTypeName)
+          .flatMap(pathType.memberBasedOnFlags(_, excluded = Private|Given|ConstructorProxy).alternatives)
+          .foreach(addForwarder(name, _, span)) // ignore if any are not added
+
+      def addWildcardForwarders(seen: List[TermName], span: Span): Unit =
+        val nonContextual = mutable.HashSet(seen: _*)
+        val fromCaseClass = pathType.widen.classSymbols.exists(_.is(Case))
+        def isCaseClassSynthesized(mbr: Symbol) =
+          fromCaseClass && defn.caseClassSynthesized.contains(mbr)
+        for mbr <- pathType.membersBasedOnFlags(required = EmptyFlags, excluded = PrivateOrSynthetic) do
+          if !mbr.symbol.isSuperAccessor
+              // Scala 2 superaccessors have neither Synthetic nor Artfact set, so we
+              // need to filter them out here (by contrast, Scala 3 superaccessors are Artifacts)
+              // Symbols from base traits of case classes that will get synthesized implementations
+              // at PostTyper are also excluded.
+            && !isCaseClassSynthesized(mbr.symbol)
+            && !mbr.symbol.name.is(DefaultGetterName)
+              // default getters are exported with the members they belong to
+          then
+            val alias = mbr.name.toTermName
+            if mbr.symbol.is(Given) then
+              if !seen.contains(alias) && mbr.matchesImportBound(givenBound) then
+                addForwarder(alias, mbr, span)
+            else if !nonContextual.contains(alias) && mbr.matchesImportBound(wildcardBound) then
+              nonContextual += alias
+              addWildcardForwardersNamed(alias, span)
+
+      def addForwarders(sels: List[untpd.ImportSelector], seen: List[TermName]): Unit = sels match
+        case sel :: sels1 =>
+          if sel.isWildcard then
+            addWildcardForwarders(seen, sel.span)
+          else
+            if sel.rename != nme.WILDCARD then
+              addForwardersNamed(sel.name, sel.rename, sel.span)
+            addForwarders(sels1, sel.name :: seen)
+        case _ =>
+
+      /** Avoid a clash of export forwarder `forwarder` with other forwarders in `forwarders`.
+       *  @return If `forwarder` clashes, a new leading forwarder and trailing forwarders list
+       *          that avoids the clash according to the scheme described in `avoidClashes`.
+       *          If there's no clash, the inputs as they are in a pair.
+       */
+      def avoidClashWith(forwarder: tpd.DefDef, forwarders: List[tpd.MemberDef]): (tpd.DefDef, List[tpd.MemberDef]) =
+        def clashes(fwd1: Symbol, fwd2: Symbol) =
+          fwd1.targetName == fwd2.targetName
+          && erasure(fwd1.info).signature == erasure(fwd2.info).signature
+
+        forwarders match
+          case forwarders @ ((forwarder1: tpd.DefDef) :: forwarders1)
+          if forwarder.name == forwarder1.name =>
+            if clashes(forwarder.symbol, forwarder1.symbol) then
+              val alt1 = tpd.methPart(forwarder.rhs).tpe
+              val alt2 = tpd.methPart(forwarder1.rhs).tpe
+              val cmp = alt1 match
+                case alt1: TermRef => alt2 match
+                  case alt2: TermRef => compare(alt1, alt2)
+                  case _ => 0
+                case _ => 0
+              if cmp == 0 then
+                report.error(
+                  ex"""Clashing exports: The exported
+                      |     ${forwarder.rhs.symbol}: ${alt1.widen}
+                      |and  ${forwarder1.rhs.symbol}: ${alt2.widen}
+                      |have the same signature after erasure and overloading resolution could not disambiguate.""",
+                  exp.srcPos)
+              avoidClashWith(if cmp < 0 then forwarder1 else forwarder, forwarders1)
+            else
+              val (forwarder2, forwarders2) = avoidClashWith(forwarder, forwarders1)
+              (forwarder2, forwarders.derivedCons(forwarder1, forwarders2))
+          case _ =>
+            (forwarder, forwarders)
+      end avoidClashWith
+
+      /** Avoid clashes of any two export forwarders in `forwarders`.
+       *  A clash is if two forwarders f1 and f2 have the same name and signatures after erasure.
+       *  We try to avoid a clash by dropping one of f1 and f2, keeping the one whose right hand
+       *  side reference would be preferred by overloading resolution.
+       *  If neither of f1 or f2 is preferred over the other, report an error.
+       *
+       *  The idea is that this simulates the hypothetical case where export forwarders
+       *  are not generated and we treat an export instead more like an import where we
+       *  expand the use site reference. Test cases in {neg,pos}/i14699.scala.
+       *
+       *  @pre Forwarders with the same name are consecutive in `forwarders`.
+       */
+      def avoidClashes(forwarders: List[tpd.MemberDef]): List[tpd.MemberDef] = forwarders match
+        case forwarders @ (forwarder :: forwarders1) =>
+          val (forwarder2, forwarders2) = forwarder match
+            case forwarder: tpd.DefDef => avoidClashWith(forwarder, forwarders1)
+            case _ => (forwarder, forwarders1)
+          forwarders.derivedCons(forwarder2, avoidClashes(forwarders2))
+        case Nil => forwarders
+
+      addForwarders(selectors, Nil)
+      val forwarders = avoidClashes(buf.toList)
+      exp.pushAttachment(ExportForwarders, forwarders)
+      forwarders
+    end exportForwarders
+
+    /** Add forwarders as required by the export statements in this class */
+    private def processExports(using Context): Unit =
+
+      def processExport(exp: Export, pathSym: Symbol)(using Context): Unit =
+        for forwarder <- exportForwarders(exp, pathSym) do
+          forwarder.symbol.entered
+
+      def exportPathSym(path: Tree, ext: ExtMethods)(using Context): Symbol =
+        def fail(msg: String): Symbol =
+          report.error(em"export qualifier $msg", path.srcPos)
+          NoSymbol
+        path match
+          case Ident(name) =>
+            def matches(cand: Tree) = cand match
+              case meth: DefDef => meth.name == name && meth.paramss.hasSameLengthAs(ext.paramss)
+              case _ => false
+            expanded(ext).toList.filter(matches) match
+              case cand :: Nil => symbolOfTree(cand)
+              case Nil => fail(i"$name is not a parameterless companion extension method")
+              case _ => fail(i"$name cannot be overloaded")
+          case _ =>
+            fail("must be a simple reference to a companion extension method")
+
+      def process(stats: List[Tree])(using Context): Unit = stats match
+        case (stat: Export) :: stats1 =>
+          processExport(stat, NoSymbol)
+          process(stats1)
+        case (stat: Import) :: stats1 =>
+          process(stats1)(using ctx.importContext(stat, symbolOfTree(stat)))
+        case (stat: ExtMethods) :: stats1 =>
+          for case exp: Export <- stat.methods do
+            val pathSym = exportPathSym(exp.expr, stat)
+            if pathSym.exists then processExport(exp, pathSym)
+          process(stats1)
+        case stat :: stats1 =>
+          process(stats1)
+        case Nil =>
+
+      def hasExport(stats: List[Tree]): Boolean = stats.exists {
+        case _: Export => true
+        case ExtMethods(_, stats1) => hasExport(stats1)
+        case _ => false
+      }
+      // Do a quick scan whether we need to process at all. This avoids creating
+      // import contexts for nothing.
+      if hasExport(rest) then
+        process(rest)
+    end processExports
+
+    /** Ensure constructor is completed so that any parameter accessors
+     *  which have type trees deriving from its parameters can be
+     *  completed in turn. Note that parent types access such parameter
+     *  accessors, that's why the constructor needs to be completed before
+     *  the parent types are elaborated.
+     */
+    def completeConstructor(denot: SymDenotation): Unit = {
+      if (tempInfo != null) // Constructor has been completed already
+        return
+
+      addAnnotations(denot.symbol)
+
+      val selfInfo: TypeOrSymbol =
+        if (self.isEmpty) NoType
+        else if (cls.is(Module)) {
+          val moduleType = cls.owner.thisType select sourceModule
+          if (self.name == nme.WILDCARD) moduleType
+          else recordSym(
+            newSymbol(cls, self.name, self.mods.flags, moduleType, coord = self.span),
+            self)
+        }
+        else createSymbol(self)
+
+      val savedInfo = denot.infoOrCompleter
+      denot.info = new TempClassInfo(cls.owner.thisType, cls, decls, selfInfo)
+
+      localCtx = completerCtx.inClassContext(selfInfo)
+
+      index(constr)
+      index(rest)(using localCtx)
+
+      symbolOfTree(constr).info.stripPoly match // Completes constr symbol as a side effect
+        case mt: MethodType if cls.is(Case) && mt.isParamDependent =>
+          // See issue #8073 for background
+          report.error(
+              i"""Implementation restriction: case classes cannot have dependencies between parameters""",
+              cls.srcPos)
+        case _ =>
+
+      tempInfo = denot.asClass.classInfo.integrateOpaqueMembers.asInstanceOf[TempClassInfo]
+      denot.info = savedInfo
+    }
+
+    /** The type signature of a ClassDef with given symbol */
+    override def completeInCreationContext(denot: SymDenotation): Unit = {
+      val parents = impl.parents
+
+      /* The type of a parent constructor. Types constructor arguments
+       * only if parent type contains uninstantiated type parameters.
+       */
+      def parentType(parent: untpd.Tree)(using Context): Type =
+        if (parent.isType)
+          typedAheadType(parent, AnyTypeConstructorProto).tpe
+        else {
+          val (core, targs) = stripApply(parent) match {
+            case TypeApply(core, targs) => (core, targs)
+            case core => (core, Nil)
+          }
+          core match {
+            case Select(New(tpt), nme.CONSTRUCTOR) =>
+              val targs1 = targs map (typedAheadType(_))
+              val ptype = typedAheadType(tpt).tpe appliedTo targs1.tpes
+              if (ptype.typeParams.isEmpty) ptype
+              else {
+                if (denot.is(ModuleClass) && denot.sourceModule.isOneOf(GivenOrImplicit))
+                  missingType(denot.symbol, "parent ")(using creationContext)
+                fullyDefinedType(typedAheadExpr(parent).tpe, "class parent", parent.srcPos)
+              }
+            case _ =>
+              UnspecifiedErrorType.assertingErrorsReported
+          }
+        }
+
+      /** Check parent type tree `parent` for the following well-formedness conditions:
+       *  (1) It must be a class type with a stable prefix (@see checkClassTypeWithStablePrefix)
+       *  (2) If may not derive from itself
+       *  (3) The class is not final
+       *  (4) If the class is sealed, it is defined in the same compilation unit as the current class
+       */
+      def checkedParentType(parent: untpd.Tree): Type = {
+        val ptype = parentType(parent)(using completerCtx.superCallContext).dealiasKeepAnnots
+        if (cls.isRefinementClass) ptype
+        else {
+          val pt = checkClassType(ptype, parent.srcPos,
+              traitReq = parent ne parents.head, stablePrefixReq = true)
+          if (pt.derivesFrom(cls)) {
+            val addendum = parent match {
+              case Select(qual: Super, _) if Feature.migrateTo3 =>
+                "\n(Note that inheriting a class of the same name is no longer allowed)"
+              case _ => ""
+            }
+            report.error(CyclicInheritance(cls, addendum), parent.srcPos)
+            defn.ObjectType
+          }
+          else {
+            val pclazz = pt.typeSymbol
+            if pclazz.is(Final) then
+              report.error(ExtendFinalClass(cls, pclazz), cls.srcPos)
+            else if pclazz.isEffectivelySealed && pclazz.associatedFile != cls.associatedFile then
+              if pclazz.is(Sealed) then
+                report.error(UnableToExtendSealedClass(pclazz), cls.srcPos)
+              else if sourceVersion.isAtLeast(future) then
+                checkFeature(nme.adhocExtensions,
+                  i"Unless $pclazz is declared 'open', its extension in a separate file",
+                  cls.topLevelClass,
+                  parent.srcPos)
+            pt
+          }
+        }
+      }
+
+      /** If `parents` contains references to traits that have supertraits with implicit parameters
+       *  add those supertraits in linearization order unless they are already covered by other
+       *  parent types. For instance, in
+       *
+       *    class A
+       *    trait B(using I) extends A
+       *    trait C extends B
+       *    class D extends A, C
+       *
+       *  the class declaration of `D` is augmented to
+       *
+       *    class D extends A, B, C
+       *
+       *  so that an implicit `I` can be passed to `B`. See i7613.scala for more examples.
+       */
+      def addUsingTraits(parents: List[Type]): List[Type] =
+        lazy val existing = parents.map(_.classSymbol).toSet
+        def recur(parents: List[Type]): List[Type] = parents match
+          case parent :: parents1 =>
+            val psym = parent.classSymbol
+            val addedTraits =
+              if psym.is(Trait) then
+                psym.asClass.baseClasses.tail.iterator
+                  .takeWhile(_.is(Trait))
+                  .filter(p =>
+                    p.primaryConstructor.info.takesImplicitParams
+                    && !cls.superClass.isSubClass(p)
+                    && !existing.contains(p))
+                  .toList.reverse
+              else Nil
+            addedTraits.map(parent.baseType) ::: parent :: recur(parents1)
+          case nil =>
+            Nil
+        if cls.isRealClass then recur(parents) else parents
+      end addUsingTraits
+
+      completeConstructor(denot)
+      denot.info = tempInfo.nn
+
+      val parentTypes = defn.adjustForTuple(cls, cls.typeParams,
+        defn.adjustForBoxedUnit(cls,
+          addUsingTraits(
+            ensureFirstIsClass(cls, parents.map(checkedParentType(_)))
+          )
+        )
+      )
+      typr.println(i"completing $denot, parents = $parents%, %, parentTypes = $parentTypes%, %")
+
+      if (impl.derived.nonEmpty) {
+        val (derivingClass, derivePos) = original.removeAttachment(desugar.DerivingCompanion) match {
+          case Some(pos) => (cls.companionClass.orElse(cls).asClass, pos)
+          case None => (cls, impl.srcPos.startPos)
+        }
+        val deriver = new Deriver(derivingClass, derivePos)(using localCtx)
+        deriver.enterDerived(impl.derived)
+        original.putAttachment(AttachedDeriver, deriver)
+      }
+
+      denot.info = tempInfo.nn.finalized(parentTypes)
+      tempInfo = null // The temporary info can now be garbage-collected
+
+      Checking.checkWellFormed(cls)
+      if (isDerivedValueClass(cls)) cls.setFlag(Final)
+      cls.info = avoidPrivateLeaks(cls)
+      cls.baseClasses.foreach(_.invalidateBaseTypeCache()) // we might have looked before and found nothing
+      cls.invalidateMemberCaches() // we might have checked for a member when parents were not known yet.
+      cls.setNoInitsFlags(parentsKind(parents), untpd.bodyKind(rest))
+      cls.setStableConstructor()
+      processExports(using localCtx)
+      defn.patchStdLibClass(cls)
+      addConstructorProxies(cls)
+    }
+  }
+
+  /** Possible actions to perform when deciding on a forwarder for a member */
+  private enum CanForward:
+    case Yes
+    case No(whyNot: String)
+    case Skip  // for members that have never forwarders
+
+  class SuspendCompleter extends LazyType, SymbolLoaders.SecondCompleter {
+
+    final override def complete(denot: SymDenotation)(using Context): Unit =
+      denot.resetFlag(Touched) // allow one more completion
+      ctx.compilationUnit.suspend()
+  }
+
+  /** Typecheck `tree` during completion using `typed`, and remember result in TypedAhead map */
+  def typedAhead(tree: Tree, typed: untpd.Tree => tpd.Tree)(using Context): tpd.Tree = {
+    val xtree = expanded(tree)
+    xtree.getAttachment(TypedAhead) match {
+      case Some(ttree) => ttree
+      case none =>
+        val ttree = typed(tree)
+        xtree.putAttachment(TypedAhead, ttree)
+        ttree
+    }
+  }
+
+  def typedAheadType(tree: Tree, pt: Type = WildcardType)(using Context): tpd.Tree =
+    typedAhead(tree, typer.typedType(_, pt))
+
+  def typedAheadExpr(tree: Tree, pt: Type = WildcardType)(using Context): tpd.Tree =
+    typedAhead(tree, typer.typedExpr(_, pt))
+
+  def typedAheadAnnotation(tree: Tree)(using Context): tpd.Tree =
+    typedAheadExpr(tree, defn.AnnotationClass.typeRef)
+
+  def typedAheadAnnotationClass(tree: Tree)(using Context): Symbol = tree match {
+    case Apply(fn, _) => typedAheadAnnotationClass(fn)
+    case TypeApply(fn, _) => typedAheadAnnotationClass(fn)
+    case Select(qual, nme.CONSTRUCTOR) => typedAheadAnnotationClass(qual)
+    case New(tpt) => typedAheadType(tpt).tpe.classSymbol
+  }
+
+  /** Enter and typecheck parameter list */
+  def completeParams(params: List[MemberDef])(using Context): Unit = {
+    index(params)
+    for (param <- params) typedAheadExpr(param)
+  }
+
+  /** The signature of a module valdef.
+   *  This will compute the corresponding module class TypeRef immediately
+   *  without going through the defined type of the ValDef. This is necessary
+   *  to avoid cyclic references involving imports and module val defs.
+   */
+  def moduleValSig(sym: Symbol)(using Context): Type = {
+    val clsName = sym.name.moduleClassName
+    val cls = ctx.effectiveScope.lookupAll(clsName)
+      .find(_.is(ModuleClass))
+      .getOrElse(newStubSymbol(ctx.owner, clsName).assertingErrorsReported)
+    ctx.owner.thisType.select(clsName, cls)
+  }
+
+  /** The type signature of a ValDef or DefDef
+   *  @param mdef     The definition
+   *  @param sym      Its symbol
+   *  @param paramFn  A wrapping function that produces the type of the
+   *                  defined symbol, given its final return type
+   */
+  def valOrDefDefSig(mdef: ValOrDefDef, sym: Symbol, paramss: List[List[Symbol]], paramFn: Type => Type)(using Context): Type = {
+
+    def inferredType = inferredResultType(mdef, sym, paramss, paramFn, WildcardType)
+    lazy val termParamss = paramss.collect { case TermSymbols(vparams) => vparams }
+
+    val tptProto = mdef.tpt match {
+      case _: untpd.DerivedTypeTree =>
+        WildcardType
+      case TypeTree() =>
+        checkMembersOK(inferredType, mdef.srcPos)
+      case DependentTypeTree(tpFun) =>
+        val tpe = tpFun(termParamss.head)
+        if (isFullyDefined(tpe, ForceDegree.none)) tpe
+        else typedAheadExpr(mdef.rhs, tpe).tpe
+      case TypedSplice(tpt: TypeTree) if !isFullyDefined(tpt.tpe, ForceDegree.none) =>
+        mdef match {
+          case mdef: DefDef if mdef.name == nme.ANON_FUN =>
+            // This case applies if the closure result type contains uninstantiated
+            // type variables. In this case, constrain the closure result from below
+            // by the parameter-capture-avoiding type of the body.
+            val rhsType = typedAheadExpr(mdef.rhs, tpt.tpe).tpe
+
+            // The following part is important since otherwise we might instantiate
+            // the closure result type with a plain functon type that refers
+            // to local parameters. An example where this happens in `dependent-closures.scala`
+            // If the code after `val rhsType` is commented out, this file fails pickling tests.
+            // AVOIDANCE TODO: Follow up why this happens, and whether there
+            // are better ways to achieve this. It would be good if we could get rid of this code.
+            // It seems at least partially redundant with the nesting level checking on TypeVar
+            // instantiation.
+            // It turns out if we fix levels on instantiation we still need this code.
+            // Examples that fail otherwise are pos/scalaz-redux.scala and pos/java-futures.scala.
+            // So fixing levels at instantiation avoids the soundness problem but apparently leads
+            // to type inference problems since it comes too late.
+            if !Config.checkLevelsOnConstraints then
+              val hygienicType = TypeOps.avoid(rhsType, termParamss.flatten)
+              if (!hygienicType.isValueType || !(hygienicType <:< tpt.tpe))
+                report.error(i"return type ${tpt.tpe} of lambda cannot be made hygienic;\n" +
+                  i"it is not a supertype of the hygienic type $hygienicType", mdef.srcPos)
+            //println(i"lifting $rhsType over $termParamss -> $hygienicType = ${tpt.tpe}")
+            //println(TypeComparer.explained { implicit ctx => hygienicType <:< tpt.tpe })
+          case _ =>
+        }
+        WildcardType
+      case _ =>
+        WildcardType
+    }
+    val mbrTpe = paramFn(checkSimpleKinded(typedAheadType(mdef.tpt, tptProto)).tpe)
+    if (ctx.explicitNulls && mdef.mods.is(JavaDefined))
+      JavaNullInterop.nullifyMember(sym, mbrTpe, mdef.mods.isAllOf(JavaEnumValue))
+    else mbrTpe
+  }
+
+  /** The type signature of a DefDef with given symbol */
+  def defDefSig(ddef: DefDef, sym: Symbol, completer: Namer#Completer)(using Context): Type = {
+    // Beware: ddef.name need not match sym.name if sym was freshened!
+    val isConstructor = sym.name == nme.CONSTRUCTOR
+
+    // The following 3 lines replace what was previously just completeParams(tparams).
+    // But that can cause bad bounds being computed, as witnessed by
+    // tests/pos/paramcycle.scala. The problematic sequence is this:
+    //   0. Class constructor gets completed.
+    //   1. Type parameter CP of constructor gets completed
+    //   2. As a first step CP's bounds are set to Nothing..Any.
+    //   3. CP's real type bound demands the completion of corresponding type parameter DP
+    //      of enclosing class.
+    //   4. Type parameter DP has a rhs a DerivedFromParam tree, as installed by
+    //      desugar.classDef
+    //   5. The completion of DP then copies the current bounds of CP, which are still Nothing..Any.
+    //   6. The completion of CP finishes installing the real type bounds.
+    // Consequence: CP ends up with the wrong bounds!
+    // To avoid this we always complete type parameters of a class before the type parameters
+    // of the class constructor, but after having indexed the constructor parameters (because
+    // indexing is needed to provide a symbol to copy for DP's completion.
+    // With the patch, we get instead the following sequence:
+    //   0. Class constructor gets completed.
+    //   1. Class constructor parameter CP is indexed.
+    //   2. Class parameter DP starts completion.
+    //   3. Info of CP is computed (to be copied to DP).
+    //   4. CP is completed.
+    //   5. Info of CP is copied to DP and DP is completed.
+    index(ddef.leadingTypeParams)
+    if (isConstructor) sym.owner.typeParams.foreach(_.ensureCompleted())
+    val completedTypeParams =
+      for tparam <- ddef.leadingTypeParams yield typedAheadExpr(tparam).symbol
+    if completedTypeParams.forall(_.isType) then
+      completer.setCompletedTypeParams(completedTypeParams.asInstanceOf[List[TypeSymbol]])
+    ddef.trailingParamss.foreach(completeParams)
+    val paramSymss = normalizeIfConstructor(ddef.paramss.nestedMap(symbolOfTree), isConstructor)
+    sym.setParamss(paramSymss)
+    def wrapMethType(restpe: Type): Type =
+      instantiateDependent(restpe, paramSymss)
+      methodType(paramSymss, restpe, ddef.mods.is(JavaDefined))
+    if isConstructor then
+      // set result type tree to unit, but take the current class as result type of the symbol
+      typedAheadType(ddef.tpt, defn.UnitType)
+      wrapMethType(effectiveResultType(sym, paramSymss))
+    else
+      valOrDefDefSig(ddef, sym, paramSymss, wrapMethType)
+  }
+
+  def inferredResultType(
+      mdef: ValOrDefDef,
+      sym: Symbol,
+      paramss: List[List[Symbol]],
+      paramFn: Type => Type,
+      fallbackProto: Type
+    )(using Context): Type =
+
+    /** A type for this definition that might be inherited from elsewhere:
+     *  If this is a setter parameter, the corresponding getter type.
+     *  If this is a class member, the conjunction of all result types
+     *  of overridden methods.
+     *  NoType if neither case holds.
+     */
+    val inherited =
+      if (sym.owner.isTerm) NoType
+      else
+        // TODO: Look only at member of supertype instead?
+        lazy val schema = paramFn(WildcardType)
+        val site = sym.owner.thisType
+        val bcs = sym.owner.info.baseClasses
+        if bcs.isEmpty then
+          assert(ctx.reporter.errorsReported)
+          NoType
+        else bcs.tail.foldLeft(NoType: Type) { (tp, cls) =>
+          def instantiatedResType(info: Type, paramss: List[List[Symbol]]): Type = info match
+            case info: PolyType =>
+              paramss match
+                case TypeSymbols(tparams) :: paramss1 if info.paramNames.length == tparams.length =>
+                  instantiatedResType(info.instantiate(tparams.map(_.typeRef)), paramss1)
+                case _ =>
+                  NoType
+            case info: MethodType =>
+              paramss match
+                case TermSymbols(vparams) :: paramss1 if info.paramNames.length == vparams.length =>
+                  instantiatedResType(info.instantiate(vparams.map(_.termRef)), paramss1)
+                case _ =>
+                  NoType
+            case _ =>
+              if paramss.isEmpty then info.widenExpr
+              else NoType
+
+          val iRawInfo =
+            cls.info.nonPrivateDecl(sym.name).matchingDenotation(site, schema, sym.targetName).info
+          val iResType = instantiatedResType(iRawInfo, paramss).asSeenFrom(site, cls)
+          if (iResType.exists)
+            typr.println(i"using inherited type for ${mdef.name}; raw: $iRawInfo, inherited: $iResType")
+          tp & iResType
+        }
+    end inherited
+
+    /** If this is a default getter, the type of the corresponding method parameter,
+     *  otherwise NoType.
+     */
+    def defaultParamType = sym.name match
+      case DefaultGetterName(original, idx) =>
+        val meth: Denotation =
+          if (original.isConstructorName && (sym.owner.is(ModuleClass)))
+            sym.owner.companionClass.info.decl(nme.CONSTRUCTOR)
+          else
+            ctx.defContext(sym).denotNamed(original)
+        def paramProto(paramss: List[List[Type]], idx: Int): Type = paramss match {
+          case params :: paramss1 =>
+            if (idx < params.length) params(idx)
+            else paramProto(paramss1, idx - params.length)
+          case nil =>
+            NoType
+        }
+        val defaultAlts = meth.altsWith(_.hasDefaultParams)
+        if (defaultAlts.length == 1)
+          paramProto(defaultAlts.head.info.widen.paramInfoss, idx)
+        else
+          NoType
+      case _ =>
+        NoType
+
+    /** The expected type for a default argument. This is normally the `defaultParamType`
+     *  with references to internal parameters replaced by wildcards. This replacement
+     *  makes it possible that the default argument can have a more specific type than the
+     *  parameter. For instance, we allow
+     *
+     *      class C[A](a: A) { def copy[B](x: B = a): C[B] = C(x) }
+     *
+     *  However, if the default parameter type is a context function type, we
+     *  have to make sure that wildcard types do not leak into the implicitly
+     *  generated closure's result type. Test case is pos/i12019.scala. If there
+     *  would be a leakage with the wildcard approximation, we pick the original
+     *  default parameter type as expected type.
+     */
+    def expectedDefaultArgType =
+      val originalTp = defaultParamType
+      val approxTp = wildApprox(originalTp)
+      approxTp.stripPoly match
+        case atp @ defn.ContextFunctionType(_, resType, _)
+        if !defn.isNonRefinedFunction(atp) // in this case `resType` is lying, gives us only the non-dependent upper bound
+            || resType.existsPart(_.isInstanceOf[WildcardType], StopAt.Static, forceLazy = false) =>
+          originalTp
+        case _ =>
+          approxTp
+
+    var rhsCtx = ctx.fresh.addMode(Mode.InferringReturnType)
+    if sym.isInlineMethod then rhsCtx = rhsCtx.addMode(Mode.InlineableBody)
+    if sym.is(ExtensionMethod) then rhsCtx = rhsCtx.addMode(Mode.InExtensionMethod)
+    val typeParams = paramss.collect { case TypeSymbols(tparams) => tparams }.flatten
+    if (typeParams.nonEmpty) {
+      // we'll be typing an expression from a polymorphic definition's body,
+      // so we must allow constraining its type parameters
+      // compare with typedDefDef, see tests/pos/gadt-inference.scala
+      rhsCtx.setFreshGADTBounds
+      rhsCtx.gadt.addToConstraint(typeParams)
+    }
+
+    def typedAheadRhs(pt: Type) =
+      PrepareInlineable.dropInlineIfError(sym,
+        typedAheadExpr(mdef.rhs, pt)(using rhsCtx))
+
+    def rhsType =
+      // For default getters, we use the corresponding parameter type as an
+      // expected type but we run it through `wildApprox` to allow default
+      // parameters like in `def mkList[T](value: T = 1): List[T]`.
+      val defaultTp = defaultParamType
+      val pt = inherited.orElse(expectedDefaultArgType).orElse(fallbackProto).widenExpr
+      val tp = typedAheadRhs(pt).tpe
+      if (defaultTp eq pt) && (tp frozen_<:< defaultTp) then
+        // When possible, widen to the default getter parameter type to permit a
+        // larger choice of overrides (see `default-getter.scala`).
+        // For justification on the use of `@uncheckedVariance`, see
+        // `default-getter-variance.scala`.
+        AnnotatedType(defaultTp, Annotation(defn.UncheckedVarianceAnnot))
+      else
+        // don't strip @uncheckedVariance annot for default getters
+        TypeOps.simplify(tp.widenTermRefExpr,
+            if defaultTp.exists then TypeOps.SimplifyKeepUnchecked() else null) match
+          case ctp: ConstantType if sym.isInlineVal => ctp
+          case tp => TypeComparer.widenInferred(tp, pt, widenUnions = true)
+
+    // Replace aliases to Unit by Unit itself. If we leave the alias in
+    // it would be erased to BoxedUnit.
+    def dealiasIfUnit(tp: Type) = if (tp.isRef(defn.UnitClass)) defn.UnitType else tp
+
+    def cookedRhsType = dealiasIfUnit(rhsType).deskolemized
+    def lhsType = fullyDefinedType(cookedRhsType, "right-hand side", mdef.srcPos)
+    //if (sym.name.toString == "y") println(i"rhs = $rhsType, cooked = $cookedRhsType")
+    if (inherited.exists)
+      if sym.isInlineVal then lhsType else inherited
+    else {
+      if (sym.is(Implicit))
+        mdef match {
+          case _: DefDef => missingType(sym, "result ")
+          case _: ValDef if sym.owner.isType => missingType(sym, "")
+          case _ =>
+        }
+      lhsType orElse WildcardType
+    }
+  end inferredResultType
+}
diff --git a/tests/pos-with-compiler-cc/dotc/typer/Nullables.scala b/tests/pos-with-compiler-cc/dotc/typer/Nullables.scala
new file mode 100644
index 000000000000..9104418d406f
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/typer/Nullables.scala
@@ -0,0 +1,569 @@
+package dotty.tools
+package dotc
+package typer
+
+import core._
+import Types._, Contexts._, Symbols._, Decorators._, Constants._
+import annotation.tailrec
+import StdNames.nme
+import util.Property
+import Names.Name
+import util.Spans.Span
+import Flags._
+import NullOpsDecorator._
+import collection.mutable
+import config.Printers.nullables
+import ast.{tpd, untpd}
+import ast.Trees.mods
+
+/** Operations for implementing a flow analysis for nullability */
+object Nullables:
+  import ast.tpd._
+
+  def importUnsafeNulls(using Context): Import = Import(
+    ref(defn.LanguageModule),
+    List(untpd.ImportSelector(untpd.Ident(nme.unsafeNulls), EmptyTree, EmptyTree)))
+
+  inline def unsafeNullsEnabled(using Context): Boolean =
+    ctx.explicitNulls && !ctx.mode.is(Mode.SafeNulls)
+
+  private def needNullifyHi(lo: Type, hi: Type)(using Context): Boolean =
+    ctx.explicitNulls
+    && lo.isExactlyNull // only nullify hi if lo is exactly Null type
+    && hi.isValueType
+    // We cannot check if hi is nullable, because it can cause cyclic reference.
+
+  /** Create a nullable type bound
+   *  If lo is `Null`, `| Null` is added to hi
+   */
+  def createNullableTypeBounds(lo: Type, hi: Type)(using Context): TypeBounds =
+    val newHi = if needNullifyHi(lo, hi) then OrType(hi, defn.NullType, soft = false) else hi
+    TypeBounds(lo, newHi)
+
+  /** Create a nullable type bound tree
+   *  If lo is `Null`, `| Null` is added to hi
+   */
+  def createNullableTypeBoundsTree(lo: Tree, hi: Tree, alias: Tree = EmptyTree)(using Context): TypeBoundsTree =
+    val hiTpe = hi.typeOpt
+    val newHi = if needNullifyHi(lo.typeOpt, hiTpe) then TypeTree(OrType(hiTpe, defn.NullType, soft = false)) else hi
+    TypeBoundsTree(lo, newHi, alias)
+
+  /** A set of val or var references that are known to be not null, plus a set of
+   *  variable references that are not known (anymore) to be not null
+   */
+  case class NotNullInfo(asserted: Set[TermRef], retracted: Set[TermRef]):
+    assert((asserted & retracted).isEmpty)
+
+    def isEmpty = this eq NotNullInfo.empty
+
+    def retractedInfo = NotNullInfo(Set(), retracted)
+
+    /** The sequential combination with another not-null info */
+    def seq(that: NotNullInfo): NotNullInfo =
+      if this.isEmpty then that
+      else if that.isEmpty then this
+      else NotNullInfo(
+        this.asserted.union(that.asserted).diff(that.retracted),
+        this.retracted.union(that.retracted).diff(that.asserted))
+
+    /** The alternative path combination with another not-null info. Used to merge
+     *  the nullability info of the two branches of an if.
+     */
+    def alt(that: NotNullInfo): NotNullInfo =
+      NotNullInfo(this.asserted.intersect(that.asserted), this.retracted.union(that.retracted))
+
+  object NotNullInfo:
+    val empty = new NotNullInfo(Set(), Set())
+    def apply(asserted: Set[TermRef], retracted: Set[TermRef]): NotNullInfo =
+      if asserted.isEmpty && retracted.isEmpty then empty
+      else new NotNullInfo(asserted, retracted)
+  end NotNullInfo
+
+  /** A pair of not-null sets, depending on whether a condition is `true` or `false` */
+  case class NotNullConditional(ifTrue: Set[TermRef], ifFalse: Set[TermRef]):
+    def isEmpty = this eq NotNullConditional.empty
+
+  object NotNullConditional:
+    val empty = new NotNullConditional(Set(), Set())
+    def apply(ifTrue: Set[TermRef], ifFalse: Set[TermRef]): NotNullConditional =
+      if ifTrue.isEmpty && ifFalse.isEmpty then empty
+      else new NotNullConditional(ifTrue, ifFalse)
+  end NotNullConditional
+
+  /** An attachment that represents conditional flow facts established
+   *  by this tree, which represents a condition.
+   */
+  private[typer] val NNConditional = Property.StickyKey[NotNullConditional]
+
+   /** An attachment that represents unconditional flow facts established
+    *  by this tree.
+    */
+  private[typer] val NNInfo = Property.StickyKey[NotNullInfo]
+
+  /** An extractor for null comparisons */
+  object CompareNull:
+
+    /** Matches one of
+     *
+     *    tree == null, tree eq null, null == tree, null eq tree
+     *    tree != null, tree ne null, null != tree, null ne tree
+     *
+     *  The second boolean result is true for equality tests, false for inequality tests
+     */
+    def unapply(tree: Tree)(using Context): Option[(Tree, Boolean)] = tree match
+      case Apply(Select(l, _), Literal(Constant(null)) :: Nil) =>
+        testSym(tree.symbol, l)
+      case Apply(Select(Literal(Constant(null)), _), r :: Nil) =>
+        testSym(tree.symbol, r)
+      case _ =>
+        None
+
+    private def testSym(sym: Symbol, operand: Tree)(using Context) =
+      if sym == defn.Any_== || sym == defn.Object_eq then Some((operand, true))
+      else if sym == defn.Any_!= || sym == defn.Object_ne then Some((operand, false))
+      else None
+
+  end CompareNull
+
+  /** An extractor for null-trackable references */
+  object TrackedRef:
+    def unapply(tree: Tree)(using Context): Option[TermRef] = tree.typeOpt match
+      case ref: TermRef if isTracked(ref) => Some(ref)
+      case _ => None
+  end TrackedRef
+
+  /** Is the given reference tracked for nullability?
+   *
+   *  This is the case if one of the following holds:
+   *  1) The reference is a path to an immutable `val`.
+   *  2) The reference is to a mutable variable, in which case all assignments to it must be
+   *    reachable (in the sense of how it is defined in assignmentSpans) _and_ the variable
+   *    must not be used "out of order" (in the sense specified by `usedOutOfOrder`).
+   *
+   *  Whether to track a local mutable variable during flow typing?
+   *  We track a local mutable variable iff the variable is not assigned in a closure.
+   *  For example, in the following code `x` is assigned to by the closure `y`, so we do not
+   *  do flow typing on `x`.
+   *
+   *  ```scala
+   *  var x: String|Null = ???
+   *  def y = {
+   *    x = null
+   *  }
+   *  if (x != null) {
+   *    // y can be called here, which break the fact
+   *    val a: String = x // error: x is captured and mutated by the closure, not trackable
+   *  }
+   *  ```
+   *
+   *  Check `usedOutOfOrder` to see the explaination and example of "out of order".
+   *  See more examples in `tests/explicit-nulls/neg/var-ref-in-closure.scala`.
+   */
+  def isTracked(ref: TermRef)(using Context) =
+    ref.isStable
+    || { val sym = ref.symbol
+         val unit = ctx.compilationUnit
+         !ref.usedOutOfOrder
+         && sym.span.exists
+         && (unit ne NoCompilationUnit) // could be null under -Ytest-pickler
+         && unit.assignmentSpans.contains(sym.span.start)
+      }
+
+  /** The nullability context to be used after a case that matches pattern `pat`.
+   *  If `pat` is `null`, this will assert that the selector `sel` is not null afterwards.
+   */
+  def afterPatternContext(sel: Tree, pat: Tree)(using Context) = (sel, pat) match
+    case (TrackedRef(ref), Literal(Constant(null))) => ctx.addNotNullRefs(Set(ref))
+    case _ => ctx
+
+  /** The nullability context to be used for the guard and rhs of a case with
+   *  given pattern `pat`. If the pattern can only match non-null values, this
+   *  will assert that the selector `sel` is not null in these regions.
+   */
+  def caseContext(sel: Tree, pat: Tree)(using Context): Context = sel match
+    case TrackedRef(ref) if matchesNotNull(pat) => ctx.addNotNullRefs(Set(ref))
+    case _ => ctx
+
+  private def matchesNotNull(pat: Tree)(using Context): Boolean = pat match
+    case _: Typed | _: UnApply => true
+    case Alternative(pats) => pats.forall(matchesNotNull)
+    // TODO: Add constant pattern if the constant type is not nullable
+    case _ => false
+
+  extension (infos: List[NotNullInfo])
+
+    /** Do the current not-null infos imply that `ref` is not null?
+    *  Not-null infos are as a history where earlier assertions and retractions replace
+    *  later ones (i.e. it records the assignment history in reverse, with most recent first)
+    */
+    @tailrec def impliesNotNull(ref: TermRef): Boolean = infos match
+      case info :: infos1 =>
+        if info.asserted.contains(ref) then true
+        else if info.retracted.contains(ref) then false
+        else infos1.impliesNotNull(ref)
+      case _ =>
+        false
+
+    /** Add `info` as the most recent entry to the list of null infos. Assertions
+    *  or retractions in `info` supersede infos in existing entries of `infos`.
+    */
+    def extendWith(info: NotNullInfo) =
+      if info.isEmpty
+        || info.asserted.forall(infos.impliesNotNull(_))
+            && !info.retracted.exists(infos.impliesNotNull(_))
+      then infos
+      else info :: infos
+
+    /** Retract all references to mutable variables */
+    def retractMutables(using Context) =
+      val mutables = infos.foldLeft(Set[TermRef]())((ms, info) =>
+        ms.union(info.asserted.filter(_.symbol.is(Mutable))))
+      infos.extendWith(NotNullInfo(Set(), mutables))
+
+  end extension
+
+  extension (ref: TermRef)
+
+    /** Is the use of a mutable variable out of order
+    *
+    *  Whether to generate and use flow typing on a specific _use_ of a local mutable variable?
+    *  We only want to do flow typing on a use that belongs to the same method as the definition
+    *  of the local variable.
+    *  For example, in the following code, even `x` is not assigned to by a closure, but we can only
+    *  use flow typing in one of the occurrences (because the other occurrence happens within a nested
+    *  closure).
+    *  ```scala
+    *  var x: String|Null = ???
+    *  def y = {
+    *    if (x != null) {
+    *      // not safe to use the fact (x != null) here
+    *      // since y can be executed at the same time as the outer block
+    *      val _: String = x
+    *    }
+    *  }
+    *  if (x != null) {
+    *    val a: String = x // ok to use the fact here
+    *    x = null
+    *  }
+    *  ```
+    *
+    *  Another example:
+    *  ```scala
+    *  var x: String|Null = ???
+    *  if (x != null) {
+    *    def f: String = {
+    *      val y: String = x // error: the use of x is out of order
+    *      y
+    *    }
+    *    x = null
+    *    val y: String = f // danger
+    *  }
+    *  ```
+    */
+    def usedOutOfOrder(using Context): Boolean =
+      val refSym = ref.symbol
+      val refOwner = refSym.owner
+
+      @tailrec def recur(s: Symbol): Boolean =
+        s != NoSymbol
+        && s != refOwner
+        && (s.isOneOf(MethodOrLazy) // not at the rhs of lazy ValDef or in a method (or lambda)
+            || s.isClass // not in a class
+            || recur(s.owner))
+
+      refSym.is(Mutable) // if it is immutable, we don't need to check the rest conditions
+      && refOwner.isTerm
+      && recur(ctx.owner)
+  end extension
+
+  extension (tree: Tree)
+
+    /* The `tree` with added nullability attachment */
+    def withNotNullInfo(info: NotNullInfo): tree.type =
+      if !info.isEmpty then tree.putAttachment(NNInfo, info)
+      tree
+
+    /* The nullability info of `tree` */
+    def notNullInfo(using Context): NotNullInfo =
+      stripInlined(tree).getAttachment(NNInfo) match
+        case Some(info) if !ctx.erasedTypes => info
+        case _ => NotNullInfo.empty
+
+    /* The nullability info of `tree`, assuming it is a condition that evaluates to `c` */
+    def notNullInfoIf(c: Boolean)(using Context): NotNullInfo =
+      val cond = tree.notNullConditional
+      if cond.isEmpty then tree.notNullInfo
+      else tree.notNullInfo.seq(NotNullInfo(if c then cond.ifTrue else cond.ifFalse, Set()))
+
+    /** The paths that are known to be not null if the condition represented
+    *  by `tree` yields `true` or `false`. Two empty sets if `tree` is not
+    *  a condition.
+    */
+    def notNullConditional(using Context): NotNullConditional =
+      stripBlock(tree).getAttachment(NNConditional) match
+        case Some(cond) if !ctx.erasedTypes => cond
+        case _ => NotNullConditional.empty
+
+    /** The current context augmented with nullability information of `tree` */
+    def nullableContext(using Context): Context =
+      val info = tree.notNullInfo
+      if info.isEmpty then ctx else ctx.addNotNullInfo(info)
+
+    /** The current context augmented with nullability information,
+    *  assuming the result of the condition represented by `tree` is the same as
+    *  the value of `c`.
+    */
+    def nullableContextIf(c: Boolean)(using Context): Context =
+      val info = tree.notNullInfoIf(c)
+      if info.isEmpty then ctx else ctx.addNotNullInfo(info)
+
+    /** The context to use for the arguments of the function represented by `tree`.
+    *  This is the current context, augmented with nullability information
+    *  of the left argument, if the application is a boolean `&&` or `||`.
+    */
+    def nullableInArgContext(using Context): Context = tree match
+      case Select(x, _) if !ctx.erasedTypes =>
+        if tree.symbol == defn.Boolean_&& then x.nullableContextIf(true)
+        else if tree.symbol == defn.Boolean_|| then x.nullableContextIf(false)
+        else ctx
+      case _ => ctx
+
+    /** The `tree` augmented with nullability information in an attachment.
+    *  The following operations lead to nullability info being recorded:
+    *
+    *  1. Null tests using `==`, `!=`, `eq`, `ne`, if the compared entity is
+    *     a path (i.e. a stable TermRef)
+    *  2. Boolean &&, ||, !
+    */
+    def computeNullable()(using Context): tree.type =
+      def setConditional(ifTrue: Set[TermRef], ifFalse: Set[TermRef]) =
+        tree.putAttachment(NNConditional, NotNullConditional(ifTrue, ifFalse))
+      if !ctx.erasedTypes && analyzedOps.contains(tree.symbol.name.toTermName) then
+        tree match
+          case CompareNull(TrackedRef(ref), testEqual) =>
+            if testEqual then setConditional(Set(), Set(ref))
+            else setConditional(Set(ref), Set())
+          case Apply(Select(x, _), y :: Nil) =>
+            val xc = x.notNullConditional
+            val yc = y.notNullConditional
+            if !(xc.isEmpty && yc.isEmpty) then
+              if tree.symbol == defn.Boolean_&& then
+                setConditional(xc.ifTrue | yc.ifTrue, xc.ifFalse & yc.ifFalse)
+              else if tree.symbol == defn.Boolean_|| then
+                setConditional(xc.ifTrue & yc.ifTrue, xc.ifFalse | yc.ifFalse)
+          case Select(x, _) if tree.symbol == defn.Boolean_! =>
+            val xc = x.notNullConditional
+            if !xc.isEmpty then
+              setConditional(xc.ifFalse, xc.ifTrue)
+          case _ =>
+      tree
+
+    /** Compute nullability information for this tree and all its subtrees */
+    def computeNullableDeeply()(using Context): Unit =
+      new TreeTraverser {
+        def traverse(tree: Tree)(using Context) =
+          traverseChildren(tree)
+          tree.computeNullable()
+      }.traverse(tree)
+  end extension
+
+  extension (tree: Assign)
+    def computeAssignNullable()(using Context): tree.type = tree.lhs match
+      case TrackedRef(ref) =>
+        val rhstp = tree.rhs.typeOpt
+        if ctx.explicitNulls && ref.isNullableUnion then
+          if rhstp.isNullType || rhstp.isNullableUnion then
+            // If the type of rhs is nullable (`T|Null` or `Null`), then the nullability of the
+            // lhs variable is no longer trackable. We don't need to check whether the type `T`
+            // is correct here, as typer will check it.
+            tree.withNotNullInfo(NotNullInfo(Set(), Set(ref)))
+          else
+            // If the initial type is nullable and the assigned value is non-null,
+            // we add it to the NotNull.
+            tree.withNotNullInfo(NotNullInfo(Set(ref), Set()))
+        else tree
+      case _ => tree
+  end extension
+
+  private val analyzedOps = Set(nme.EQ, nme.NE, nme.eq, nme.ne, nme.ZAND, nme.ZOR, nme.UNARY_!)
+
+  /** A map from (name-) offsets of all local variables in this compilation unit
+   *  that can be tracked for being not null to the list of spans of assignments
+   *  to these variables. A variable can be tracked if it has only reachable assignments
+   *  An assignment is reachable if the path of tree nodes between the block enclosing
+   *  the variable declaration to the assignment consists only of if-expressions,
+   *  while-expressions, block-expressions and type-ascriptions.
+   *  Only reachable assignments are handled correctly in the nullability analysis.
+   *  Therefore, variables with unreachable assignments can be assumed to be not-null
+   *  only if their type asserts it.
+   *
+   *  Note: we track the local variables through their offset and not through their name
+   *  because of shadowing.
+   */
+  def assignmentSpans(using Context): Map[Int, List[Span]] =
+    import ast.untpd._
+
+    object populate extends UntypedTreeTraverser:
+
+      /** The name offsets of variables that are tracked */
+      var tracked: Map[Int, List[Span]] = Map.empty
+
+      /** Map the names of potentially trackable candidate variables in scope to the spans
+       *  of their reachable assignments
+       */
+      val candidates = mutable.Map[Name, List[Span]]()
+
+      /** An assignment to a variable that's not in reachable makes the variable
+       *  ineligible for tracking
+       */
+      var reachable: Set[Name] = Set.empty
+
+      def traverse(tree: Tree)(using Context) =
+        val savedReachable = reachable
+        tree match
+          case Block(stats, expr) =>
+            var shadowed: Set[(Name, List[Span])] = Set.empty
+            for stat <- stats do
+              stat match
+                case stat: ValDef if stat.mods.is(Mutable) =>
+                  for prevSpans <- candidates.put(stat.name, Nil) do
+                    shadowed += (stat.name -> prevSpans)
+                  reachable += stat.name
+                case _ =>
+            traverseChildren(tree)
+            for stat <- stats do
+              stat match
+                case stat: ValDef if stat.mods.is(Mutable) =>
+                  for spans <- candidates.remove(stat.name) do
+                    tracked += (stat.nameSpan.start -> spans) // candidates that survive until here are tracked
+                case _ =>
+            candidates ++= shadowed
+          case Assign(Ident(name), rhs) =>
+            candidates.get(name) match
+              case Some(spans) =>
+                if reachable.contains(name) then candidates(name) = tree.span :: spans
+                else candidates -= name
+              case None =>
+            traverseChildren(tree)
+          case _: (If | WhileDo | Typed) =>
+            traverseChildren(tree)      // assignments to candidate variables are OK here ...
+          case _ =>
+            reachable = Set.empty       // ... but not here
+            traverseChildren(tree)
+        reachable = savedReachable
+
+    populate.traverse(ctx.compilationUnit.untpdTree)
+    populate.tracked
+  end assignmentSpans
+
+  /** The initial context to be used for a while expression with given span.
+   *  In this context, all variables that are assigned within the while expression
+   *  have their nullability status retracted, i.e. are not known to be not null.
+   *  While necessary for soundness, this scheme loses precision: Even if
+   *  the initial state of the variable is not null and all assignments to the variable
+   *  in the while expression are also known to be not null, the variable is still
+   *  assumed to be potentially null. The loss of precision is unavoidable during
+   *  normal typing, since we can only do a linear traversal which does not allow
+   *  a fixpoint computation. But it could be mitigated as follows:
+   *
+   *   - initially, use `whileContext` as computed here
+   *   - when typechecking the while, delay all errors due to a variable being potentially null
+   *   - afterwards, if there are such delayed errors, run the analysis again with
+   *     as a fixpoint computation, reporting all previously delayed errors that remain.
+   *
+   *  The following code would produce an error in the current analysis, but not in the
+   *  refined analysis:
+   *
+   *     class Links(val elem: T, val next: Links | Null)
+   *
+   *     var xs: Links | Null = Links(1, null)
+   *     var ys: Links | Null = xs
+   *     while xs != null
+   *       ys = Links(xs.elem, ys.next)  // error in unrefined: ys is potentially null here
+   *       xs = xs.next
+   */
+  def whileContext(whileSpan: Span)(using Context): Context =
+
+    def isRetracted(ref: TermRef): Boolean =
+      val sym = ref.symbol
+      sym.span.exists
+      && assignmentSpans.getOrElse(sym.span.start, Nil).exists(whileSpan.contains(_))
+      && ctx.notNullInfos.impliesNotNull(ref)
+
+    val retractedVars = ctx.notNullInfos.flatMap(_.asserted.filter(isRetracted)).toSet
+    ctx.addNotNullInfo(NotNullInfo(Set(), retractedVars))
+  end whileContext
+
+  /** Post process all arguments to by-name parameters by removing any not-null
+   *  info that was used when typing them. Concretely:
+   *  If an argument corresponds to a call-by-name parameter, drop all
+   *  embedded not-null assertions of the form `x.$asInstanceOf[x.type & T]`
+   *  where `x` is a reference to a mutable variable. If the argument still typechecks
+   *  with the removed assertions and is still compatible with the formal parameter,
+   *  keep it. Otherwise issue an error that the call-by-name argument was typed using
+   *  flow assumptions about mutable variables and suggest that it is enclosed
+   *  in a `byName(...)` call instead.
+   */
+  def postProcessByNameArgs(fn: TermRef, app: Tree)(using Context): Tree =
+    fn.widen match
+      case mt: MethodType
+      if mt.paramInfos.exists(_.isInstanceOf[ExprType]) && !fn.symbol.is(Inline) =>
+        app match
+          case Apply(fn, args) =>
+            object dropNotNull extends TreeMap:
+              var dropped: Boolean = false
+              override def transform(t: Tree)(using Context) = t match
+                case AssertNotNull(t0) if t0.symbol.is(Mutable) =>
+                  nullables.println(i"dropping $t")
+                  dropped = true
+                  transform(t0)
+                case t: ValDef if !t.symbol.is(Lazy) => super.transform(t)
+                case t: MemberDef =>
+                  // stop here since embedded references to mutable variables would be
+                  // out of order, so they would not asserted ot be not-null anyway.
+                  // @see Nullables.usedOutOfOrder
+                  t
+                case _ => super.transform(t)
+
+            object retyper extends ReTyper:
+              override def typedUnadapted(t: untpd.Tree, pt: Type, locked: TypeVars)(using Context): Tree = t match
+                case t: untpd.ValDef if !t.symbol.is(Lazy) => super.typedUnadapted(t, pt, locked)
+                case t: untpd.MemberDef => promote(t)
+                case _ => super.typedUnadapted(t, pt, locked)
+
+            def postProcess(formal: Type, arg: Tree): Tree =
+              val nestedCtx = ctx.fresh.setNewTyperState()
+              val arg1 = dropNotNull.transform(arg)(using nestedCtx)
+              if !dropNotNull.dropped then arg
+              else
+                val arg2 = retyper.typed(arg1, formal)(using nestedCtx)
+                if nestedCtx.reporter.hasErrors || !(arg2.tpe <:< formal) then
+                  report.error(em"""This argument was typed using flow assumptions about mutable variables
+                                |but it is passed to a by-name parameter where such flow assumptions are unsound.
+                                |Wrapping the argument in `byName(...)` fixes the problem by disabling the flow assumptions.
+                                |
+                                |`byName` needs to be imported from the `scala.compiletime` package.""",
+                            arg.srcPos)
+                  arg
+                else
+                  nestedCtx.typerState.commit()
+                  arg2
+
+            def recur(formals: List[Type], args: List[Tree]): List[Tree] = (formals, args) match
+              case (formal :: formalsRest, arg :: argsRest) =>
+                val arg1 =
+                  if formal.isInstanceOf[ExprType]
+                  then postProcess(formal.widenExpr.repeatedToSingle, arg)
+                  else arg
+                val argsRest1 = recur(
+                  if formal.isRepeatedParam then formals else formalsRest,
+                  argsRest)
+                if (arg1 eq arg) && (argsRest1 eq argsRest) then args
+                else arg1 :: argsRest1
+              case _ => args
+
+            tpd.cpy.Apply(app)(fn, recur(mt.paramInfos, args))
+          case _ => app
+      case _ => app
+  end postProcessByNameArgs
+end Nullables
diff --git a/tests/pos-with-compiler-cc/dotc/typer/ProtoTypes.scala b/tests/pos-with-compiler-cc/dotc/typer/ProtoTypes.scala
new file mode 100644
index 000000000000..8775206ace7b
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/typer/ProtoTypes.scala
@@ -0,0 +1,958 @@
+package dotty.tools
+package dotc
+package typer
+
+import core._
+import ast._
+import Contexts._, Types._, Denotations._, Names._, StdNames._, NameOps._, Symbols._
+import NameKinds.DepParamName
+import Trees._
+import Constants._
+import util.{Stats, SimpleIdentityMap, SimpleIdentitySet}
+import Decorators._
+import Uniques._
+import inlines.Inlines
+import config.Printers.typr
+import util.SourceFile
+import TypeComparer.necessarySubType
+
+import scala.annotation.internal.sharable
+import scala.annotation.retains
+
+object ProtoTypes {
+
+  import tpd._
+
+  /** A trait defining an `isCompatible` method. */
+  trait Compatibility {
+
+    /** Is there an implicit conversion from `tp` to `pt`? */
+    def viewExists(tp: Type, pt: Type)(using Context): Boolean
+
+    /** A type `tp` is compatible with a type `pt` if one of the following holds:
+     *    1. `tp` is a subtype of `pt`
+     *    2. `pt` is by name parameter type, and `tp` is compatible with its underlying type
+     *    3. there is an implicit conversion from `tp` to `pt`.
+     *    4. `tp` is a numeric subtype of `pt` (this case applies even if implicit conversions are disabled)
+     *  If `pt` is a by-name type, we compare against the underlying type instead.
+     */
+    def isCompatible(tp: Type, pt: Type)(using Context): Boolean =
+      (tp.widenExpr relaxed_<:< pt.widenExpr) || viewExists(tp, pt)
+
+    /** Like normalize and then isCompatible, but using a subtype comparison with
+     *  necessary eithers that does not unnecessarily truncate the constraint space,
+     *  returning false instead.
+     */
+    def necessarilyCompatible(tp: Type, pt: Type)(using Context): Boolean =
+      val tpn = normalize(tp, pt, followIFT = !defn.isContextFunctionType(pt))
+      necessarySubType(tpn, pt) || tpn.isValueSubType(pt) || viewExists(tpn, pt)
+
+    /** Test compatibility after normalization.
+     *  If `keepConstraint` is false, the current constraint set will not be modified by this call.
+     */
+    def normalizedCompatible(tp: Type, pt: Type, keepConstraint: Boolean)(using Context): Boolean =
+
+      def testCompat(using Context): Boolean =
+        val normTp = normalize(tp, pt)
+        isCompatible(normTp, pt) || pt.isRef(defn.UnitClass) && normTp.isParameterless
+
+      if keepConstraint then
+        tp.widenSingleton match
+          case poly: PolyType =>
+            val newctx = ctx.fresh.setNewTyperState()
+            val result = testCompat(using newctx)
+            typr.println(
+                i"""normalizedCompatible for $poly, $pt = $result
+                   |constraint was: ${ctx.typerState.constraint}
+                   |constraint now: ${newctx.typerState.constraint}""")
+            if result && (ctx.typerState.constraint ne newctx.typerState.constraint) then
+              newctx.typerState.commit()
+            result
+          case _ => testCompat
+      else explore(testCompat)
+    end normalizedCompatible
+
+    private def disregardProto(pt: Type)(using Context): Boolean =
+      pt.dealias.isRef(defn.UnitClass)
+
+    /** Check that the result type of the current method
+     *  fits the given expected result type.
+     */
+    def constrainResult(mt: Type, pt: Type)(using Context): Boolean =
+      val savedConstraint = ctx.typerState.constraint
+      val res = pt.widenExpr match {
+        case pt: FunProto =>
+          mt match
+            case mt: MethodType =>
+              constrainResult(resultTypeApprox(mt), pt.resultType)
+              && {
+                if pt.constrainResultDeep
+                   && mt.isImplicitMethod == (pt.applyKind == ApplyKind.Using)
+                then
+                  pt.args.lazyZip(mt.paramInfos).forall((arg, paramInfo) =>
+                    pt.typedArg(arg, paramInfo).tpe <:< paramInfo)
+                else true
+              }
+            case _ => true
+        case _: ValueTypeOrProto if !disregardProto(pt) =>
+          necessarilyCompatible(mt, pt)
+        case pt: WildcardType if pt.optBounds.exists =>
+          necessarilyCompatible(mt, pt)
+        case _ =>
+          true
+      }
+      if !res then ctx.typerState.constraint = savedConstraint
+      res
+
+    /** Constrain result with special case if `meth` is an inlineable method in an inlineable context.
+     *  In that case, we should always succeed and not constrain type parameters in the expected type,
+     *  because the actual return type can be a subtype of the currently known return type.
+     *  However, we should constrain parameters of the declared return type. This distinction is
+     *  achieved by replacing expected type parameters with wildcards.
+     */
+    def constrainResult(meth: Symbol, mt: Type, pt: Type)(using Context): Boolean =
+      if (Inlines.isInlineable(meth)) {
+        constrainResult(mt, wildApprox(pt))
+        true
+      }
+      else constrainResult(mt, pt)
+  }
+
+  object NoViewsAllowed extends Compatibility {
+    override def viewExists(tp: Type, pt: Type)(using Context): Boolean = false
+  }
+
+  /** A trait for prototypes that match all types */
+  trait MatchAlways extends ProtoType, caps.Pure {
+    def isMatchedBy(tp1: Type, keepConstraint: Boolean)(using Context): Boolean = true
+    def map(tm: TypeMap)(using Context): ProtoType = this
+    def fold[T](x: T, ta: TypeAccumulator[T] @retains(caps.*))(using Context): T = x
+    override def toString: String = getClass.toString
+  }
+
+  /** A class marking ignored prototypes that can be revealed by `deepenProto` */
+  abstract case class IgnoredProto(ignored: Type) extends CachedGroundType, MatchAlways, caps.Pure:
+    private var myWasDeepened = false
+    override def revealIgnored = ignored
+    override def deepenProto(using Context): Type =
+      myWasDeepened = true
+      ignored
+    override def deepenProtoTrans(using Context): Type = ignored.deepenProtoTrans
+
+    /** Did someone look inside via deepenProto? Used for error deagniostics
+     *  to give a more extensive expected type.
+     */
+    def wasDeepened: Boolean = myWasDeepened
+
+    override def computeHash(bs: Hashable.Binders): Int = doHash(bs, ignored)
+
+    override def eql(that: Type): Boolean = that match
+      case that: IgnoredProto => ignored eq that.ignored
+      case _ => false
+
+    // equals comes from case class; no need to redefine
+  end IgnoredProto
+
+  final class CachedIgnoredProto(ignored: Type) extends IgnoredProto(ignored)
+
+  object IgnoredProto:
+    def apply(ignored: Type)(using Context): IgnoredProto = ignored match
+      case ignored: IgnoredProto => ignored
+      case _ => unique(CachedIgnoredProto(ignored))
+
+  /** A prototype for expressions [] that are part of a selection operation:
+   *
+   *       [ ].name: proto
+   */
+  abstract case class SelectionProto(name: Name, memberProto: Type, compat: Compatibility, privateOK: Boolean)
+  extends CachedProxyType, ProtoType, ValueTypeOrProto, caps.Pure {
+
+    /** Is the set of members of this type unknown, in the sense that we
+     *  cannot compute a non-trivial upper approximation? This is the case if:
+     *    1. The type has Nothing or Wildcard as a prefix or underlying type
+     *    2. The type is an abstract type with a lower bound that has a unknown
+     *       members and an upper bound that is both provisional and has unknown members.
+     *    3. The type is an uninstiated type var with a lower that has unknown members.
+     *    4. Type proxies have unknown members if their super types do
+     */
+    private def hasUnknownMembers(tp: Type)(using Context): Boolean = tp match
+      case tp: WildcardType => true
+      case NoType => true
+      case tp: TypeRef =>
+        val sym = tp.symbol
+        sym == defn.NothingClass
+        ||     !sym.isClass
+            && !sym.isStatic
+            && {
+                hasUnknownMembers(tp.prefix)
+                || { val bound = tp.info.hiBound
+                     bound.isProvisional && hasUnknownMembers(bound)
+                  } && hasUnknownMembers(tp.info.loBound)
+              }
+      case tp: TypeVar if !tp.isInstantiated =>
+        hasUnknownMembers(TypeComparer.bounds(tp.origin).lo)
+      case tp: AppliedType => hasUnknownMembers(tp.tycon) || hasUnknownMembers(tp.superType)
+      case tp: TypeProxy => hasUnknownMembers(tp.superType)
+      // It woukd make sense to also include And/OrTypes, but that leads to
+      // infinite recursions, as observed for instance for t2399.scala.
+      case _ => false
+
+    override def isMatchedBy(tp1: Type, keepConstraint: Boolean)(using Context): Boolean =
+      name == nme.WILDCARD
+      || hasUnknownMembers(tp1)
+      || {
+        try
+          val mbr = if privateOK then tp1.member(name) else tp1.nonPrivateMember(name)
+          def qualifies(m: SingleDenotation) =
+            val isAccessible = !m.symbol.exists || m.symbol.isAccessibleFrom(tp1, superAccess = true)
+            isAccessible
+            && (memberProto.isRef(defn.UnitClass)
+              || tp1.isValueType && compat.normalizedCompatible(NamedType(tp1, name, m), memberProto, keepConstraint))
+                // Note: can't use `m.info` here because if `m` is a method, `m.info`
+                //       loses knowledge about `m`'s default arguments.
+          mbr match // hasAltWith inlined for performance
+            case mbr: SingleDenotation => mbr.exists && qualifies(mbr)
+            case _ => mbr hasAltWith qualifies
+        catch case ex: TypeError =>
+          // A scenario where this can happen is in pos/15673.scala:
+          // We have a type `CC[A]#C` where `CC`'s upper bound is `[X] => Any`, but
+          // the current constraint stipulates CC <: SeqOps[...], where `SeqOps` defines
+          // the `C` parameter. We try to resolve this using `argDenot` but `argDenot`
+          // consults the base type of `CC`, which is not `SeqOps`, so it does not
+          // find a corresponding argument. In fact, `argDenot` is not allowed to
+          // consult short-lived things like the current constraint, so it has no other
+          // choice. The problem will be healed later, when normal selection fails
+          // and we try to instantiate type variables to compensate. But we have to make
+          // sure we do not issue a type error before we get there.
+          false
+      }
+
+    def underlying(using Context): Type = WildcardType
+
+    def derivedSelectionProto(name: Name, memberProto: Type, compat: Compatibility)(using Context): SelectionProto =
+      if ((name eq this.name) && (memberProto eq this.memberProto) && (compat eq this.compat)) this
+      else SelectionProto(name, memberProto, compat, privateOK)
+
+    override def isErroneous(using Context): Boolean =
+      memberProto.isErroneous
+
+    override def unusableForInference(using Context): Boolean =
+      memberProto.unusableForInference
+
+    def map(tm: TypeMap)(using Context): SelectionProto = derivedSelectionProto(name, tm(memberProto), compat)
+    def fold[T](x: T, ta: TypeAccumulator[T] @retains(caps.*))(using Context): T = ta(x, memberProto)
+
+    override def deepenProto(using Context): SelectionProto =
+      derivedSelectionProto(name, memberProto.deepenProto, compat)
+
+    override def deepenProtoTrans(using Context): SelectionProto =
+      derivedSelectionProto(name, memberProto.deepenProtoTrans, compat)
+
+    override def computeHash(bs: Hashable.Binders): Int = {
+      val delta = (if (compat eq NoViewsAllowed) 1 else 0) | (if (privateOK) 2 else 0)
+      addDelta(doHash(bs, name, memberProto), delta)
+    }
+
+    override def equals(that: Any): Boolean = that match
+      case that: SelectionProto =>
+        (name eq that.name) && memberProto.equals(that.memberProto) && (compat eq that.compat) && (privateOK == that.privateOK)
+      case _ =>
+        false
+
+    override def eql(that: Type): Boolean = that match {
+      case that: SelectionProto =>
+        (name eq that.name) && (memberProto eq that.memberProto) && (compat eq that.compat) && (privateOK == that.privateOK)
+      case _ =>
+        false
+    }
+  }
+
+  class CachedSelectionProto(name: Name, memberProto: Type, compat: Compatibility, privateOK: Boolean)
+  extends SelectionProto(name, memberProto, compat, privateOK)
+
+  object SelectionProto {
+    def apply(name: Name, memberProto: Type, compat: Compatibility, privateOK: Boolean)(using Context): SelectionProto = {
+      val selproto = new CachedSelectionProto(name, memberProto, compat, privateOK)
+      if (compat eq NoViewsAllowed) unique(selproto) else selproto
+    }
+  }
+
+  /** Create a selection proto-type, but only one level deep;
+   *  treat constructors specially
+   */
+  def shallowSelectionProto(name: Name, tp: Type, typer: Typer)(using Context): TermType =
+    if (name.isConstructorName) WildcardType
+    else tp match
+      case tp: UnapplyFunProto => new UnapplySelectionProto(name)
+      case tp => SelectionProto(name, IgnoredProto(tp), typer, privateOK = true)
+
+  /** A prototype for expressions [] that are in some unspecified selection operation
+   *
+   *    [].?: ?
+   *
+   *  Used to indicate that expression is in a context where the only valid
+   *  operation is further selection. In this case, the expression need not be a value.
+   *  @see checkValue
+   */
+  @sharable object AnySelectionProto extends SelectionProto(nme.WILDCARD, WildcardType, NoViewsAllowed, true)
+
+  /** A prototype for selections in pattern constructors */
+  class UnapplySelectionProto(name: Name) extends SelectionProto(name, WildcardType, NoViewsAllowed, true)
+
+  trait ApplyingProto extends ProtoType   // common trait of ViewProto and FunProto
+  trait FunOrPolyProto extends ProtoType: // common trait of PolyProto and FunProto
+    def applyKind: ApplyKind = ApplyKind.Regular
+
+  class FunProtoState {
+
+    /** The list of typed arguments, if all arguments are typed */
+    var typedArgs: List[Tree] = Nil
+
+    /** A map in which typed arguments can be stored to be later integrated in `typedArgs`. */
+    var typedArg: SimpleIdentityMap[untpd.Tree, Tree] = SimpleIdentityMap.empty
+
+    /** The argument that produced errors during typing */
+    var errorArgs: SimpleIdentitySet[untpd.Tree] = SimpleIdentitySet.empty
+
+    /** The tupled or untupled version of this prototype, if it has been computed */
+    var tupledDual: Type = NoType
+
+    /** If true, the application of this prototype was canceled. */
+    var toDrop: Boolean = false
+  }
+
+  /** A prototype for expressions that appear in function position
+   *
+   *  [](args): resultType
+   *
+   *  @param  args      The untyped arguments to which the function is applied
+   *  @param  resType   The expeected result type
+   *  @param  typer     The typer to use for typing the arguments
+   *  @param  applyKind The kind of application (regular/using/tupled infix operand)
+   *  @param  state     The state object to use for tracking the changes to this prototype
+   *  @param  constrainResultDeep
+   *                    A flag to indicate that constrainResult on this prototype
+   *                    should typecheck and compare the arguments.
+   */
+  case class FunProto(args: List[untpd.Tree], resType: Type)(
+    typer: Typer,
+    override val applyKind: ApplyKind,
+    state: FunProtoState = new FunProtoState,
+    val constrainResultDeep: Boolean = false)(using protoCtx: Context)
+  extends UncachedGroundType with ApplyingProto with FunOrPolyProto {
+    override def resultType(using Context): Type = resType
+
+    def isMatchedBy(tp: Type, keepConstraint: Boolean)(using Context): Boolean = {
+      val args = typedArgs()
+      def isPoly(tree: Tree) = tree.tpe.widenSingleton.isInstanceOf[PolyType]
+      // See remark in normalizedCompatible for why we can't keep the constraint
+      // if one of the arguments has a PolyType.
+      typer.isApplicableType(tp, args, resultType, keepConstraint && !args.exists(isPoly))
+    }
+
+    def derivedFunProto(
+        args: List[untpd.Tree] = this.args,
+        resultType: Type = this.resultType,
+        typer: Typer = this.typer,
+        constrainResultDeep: Boolean = this.constrainResultDeep): FunProto =
+      if (args eq this.args)
+          && (resultType eq this.resultType)
+          && (typer eq this.typer)
+          && constrainResultDeep == this.constrainResultDeep
+      then this
+      else new FunProto(args, resultType)(typer, applyKind, constrainResultDeep = constrainResultDeep)
+
+    /** @return True if all arguments have types.
+     */
+    def allArgTypesAreCurrent()(using Context): Boolean =
+      state.typedArg.size == args.length
+
+    private def isUndefined(tp: Type): Boolean = tp match {
+      case _: WildcardType => true
+      case defn.FunctionOf(args, result, _, _) => args.exists(isUndefined) || isUndefined(result)
+      case _ => false
+    }
+
+    /** Did an argument produce an error when typing? This means: an error was reported
+     *  and a tree got an error type. Errors of adaptation whree a tree has a good type
+     *  but that type does not conform to the expected type are not counted.
+     */
+    def hasErrorArg = !state.errorArgs.isEmpty
+
+    /** Does tree have embedded error trees that are not at the outside.
+     *  A nested tree t1 is "at the outside" relative to a tree t2 if
+     *    - t1 and t2 have the same span, or
+     *    - t2 is a ascription (t22: T) and t1 is at the outside of t22
+     *    - t2 is a closure (...) => t22 and t1 is at the outside of t22
+     */
+    def hasInnerErrors(t: Tree)(using Context): Boolean = t match
+      case Typed(expr, tpe) => hasInnerErrors(expr)
+      case closureDef(mdef) => hasInnerErrors(mdef.rhs)
+      case _ =>
+        t.existsSubTree { t1 =>
+          if t1.typeOpt.isError && t1.span.toSynthetic != t.span.toSynthetic then
+            typr.println(i"error subtree $t1 of $t with ${t1.typeOpt}, spans = ${t1.span}, ${t.span}")
+            true
+          else
+            false
+        }
+
+    private def cacheTypedArg(arg: untpd.Tree, typerFn: untpd.Tree => Tree, force: Boolean)(using Context): Tree = {
+      var targ = state.typedArg(arg)
+      if (targ == null)
+        untpd.functionWithUnknownParamType(arg) match {
+          case Some(untpd.Function(args, _)) if !force =>
+            // If force = false, assume what we know about the parameter types rather than reporting an error.
+            // That way we don't cause a "missing parameter" error in `typerFn(arg)`
+            val paramTypes = args map {
+              case ValDef(_, tpt, _) if !tpt.isEmpty => typer.typedType(tpt).typeOpt
+              case _ => WildcardType
+            }
+            targ = arg.withType(defn.FunctionOf(paramTypes, WildcardType))
+          case Some(_) if !force =>
+            targ = arg.withType(WildcardType)
+          case _ =>
+            targ = typerFn(arg)
+            // TODO: investigate why flow typing is not working on `targ`
+            if ctx.reporter.hasUnreportedErrors then
+              if hasInnerErrors(targ.nn) then
+                state.errorArgs += arg
+            else
+              state.typedArg = state.typedArg.updated(arg, targ.nn)
+              state.errorArgs -= arg
+        }
+      targ.nn
+    }
+
+    /** The typed arguments. This takes any arguments already typed using
+     *  `typedArg` into account.
+     *
+     *  Arguments are typechecked in the typerState where the FunProto was created.
+     *  However, any constraint changes are also propagated to the currently passed
+     *  context.
+     *
+     *  @param norm   a normalization function that is applied to an untyped argument tree
+     *                before it is typed. The second Int parameter is the parameter index.
+     */
+    def typedArgs(norm: (untpd.Tree, Int) => untpd.Tree = sameTree)(using Context): List[Tree] =
+      if state.typedArgs.size == args.length then state.typedArgs
+      else
+        val passedCtx = ctx
+        val passedTyperState = ctx.typerState
+        inContext(protoCtx.withUncommittedTyperState) {
+          val protoTyperState = ctx.typerState
+          val oldConstraint = protoTyperState.constraint
+          val args1 = args.mapWithIndexConserve((arg, idx) =>
+            cacheTypedArg(arg, arg => typer.typed(norm(arg, idx)), force = false))
+          val newConstraint = protoTyperState.constraint
+
+          if !args1.exists(arg => isUndefined(arg.tpe)) then state.typedArgs = args1
+
+          // We only need to propagate constraints if we typed the arguments in a different
+          // TyperState and if that created additional constraints.
+          if (passedTyperState ne protoTyperState) && (oldConstraint ne newConstraint) then
+            // To respect the pre-condition of `mergeConstraintWith` and keep
+            // `protoTyperState` committable we must ensure that it does not
+            // contain any type variable which don't already exist in the passed
+            // TyperState. This is achieved by instantiating any such type
+            // variable. NOTE: this does not suffice to discard type variables
+            // in ancestors of `protoTyperState`, if this situation ever
+            // comes up, an assertion in TyperState will trigger and this code
+            // will need to be generalized.
+            if protoTyperState.isCommittable then
+              val passedConstraint = passedTyperState.constraint
+              val newLambdas = newConstraint.domainLambdas.filter(tl =>
+                !passedConstraint.contains(tl) || passedConstraint.hasConflictingTypeVarsFor(tl, newConstraint))
+              val newTvars = newLambdas.flatMap(_.paramRefs).map(newConstraint.typeVarOfParam)
+
+              args1.foreach(arg => Inferencing.instantiateSelected(arg.tpe, newTvars))
+
+              // `instantiateSelected` can leave some type variables uninstantiated,
+              // so we maximize them in a second pass.
+              newTvars.foreach {
+                case tvar: TypeVar if !tvar.isInstantiated =>
+                  tvar.instantiate(fromBelow = false)
+                case _ =>
+              }
+            passedTyperState.mergeConstraintWith(protoTyperState)(using passedCtx)
+          end if
+          args1
+        }
+
+    /** Type single argument and remember the unadapted result in `myTypedArg`.
+     *  used to avoid repeated typings of trees when backtracking.
+     */
+    def typedArg(arg: untpd.Tree, formal: Type)(using Context): Tree = {
+      val wideFormal = formal.widenExpr
+      val argCtx =
+        if wideFormal eq formal then ctx
+        else ctx.withNotNullInfos(ctx.notNullInfos.retractMutables)
+      val locked = ctx.typerState.ownedVars
+      val targ = cacheTypedArg(arg,
+        typer.typedUnadapted(_, wideFormal, locked)(using argCtx),
+        force = true)
+      typer.adapt(targ, wideFormal, locked)
+    }
+
+    /** The type of the argument `arg`, or `NoType` if `arg` has not been typed before
+     *  or if `arg`'s typing produced a type error.
+     */
+    def typeOfArg(arg: untpd.Tree)(using Context): Type = {
+      val t = state.typedArg(arg)
+      if (t == null) NoType else t.tpe
+    }
+
+    /** Cache the typed argument */
+    def cacheArg(arg: untpd.Tree, targ: Tree) =
+      state.typedArg = state.typedArg.updated(arg, targ)
+
+    /** The same proto-type but with all arguments combined in a single tuple */
+    def tupledDual: FunProto = state.tupledDual match {
+      case pt: FunProto =>
+        pt
+      case _ =>
+        val dualArgs = args match
+          case untpd.Tuple(elems) :: Nil => elems
+          case _ => untpd.Tuple(args) :: Nil
+        state.tupledDual = new FunProto(dualArgs, resultType)(typer, applyKind)
+        tupledDual
+    }
+
+    /** Somebody called the `tupledDual` method of this prototype */
+    def hasTupledDual: Boolean = state.tupledDual.isInstanceOf[FunProto]
+
+    /** Cancel the application of this prototype. This can happen for a nullary
+     *  application `f()` if `f` refers to a symbol that exists both in parameterless
+     *  form `def f` and nullary method form `def f()`. A common example for such
+     *  a method is `toString`. If in that case the type in the denotation is
+     *  parameterless, we compensate by dropping the application.
+     */
+    def markAsDropped(): Unit = {
+      assert(args.isEmpty)
+      state.toDrop = true
+    }
+
+    def isDropped: Boolean = state.toDrop
+
+    override def isErroneous(using Context): Boolean =
+      state.typedArgs.tpes.exists(_.isErroneous)
+
+    override def unusableForInference(using Context): Boolean =
+      state.typedArgs.exists(_.tpe.unusableForInference)
+
+    override def toString: String = s"FunProto(${args mkString ","} => $resultType)"
+
+    def map(tm: TypeMap)(using Context): FunProto =
+      derivedFunProto(args, tm(resultType), typer)
+
+    def fold[T](x: T, ta: TypeAccumulator[T] @retains(caps.*))(using Context): T =
+      ta(ta.foldOver(x, typedArgs().tpes), resultType)
+
+    override def deepenProto(using Context): FunProto =
+      derivedFunProto(args, resultType.deepenProto)
+
+    override def deepenProtoTrans(using Context): FunProto =
+      derivedFunProto(args, resultType.deepenProtoTrans, constrainResultDeep = true)
+
+    override def withContext(newCtx: Context): ProtoType =
+      if newCtx `eq` protoCtx then this
+      else new FunProto(args, resType)(typer, applyKind, state)(using newCtx)
+  }
+
+  /** A prototype for expressions that appear in function position
+   *
+   *  [](args): resultType, where args are known to be typed
+   */
+  class FunProtoTyped(args: List[tpd.Tree], resultType: Type)(typer: Typer, applyKind: ApplyKind)(using Context)
+  extends FunProto(args, resultType)(typer, applyKind):
+    override def typedArgs(norm: (untpd.Tree, Int) => untpd.Tree)(using Context): List[tpd.Tree] = args
+    override def typedArg(arg: untpd.Tree, formal: Type)(using Context): tpd.Tree = arg.asInstanceOf[tpd.Tree]
+    override def allArgTypesAreCurrent()(using Context): Boolean = true
+    override def withContext(ctx: Context): FunProtoTyped = this
+
+  /** A prototype for implicitly inferred views:
+   *
+   *    []: argType => resultType
+   */
+  abstract case class ViewProto(argType: Type, resType: Type)
+  extends CachedGroundType, ApplyingProto, caps.Pure {
+
+    override def resultType(using Context): Type = resType
+
+    def isMatchedBy(tp: Type, keepConstraint: Boolean)(using Context): Boolean =
+      ctx.typer.isApplicableType(tp, argType :: Nil, resultType) || {
+        resType match {
+          case selProto @ SelectionProto(selName: TermName, mbrType, _, _) =>
+            ctx.typer.hasExtensionMethodNamed(tp, selName, argType, mbrType)
+              //.reporting(i"has ext $tp $name $argType $mbrType: $result")
+          case _ =>
+            false
+        }
+      }
+
+    def derivedViewProto(argType: Type, resultType: Type)(using Context): ViewProto =
+      if ((argType eq this.argType) && (resultType eq this.resultType)) this
+      else ViewProto(argType, resultType)
+
+    override def isErroneous(using Context): Boolean =
+      argType.isErroneous || resType.isErroneous
+
+    override def unusableForInference(using Context): Boolean =
+      argType.unusableForInference || resType.unusableForInference
+
+    def map(tm: TypeMap)(using Context): ViewProto = derivedViewProto(tm(argType), tm(resultType))
+
+    def fold[T](x: T, ta: TypeAccumulator[T] @retains(caps.*))(using Context): T =
+      ta(ta(x, argType), resultType)
+
+    override def deepenProto(using Context): ViewProto =
+      derivedViewProto(argType, resultType.deepenProto)
+
+    override def deepenProtoTrans(using Context): ViewProto =
+      derivedViewProto(argType, resultType.deepenProtoTrans)
+  }
+
+  class CachedViewProto(argType: Type, resultType: Type) extends ViewProto(argType, resultType) {
+    override def computeHash(bs: Hashable.Binders): Int = doHash(bs, argType, resultType)
+    override def eql(that: Type): Boolean = that match
+      case that: ViewProto => (argType eq that.argType) && (resType eq that.resType)
+      case _ => false
+    // equals comes from case class; no need to redefine
+  }
+
+  object ViewProto {
+    def apply(argType: Type, resultType: Type)(using Context): ViewProto =
+      unique(new CachedViewProto(argType, resultType))
+  }
+
+  class UnapplyFunProto(argType: Type, typer: Typer)(using Context) extends FunProto(
+    untpd.TypedSplice(dummyTreeOfType(argType)(ctx.source)) :: Nil, WildcardType)(typer, applyKind = ApplyKind.Regular)
+
+  /** A prototype for expressions [] that are type-parameterized:
+   *
+   *    [] [targs] resultType
+   */
+  case class PolyProto(targs: List[Tree], resType: Type) extends UncachedGroundType with FunOrPolyProto {
+
+    override def resultType(using Context): Type = resType
+
+    def canInstantiate(tp: Type)(using Context) = tp.widen match
+      case tp: PolyType => tp.paramNames.length == targs.length
+      case _ => false
+
+    override def isMatchedBy(tp: Type, keepConstraint: Boolean)(using Context): Boolean =
+      canInstantiate(tp) || tp.member(nme.apply).hasAltWith(d => canInstantiate(d.info))
+
+    def derivedPolyProto(targs: List[Tree], resType: Type): PolyProto =
+      if ((targs eq this.targs) && (resType eq this.resType)) this
+      else PolyProto(targs, resType)
+
+    override def isErroneous(using Context): Boolean =
+      targs.exists(_.tpe.isErroneous)
+
+    override def unusableForInference(using Context): Boolean =
+      targs.exists(_.tpe.unusableForInference)
+
+    def map(tm: TypeMap)(using Context): PolyProto =
+      derivedPolyProto(targs, tm(resultType))
+
+    def fold[T](x: T, ta: TypeAccumulator[T] @retains(caps.*))(using Context): T =
+      ta(ta.foldOver(x, targs.tpes), resultType)
+
+    override def deepenProto(using Context): PolyProto =
+      derivedPolyProto(targs, resultType.deepenProto)
+
+    override def deepenProtoTrans(using Context): PolyProto =
+      derivedPolyProto(targs, resultType.deepenProtoTrans)
+  }
+
+  /** A prototype for expressions [] that are known to be functions:
+   *
+   *    [] _
+   */
+  @sharable object AnyFunctionProto extends UncachedGroundType with MatchAlways
+
+  /** A prototype for type constructors that are followed by a type application */
+  @sharable object AnyTypeConstructorProto extends UncachedGroundType with MatchAlways
+
+  extension (pt: Type)
+    def isExtensionApplyProto: Boolean = pt match
+      case PolyProto(targs, res) => res.isExtensionApplyProto
+      case FunProto((arg: untpd.TypedSplice) :: Nil, _) => arg.isExtensionReceiver
+      case _ => false
+
+  /** Add all parameters of given type lambda `tl` to the constraint's domain.
+   *  If the constraint contains already some of these parameters in its domain,
+   *  make a copy of the type lambda and add the copy's type parameters instead.
+   *  Return either the original type lambda, or the copy, if one was made.
+   *  Also, if `owningTree` is non-empty or `alwaysAddTypeVars` is true, add a type variable
+   *  for each parameter.
+   *  @return  The added type lambda, and the list of created type variables.
+   */
+  def constrained(using Context)(
+    tl: TypeLambda, owningTree: untpd.Tree,
+    alwaysAddTypeVars: Boolean,
+    nestingLevel: Int = ctx.nestingLevel
+  ): (TypeLambda, List[TypeTree]) = {
+    val state = ctx.typerState
+    val addTypeVars = alwaysAddTypeVars || !owningTree.isEmpty
+    if (tl.isInstanceOf[PolyType])
+      assert(!ctx.typerState.isCommittable || addTypeVars,
+        s"inconsistent: no typevars were added to committable constraint ${state.constraint}")
+      // hk type lambdas can be added to constraints without typevars during match reduction
+
+    def newTypeVars(tl: TypeLambda): List[TypeTree] =
+      for (paramRef <- tl.paramRefs)
+      yield {
+        val tt = InferredTypeTree[Type]().withSpan(owningTree.span)
+          // !cc! explicit type argument [Type] needed since otherwise it is
+          // inferred to be `{*} Type`, which violates the upper bound. The
+          // inference works like this because of the contravariance of Tree.
+        val tvar = TypeVar(paramRef, state, nestingLevel)
+        state.ownedVars += tvar
+        tt.withType(tvar)
+      }
+
+    val added = state.constraint.ensureFresh(tl)
+    val tvars = if (addTypeVars) newTypeVars(added) else Nil
+    TypeComparer.addToConstraint(added, tvars.tpes.asInstanceOf[List[TypeVar]])
+    (added, tvars)
+  }
+
+  def constrained(tl: TypeLambda, owningTree: untpd.Tree)(using Context): (TypeLambda, List[TypeTree]) =
+    constrained(tl, owningTree,
+      alwaysAddTypeVars = tl.isInstanceOf[PolyType] && ctx.typerState.isCommittable)
+
+  /**  Same as `constrained(tl, EmptyTree)`, but returns just the created type lambda */
+  def constrained(tl: TypeLambda)(using Context): TypeLambda =
+    constrained(tl, EmptyTree)._1
+
+  /** Instantiate `tl` with fresh type variables added to the constraint. */
+  def instantiateWithTypeVars(tl: TypeLambda)(using Context): Type =
+    val targs = constrained(tl, ast.tpd.EmptyTree, alwaysAddTypeVars = true)._2
+    tl.instantiate(targs.tpes)
+
+  /** A fresh type variable added to the current constraint.
+   *  @param  bounds        The initial bounds of the variable
+   *  @param  name          The name of the variable, defaults a fresh `DepParamName`
+   *  @param  nestingLevel  See `TypeVar#nestingLevel`
+   *  @param  represents    If it exists, a ParamRef that this TypeVar represents,
+   *                        to be retrieved using `representedParamRef`.
+   *                        in the substitution generated by `resultTypeApprox`
+   *  If `represents` exists, it is stored in the result type of the PolyType
+   *  that backs the TypeVar, to be retrieved by `representedParamRef`.
+   */
+  def newTypeVar(using Context)(
+      bounds: TypeBounds, name: TypeName = DepParamName.fresh().toTypeName,
+      nestingLevel: Int = ctx.nestingLevel, represents: Type = NoType): TypeVar =
+    val poly = PolyType(name :: Nil)(
+        pt => bounds :: Nil,
+        pt => represents.orElse(defn.AnyType))
+    constrained(poly, untpd.EmptyTree, alwaysAddTypeVars = true, nestingLevel)
+      ._2.head.tpe.asInstanceOf[TypeVar]
+
+  /** If `param` was created using `newTypeVar(..., represents = X)`, returns X.
+   *  This is used in:
+   *  - `Inferencing#constrainIfDependentParamRef` to retrieve the dependent function
+   *    parameter for which the variable was substituted.
+   *  - `ConstraintHandling#LevelAvoidMap#legalVar` to retrieve the type variable that was
+   *    avoided in a previous call to `legalVar`.
+   */
+  def representedParamRef(param: TypeParamRef)(using Context): Type =
+    param.binder.resultType match
+      case ref: ParamRef => ref
+      case _ => NoType
+
+  /** Create a new TypeVar that represents a dependent method parameter singleton `ref` */
+  def newDepTypeVar(ref: TermParamRef)(using Context): TypeVar =
+    newTypeVar(
+      TypeBounds.upper(AndType(ref.underlying.widenExpr, defn.SingletonClass.typeRef)),
+      represents = ref)
+
+  /** The result type of `mt`, where all references to parameters of `mt` are
+   *  replaced by either wildcards or TypeParamRefs.
+   */
+  def resultTypeApprox(mt: MethodType, wildcardOnly: Boolean = false)(using Context): Type =
+    if mt.isResultDependent then
+      def replacement(ref: TermParamRef) =
+        if wildcardOnly
+           || ctx.mode.is(Mode.TypevarsMissContext)
+           || !ref.underlying.widenExpr.isValueTypeOrWildcard
+        then
+          WildcardType(ref.underlying.substParams(mt, mt.paramRefs.map(_ => WildcardType)).toBounds)
+        else
+          newDepTypeVar(ref)
+      mt.resultType.substParams(mt, mt.paramRefs.map(replacement))
+    else mt.resultType
+
+  /** The normalized form of a type
+   *   - instantiate polymorphic types with fresh type variables in the current constraint
+   *   - skips implicit parameters of methods and functions;
+   *     if result type depends on implicit parameter, replace with wildcard.
+   *   - converts non-dependent method types to the corresponding function types
+   *     unless the expected type is an ApplyingProto or IgnoredProto.
+   *   - dereferences parameterless method types
+   *   - dereferences nullary method types provided the corresponding function type
+   *     is not a subtype of the expected type.
+   * Note: We need to take account of the possibility of inserting a () argument list in normalization. Otherwise, a type with a
+   *     def toString(): String
+   * member would not count as a valid solution for ?{toString: String}. This would then lead to an implicit
+   * insertion, with a nice explosion of inference search because of course every implicit result has some sort
+   * of toString method. The problem is solved by dereferencing nullary method types if the corresponding
+   * function type is not compatible with the prototype.
+   */
+  def normalize(tp: Type, pt: Type, followIFT: Boolean = true)(using Context): Type = {
+    Stats.record("normalize")
+    tp.widenSingleton match {
+      case poly: PolyType =>
+        normalize(instantiateWithTypeVars(poly), pt)
+      case mt: MethodType =>
+        if (mt.isImplicitMethod) normalize(resultTypeApprox(mt, wildcardOnly = true), pt)
+        else if (mt.isResultDependent) tp
+        else {
+          val rt = normalize(mt.resultType, pt)
+          pt match {
+            case pt: IgnoredProto  =>
+              tp
+            case pt: ApplyingProto =>
+              if (rt eq mt.resultType) tp
+              else mt.derivedLambdaType(mt.paramNames, mt.paramInfos, rt)
+            case _ =>
+              val ft = defn.FunctionOf(mt.paramInfos, rt)
+              if mt.paramInfos.nonEmpty || (ft frozen_<:< pt) then ft else rt
+          }
+        }
+      case et: ExprType =>
+        normalize(et.resultType, pt)
+      case wtp =>
+        val iftp = defn.asContextFunctionType(wtp)
+        if iftp.exists && followIFT then normalize(iftp.dropDependentRefinement.argInfos.last, pt)
+        else tp
+    }
+  }
+
+  /** Approximate occurrences of parameter types and uninstantiated typevars
+   *  by wildcard types.
+   */
+  private def wildApprox(tp: Type, theMap: WildApproxMap | Null, seen: Set[TypeParamRef], internal: Set[TypeLambda])(using Context): Type =
+    tp match {
+    case tp: NamedType => // default case, inlined for speed
+      val isPatternBoundTypeRef = tp.isInstanceOf[TypeRef] && tp.symbol.isPatternBound
+      if (isPatternBoundTypeRef) WildcardType(tp.underlying.bounds)
+      else if (tp.symbol.isStatic || (tp.prefix `eq` NoPrefix)) tp
+      else tp.derivedSelect(wildApprox(tp.prefix, theMap, seen, internal))
+    case tp @ AppliedType(tycon, args) =>
+      def wildArgs = args.mapConserve(arg => wildApprox(arg, theMap, seen, internal))
+      wildApprox(tycon, theMap, seen, internal) match {
+        case WildcardType(TypeBounds(lo, hi)) if hi.typeParams.hasSameLengthAs(args) =>
+          val args1 = wildArgs
+          val lo1 = if lo.typeParams.hasSameLengthAs(args) then lo.appliedTo(args1) else lo
+          WildcardType(TypeBounds(lo1, hi.appliedTo(args1)))
+        case WildcardType(_) =>
+          WildcardType
+        case tycon1 => tp.derivedAppliedType(tycon1, wildArgs)
+      }
+    case tp: RefinedType => // default case, inlined for speed
+      tp.derivedRefinedType(
+          wildApprox(tp.parent, theMap, seen, internal),
+          tp.refinedName,
+          wildApprox(tp.refinedInfo, theMap, seen, internal))
+    case tp: AliasingBounds => // default case, inlined for speed
+      tp.derivedAlias(wildApprox(tp.alias, theMap, seen, internal))
+    case tp: TypeBounds =>
+      tp.derivedTypeBounds(
+        wildApprox(tp.lo, theMap, seen, internal),
+        wildApprox(tp.hi, theMap, seen, internal))
+    case tp @ TypeParamRef(tl, _) if internal.contains(tl) => tp
+    case tp @ TypeParamRef(poly, pnum) =>
+      def wildApproxBounds(bounds: TypeBounds) =
+        if (seen.contains(tp)) WildcardType
+        else WildcardType(wildApprox(bounds, theMap, seen + tp, internal).bounds)
+      def unconstrainedApprox = wildApproxBounds(poly.paramInfos(pnum))
+      def approxPoly =
+        if (ctx.mode.is(Mode.TypevarsMissContext)) unconstrainedApprox
+        else
+          ctx.typerState.constraint.entry(tp) match {
+            case bounds: TypeBounds => wildApproxBounds(bounds)
+            case NoType             => unconstrainedApprox
+            case inst               => wildApprox(inst, theMap, seen, internal)
+          }
+      approxPoly
+    case TermParamRef(mt, pnum) =>
+      WildcardType(TypeBounds.upper(wildApprox(mt.paramInfos(pnum), theMap, seen, internal)))
+    case tp: TypeVar =>
+      wildApprox(tp.underlying, theMap, seen, internal)
+    case tp: AndType =>
+      def approxAnd = {
+        val tp1a = wildApprox(tp.tp1, theMap, seen, internal)
+        val tp2a = wildApprox(tp.tp2, theMap, seen, internal)
+        def wildBounds(tp: Type) =
+          if (tp.isInstanceOf[WildcardType]) tp.bounds else TypeBounds.upper(tp)
+        if (tp1a.isInstanceOf[WildcardType] || tp2a.isInstanceOf[WildcardType])
+          WildcardType(wildBounds(tp1a) & wildBounds(tp2a))
+        else
+          tp.derivedAndType(tp1a, tp2a)
+      }
+      approxAnd
+    case tp: OrType =>
+      def approxOr = {
+        val tp1a = wildApprox(tp.tp1, theMap, seen, internal)
+        val tp2a = wildApprox(tp.tp2, theMap, seen, internal)
+        if (tp1a.isInstanceOf[WildcardType] || tp2a.isInstanceOf[WildcardType])
+          WildcardType(tp1a.bounds | tp2a.bounds)
+        else
+          tp.derivedOrType(tp1a, tp2a)
+      }
+      approxOr
+    case tp: SelectionProto =>
+      tp.derivedSelectionProto(tp.name, wildApprox(tp.memberProto, theMap, seen, internal), NoViewsAllowed)
+    case tp: ViewProto =>
+      tp.derivedViewProto(
+          wildApprox(tp.argType, theMap, seen, internal),
+          wildApprox(tp.resultType, theMap, seen, internal))
+    case tp: FunProto =>
+      val args = tp.args.mapconserve(arg =>
+        val argTp = tp.typeOfArg(arg) match
+          case NoType => WildcardType
+          case tp => wildApprox(tp, theMap, seen, internal)
+        arg.withType(argTp))
+      val resTp = wildApprox(tp.resultType, theMap, seen, internal)
+      if (args eq tp.args) && (resTp eq tp.resultType) then
+        tp
+      else
+        FunProtoTyped(args, resTp)(ctx.typer, tp.applyKind)
+    case tp: IgnoredProto =>
+      WildcardType
+    case  _: ThisType | _: BoundType => // default case, inlined for speed
+      tp
+    case tl: TypeLambda =>
+      val internal1 = internal + tl
+      tl.derivedLambdaType(
+        paramInfos = tl.paramInfos.mapConserve(wildApprox(_, theMap, seen, internal1).bounds),
+        resType = wildApprox(tl.resType, theMap, seen, internal1)
+      )
+    case _ =>
+      (if (theMap != null && seen.eq(theMap.seen)) theMap else new WildApproxMap(seen, internal))
+        .mapOver(tp)
+  }
+
+  final def wildApprox(tp: Type)(using Context): Type = wildApprox(tp, null, Set.empty, Set.empty)
+
+  @sharable object AssignProto extends UncachedGroundType with MatchAlways
+
+  private[ProtoTypes] class WildApproxMap(val seen: Set[TypeParamRef], val internal: Set[TypeLambda])(using Context) extends TypeMap {
+    def apply(tp: Type): Type = wildApprox(tp, this, seen, internal)
+  }
+
+  /** Dummy tree to be used as an argument of a FunProto or ViewProto type */
+  object dummyTreeOfType {
+    def apply(tp: Type)(implicit src: SourceFile): Tree =
+      untpd.Literal(Constant(null)) withTypeUnchecked tp
+    def unapply(tree: untpd.Tree): Option[Type] = tree match {
+      case Literal(Constant(null)) => Some(tree.typeOpt)
+      case _ => None
+    }
+  }
+
+  private val sameTree = (t: untpd.Tree, n: Int) => t
+}
diff --git a/tests/pos-with-compiler-cc/dotc/typer/QuotesAndSplices.scala b/tests/pos-with-compiler-cc/dotc/typer/QuotesAndSplices.scala
new file mode 100644
index 000000000000..fa29f450be2a
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/typer/QuotesAndSplices.scala
@@ -0,0 +1,455 @@
+package dotty.tools.dotc
+package typer
+
+import dotty.tools.dotc.ast._
+import dotty.tools.dotc.config.Feature._
+import dotty.tools.dotc.config.SourceVersion._
+import dotty.tools.dotc.core._
+import dotty.tools.dotc.core.Annotations._
+import dotty.tools.dotc.core.Contexts._
+import dotty.tools.dotc.core.Decorators._
+import dotty.tools.dotc.core.Flags._
+import dotty.tools.dotc.core.NameKinds.PatMatGivenVarName
+import dotty.tools.dotc.core.Names._
+import dotty.tools.dotc.core.StagingContext._
+import dotty.tools.dotc.core.StdNames._
+import dotty.tools.dotc.core.Symbols._
+import dotty.tools.dotc.core.Types._
+import dotty.tools.dotc.inlines.PrepareInlineable
+import dotty.tools.dotc.transform.SymUtils._
+import dotty.tools.dotc.typer.Implicits._
+import dotty.tools.dotc.typer.Inferencing._
+import dotty.tools.dotc.util.Spans._
+import dotty.tools.dotc.util.Stats.record
+import dotty.tools.dotc.reporting.IllegalVariableInPatternAlternative
+import scala.collection.mutable
+
+
+/** Type quotes `'{ ... }` and splices `${ ... }` */
+trait QuotesAndSplices {
+  self: Typer =>
+
+  import tpd._
+
+  /** Translate `'{ e }` into `scala.quoted.Expr.apply(e)` and `'[T]` into `scala.quoted.Type.apply[T]`
+   *  while tracking the quotation level in the context.
+   */
+  def typedQuote(tree: untpd.Quote, pt: Type)(using Context): Tree = {
+    record("typedQuote")
+    tree.quoted match {
+      case untpd.Splice(innerExpr) if tree.isTerm && !ctx.mode.is(Mode.Pattern) =>
+        report.warning("Canceled splice directly inside a quote. '{ ${ XYZ } } is equivalent to XYZ.", tree.srcPos)
+      case _ =>
+    }
+    val qctx = inferImplicitArg(defn.QuotesClass.typeRef, tree.span)
+
+    if qctx.tpe.isInstanceOf[SearchFailureType] then
+      report.error(missingArgMsg(qctx, defn.QuotesClass.typeRef, ""), ctx.source.atSpan(tree.span))
+    else if !qctx.tpe.isStable then
+      report.error(em"Quotes require stable Quotes, but found non stable $qctx", qctx.srcPos)
+
+    if ctx.mode.is(Mode.Pattern) then
+      typedQuotePattern(tree, pt, qctx).withSpan(tree.span)
+    else if tree.quoted.isType then
+      val msg = em"""Quoted types `'[..]` can only be used in patterns.
+                    |
+                    |Hint: To get a scala.quoted.Type[T] use scala.quoted.Type.of[T] instead.
+                    |""".stripMargin
+      report.error(msg, tree.srcPos)
+      EmptyTree
+    else
+      val exprQuoteTree = untpd.Apply(untpd.ref(defn.QuotedRuntime_exprQuote.termRef), tree.quoted)
+      makeInlineable(typedApply(exprQuoteTree, pt)(using pushQuotes(qctx)).select(nme.apply).appliedTo(qctx).withSpan(tree.span))
+  }
+
+  private def makeInlineable(tree: Tree)(using Context): Tree =
+    inContext(ctx.withOwner(ctx.owner.skipLocalOwners)) {
+      PrepareInlineable.makeInlineable(tree)
+    }
+
+  /** Translate `${ t: Expr[T] }` into expression `t.splice` while tracking the quotation level in the context */
+  def typedSplice(tree: untpd.Splice, pt: Type)(using Context): Tree = {
+    record("typedSplice")
+    checkSpliceOutsideQuote(tree)
+    tree.expr match {
+      case untpd.Quote(innerExpr) if innerExpr.isTerm =>
+        report.warning("Canceled quote directly inside a splice. ${ '{ XYZ } } is equivalent to XYZ.", tree.srcPos)
+      case _ =>
+    }
+    if (ctx.mode.is(Mode.QuotedPattern))
+      if (isFullyDefined(pt, ForceDegree.flipBottom)) {
+        def spliceOwner(ctx: Context): Symbol =
+          if (ctx.mode.is(Mode.QuotedPattern)) spliceOwner(ctx.outer) else ctx.owner
+        val pat = typedPattern(tree.expr, defn.QuotedExprClass.typeRef.appliedTo(pt))(
+          using spliceContext.retractMode(Mode.QuotedPattern).addMode(Mode.Pattern).withOwner(spliceOwner(ctx)))
+        val baseType = pat.tpe.baseType(defn.QuotedExprClass)
+        val argType = if baseType != NoType then baseType.argTypesHi.head else defn.NothingType
+        ref(defn.QuotedRuntime_exprSplice).appliedToType(argType).appliedTo(pat)
+      }
+      else {
+        report.error(i"Type must be fully defined.\nConsider annotating the splice using a type ascription:\n  ($tree: XYZ).", tree.expr.srcPos)
+        tree.withType(UnspecifiedErrorType)
+      }
+    else {
+      if (StagingContext.level == 0) {
+        // Mark the first inline method from the context as a macro
+        def markAsMacro(c: Context): Unit =
+          if (c.owner eq c.outer.owner) markAsMacro(c.outer)
+          else if (c.owner.isInlineMethod) c.owner.setFlag(Macro)
+          else if (!c.outer.owner.is(Package)) markAsMacro(c.outer)
+          else assert(ctx.reporter.hasErrors) // Did not find inline def to mark as macro
+        markAsMacro(ctx)
+      }
+
+      val (outerQctx, ctx1) = popQuotes()
+
+      val internalSplice =
+        outerQctx match
+          case Some(qctxRef) => untpd.Apply(untpd.Apply(untpd.ref(defn.QuotedRuntime_exprNestedSplice.termRef), qctxRef), tree.expr)
+          case _ => untpd.Apply(untpd.ref(defn.QuotedRuntime_exprSplice.termRef), tree.expr)
+
+      typedApply(internalSplice, pt)(using ctx1).withSpan(tree.span)
+    }
+  }
+
+  /** Types a splice applied to some arguments `$f(arg1, ..., argn)` in a quote pattern.
+   *
+   *  The tree is desugared into `$f.apply(arg1, ..., argn)` where the expression `$f`
+   *  is expected to type as a function type `(T1, ..., Tn) => R`.
+   *  `Ti` is the type of the argument `argi` and R if the type of the prototype.
+   *  The prototype must be fully defined to be able to infer the type of `R`.
+   */
+  def typedAppliedSplice(tree: untpd.Apply, pt: Type)(using Context): Tree = {
+    assert(ctx.mode.is(Mode.QuotedPattern))
+    val untpd.Apply(splice: untpd.Splice, args) = tree: @unchecked
+    if !isFullyDefined(pt, ForceDegree.flipBottom) then
+      report.error(i"Type must be fully defined.", splice.srcPos)
+      tree.withType(UnspecifiedErrorType)
+    else if splice.isInBraces then // ${x}(...) match an application
+      val typedArgs = args.map(arg => typedExpr(arg))
+      val argTypes = typedArgs.map(_.tpe.widenTermRefExpr)
+      val splice1 = typedSplice(splice, defn.FunctionOf(argTypes, pt))
+      Apply(splice1.select(nme.apply), typedArgs).withType(pt).withSpan(tree.span)
+    else // $x(...) higher-order quasipattern
+      val typedArgs = args.map {
+        case arg: untpd.Ident =>
+          typedExpr(arg)
+        case arg =>
+          report.error("Open pattern expected an identifier", arg.srcPos)
+          EmptyTree
+      }
+      if args.isEmpty then
+        report.error("Missing arguments for open pattern", tree.srcPos)
+      val argTypes = typedArgs.map(_.tpe.widenTermRefExpr)
+      val typedPat = typedSplice(splice, defn.FunctionOf(argTypes, pt))
+      ref(defn.QuotedRuntimePatterns_patternHigherOrderHole).appliedToType(pt).appliedTo(typedPat, SeqLiteral(typedArgs, TypeTree(defn.AnyType)))
+  }
+
+  /** Type a pattern variable name `t` in quote pattern as `${given t$giveni: Type[t @ _]}`.
+   *  The resulting pattern is the split in `splitQuotePattern`.
+   */
+  def typedQuotedTypeVar(tree: untpd.Ident, pt: Type)(using Context): Tree =
+    def spliceOwner(ctx: Context): Symbol =
+      if (ctx.mode.is(Mode.QuotedPattern)) spliceOwner(ctx.outer) else ctx.owner
+    val name = tree.name.toTypeName
+    val nameOfSyntheticGiven = PatMatGivenVarName.fresh(tree.name.toTermName)
+    val expr = untpd.cpy.Ident(tree)(nameOfSyntheticGiven)
+    val typeSymInfo = pt match
+      case pt: TypeBounds => pt
+      case _ => TypeBounds.empty
+    val typeSym = newSymbol(spliceOwner(ctx), name, EmptyFlags, typeSymInfo, NoSymbol, tree.span)
+    typeSym.addAnnotation(Annotation(New(ref(defn.QuotedRuntimePatterns_patternTypeAnnot.typeRef)).withSpan(tree.span)))
+    val pat = typedPattern(expr, defn.QuotedTypeClass.typeRef.appliedTo(typeSym.typeRef))(
+        using spliceContext.retractMode(Mode.QuotedPattern).withOwner(spliceOwner(ctx)))
+    pat.select(tpnme.Underlying)
+
+  def typedHole(tree: untpd.Hole, pt: Type)(using Context): Tree =
+    val tpt = typedType(tree.tpt)
+    assignType(tree, tpt)
+
+  private def checkSpliceOutsideQuote(tree: untpd.Tree)(using Context): Unit =
+    if (level == 0 && !ctx.owner.ownersIterator.exists(_.isInlineMethod))
+      report.error("Splice ${...} outside quotes '{...} or inline method", tree.srcPos)
+    else if (level < 0)
+      report.error(
+        s"""Splice $${...} at level $level.
+          |
+          |Inline method may contain a splice at level 0 but the contents of this splice cannot have a splice.
+          |""".stripMargin, tree.srcPos
+      )
+
+  /** Split a typed quoted pattern is split into its type bindings, pattern expression and inner patterns.
+   *  Type definitions with `@patternType` will be inserted in the pattern expression for each type binding.
+   *
+   *  A quote pattern
+   *  ```
+   *  case '{ type ${given t$giveni: Type[t @ _]}; ${ls: Expr[List[t]]} } => ...
+   *  ```
+   *  will return
+   *  ```
+   *  (
+   *    Map(<t$giveni>: Symbol -> <t @ _>: Bind),
+   *    <'{
+   *       @scala.internal.Quoted.patternType type t
+   *       scala.internal.Quoted.patternHole[List[t]]
+   *    }>: Tree,
+   *    List(<ls: Expr[List[t]]>: Tree)
+   *  )
+   *  ```
+   */
+  private def splitQuotePattern(quoted: Tree)(using Context): (Map[Symbol, Bind], Tree, List[Tree]) = {
+    val ctx0 = ctx
+
+    val typeBindings: collection.mutable.Map[Symbol, Bind] = collection.mutable.Map.empty
+    def getBinding(sym: Symbol): Bind =
+      typeBindings.getOrElseUpdate(sym, {
+        val bindingBounds = sym.info
+        val bsym = newPatternBoundSymbol(sym.name.toString.stripPrefix("$").toTypeName, bindingBounds, quoted.span)
+        Bind(bsym, untpd.Ident(nme.WILDCARD).withType(bindingBounds)).withSpan(quoted.span)
+      })
+
+    object splitter extends tpd.TreeMap {
+      private var variance: Int = 1
+
+      inline private def atVariance[T](v: Int)(op: => T): T = {
+        val saved = variance
+        variance = v
+        val res = op
+        variance = saved
+        res
+      }
+
+      val patBuf = new mutable.ListBuffer[Tree]
+      val freshTypePatBuf = new mutable.ListBuffer[Tree]
+      val freshTypeBindingsBuff = new mutable.ListBuffer[Tree]
+      val typePatBuf = new mutable.ListBuffer[Tree]
+      override def transform(tree: Tree)(using Context) = tree match {
+        case Typed(Apply(fn, pat :: Nil), tpt) if fn.symbol.isExprSplice && !tpt.tpe.derivesFrom(defn.RepeatedParamClass) =>
+          val tpt1 = transform(tpt) // Transform type bindings
+          val exprTpt = AppliedTypeTree(TypeTree(defn.QuotedExprClass.typeRef), tpt1 :: Nil)
+          val newSplice = ref(defn.QuotedRuntime_exprSplice).appliedToType(tpt1.tpe).appliedTo(Typed(pat, exprTpt))
+          transform(newSplice)
+        case Apply(TypeApply(fn, targs), Apply(sp, pat :: Nil) :: args :: Nil) if fn.symbol == defn.QuotedRuntimePatterns_patternHigherOrderHole =>
+          args match // TODO support these patterns. Possibly using scala.quoted.util.Var
+            case SeqLiteral(args, _) =>
+              for arg <- args; if arg.symbol.is(Mutable) do
+                report.error("References to `var`s cannot be used in higher-order pattern", arg.srcPos)
+          try ref(defn.QuotedRuntimePatterns_higherOrderHole.termRef).appliedToTypeTrees(targs).appliedTo(args).withSpan(tree.span)
+          finally {
+            val patType = pat.tpe.widen
+            val patType1 = patType.translateFromRepeated(toArray = false)
+            val pat1 = if (patType eq patType1) pat else pat.withType(patType1)
+            patBuf += pat1
+          }
+        case Apply(fn, pat :: Nil) if fn.symbol.isExprSplice =>
+          try ref(defn.QuotedRuntimePatterns_patternHole.termRef).appliedToType(tree.tpe).withSpan(tree.span)
+          finally {
+            val patType = pat.tpe.widen
+            val patType1 = patType.translateFromRepeated(toArray = false)
+            val pat1 = if (patType eq patType1) pat else pat.withType(patType1)
+            patBuf += pat1
+          }
+        case Select(pat, _) if tree.symbol.isTypeSplice =>
+          val sym = tree.tpe.dealias.typeSymbol
+          if sym.exists then
+            val tdef = TypeDef(sym.asType).withSpan(sym.span)
+            val nameOfSyntheticGiven = pat.symbol.name.toTermName
+            freshTypeBindingsBuff += transformTypeBindingTypeDef(nameOfSyntheticGiven, tdef, freshTypePatBuf)
+            TypeTree(tree.tpe.dealias).withSpan(tree.span)
+          else
+            tree
+        case tdef: TypeDef  =>
+          if tdef.symbol.hasAnnotation(defn.QuotedRuntimePatterns_patternTypeAnnot) then
+            transformTypeBindingTypeDef(PatMatGivenVarName.fresh(tdef.name.toTermName), tdef, typePatBuf)
+          else if tdef.symbol.isClass then
+            val kind = if tdef.symbol.is(Module) then "objects" else "classes"
+            report.error("Implementation restriction: cannot match " + kind, tree.srcPos)
+            EmptyTree
+          else
+            super.transform(tree)
+        case tree @ AppliedTypeTree(tpt, args) =>
+            val args1: List[Tree] = args.zipWithConserve(tpt.tpe.typeParams.map(_.paramVarianceSign)) { (arg, v) =>
+              arg.tpe match {
+                case _: TypeBounds => transform(arg)
+                case _ => atVariance(variance * v)(transform(arg))
+              }
+            }
+            cpy.AppliedTypeTree(tree)(transform(tpt), args1)
+        case tree: NamedDefTree =>
+          if tree.name.is(NameKinds.WildcardParamName) then
+            report.warning(
+              "Use of `_` for lambda in quoted pattern. Use explicit lambda instead or use `$_` to match any term.",
+              tree.srcPos)
+          if tree.name.isTermName && !tree.nameSpan.isSynthetic && tree.name.startsWith("$") then
+            report.error("Names cannot start with $ quote pattern ", tree.namePos)
+          super.transform(tree)
+        case _: Match =>
+          report.error("Implementation restriction: cannot match `match` expressions", tree.srcPos)
+          EmptyTree
+        case _: Try =>
+          report.error("Implementation restriction: cannot match `try` expressions", tree.srcPos)
+          EmptyTree
+        case _: Return =>
+          report.error("Implementation restriction: cannot match `return` statements", tree.srcPos)
+          EmptyTree
+        case _ =>
+          super.transform(tree)
+      }
+
+      private def transformTypeBindingTypeDef(nameOfSyntheticGiven: TermName, tdef: TypeDef, buff: mutable.Builder[Tree, List[Tree]])(using Context): Tree = {
+        if ctx.mode.is(Mode.InPatternAlternative) then
+          report.error(IllegalVariableInPatternAlternative(tdef.symbol.name), tdef.srcPos)
+        if variance == -1 then
+          tdef.symbol.addAnnotation(Annotation(New(ref(defn.QuotedRuntimePatterns_fromAboveAnnot.typeRef)).withSpan(tdef.span)))
+        val bindingType = getBinding(tdef.symbol).symbol.typeRef
+        val bindingTypeTpe = AppliedType(defn.QuotedTypeClass.typeRef, bindingType :: Nil)
+        val sym = newPatternBoundSymbol(nameOfSyntheticGiven, bindingTypeTpe, tdef.span, flags = ImplicitVal)(using ctx0)
+        buff += Bind(sym, untpd.Ident(nme.WILDCARD).withType(bindingTypeTpe)).withSpan(tdef.span)
+        super.transform(tdef)
+      }
+    }
+    val shape0 = splitter.transform(quoted)
+    val patterns = (splitter.freshTypePatBuf.iterator ++ splitter.typePatBuf.iterator ++ splitter.patBuf.iterator).toList
+    val freshTypeBindings = splitter.freshTypeBindingsBuff.result()
+
+    val shape1 = seq(
+      freshTypeBindings,
+      shape0
+    )
+    val shape2 =
+      if (freshTypeBindings.isEmpty) shape1
+      else {
+        val isFreshTypeBindings = freshTypeBindings.map(_.symbol).toSet
+        val typeMap = new TypeMap() {
+          def apply(tp: Type): Type = tp match {
+            case tp: TypeRef if tp.symbol.isTypeSplice =>
+              val tp1 = tp.dealias
+              if (isFreshTypeBindings(tp1.typeSymbol)) tp1
+              else tp
+            case tp => mapOver(tp)
+          }
+        }
+        new TreeTypeMap(typeMap = typeMap).transform(shape1)
+      }
+
+    (typeBindings.toMap, shape2, patterns)
+  }
+
+  /** Type a quote pattern `case '{ <quoted> } =>` qiven the a current prototype. Typing the pattern
+   *  will also transform it into a call to `scala.internal.quoted.Expr.unapply`.
+   *
+   *  Code directly inside the quote is typed as an expression using Mode.QuotedPattern. Splices
+   *  within the quotes become patterns again and typed accordingly.
+   *
+   *  ```
+   *  case '{ ($ls: List[t]) } =>
+   *    // `t$giveni` is of type `Type[t]` for some unknown `t`
+   *    // `t$giveni` is implicitly available
+   *    // `ls` is of type `Expr[List[t]]`
+   *    '{ val h: $t = $ls.head  }
+   *  ```
+   *
+   *  For each type splice we will create a new type binding in the pattern match (`t @ _` in this case)
+   *  and a corresponding type in the quoted pattern as a hole (`@patternType type t` in this case).
+   *  All these generated types are inserted at the start of the quoted code.
+   *
+   *  After typing the tree will resemble
+   *
+   *  ```
+   *  case '{ type ${given t$giveni: Type[t @ _]}; ${ls: Expr[List[t]]} } => ...
+   *  ```
+   *
+   *  Then the pattern is _split_ into the expression contained in the pattern replacing the splices by holes,
+   *  and the patterns in the splices. All these are recombined into a call to `Matcher.unapply`.
+   *
+   *  ```
+   *  case scala.internal.quoted.Expr.unapply[
+   *          Tuple1[t @ _], // Type binging definition
+   *          Tuple2[Type[t], Expr[List[t]]] // Typing the result of the pattern match
+   *        ](
+   *          Tuple2.unapply
+   *            [Type[t], Expr[List[t]]] //Propagated from the tuple above
+   *            (given t$giveni @ _, ls @ _: Expr[List[t]]) // from the spliced patterns
+   *        )(
+   *         '{ // Runtime quote Matcher.unapply uses to mach against. Expression directly inside the quoted pattern without the splices
+   *            @scala.internal.Quoted.patternType type t
+   *            scala.internal.Quoted.patternHole[List[t]]
+   *          },
+   *          true, // If there is at least one type splice. Used to instantiate the context with or without GADT constraints
+   *          x$2 // tasty.Reflection instance
+   *        ) => ...
+   *  ```
+   */
+  private def typedQuotePattern(tree: untpd.Quote, pt: Type, qctx: Tree)(using Context): Tree = {
+    if tree.quoted.isTerm && !pt.derivesFrom(defn.QuotedExprClass) then
+      report.error("Quote pattern can only match scrutinees of type scala.quoted.Expr", tree.srcPos)
+    else if tree.quoted.isType && !pt.derivesFrom(defn.QuotedTypeClass) then
+      report.error("Quote pattern can only match scrutinees of type scala.quoted.Type", tree.srcPos)
+
+    val quoted = tree.quoted
+    val exprPt = pt.baseType(if quoted.isType then defn.QuotedTypeClass else defn.QuotedExprClass)
+    val quotedPt = exprPt.argInfos.headOption match {
+      case Some(argPt: ValueType) => argPt // excludes TypeBounds
+      case _ => defn.AnyType
+    }
+    val quoted0 = desugar.quotedPattern(quoted, untpd.TypedSplice(TypeTree(quotedPt)))
+    val quoteCtx = quoteContext.addMode(Mode.QuotedPattern).retractMode(Mode.Pattern)
+    val quoted1 =
+      if quoted.isType then typedType(quoted0, WildcardType)(using quoteCtx)
+      else typedExpr(quoted0, WildcardType)(using quoteCtx)
+
+    val (typeBindings, shape, splices) = splitQuotePattern(quoted1)
+
+    class ReplaceBindings extends TypeMap() {
+      override def apply(tp: Type): Type = tp match {
+        case tp: TypeRef =>
+          val tp1 = if (tp.symbol.isTypeSplice) tp.dealias else tp
+          mapOver(typeBindings.get(tp1.typeSymbol).fold(tp)(_.symbol.typeRef))
+        case tp => mapOver(tp)
+      }
+    }
+    val replaceBindings = new ReplaceBindings
+    val patType = defn.tupleType(splices.tpes.map(tpe => replaceBindings(tpe.widen)))
+
+    val typeBindingsTuple = tpd.tupleTypeTree(typeBindings.values.toList)
+
+    val replaceBindingsInTree = new TreeMap {
+      private var bindMap = Map.empty[Symbol, Symbol]
+      override def transform(tree: tpd.Tree)(using Context): tpd.Tree =
+        tree match {
+          case tree: Bind =>
+            val sym = tree.symbol
+            val newInfo = replaceBindings(sym.info)
+            val newSym = newSymbol(sym.owner, sym.name, sym.flags, newInfo, sym.privateWithin, sym.coord)
+            bindMap += sym -> newSym
+            Bind(newSym, transform(tree.body)).withSpan(sym.span)
+          case _ =>
+            super.transform(tree).withType(replaceBindingsInType(tree.tpe))
+        }
+      private val replaceBindingsInType = new ReplaceBindings {
+        override def apply(tp: Type): Type = tp match {
+          case tp: TermRef => bindMap.get(tp.termSymbol).fold[Type](tp)(_.typeRef)
+          case tp => super.apply(tp)
+        }
+      }
+    }
+
+    val splicePat =
+      if splices.isEmpty then ref(defn.EmptyTupleModule.termRef)
+      else typed(untpd.Tuple(splices.map(x => untpd.TypedSplice(replaceBindingsInTree.transform(x)))).withSpan(quoted.span), patType)
+
+    val quoteClass = if (tree.quoted.isTerm) defn.QuotedExprClass else defn.QuotedTypeClass
+    val quotedPattern =
+      if (tree.quoted.isTerm) ref(defn.QuotedRuntime_exprQuote.termRef).appliedToType(defn.AnyType).appliedTo(shape).select(nme.apply).appliedTo(qctx)
+      else ref(defn.QuotedTypeModule_of.termRef).appliedToTypeTree(shape).appliedTo(qctx)
+
+    val matchModule = if tree.quoted.isTerm then defn.QuoteMatching_ExprMatch else defn.QuoteMatching_TypeMatch
+    val unapplyFun = qctx.asInstance(defn.QuoteMatchingClass.typeRef).select(matchModule).select(nme.unapply)
+
+    UnApply(
+      fun = unapplyFun.appliedToTypeTrees(typeBindingsTuple :: TypeTree(patType) :: Nil),
+      implicits = quotedPattern :: Nil,
+      patterns = splicePat :: Nil,
+      proto = quoteClass.typeRef.appliedTo(replaceBindings(quoted1.tpe) & quotedPt))
+  }
+}
diff --git a/tests/pos-with-compiler-cc/dotc/typer/ReTyper.scala b/tests/pos-with-compiler-cc/dotc/typer/ReTyper.scala
new file mode 100644
index 000000000000..7099234c80e1
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/typer/ReTyper.scala
@@ -0,0 +1,146 @@
+package dotty.tools.dotc
+package typer
+
+import core._
+import Contexts._
+import Types._
+import Symbols._
+import StdNames._
+import Decorators._
+import typer.ProtoTypes._
+import ast.{tpd, untpd}
+import scala.util.control.NonFatal
+import util.Spans.Span
+import Nullables._
+
+/** A version of Typer that keeps all symbols defined and referenced in a
+ *  previously typed tree.
+ *
+ *  All definition nodes keep their symbols. All leaf nodes for idents, selects,
+ *  and TypeTrees keep their types. Indexing is a no-op.
+ *
+ *  Otherwise, everything is as in Typer.
+ */
+class ReTyper(nestingLevel: Int = 0) extends Typer(nestingLevel) with ReChecking {
+  import tpd._
+
+  private def assertTyped(tree: untpd.Tree)(using Context): Unit =
+    assert(tree.hasType, i"$tree ${tree.getClass} ${tree.uniqueId}")
+
+  /** Checks that the given tree has been typed */
+  protected def promote(tree: untpd.Tree)(using Context): tree.ThisTree[Type] = {
+    assertTyped(tree)
+    tree.withType(tree.typeOpt)
+  }
+
+  override def typedIdent(tree: untpd.Ident, pt: Type)(using Context): Tree =
+    promote(tree)
+
+  override def typedSelect(tree: untpd.Select, pt: Type)(using Context): Tree = {
+    assertTyped(tree)
+    val qual1 = withoutMode(Mode.Pattern)(typed(tree.qualifier, AnySelectionProto))
+    untpd.cpy.Select(tree)(qual1, tree.name).withType(tree.typeOpt)
+  }
+
+  override def typedLiteral(tree: untpd.Literal)(implicit ctc: Context): Tree =
+    promote(tree)
+
+  override def typedThis(tree: untpd.This)(using Context): Tree =
+    promote(tree)
+
+  override def typedSuper(tree: untpd.Super, pt: Type)(using Context): Tree =
+    promote(tree)
+
+  override def typedImport(tree: untpd.Import)(using Context): Tree =
+    promote(tree)
+
+  override def typedTyped(tree: untpd.Typed, pt: Type)(using Context): Tree = {
+    assertTyped(tree)
+
+    val tpt1 = checkSimpleKinded(typedType(tree.tpt))
+    val expr1 = tree.expr match {
+      case id: untpd.Ident if (ctx.mode is Mode.Pattern) && untpd.isVarPattern(id) && (id.name == nme.WILDCARD || id.name == nme.WILDCARD_STAR) =>
+        tree.expr.withType(tpt1.tpe)
+      case _ => typed(tree.expr)
+    }
+    val result = untpd.cpy.Typed(tree)(expr1, tpt1).withType(tree.typeOpt)
+    if ctx.mode.isExpr then result.withNotNullInfo(expr1.notNullInfo) else result
+  }
+
+  override def typedTypeTree(tree: untpd.TypeTree, pt: Type)(using Context): TypeTree =
+    promote(tree)
+
+  override def typedRefinedTypeTree(tree: untpd.RefinedTypeTree)(using Context): TypTree =
+    promote(TypeTree(tree.tpe).withSpan(tree.span))
+
+  override def typedExport(exp: untpd.Export)(using Context): Export =
+    promote(exp)
+
+  override def typedBind(tree: untpd.Bind, pt: Type)(using Context): Bind = {
+    assertTyped(tree)
+    val body1 = typed(tree.body, pt)
+    untpd.cpy.Bind(tree)(tree.name, body1).withType(tree.typeOpt)
+  }
+
+  override def typedUnApply(tree: untpd.UnApply, selType: Type)(using Context): UnApply = {
+    val fun1 =
+      // retract PatternOrTypeBits like in typedExpr
+      withoutMode(Mode.PatternOrTypeBits)(typedUnadapted(tree.fun, AnyFunctionProto))
+    val implicits1 = tree.implicits.map(typedExpr(_))
+    val patterns1 = tree.patterns.mapconserve(pat => typed(pat, pat.tpe))
+    untpd.cpy.UnApply(tree)(fun1, implicits1, patterns1).withType(tree.tpe)
+  }
+
+  override def typedUnApply(tree: untpd.Apply, selType: Type)(using Context): Tree =
+    typedApply(tree, selType)
+
+  override def localDummy(cls: ClassSymbol, impl: untpd.Template)(using Context): Symbol = impl.symbol
+
+  override def retrieveSym(tree: untpd.Tree)(using Context): Symbol = tree.symbol
+  override def symbolOfTree(tree: untpd.Tree)(using Context): Symbol = tree.symbol
+
+  override def localTyper(sym: Symbol): Typer = this
+
+  override def index(trees: List[untpd.Tree])(using Context): Context = ctx
+
+  override def tryInsertApplyOrImplicit(tree: Tree, pt: ProtoType, locked: TypeVars)(fallBack: => Tree)(using Context): Tree =
+    fallBack
+
+  override def completeAnnotations(mdef: untpd.MemberDef, sym: Symbol)(using Context): Unit = ()
+
+  override def ensureConstrCall(cls: ClassSymbol, parent: Tree, psym: Symbol)(using Context): Tree =
+    parent
+
+  override def handleUnexpectedFunType(tree: untpd.Apply, fun: Tree)(using Context): Tree = fun.tpe match {
+    case mt: MethodType =>
+      val args: List[Tree] = tree.args.zipWithConserve(mt.paramInfos)(typedExpr)
+      assignType(untpd.cpy.Apply(tree)(fun, args), fun, args)
+    case _ =>
+      super.handleUnexpectedFunType(tree, fun)
+  }
+
+  override def addCanThrowCapabilities(expr: untpd.Tree, cases: List[CaseDef])(using Context): untpd.Tree =
+    expr
+
+  override def typedUnadapted(tree: untpd.Tree, pt: Type, locked: TypeVars)(using Context): Tree =
+    try super.typedUnadapted(tree, pt, locked)
+    catch {
+      case NonFatal(ex) =>
+        if ctx.phase != Phases.typerPhase && ctx.phase != Phases.inliningPhase then
+          println(i"exception while typing $tree of class ${tree.getClass} # ${tree.uniqueId}")
+        throw ex
+    }
+
+  override def inlineExpansion(mdef: DefDef)(using Context): List[Tree] = mdef :: Nil
+
+  override def inferView(from: Tree, to: Type)(using Context): Implicits.SearchResult =
+    Implicits.NoMatchingImplicitsFailure
+  override def checkCanEqual(ltp: Type, rtp: Type, span: Span)(using Context): Unit = ()
+
+  override def widenEnumCase(tree: Tree, pt: Type)(using Context): Tree = tree
+
+  override protected def addAccessorDefs(cls: Symbol, body: List[Tree])(using Context): List[Tree] = body
+  override protected def checkEqualityEvidence(tree: tpd.Tree, pt: Type)(using Context): Unit = ()
+  override protected def matchingApply(methType: MethodOrPoly, pt: FunProto)(using Context): Boolean = true
+  override protected def typedScala2MacroBody(call: untpd.Tree)(using Context): Tree = promote(call)
+}
diff --git a/tests/pos-with-compiler-cc/dotc/typer/RefChecks.scala b/tests/pos-with-compiler-cc/dotc/typer/RefChecks.scala
new file mode 100644
index 000000000000..4d2c7ffdfe7d
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/typer/RefChecks.scala
@@ -0,0 +1,1806 @@
+package dotty.tools
+package dotc
+package typer
+
+import transform._
+import core._
+import Symbols._, Types._, Contexts._, Flags._, Names._, NameOps._, NameKinds._
+import StdNames._, Denotations._, SymUtils._, Phases._, SymDenotations._
+import NameKinds.DefaultGetterName
+import util.Spans._
+import scala.collection.mutable
+import ast._
+import MegaPhase._
+import config.Printers.{checks, noPrinter}
+import Decorators._
+import OverridingPairs.isOverridingPair
+import typer.ErrorReporting._
+import config.Feature.{warnOnMigration, migrateTo3, sourceVersion}
+import config.SourceVersion.{`3.0`, `future`}
+import config.Printers.refcheck
+import reporting._
+import Constants.Constant
+import language.experimental.pureFunctions
+
+object RefChecks {
+  import tpd._
+
+  val name: String = "refchecks"
+  val description: String = "checks related to abstract members and overriding"
+
+  private val defaultMethodFilter = new NameFilter {
+    def apply(pre: Type, name: Name)(using Context): Boolean = name.is(DefaultGetterName)
+    def isStable = true
+  }
+
+  /** Only one overloaded alternative is allowed to define default arguments */
+  private def checkOverloadedRestrictions(clazz: Symbol)(using Context): Unit = {
+    // Using the default getters (such as methodName$default$1) as a cheap way of
+    // finding methods with default parameters. This way, we can limit the members to
+    // those with the DEFAULTPARAM flag, and infer the methods. Looking for the methods
+    // directly requires inspecting the parameter list of every one. That modification
+    // shaved 95% off the time spent in this method.
+
+    for {
+      defaultGetterClass <- List(clazz, clazz.companionModule.moduleClass);
+      if defaultGetterClass.isClass
+    }
+    {
+      val defaultGetterNames = defaultGetterClass.asClass.memberNames(defaultMethodFilter)
+      val defaultMethodNames = defaultGetterNames map { _ replace {
+        case DefaultGetterName(methName, _) => methName
+      }}
+
+      for (name <- defaultMethodNames) {
+        val methods = clazz.info.member(name).alternatives.map(_.symbol)
+        val haveDefaults = methods.filter(_.hasDefaultParams)
+        if (haveDefaults.length > 1) {
+          val owners = haveDefaults map (_.owner)
+          // constructors of different classes are allowed to have defaults
+          if (haveDefaults.exists(x => !x.isConstructor) || owners.distinct.size < haveDefaults.size)
+            report.error(
+              "in " + clazz +
+                ", multiple overloaded alternatives of " + haveDefaults.head +
+                " define default arguments" + (
+                  if (owners.forall(_ == clazz)) "."
+                  else ".\nThe members with defaults are defined in " + owners.map(_.showLocated).mkString("", " and ", ".")),
+              clazz.srcPos)
+        }
+      }
+    }
+
+    // Check for doomed attempt to overload applyDynamic
+    if (clazz derivesFrom defn.DynamicClass)
+      for (case (_, m1 :: m2 :: _) <- (clazz.info member nme.applyDynamic).alternatives groupBy (_.symbol.typeParams.length))
+        report.error("implementation restriction: applyDynamic cannot be overloaded except by methods with different numbers of type parameters, e.g. applyDynamic[T1](method: String)(arg: T1) and applyDynamic[T1, T2](method: String)(arg1: T1, arg2: T2)",
+          m1.symbol.srcPos)
+  }
+
+  /** The this-type of `cls` which should be used when looking at the types of
+   *  inherited members. If `cls` has a non-trivial self type, this returns a skolem
+   *  with the class type instead of the `this-type` of the class as usual.
+   *  This is done because otherwise we want to understand inherited infos
+   *  as they are written, whereas with the this-type they could be
+   *  more special. A test where this makes a difference is pos/i1401.scala.
+   *  This one used to succeed only if forwarding parameters is on.
+   *  (Forwarding tends to hide problems by binding parameter names).
+   */
+  private def upwardsThisType(cls: Symbol)(using Context) = cls.info match {
+    case ClassInfo(_, _, _, _, tp: Type) if (tp ne cls.typeRef) && !cls.isOneOf(FinalOrModuleClass) =>
+      SkolemType(cls.appliedRef).withName(nme.this_)
+    case _ =>
+      cls.thisType
+  }
+
+  /**  - Check that self type of `cls` conforms to self types of all `parents` as seen from
+   *     `cls.thisType`
+   *   - If self type of `cls` is explicit, check that it conforms to the self types
+   *     of all its class symbols.
+   *  @param deep  If true and a self type of a parent is not given explicitly, recurse to
+   *               check against the parents of the parent. This is needed when capture checking,
+   *               since we assume (& check) that the capture set of an inferred self type
+   *               is the intersection of the capture sets of all its parents
+   */
+  def checkSelfAgainstParents(cls: ClassSymbol, parents: List[Symbol])(using Context): Unit =
+    withMode(Mode.CheckBoundsOrSelfType) {
+      val cinfo = cls.classInfo
+
+      def checkSelfConforms(other: ClassSymbol, category: String, relation: String) =
+        val otherSelf = other.declaredSelfTypeAsSeenFrom(cls.thisType)
+        if otherSelf.exists then
+          if !(cinfo.selfType <:< otherSelf) then
+            report.error(DoesNotConformToSelfType(category, cinfo.selfType, cls, otherSelf, relation, other),
+              cls.srcPos)
+
+      for psym <- parents do
+        checkSelfConforms(psym.asClass, "illegal inheritance", "parent")
+      for reqd <- cls.asClass.givenSelfType.classSymbols do
+        if reqd != cls then
+          checkSelfConforms(reqd, "missing requirement", "required")
+    }
+  end checkSelfAgainstParents
+
+  /** Check that self type of this class conforms to self types of parents
+   *  and required classes. Also check that only `enum` constructs extend
+   *  `java.lang.Enum` and no user-written class extends ContextFunctionN.
+   */
+  def checkParents(cls: Symbol, parentTrees: List[Tree])(using Context): Unit = cls.info match {
+    case cinfo: ClassInfo =>
+      val psyms = cls.asClass.parentSyms
+      checkSelfAgainstParents(cls.asClass, psyms)
+
+      def isClassExtendingJavaEnum =
+        !cls.isOneOf(Enum | Trait) && psyms.contains(defn.JavaEnumClass)
+
+      // Prevent wrong `extends` of java.lang.Enum
+      if isClassExtendingJavaEnum then
+        if !migrateTo3 then // always error, only traits or enum-syntax is possible under scala 3.x
+          report.error(CannotExtendJavaEnum(cls), cls.sourcePos)
+        else
+          // conditionally error, we allow classes to extend java.lang.Enum in scala 2 migration mode,
+          // however the no-arg constructor is forbidden, we must look at the parent trees to see
+          // which overload is called.
+          val javaEnumCtor = defn.JavaEnumClass.primaryConstructor
+          parentTrees.exists {
+            case parent @ tpd.Apply(tpd.TypeApply(fn, _), _) if fn.tpe.termSymbol eq javaEnumCtor =>
+              // here we are simulating the error for missing arguments to a constructor.
+              report.error(JavaEnumParentArgs(parent.tpe), cls.sourcePos)
+              true
+            case _ =>
+              false
+          }
+      if psyms.exists(defn.isContextFunctionClass) then
+        report.error(CannotExtendContextFunction(cls), cls.sourcePos)
+
+      /** Check that arguments passed to trait parameters conform to the parameter types
+       *  in the current class. This is necessary since parameter types might be narrowed
+       *  through intersection with other parent traits. See neg/i11018.scala.
+       */
+      def checkParamInits(app: Apply): Unit =
+        val parentCls = app.tpe.classSymbol
+        if parentCls.is(Trait) then
+          val params = parentCls.asClass.paramGetters
+          val args = termArgss(app).flatten
+          for (param, arg) <- params.lazyZip(args) do
+            if !param.is(Private) then // its type can be narrowed through intersection -> a check is needed
+              val paramType = cls.thisType.memberInfo(param)
+              if !(arg.tpe <:< paramType) then
+                val argTypes = args.tpes
+                // it could still be OK but we might need to substitute arguments for parameters
+                // to account for dependent parameters. See pos/i11993.scala
+                if !(arg.tpe.subst(params, argTypes) <:< paramType.subst(params, argTypes))
+                then
+                  report.error(IllegalParameterInit(arg.tpe, paramType, param, cls), arg.srcPos)
+
+      for case app: Apply <- parentTrees do checkParamInits(app)
+    case _ =>
+  }
+
+  /** Disallow using trait parameters as prefix for its parents.
+   *
+   *  The rationale is to ensure outer-related NPE never happen in Scala.
+   *  Otherwise, outer NPE may happen, see tests/neg/i5083.scala
+   */
+  private def checkParentPrefix(cls: Symbol, parent: Tree)(using Context): Unit =
+    parent.tpe.typeConstructor match {
+      case TypeRef(ref: TermRef, _) =>
+        val paramRefs = ref.namedPartsWith(ntp => ntp.symbol.enclosingClass == cls)
+        if (paramRefs.nonEmpty)
+          report.error(TraitParameterUsedAsParentPrefix(cls), parent.srcPos)
+      case _ =>
+    }
+
+  /** Check that a class and its companion object to not both define
+   *  a class or module with same name
+   */
+  private def checkCompanionNameClashes(cls: Symbol)(using Context): Unit =
+    if (!cls.owner.is(ModuleClass)) {
+      def clashes(sym: Symbol) =
+        sym.isClass &&
+        sym.name.stripModuleClassSuffix == cls.name.stripModuleClassSuffix
+
+      val others = cls.owner.linkedClass.info.decls.filter(clashes)
+      others.foreach { other =>
+        report.error(ClassAndCompanionNameClash(cls, other), cls.srcPos)
+      }
+    }
+
+  // Override checking ------------------------------------------------------------
+
+  /** A class for checking all overriding pairs of `class` with a given check function */
+  class OverridingPairsChecker(clazz: ClassSymbol, self: Type)(using Context) extends OverridingPairs.Cursor(clazz):
+
+    override def matches(sym1: Symbol, sym2: Symbol): Boolean =
+      isOverridingPair(sym1, sym2, self)
+
+    private def inLinearizationOrder(sym1: Symbol, sym2: Symbol, parent: Symbol): Boolean =
+      val owner1 = sym1.owner
+      val owner2 = sym2.owner
+      def precedesIn(bcs: List[ClassSymbol]): Boolean = (bcs: @unchecked) match
+        case bc :: bcs1 =>
+          if owner1 eq bc then true
+          else if owner2 eq bc then false
+          else precedesIn(bcs1)
+        case _ =>
+          false
+      precedesIn(parent.asClass.baseClasses)
+
+    // We can exclude pairs safely from checking only under three additional conditions
+    //   - their signatures also match in the parent class.
+    //     See neg/i12828.scala for an example where this matters.
+    //   - They overriding/overridden appear in linearization order.
+    //     See neg/i5094.scala for an example where this matters.
+    //   - The overridden symbol is not `abstract override`. For such symbols
+    //     we need a more extensive test since the virtual super chain depends
+    //     on the precise linearization order, which might be different for the
+    //     subclass. See neg/i14415.scala.
+    override def canBeHandledByParent(sym1: Symbol, sym2: Symbol, parent: Symbol): Boolean =
+      isOverridingPair(sym1, sym2, parent.thisType)
+        .showing(i"already handled ${sym1.showLocated}: ${sym1.asSeenFrom(parent.thisType).signature}, ${sym2.showLocated}: ${sym2.asSeenFrom(parent.thisType).signature} = $result", refcheck)
+      && inLinearizationOrder(sym1, sym2, parent)
+      && !sym2.is(AbsOverride)
+
+    def checkAll(checkOverride: (Symbol, Symbol) => Unit) =
+      while hasNext do
+        checkOverride(overriding, overridden)
+        next()
+
+      // The OverridingPairs cursor does assume that concrete overrides abstract
+      // We have to check separately for an abstract definition in a subclass that
+      // overrides a concrete definition in a superclass. E.g. the following (inspired
+      // from neg/i11130.scala) needs to be rejected as well:
+      //
+      //   class A { type T = B }
+      //   class B extends A { override type T }
+      for dcl <- clazz.info.decls.iterator do
+        if dcl.is(Deferred) then
+          for other <- dcl.allOverriddenSymbols do
+            if !other.is(Deferred) then
+              checkOverride(dcl, other)
+    end checkAll
+  end OverridingPairsChecker
+
+  /** 1. Check all members of class `clazz` for overriding conditions.
+   *  That is for overriding member M and overridden member O:
+   *
+   *    1.1. M must have the same or stronger access privileges as O.
+   *    1.2. O must not be effectively final.
+   *    1.3. If M or O are extension methods, they must both be extension methods.
+   *         (Should be before the check for the need of `override` modifier.)
+   *    1.4. O is deferred, or M has `override` modifier.
+   *    1.5. If O is stable, then so is M.
+   *    1.6. If O is a type alias, then M is an alias of O.
+   *    1.7. If O is an abstract type then
+   *       1.7.1 either M is an abstract type, and M's bounds are sharper than O's bounds.
+   *             or M is a type alias or class which conforms to O's bounds.
+   *       1.7.2 higher-order type arguments must respect bounds on higher-order type parameters  -- @M
+   *              (explicit bounds and those implied by variance annotations) -- @see checkKindBounds
+   *    1.8. If O and M are values, then
+   *    1.8.1  M's type is a subtype of O's type, or
+   *    1.8.2  M is of type []S, O is of type ()T and S <: T, or
+   *    1.8.3  M is of type ()S, O is of type []T and S <: T, or
+   *    1.9. If M is erased, O is erased. If O is erased, M is erased or inline.
+   *    1.10.  If O is inline (and deferred, otherwise O would be final), M must be inline
+   *    1.11.  If O is a Scala-2 macro, M must be a Scala-2 macro.
+   *    1.12.  If O is non-experimental, M must be non-experimental.
+   *    1.13   Under -source future, if O is a val parameter, M must be a val parameter
+   *           that passes its value on to O.
+   *  2. Check that only abstract classes have deferred members
+   *  3. Check that concrete classes do not have deferred definitions
+   *     that are not implemented in a subclass.
+   *  4. Check that every member with an `override` modifier
+   *     overrides some other member.
+   *  TODO check that classes are not overridden
+   *  TODO This still needs to be cleaned up; the current version is a straight port of what was there
+   *       before, but it looks too complicated and method bodies are far too large.
+   */
+  def checkAllOverrides(clazz: ClassSymbol)(using Context): Unit = {
+    val self = clazz.thisType
+    val upwardsSelf = upwardsThisType(clazz)
+    var hasErrors = false
+
+    case class MixinOverrideError(member: Symbol, msg: Message)
+
+    val mixinOverrideErrors = new mutable.ListBuffer[MixinOverrideError]()
+
+    def printMixinOverrideErrors(): Unit =
+      mixinOverrideErrors.toList match {
+        case Nil =>
+        case List(MixinOverrideError(_, msg)) =>
+          report.error(msg, clazz.srcPos)
+        case MixinOverrideError(member, msg) :: others =>
+          val others1 = others.map(_.member).filter(_.name != member.name).distinct
+          def othersMsg = {
+            val others1 = others.map(_.member)
+              .filter(_.name != member.name)
+              .map(_.show).distinct
+            if (others1.isEmpty) ""
+            else i";\nother members with override errors are:: $others1%, %"
+          }
+          report.error(msg.append(othersMsg), clazz.srcPos)
+      }
+
+    def infoString(sym: Symbol) = infoString0(sym, sym.owner != clazz)
+    def infoStringWithLocation(sym: Symbol) = infoString0(sym, true)
+
+    def infoString0(sym: Symbol, showLocation: Boolean) = {
+      val sym1 = sym.underlyingSymbol
+      def info = self.memberInfo(sym1)
+      val infoStr =
+        if (sym1.isAliasType) i", which equals ${info.bounds.hi}"
+        else if (sym1.isAbstractOrParamType && info != TypeBounds.empty) i" with bounds$info"
+        else if (sym1.is(Module)) ""
+        else if (sym1.isTerm) i" of type $info"
+        else ""
+      i"${if (showLocation) sym1.showLocated else sym1}$infoStr"
+    }
+
+    /* Check that all conditions for overriding `other` by `member`
+       * of class `clazz` are met.
+       */
+    def checkOverride(member: Symbol, other: Symbol): Unit =
+      def memberTp(self: Type) =
+        if (member.isClass) TypeAlias(member.typeRef.EtaExpand(member.typeParams))
+        else self.memberInfo(member)
+      def otherTp(self: Type) = self.memberInfo(other)
+
+      refcheck.println(i"check override ${infoString(member)} overriding ${infoString(other)}")
+
+      def noErrorType = !memberTp(self).isErroneous && !otherTp(self).isErroneous
+
+      def overrideErrorMsg(msg: String, compareTypes: Boolean = false): Message = {
+        val isConcreteOverAbstract =
+          (other.owner isSubClass member.owner) && other.is(Deferred) && !member.is(Deferred)
+        val addendum =
+          if isConcreteOverAbstract then
+            ";\n  (Note that %s is abstract,\n  and is therefore overridden by concrete %s)".format(
+              infoStringWithLocation(other),
+              infoStringWithLocation(member))
+          else ""
+        val fullMsg =
+          s"error overriding ${infoStringWithLocation(other)};\n  ${infoString(member)} $msg$addendum"
+        if compareTypes then OverrideTypeMismatchError(fullMsg, memberTp(self), otherTp(self))
+        else OverrideError(fullMsg)
+      }
+
+      def compatTypes(memberTp: Type, otherTp: Type): Boolean =
+        try
+          isOverridingPair(member, memberTp, other, otherTp,
+            fallBack = warnOnMigration(
+              overrideErrorMsg("no longer has compatible type"),
+              (if (member.owner == clazz) member else clazz).srcPos, version = `3.0`))
+        catch case ex: MissingType =>
+          // can happen when called with upwardsSelf as qualifier of memberTp and otherTp,
+          // because in that case we might access types that are not members of the qualifier.
+          false
+
+      /** Do types of term members `member` and `other` as seen from `self` match?
+       *  If not we treat them as not a real override and don't issue override
+       *  error messages. Also, bridges are not generated in this case.
+       *  Type members are always assumed to match.
+       */
+      def trueMatch: Boolean =
+        member.isType || memberTp(self).matches(otherTp(self))
+
+      def emitOverrideError(fullmsg: Message) =
+        if (!(hasErrors && member.is(Synthetic) && member.is(Module))) {
+          // suppress errors relating toi synthetic companion objects if other override
+          // errors (e.g. relating to the companion class) have already been reported.
+          if (member.owner == clazz) report.error(fullmsg, member.srcPos)
+          else mixinOverrideErrors += new MixinOverrideError(member, fullmsg)
+          hasErrors = true
+        }
+
+      def overrideError(msg: String, compareTypes: Boolean = false) =
+        if trueMatch && noErrorType then
+          emitOverrideError(overrideErrorMsg(msg, compareTypes))
+
+      def overrideDeprecation(what: String, member: Symbol, other: Symbol, fix: String): Unit =
+        report.deprecationWarning(
+          s"overriding $what${infoStringWithLocation(other)} is deprecated;\n  ${infoString(member)} should be $fix.",
+          if member.owner == clazz then member.srcPos else clazz.srcPos)
+
+      def autoOverride(sym: Symbol) =
+        sym.is(Synthetic) && (
+          desugar.isDesugaredCaseClassMethodName(member.name) || // such names are added automatically, can't have an override preset.
+          sym.is(Module)) // synthetic companion
+
+      def overrideAccessError() = {
+        report.log(i"member: ${member.showLocated} ${member.flagsString}") // DEBUG
+        report.log(i"other: ${other.showLocated} ${other.flagsString}") // DEBUG
+        val otherAccess = (other.flags & AccessFlags).flagsString
+        overrideError("has weaker access privileges; it should be " +
+          (if (otherAccess == "") "public" else "at least " + otherAccess))
+      }
+
+      def overrideTargetNameError() =
+        val otherTargetName = i"@targetName(${other.targetName})"
+        if member.hasTargetName(member.name) then
+          overrideError(i"misses a target name annotation $otherTargetName")
+        else if other.hasTargetName(other.name) then
+          overrideError(i"should not have a @targetName annotation since the overridden member hasn't one either")
+        else
+          overrideError(i"has a different target name annotation; it should be $otherTargetName")
+
+      //Console.println(infoString(member) + " overrides " + infoString(other) + " in " + clazz);//DEBUG
+
+      /* Is the intersection between given two lists of overridden symbols empty? */
+      def intersectionIsEmpty(syms1: Iterator[Symbol], syms2: Iterator[Symbol]) = {
+        val set2 = syms2.toSet
+        !(syms1 exists (set2 contains _))
+      }
+
+      // o: public | protected        | package-protected  (aka java's default access)
+      // ^-may be overridden by member with access privileges-v
+      // m: public | public/protected | public/protected/package-protected-in-same-package-as-o
+
+      if (member.is(Private)) // (1.1)
+        overrideError("has weaker access privileges; it should not be private")
+
+      // todo: align accessibility implication checking with isAccessible in Contexts
+      def isOverrideAccessOK =
+        val memberIsPublic = (member.flags & AccessFlags).isEmpty && !member.privateWithin.exists
+        def protectedOK = !other.is(Protected) || member.is(Protected)        // if o is protected, so is m
+        def accessBoundaryOK =
+          val ob = other.accessBoundary(member.owner)
+          val mb = member.accessBoundary(member.owner)
+          // restriction isLocalToBlock because companionModule fails under -from-tasty (#14508)
+          def companionBoundaryOK = ob.isClass && !ob.isLocalToBlock && mb.is(Module) && (ob.companionModule eq mb.companionModule)
+          ob.isContainedIn(mb) || companionBoundaryOK    // m relaxes o's access boundary,
+        def otherIsJavaProtected = other.isAllOf(JavaProtected)               // or o is Java defined and protected (see #3946)
+        memberIsPublic || protectedOK && (accessBoundaryOK || otherIsJavaProtected)
+      end isOverrideAccessOK
+
+      if !member.hasTargetName(other.targetName) then
+        overrideTargetNameError()
+      else if !isOverrideAccessOK then
+        overrideAccessError()
+      else if (other.isClass)
+        // direct overrides were already checked on completion (see Checking.chckWellFormed)
+        // the test here catches indirect overriddes between two inherited base types.
+        overrideError("cannot be used here - class definitions cannot be overridden")
+      else if (other.isOpaqueAlias)
+        // direct overrides were already checked on completion (see Checking.chckWellFormed)
+        // the test here catches indirect overriddes between two inherited base types.
+        overrideError("cannot be used here - opaque type aliases cannot be overridden")
+      else if (!other.is(Deferred) && member.isClass)
+        overrideError("cannot be used here - classes can only override abstract types")
+      else if other.isEffectivelyFinal then // (1.2)
+        overrideError(i"cannot override final member ${other.showLocated}")
+      else if (member.is(ExtensionMethod) && !other.is(ExtensionMethod)) // (1.3)
+        overrideError("is an extension method, cannot override a normal method")
+      else if (other.is(ExtensionMethod) && !member.is(ExtensionMethod)) // (1.3)
+        overrideError("is a normal method, cannot override an extension method")
+      else if !other.is(Deferred)
+            && !member.is(Deferred)
+            && !other.name.is(DefaultGetterName)
+            && !member.isAnyOverride
+      then
+        // Exclusion for default getters, fixes SI-5178. We cannot assign the Override flag to
+        // the default getter: one default getter might sometimes override, sometimes not. Example in comment on ticket.
+        // Also exclusion for implicit shortcut methods
+        // Also excluded under Scala2 mode are overrides of default methods of Java traits.
+        if (autoOverride(member) ||
+            other.owner.isAllOf(JavaInterface) &&
+            warnOnMigration(
+              "`override` modifier required when a Java 8 default method is re-implemented".toMessage,
+              member.srcPos, version = `3.0`))
+          member.setFlag(Override)
+        else if (member.isType && self.memberInfo(member) =:= self.memberInfo(other))
+          () // OK, don't complain about type aliases which are equal
+        else if member.owner != clazz
+             && other.owner != clazz
+             && !other.owner.derivesFrom(member.owner)
+        then
+          overrideError(
+            s"$clazz inherits conflicting members:\n  "
+              + infoStringWithLocation(other) + "  and\n  " + infoStringWithLocation(member)
+              + "\n(Note: this can be resolved by declaring an override in " + clazz + ".)")
+        else if member.is(Exported) then
+          overrideError("cannot override since it comes from an export")
+        else
+          overrideError("needs `override` modifier")
+      else if (other.is(AbsOverride) && other.isIncompleteIn(clazz) && !member.is(AbsOverride))
+        overrideError("needs `abstract override` modifiers")
+      else if member.is(Override) && other.is(Mutable) then
+        overrideError("cannot override a mutable variable")
+      else if (member.isAnyOverride &&
+        !(member.owner.thisType.baseClasses exists (_ isSubClass other.owner)) &&
+        !member.is(Deferred) && !other.is(Deferred) &&
+        intersectionIsEmpty(member.extendedOverriddenSymbols, other.extendedOverriddenSymbols))
+        overrideError("cannot override a concrete member without a third member that's overridden by both " +
+          "(this rule is designed to prevent ``accidental overrides'')")
+      else if (other.isStableMember && !member.isStableMember) // (1.5)
+        overrideError("needs to be a stable, immutable value")
+      else if (member.is(ModuleVal) && !other.isRealMethod && !other.isOneOf(DeferredOrLazy))
+        overrideError("may not override a concrete non-lazy value")
+      else if (member.is(Lazy, butNot = Module) && !other.isRealMethod && !other.is(Lazy) &&
+                 !warnOnMigration(overrideErrorMsg("may not override a non-lazy value"), member.srcPos, version = `3.0`))
+        overrideError("may not override a non-lazy value")
+      else if (other.is(Lazy) && !other.isRealMethod && !member.is(Lazy))
+        overrideError("must be declared lazy to override a lazy value")
+      else if (member.is(Erased) && !other.is(Erased)) // (1.9)
+        overrideError("is erased, cannot override non-erased member")
+      else if (other.is(Erased) && !member.isOneOf(Erased | Inline)) // (1.9)
+        overrideError("is not erased, cannot override erased member")
+      else if other.is(Inline) && !member.is(Inline) then // (1.10)
+        overrideError("is not inline, cannot implement an inline method")
+      else if (other.isScala2Macro && !member.isScala2Macro) // (1.11)
+        overrideError("cannot be used here - only Scala-2 macros can override Scala-2 macros")
+      else if (!compatTypes(memberTp(self), otherTp(self)) &&
+                 !compatTypes(memberTp(upwardsSelf), otherTp(upwardsSelf)))
+        overrideError("has incompatible type", compareTypes = true)
+      else if (member.targetName != other.targetName)
+        if (other.targetName != other.name)
+          overrideError(i"needs to be declared with @targetName(${"\""}${other.targetName}${"\""}) so that external names match")
+        else
+          overrideError("cannot have a @targetName annotation since external names would be different")
+      else if other.is(ParamAccessor) && !isInheritedAccessor(member, other) then // (1.13)
+        if sourceVersion.isAtLeast(`future`) then
+          overrideError(i"cannot override val parameter ${other.showLocated}")
+        else
+          report.deprecationWarning(
+            i"overriding val parameter ${other.showLocated} is deprecated, will be illegal in a future version",
+            member.srcPos)
+      else if !other.isExperimental && member.hasAnnotation(defn.ExperimentalAnnot) then // (1.12)
+        overrideError("may not override non-experimental member")
+      else if other.hasAnnotation(defn.DeprecatedOverridingAnnot) then
+        overrideDeprecation("", member, other, "removed or renamed")
+    end checkOverride
+
+    def isInheritedAccessor(mbr: Symbol, other: Symbol): Boolean =
+      mbr.is(ParamAccessor)
+      && {
+        val next = ParamForwarding.inheritedAccessor(mbr)
+        next == other || isInheritedAccessor(next, other)
+      }
+
+    OverridingPairsChecker(clazz, self).checkAll(checkOverride)
+    printMixinOverrideErrors()
+
+    // Verifying a concrete class has nothing unimplemented.
+    if (!clazz.isOneOf(AbstractOrTrait)) {
+      val abstractErrors = new mutable.ListBuffer[String]
+      def abstractErrorMessage =
+        // a little formatting polish
+        if (abstractErrors.size <= 2) abstractErrors mkString " "
+        else abstractErrors.tail.mkString(abstractErrors.head + ":\n", "\n", "")
+
+      def abstractClassError(mustBeMixin: Boolean, msg: String): Unit = {
+        def prelude = (
+          if (clazz.isAnonymousClass || clazz.is(Module)) "object creation impossible"
+          else if (mustBeMixin) s"$clazz needs to be a mixin"
+          else if clazz.is(Synthetic) then "instance cannot be created"
+          else s"$clazz needs to be abstract"
+          ) + ", since"
+
+        if (abstractErrors.isEmpty) abstractErrors ++= List(prelude, msg)
+        else abstractErrors += msg
+      }
+
+      def hasJavaErasedOverriding(sym: Symbol): Boolean =
+        !erasurePhase.exists || // can't do the test, assume the best
+          atPhase(erasurePhase.next) {
+            clazz.info.nonPrivateMember(sym.name).hasAltWith { alt =>
+              alt.symbol.is(JavaDefined, butNot = Deferred) &&
+                !sym.owner.derivesFrom(alt.symbol.owner) &&
+                alt.matches(sym)
+            }
+        }
+
+      def ignoreDeferred(mbr: Symbol) =
+        mbr.isType
+        || mbr.isSuperAccessor // not yet synthesized
+        || mbr.is(JavaDefined) && hasJavaErasedOverriding(mbr)
+
+      def isImplemented(mbr: Symbol) =
+        val mbrDenot = mbr.asSeenFrom(clazz.thisType)
+        def isConcrete(sym: Symbol) = sym.exists && !sym.isOneOf(NotConcrete)
+        clazz.nonPrivateMembersNamed(mbr.name)
+          .filterWithPredicate(
+            impl => isConcrete(impl.symbol)
+              && mbrDenot.matchesLoosely(impl, alwaysCompareTypes = true))
+          .exists
+
+      /** The term symbols in this class and its baseclasses that are
+       *  abstract in this class. We can't use memberNames for that since
+       *  a concrete member might have the same signature as an abstract
+       *  member in a base class, yet might not override it.
+       */
+      def missingTermSymbols: List[Symbol] =
+        val buf = new mutable.ListBuffer[Symbol]
+        for bc <- clazz.baseClasses; sym <- bc.info.decls.toList do
+          if sym.is(DeferredTerm) && !isImplemented(sym) && !ignoreDeferred(sym) then
+            buf += sym
+        buf.toList
+
+      // 2. Check that only abstract classes have deferred members
+      def checkNoAbstractMembers(): Unit = {
+        // Avoid spurious duplicates: first gather any missing members.
+        val missing = missingTermSymbols
+        // Group missing members by the name of the underlying symbol,
+        // to consolidate getters and setters.
+        val grouped = missing.groupBy(sym => sym.underlyingSymbol.name: Name)
+          // !cc! type ascription needed
+
+        val missingMethods = grouped.toList flatMap {
+          case (name, syms) =>
+            val withoutSetters = syms filterNot (_.isSetter)
+            if (withoutSetters.nonEmpty) withoutSetters else syms
+        }
+
+        def stubImplementations: List[String] = {
+          // Grouping missing methods by the declaring class
+          val regrouped = missingMethods.groupBy(_.owner).toList
+          def membersStrings(members: List[Symbol]) =
+            members.sortBy(_.name.toString).map(_.asSeenFrom(clazz.thisType).showDcl + " = ???")
+
+          if (regrouped.tail.isEmpty)
+            membersStrings(regrouped.head._2)
+          else (regrouped.sortBy("" + _._1.name) flatMap {
+            case (owner, members) =>
+              ("// Members declared in " + owner.fullName) +: membersStrings(members) :+ ""
+          }).init
+        }
+
+        // If there are numerous missing methods, we presume they are aware of it and
+        // give them a nicely formatted set of method signatures for implementing.
+        if (missingMethods.size > 1) {
+          abstractClassError(false, "it has " + missingMethods.size + " unimplemented members.")
+          val preface =
+            """|/** As seen from %s, the missing signatures are as follows.
+                 | *  For convenience, these are usable as stub implementations.
+                 | */
+                 |""".stripMargin.format(clazz)
+          abstractErrors += stubImplementations.map("  " + _ + "\n").mkString(preface, "", "")
+          return
+        }
+
+        for (member <- missing) {
+          def showDclAndLocation(sym: Symbol) =
+            s"${sym.showDcl} in ${sym.owner.showLocated}"
+          def undefined(msg: String) =
+            abstractClassError(false, s"${showDclAndLocation(member)} is not defined $msg")
+          val underlying = member.underlyingSymbol
+
+          // Give a specific error message for abstract vars based on why it fails:
+          // It could be unimplemented, have only one accessor, or be uninitialized.
+          if (underlying.is(Mutable)) {
+            val isMultiple = grouped.getOrElse(underlying.name, Nil).size > 1
+
+            // If both getter and setter are missing, squelch the setter error.
+            if (member.isSetter && isMultiple) ()
+            else undefined(
+              if (member.isSetter) "\n(Note that an abstract var requires a setter in addition to the getter)"
+              else if (member.isGetter && !isMultiple) "\n(Note that an abstract var requires a getter in addition to the setter)"
+              else err.abstractVarMessage(member))
+          }
+          else if (underlying.is(Method)) {
+            // If there is a concrete method whose name matches the unimplemented
+            // abstract method, and a cursory examination of the difference reveals
+            // something obvious to us, let's make it more obvious to them.
+            val abstractParams = underlying.info.firstParamTypes
+            val matchingName = clazz.info.nonPrivateMember(underlying.name).alternatives
+            val matchingArity = matchingName filter { m =>
+              !m.symbol.is(Deferred) &&
+                m.info.firstParamTypes.length == abstractParams.length
+            }
+
+            matchingArity match {
+              // So far so good: only one candidate method
+              case concrete :: Nil =>
+                val mismatches =
+                  abstractParams.zip(concrete.info.firstParamTypes)
+                    .filterNot { case (x, y) => x =:= y }
+                mismatches match {
+                  // Only one mismatched parameter: say something useful.
+                  case (pa, pc) :: Nil =>
+                    val abstractSym = pa.typeSymbol
+                    val concreteSym = pc.typeSymbol
+                    def subclassMsg(c1: Symbol, c2: Symbol) =
+                      s"${c1.showLocated} is a subclass of ${c2.showLocated}, but method parameter types must match exactly."
+                    val addendum =
+                      if (abstractSym == concreteSym)
+                        (pa.typeConstructor, pc.typeConstructor) match {
+                          case (TypeRef(pre1, _), TypeRef(pre2, _)) =>
+                            if (pre1 =:= pre2) "their type parameters differ"
+                            else "their prefixes (i.e. enclosing instances) differ"
+                          case _ =>
+                            ""
+                        }
+                      else if (abstractSym isSubClass concreteSym)
+                        subclassMsg(abstractSym, concreteSym)
+                      else if (concreteSym isSubClass abstractSym)
+                        subclassMsg(concreteSym, abstractSym)
+                      else ""
+
+                    undefined(s"""
+                                 |(Note that
+                                 | parameter ${pa.show} in ${showDclAndLocation(underlying)} does not match
+                                 | parameter ${pc.show} in ${showDclAndLocation(concrete.symbol)}
+                                 | $addendum)""".stripMargin)
+                  case xs =>
+                    undefined(
+                      if concrete.symbol.is(AbsOverride) then
+                        s"\n(The class implements ${showDclAndLocation(concrete.symbol)} but that definition still needs an implementation)"
+                      else
+                        s"\n(The class implements a member with a different type: ${showDclAndLocation(concrete.symbol)})")
+                }
+              case Nil =>
+                undefined("")
+              case concretes =>
+                undefined(s"\n(The class implements members with different types: ${concretes.map(c => showDclAndLocation(c.symbol))}%\n  %)")
+            }
+          }
+          else undefined("")
+        }
+      }
+
+      // 3. Check that concrete classes do not have deferred definitions
+      // that are not implemented in a subclass.
+      // Note that this is not the same as (2); In a situation like
+      //
+      // class C { def m: Int = 0}
+      // class D extends C { def m: Int }
+      //
+      // (3) is violated but not (2).
+      def checkNoAbstractDecls(bc: Symbol): Unit = {
+        for (decl <- bc.info.decls)
+          if (decl.is(Deferred)) {
+            val impl = decl.matchingMember(clazz.thisType)
+            if (impl == NoSymbol || decl.owner.isSubClass(impl.owner))
+               && !ignoreDeferred(decl)
+            then
+              val impl1 = clazz.thisType.nonPrivateMember(decl.name) // DEBUG
+              report.log(i"${impl1}: ${impl1.info}") // DEBUG
+              report.log(i"${clazz.thisType.memberInfo(decl)}") // DEBUG
+              abstractClassError(false, "there is a deferred declaration of " + infoString(decl) +
+                " which is not implemented in a subclass" + err.abstractVarMessage(decl))
+          }
+        if (bc.asClass.superClass.is(Abstract))
+          checkNoAbstractDecls(bc.asClass.superClass)
+      }
+
+      // Check that every term member of this concrete class has a symbol that matches the member's type
+      // Member types are computed by intersecting the types of all members that have the same name
+      // and signature. But a member selection will pick one particular implementation, according to
+      // the rules of overriding and linearization. This method checks that the implementation has indeed
+      // a type that subsumes the full member type.
+      def checkMemberTypesOK() = {
+
+        // First compute all member names we need to check in `membersToCheck`.
+        // We do not check
+        //  - types
+        //  - synthetic members or bridges
+        //  - members in other concrete classes, since these have been checked before
+        //    (this is done for efficiency)
+        //  - members in a prefix of inherited parents that all come from Java or Scala2
+        //    (this is done to avoid false positives since Scala2's rules for checking are different)
+        val membersToCheck = new util.HashSet[Name](4096)
+        val seenClasses = new util.HashSet[Symbol](256)
+        def addDecls(cls: Symbol): Unit =
+          if (!seenClasses.contains(cls)) {
+            seenClasses += cls
+            for (mbr <- cls.info.decls)
+              if (mbr.isTerm && !mbr.isOneOf(Synthetic | Bridge) && mbr.memberCanMatchInheritedSymbols &&
+                  !membersToCheck.contains(mbr.name))
+                membersToCheck += mbr.name
+            cls.info.parents.map(_.classSymbol)
+              .filter(_.isOneOf(AbstractOrTrait))
+              .dropWhile(_.isOneOf(JavaDefined | Scala2x))
+              .foreach(addDecls)
+          }
+        addDecls(clazz)
+
+        // For each member, check that the type of its symbol, as seen from `self`
+        // can override the info of this member
+        withMode(Mode.IgnoreCaptures) {
+          for (name <- membersToCheck)
+            for (mbrd <- self.member(name).alternatives) {
+              val mbr = mbrd.symbol
+              val mbrType = mbr.info.asSeenFrom(self, mbr.owner)
+              if (!mbrType.overrides(mbrd.info, relaxedCheck = false, matchLoosely = true))
+                report.errorOrMigrationWarning(
+                  em"""${mbr.showLocated} is not a legal implementation of `$name` in $clazz
+                      |  its type             $mbrType
+                      |  does not conform to  ${mbrd.info}""",
+                  (if (mbr.owner == clazz) mbr else clazz).srcPos, from = `3.0`)
+          }
+        }
+      }
+
+      /** Check that inheriting a case class does not constitute a variant refinement
+       *  of a base type of the case class. It is because of this restriction that we
+       *  can assume invariant refinement for case classes in `constrainPatternType`.
+       */
+      def checkCaseClassInheritanceInvariant() =
+        for (caseCls <- clazz.info.baseClasses.tail.find(_.is(Case)))
+          for (baseCls <- caseCls.info.baseClasses.tail)
+            if (baseCls.typeParams.exists(_.paramVarianceSign != 0))
+              for (problem <- variantInheritanceProblems(baseCls, caseCls, "non-variant", "case "))
+                report.errorOrMigrationWarning(problem(), clazz.srcPos, from = `3.0`)
+      checkNoAbstractMembers()
+      if (abstractErrors.isEmpty)
+        checkNoAbstractDecls(clazz)
+
+      if (abstractErrors.nonEmpty)
+        report.error(abstractErrorMessage, clazz.srcPos)
+
+      checkMemberTypesOK()
+      checkCaseClassInheritanceInvariant()
+    }
+
+    if (!clazz.is(Trait)) {
+      // check that parameterized base classes and traits are typed in the same way as from the superclass
+      // I.e. say we have
+      //
+      //    Sub extends Super extends* Base
+      //
+      // where `Base` has value parameters. Enforce that
+      //
+      //    Sub.thisType.baseType(Base)  =:=  Sub.thisType.baseType(Super).baseType(Base)
+      //
+      // This is necessary because parameter values are determined directly or indirectly
+      // by `Super`. So we cannot pretend they have a different type when seen from `Sub`.
+      def checkParameterizedTraitsOK() = {
+        val mixins = clazz.mixins
+        for {
+          cls <- clazz.info.baseClasses.tail
+          if cls.paramAccessors.nonEmpty && !mixins.contains(cls)
+          problem <- variantInheritanceProblems(cls, clazz.asClass.superClass, "parameterized", "super")
+        }
+        report.error(problem(), clazz.srcPos)
+      }
+
+      checkParameterizedTraitsOK()
+    }
+
+    /** Check that `site` does not inherit conflicting generic instances of `baseCls`,
+     *  when doing a direct base type or going via intermediate class `middle`. I.e, we require:
+     *
+     *     site.baseType(baseCls)  =:=  site.baseType(middle).baseType(baseCls)
+     *
+     *  Return an optional by name error message if this test fails.
+     */
+    def variantInheritanceProblems(
+        baseCls: Symbol, middle: Symbol, baseStr: String, middleStr: String): Option[() -> String] = {
+      val superBT = self.baseType(middle)
+      val thisBT = self.baseType(baseCls)
+      val combinedBT = superBT.baseType(baseCls)
+      if (combinedBT =:= thisBT) None // ok
+      else
+        Some(() =>
+          em"""illegal inheritance: $clazz inherits conflicting instances of $baseStr base $baseCls.
+              |
+              |  Direct basetype: $thisBT
+              |  Basetype via $middleStr$middle: $combinedBT""")
+    }
+
+    /* Returns whether there is a symbol declared in class `inclazz`
+       * (which must be different from `clazz`) whose name and type
+       * seen as a member of `class.thisType` matches `member`'s.
+       */
+    def hasMatchingSym(inclazz: Symbol, member: Symbol): Boolean = {
+
+      def isSignatureMatch(sym: Symbol) = sym.isType || {
+        val self = clazz.thisType
+        sym.asSeenFrom(self).matches(member.asSeenFrom(self))
+      }
+
+      /* The rules for accessing members which have an access boundary are more
+         * restrictive in java than scala.  Since java has no concept of package nesting,
+         * a member with "default" (package-level) access can only be accessed by members
+         * in the exact same package.  Example:
+         *
+         *   package a.b;
+         *   public class JavaClass { void foo() { } }
+         *
+         * The member foo() can be accessed only from members of package a.b, and not
+         * nested packages like a.b.c.  In the analogous scala class:
+         *
+         *   package a.b
+         *   class ScalaClass { private[b] def foo() = () }
+         *
+         * The member IS accessible to classes in package a.b.c.  The javaAccessCheck logic
+         * is restricting the set of matching signatures according to the above semantics.
+         */
+      def javaAccessCheck(sym: Symbol) = (
+        !inclazz.is(JavaDefined) // not a java defined member
+        || !sym.privateWithin.exists // no access boundary
+        || sym.is(Protected) // marked protected in java, thus accessible to subclasses
+        || sym.privateWithin == member.enclosingPackageClass // exact package match
+        )
+      def classDecls = inclazz.info.nonPrivateDecl(member.name)
+
+      (inclazz != clazz) &&
+        classDecls.hasAltWith(d => isSignatureMatch(d.symbol) && javaAccessCheck(d.symbol))
+    }
+
+    // 4. Check that every defined member with an `override` modifier overrides some other member.
+    for (member <- clazz.info.decls)
+      if (member.isAnyOverride && !(clazz.thisType.baseClasses exists (hasMatchingSym(_, member)))) {
+        if (checks != noPrinter)
+          for (bc <- clazz.info.baseClasses.tail) {
+            val sym = bc.info.decl(member.name).symbol
+            if (sym.exists)
+              checks.println(i"$bc has $sym: ${clazz.thisType.memberInfo(sym)}")
+          }
+
+        val nonMatching = clazz.info.member(member.name).altsWith(alt => alt.owner != clazz)
+        nonMatching match {
+          case Nil =>
+            report.error(OverridesNothing(member), member.srcPos)
+          case ms =>
+            // getClass in primitive value classes is defined in the standard library as:
+            //     override def getClass(): Class[Int] = ???
+            // However, it's not actually an override in Dotty because our Any#getClass
+            // is polymorphic (see `Definitions#Any_getClass`), so since we can't change
+            // the standard library, we need to drop the override flag without reporting
+            // an error.
+            if (!(member.name == nme.getClass_ && clazz.isPrimitiveValueClass))
+              report.error(OverridesNothingButNameExists(member, ms), member.srcPos)
+        }
+        member.resetFlag(Override)
+        member.resetFlag(AbsOverride)
+      }
+  }
+
+  /** Check that we do not "override" anything with a private method
+   *  or something that becomes a private method. According to the Scala
+   *  modeling this is non-sensical since private members don't override.
+   *  But Java and the JVM disagree, if the private member is a method.
+   *  A test case is neg/i7926b.scala.
+   *  Note: The compiler could possibly silently rename the offending private
+   *  instead of flagging it as an error. But that might mean we see some
+   *  surprising names at runtime. E.g. in neg/i4564a.scala, a private
+   *  case class `apply` method would have to be renamed to something else.
+   */
+  def checkNoPrivateOverrides(tree: Tree)(using Context): Unit =
+    val sym = tree.symbol
+    if sym.maybeOwner.isClass
+       && sym.is(Private)
+       && (sym.isOneOf(MethodOrLazyOrMutable) || !sym.is(Local)) // in these cases we'll produce a getter later
+       && !sym.isConstructor
+    then
+      val cls = sym.owner.asClass
+      for bc <- cls.baseClasses.tail do
+        val other = sym.matchingDecl(bc, cls.thisType)
+        if other.exists then
+          report.error(i"private $sym cannot override ${other.showLocated}", sym.srcPos)
+  end checkNoPrivateOverrides
+
+  /** Check that unary method definition do not receive parameters.
+   *  They can only receive inferred parameters such as type parameters and implicit parameters.
+   */
+  def checkUnaryMethods(sym: Symbol)(using Context): Unit =
+    /** Check that the only term parameters are contextual or implicit */
+    def checkParameters(tpe: Type): Unit =
+      tpe match
+        case tpe: MethodType =>
+          if tpe.isImplicitMethod || tpe.isContextualMethod then
+            checkParameters(tpe.resType)
+          else
+            val what =
+              if tpe.paramNames.isEmpty then "empty parameter list.\n\nPossible fix: remove the `()` arguments."
+              else "parameters"
+            report.warning(s"unary_<op> method cannot take $what", sym.sourcePos)
+        case tpe: PolyType =>
+          checkParameters(tpe.resType)
+        case _ =>
+          // ok
+
+    /** Skip leading type and contextual parameters, then skip the
+     *  self parameter, and finally check the parameter
+     */
+    def checkExtensionParameters(tpe: Type): Unit =
+      tpe match
+        case tpe: MethodType =>
+          assert(tpe.paramNames.length == 1)
+          if tpe.isContextualMethod then checkExtensionParameters(tpe.resType)
+          else checkParameters(tpe.resType)
+        case tpe: PolyType =>
+          checkExtensionParameters(tpe.resType)
+
+    def isUnaryPrefixName(name: Name) = name match
+      case name: SimpleName =>
+        name.startsWith("unary_") && nme.raw.isUnary(name.drop(6))
+      case _ =>
+        false
+
+    if isUnaryPrefixName(sym.name) then
+      if sym.is(Extension) || sym.name.is(ExtMethName) then
+        // if is method from `extension` or value class
+        checkExtensionParameters(sym.info)
+      else
+        checkParameters(sym.info)
+
+  end checkUnaryMethods
+
+  /** Verify that references in the user-defined `@implicitNotFound` message are valid.
+   *  (i.e. they refer to a type variable that really occurs in the signature of the annotated symbol.)
+   */
+  private object checkImplicitNotFoundAnnotation:
+    /** Warns if the class or trait has an @implicitNotFound annotation
+     *  with invalid type variable references.
+     */
+    def template(sd: SymDenotation)(using Context): Unit =
+      checkReferences(sd)
+
+    /** Warns if the def has parameters with an `@implicitNotFound` annotation
+     *  with invalid type variable references.
+     */
+    def defDef(sd: SymDenotation)(using Context): Unit =
+      for
+        paramSymss <- sd.paramSymss
+        param <- paramSymss
+        if param.isTerm
+      do checkReferences(param.denot)
+
+    private object PositionedStringLiteralArgument:
+      def unapply(tree: Tree): Option[(String, Span)] = tree match {
+        case l@Literal(Constant(s: String)) => Some((s, l.span))
+        case NamedArg(_, l@Literal(Constant(s: String))) => Some((s, l.span))
+        case _ => None
+      }
+
+    private def checkReferences(sd: SymDenotation)(using Context): Unit =
+      lazy val substitutableTypesNames =
+        ErrorReporting.substitutableTypeSymbolsInScope(sd.symbol).map(_.denot.name.show)
+      for
+        annotation <- sd.getAnnotation(defn.ImplicitNotFoundAnnot)
+        case PositionedStringLiteralArgument(msg, span) <- annotation.argument(0)
+      do forEachTypeVariableReferenceIn(msg) { case (ref, start) =>
+        if !substitutableTypesNames.contains(ref) then
+          reportInvalidReference(span, ref, start, sd)
+      }
+
+    /** Reports an invalid reference to a type variable `typeRef` that was found in `span` */
+    private def reportInvalidReference(
+      span: Span,
+      typeRef: String,
+      variableOffsetinArgumentLiteral: Int,
+      sd: SymDenotation
+    )(using Context) =
+      val typeRefName = s"`$typeRef`"
+      val ownerName =
+        if sd.isType then s"type `${sd.name.show}`"
+        else if sd.owner.isConstructor then s"the constructor of `${sd.owner.owner.name.show}`"
+        else s"method `${sd.owner.name.show}`"
+      val msg = InvalidReferenceInImplicitNotFoundAnnotation(typeRefName, ownerName)
+      val startPos = span.shift(variableOffsetinArgumentLiteral + 1).startPos // +1 because of 0-based index
+      val pos = ctx.source.atSpan(startPos)
+      report.warning(msg, pos)
+
+    /** Calls the supplied function for each quoted reference to a type variable in <pre>s</pre>.
+     *  The input
+     *
+     *  ```scala
+     *     "This is a ${T}ype re${F}erence"
+     *  //  ^0          ^12       ^22
+     *  ```
+     *
+     *  will lead to two invocations of `f`, once with `(T, 12)` and once with `(F, 22)` as argument.
+     *
+     * @param s The string to query for type variable references.
+     * @param f A function to apply to every pair of (\<type variable>, \<position in string>).
+     */
+    private def forEachTypeVariableReferenceIn(s: String)(f: (String, Int) => Unit) =
+      // matches quoted references such as "${A}", "${ Abc }", etc.
+      val referencePattern = """\$\{\s*([^}\s]+)\s*\}""".r
+      val matches = referencePattern.findAllIn(s)
+      for reference <- matches do
+        val referenceOffset = matches.start
+        val prefixlessReference = reference.replaceFirst("""\$\{\s*""", "").nn
+        val variableOffset = referenceOffset + reference.length - prefixlessReference.length
+        val variableName = prefixlessReference.replaceFirst("""\s*\}""", "").nn
+        f(variableName, variableOffset)
+
+  end checkImplicitNotFoundAnnotation
+
+}
+import RefChecks._
+
+/** Post-attribution checking and transformation, which fulfills the following roles
+ *
+ *  1. This phase performs the following checks.
+ *
+ *  - only one overloaded alternative defines default arguments
+ *  - applyDynamic methods are not overloaded
+ *  - all overrides conform to rules laid down by `checkAllOverrides`.
+ *  - any value classes conform to rules laid down by `checkDerivedValueClass`.
+ *  - this(...) constructor calls do not forward reference other definitions in their block (not even lazy vals).
+ *  - no forward reference in a local block jumps over a non-lazy val definition.
+ *  - a class and its companion object do not both define a class or module with the same name.
+ *
+ *  2. It warns about references to symbols labeled deprecated or migration.
+
+ *  3. It eliminates macro definitions.
+ *
+ *  4. It makes members not private where necessary. The following members
+ *  cannot be private in the Java model:
+ *   - term members of traits
+ *   - the primary constructor of a value class
+ *   - the parameter accessor of a value class
+ *   - members accessed from an inner or companion class.
+ *  All these members are marked as NotJavaPrivate.
+ *  Unlike in Scala 2.x not-private members keep their name. It is
+ *  up to the backend to find a unique expanded name for them. The
+ *  rationale to do name changes that late is that they are very fragile.
+
+ *  todo: But RefChecks is not done yet. It's still a somewhat dirty port from the Scala 2 version.
+ *  todo: move untrivial logic to their own mini-phases
+ */
+class RefChecks extends MiniPhase { thisPhase =>
+
+  import tpd._
+
+  override def phaseName: String = RefChecks.name
+
+  override def description: String = RefChecks.description
+
+  override def runsAfter: Set[String] = Set(ElimRepeated.name)
+    // Needs to run after ElimRepeated for override checks involving varargs methods
+
+  override def transformValDef(tree: ValDef)(using Context): ValDef = {
+    if tree.symbol.exists then
+      checkNoPrivateOverrides(tree)
+      val sym = tree.symbol
+      if (sym.exists && sym.owner.isTerm) {
+        tree.rhs match {
+          case Ident(nme.WILDCARD) => report.error(UnboundPlaceholderParameter(), sym.srcPos)
+          case _ =>
+        }
+      }
+    tree
+  }
+
+  override def transformDefDef(tree: DefDef)(using Context): DefDef = {
+    checkNoPrivateOverrides(tree)
+    checkImplicitNotFoundAnnotation.defDef(tree.symbol.denot)
+    checkUnaryMethods(tree.symbol)
+    tree
+  }
+
+  override def transformTemplate(tree: Template)(using Context): Tree = try {
+    val cls = ctx.owner.asClass
+    checkOverloadedRestrictions(cls)
+    checkParents(cls, tree.parents)
+    if (cls.is(Trait)) tree.parents.foreach(checkParentPrefix(cls, _))
+    checkCompanionNameClashes(cls)
+    checkAllOverrides(cls)
+    checkImplicitNotFoundAnnotation.template(cls.classDenot)
+    tree
+  }
+  catch {
+    case ex: TypeError =>
+      report.error(ex, tree.srcPos)
+      tree
+  }
+}
+
+/* todo: rewrite and re-enable
+
+// Comparison checking -------------------------------------------------------
+
+    object normalizeAll extends TypeMap {
+      def apply(tp: Type) = mapOver(tp).normalize
+    }
+
+    def checkImplicitViewOptionApply(pos: Position, fn: Tree, args: List[Tree]): Unit = if (settings.lint) (fn, args) match {
+      case (tap@TypeApply(fun, targs), List(view: ApplyImplicitView)) if fun.symbol == currentRun.runDefinitions.Option_apply =>
+        unit.warning(pos, s"Suspicious application of an implicit view (${view.fun}) in the argument to Option.apply.") // SI-6567
+      case _ =>
+    }
+
+    private def isObjectOrAnyComparisonMethod(sym: Symbol) = sym match {
+      case Object_eq | Object_ne | Object_== | Object_!= | Any_== | Any_!= => true
+      case _                                                               => false
+    }
+    /** Check the sensibility of using the given `equals` to compare `qual` and `other`. */
+    private def checkSensibleEquals(pos: Position, qual: Tree, name: Name, sym: Symbol, other: Tree) = {
+      def isReferenceOp = sym == Object_eq || sym == Object_ne
+      def isNew(tree: Tree) = tree match {
+        case Function(_, _) | Apply(Select(New(_), nme.CONSTRUCTOR), _) => true
+        case _ => false
+      }
+      def underlyingClass(tp: Type): Symbol = {
+        val sym = tp.typeSymbol
+        if (sym.isAbstractOrParamType) underlyingClass(sym.info.bounds.hi)
+        else sym
+      }
+      val actual   = underlyingClass(other.tpe)
+      val receiver = underlyingClass(qual.tpe)
+      def onTrees[T](f: List[Tree] => T) = f(List(qual, other))
+      def onSyms[T](f: List[Symbol] => T) = f(List(receiver, actual))
+
+      // @MAT normalize for consistency in error message, otherwise only part is normalized due to use of `typeSymbol`
+      def typesString = normalizeAll(qual.tpe.widen)+" and " + normalizeAll(other.tpe.widen)
+
+      /* Symbols which limit the warnings we can issue since they may be value types */
+      val isMaybeValue = Set[Symbol](AnyClass, AnyRefClass, AnyValClass, ObjectClass, ComparableClass, JavaSerializableClass)
+
+      // Whether def equals(other: Any) has known behavior: it is the default
+      // inherited from java.lang.Object, or it is a synthetically generated
+      // case equals.  TODO - more cases are warnable if the target is a synthetic
+      // equals.
+      def isUsingWarnableEquals = {
+        val m = receiver.info.member(nme.equals_)
+        ((m == Object_equals) || (m == Any_equals) || isMethodCaseEquals(m))
+      }
+      def isMethodCaseEquals(m: Symbol) = m.isSynthetic && m.owner.isCase
+      def isCaseEquals = isMethodCaseEquals(receiver.info.member(nme.equals_))
+      // Whether this == or != is one of those defined in Any/AnyRef or an overload from elsewhere.
+      def isUsingDefaultScalaOp = sym == Object_== || sym == Object_!= || sym == Any_== || sym == Any_!=
+      def haveSubclassRelationship = (actual isSubClass receiver) || (receiver isSubClass actual)
+
+      // Whether the operands+operator represent a warnable combo (assuming anyrefs)
+      // Looking for comparisons performed with ==/!= in combination with either an
+      // equals method inherited from Object or a case class synthetic equals (for
+      // which we know the logic.)
+      def isWarnable           = isReferenceOp || (isUsingDefaultScalaOp && isUsingWarnableEquals)
+      def isEitherNullable     = (NullTpe <:< receiver.info) || (NullTpe <:< actual.info)
+      def isEitherValueClass   = actual.isDerivedValueClass || receiver.isDerivedValueClass
+      def isBoolean(s: Symbol) = unboxedValueClass(s) == BooleanClass
+      def isUnit(s: Symbol)    = unboxedValueClass(s) == UnitClass
+      def isNumeric(s: Symbol) = isNumericValueClass(unboxedValueClass(s)) || isAnyNumber(s)
+      def isScalaNumber(s: Symbol) = s isSubClass ScalaNumberClass
+      def isJavaNumber(s: Symbol)  = s isSubClass JavaNumberClass
+      // includes java.lang.Number if appropriate [SI-5779]
+      def isAnyNumber(s: Symbol)     = isScalaNumber(s) || isJavaNumber(s)
+      def isMaybeAnyValue(s: Symbol) = isPrimitiveValueClass(unboxedValueClass(s)) || isMaybeValue(s)
+      // used to short-circuit unrelatedTypes check if both sides are special
+      def isSpecial(s: Symbol) = isMaybeAnyValue(s) || isAnyNumber(s)
+      val nullCount            = onSyms(_ filter (_ == NullClass) size)
+      def isNonsenseValueClassCompare = (
+           !haveSubclassRelationship
+        && isUsingDefaultScalaOp
+        && isEitherValueClass
+        && !isCaseEquals
+      )
+
+      // Have we already determined that the comparison is non-sensible? I mean, non-sensical?
+      var isNonSensible = false
+
+      def nonSensibleWarning(what: String, alwaysEqual: Boolean) = {
+        val msg = alwaysEqual == (name == nme.EQ || name == nme.eq)
+        unit.warning(pos, s"comparing $what using `${name.decode}` will always yield $msg")
+        isNonSensible = true
+      }
+      def nonSensible(pre: String, alwaysEqual: Boolean) =
+        nonSensibleWarning(s"${pre}values of types $typesString", alwaysEqual)
+      def nonSensiblyEq() = nonSensible("", alwaysEqual = true)
+      def nonSensiblyNeq() = nonSensible("", alwaysEqual = false)
+      def nonSensiblyNew() = nonSensibleWarning("a fresh object", alwaysEqual = false)
+
+      def unrelatedMsg = name match {
+        case nme.EQ | nme.eq => "never compare equal"
+        case _               => "always compare unequal"
+      }
+      def unrelatedTypes() = if (!isNonSensible) {
+        val weaselWord = if (isEitherValueClass) "" else " most likely"
+        unit.warning(pos, s"$typesString are unrelated: they will$weaselWord $unrelatedMsg")
+      }
+
+      if (nullCount == 2) // null == null
+        nonSensiblyEq()
+      else if (nullCount == 1) {
+        if (onSyms(_ exists isPrimitiveValueClass)) // null == 5
+          nonSensiblyNeq()
+        else if (onTrees( _ exists isNew)) // null == new AnyRef
+          nonSensiblyNew()
+      }
+      else if (isBoolean(receiver)) {
+        if (!isBoolean(actual) && !isMaybeValue(actual))    // true == 5
+          nonSensiblyNeq()
+      }
+      else if (isUnit(receiver)) {
+        if (isUnit(actual)) // () == ()
+          nonSensiblyEq()
+        else if (!isUnit(actual) && !isMaybeValue(actual))  // () == "abc"
+          nonSensiblyNeq()
+      }
+      else if (isNumeric(receiver)) {
+        if (!isNumeric(actual))
+          if (isUnit(actual) || isBoolean(actual) || !isMaybeValue(actual))   // 5 == "abc"
+            nonSensiblyNeq()
+      }
+      else if (isWarnable && !isCaseEquals) {
+        if (isNew(qual)) // new X == y
+          nonSensiblyNew()
+        else if (isNew(other) && (receiver.isEffectivelyFinal || isReferenceOp))   // object X ; X == new Y
+          nonSensiblyNew()
+        else if (receiver.isEffectivelyFinal && !(receiver isSubClass actual) && !actual.isRefinementClass) {  // object X, Y; X == Y
+          if (isEitherNullable)
+            nonSensible("non-null ", false)
+          else
+            nonSensiblyNeq()
+        }
+      }
+
+      // warn if one but not the other is a derived value class
+      // this is especially important to enable transitioning from
+      // regular to value classes without silent failures.
+      if (isNonsenseValueClassCompare)
+        unrelatedTypes()
+      // possibleNumericCount is insufficient or this will warn on e.g. Boolean == j.l.Boolean
+      else if (isWarnable && nullCount == 0 && !(isSpecial(receiver) && isSpecial(actual))) {
+        // better to have lubbed and lost
+        def warnIfLubless(): Unit = {
+          val common = global.lub(List(actual.tpe, receiver.tpe))
+          if (ObjectTpe <:< common)
+            unrelatedTypes()
+        }
+        // warn if actual has a case parent that is not same as receiver's;
+        // if actual is not a case, then warn if no common supertype, as below
+        if (isCaseEquals) {
+          def thisCase = receiver.info.member(nme.equals_).owner
+          actual.info.baseClasses.find(_.isCase) match {
+            case Some(p) if p != thisCase => nonSensible("case class ", false)
+            case None =>
+              // stronger message on (Some(1) == None)
+              //if (receiver.isCase && receiver.isEffectivelyFinal && !(receiver isSubClass actual)) nonSensiblyNeq()
+              //else
+              // if a class, it must be super to thisCase (and receiver) since not <: thisCase
+              if (!actual.isTrait && !(receiver isSubClass actual)) nonSensiblyNeq()
+              else if (!haveSubclassRelationship) warnIfLubless()
+            case _ =>
+          }
+        }
+        // warn only if they have no common supertype below Object
+        else if (!haveSubclassRelationship) {
+          warnIfLubless()
+        }
+      }
+    }
+    /** Sensibility check examines flavors of equals. */
+    def checkSensible(pos: Position, fn: Tree, args: List[Tree]) = fn match {
+      case Select(qual, name @ (nme.EQ | nme.NE | nme.eq | nme.ne)) if args.length == 1 && isObjectOrAnyComparisonMethod(fn.symbol) =>
+        checkSensibleEquals(pos, qual, name, fn.symbol, args.head)
+      case _ =>
+    }
+*/
+
+/* --------------- Overflow -------------------------------------------------
+ *
+
+  def accessFlagsToString(sym: Symbol) = flagsToString(
+    sym getFlag (PRIVATE | PROTECTED),
+    if (sym.hasAccessBoundary) "" + sym.privateWithin.name else ""
+  )
+
+  def overridesTypeInPrefix(tp1: Type, tp2: Type, prefix: Type): Boolean = (tp1.dealiasWiden, tp2.dealiasWiden) match {
+    case (MethodType(List(), rtp1), NullaryMethodType(rtp2)) =>
+      rtp1 <:< rtp2
+    case (NullaryMethodType(rtp1), MethodType(List(), rtp2)) =>
+      rtp1 <:< rtp2
+    case (TypeRef(_, sym, _),  _) if sym.isModuleClass =>
+      overridesTypeInPrefix(NullaryMethodType(tp1), tp2, prefix)
+    case _ =>
+      def classBoundAsSeen(tp: Type) = tp.typeSymbol.classBound.asSeenFrom(prefix, tp.typeSymbol.owner)
+
+      (tp1 <:< tp2) || (  // object override check
+        tp1.typeSymbol.isModuleClass && tp2.typeSymbol.isModuleClass && {
+          val cb1 = classBoundAsSeen(tp1)
+          val cb2 = classBoundAsSeen(tp2)
+          (cb1 <:< cb2) && {
+            log("Allowing %s to override %s because %s <:< %s".format(tp1, tp2, cb1, cb2))
+            true
+          }
+        }
+      )
+  }
+    private def checkTypeRef(tp: Type, tree: Tree, skipBounds: Boolean)(using Context) = tp match {
+      case TypeRef(pre, sym, args) =>
+        tree match {
+          case tt: TypeTree if tt.original == null => // SI-7783 don't warn about inferred types
+                                                      // FIXME: reconcile this check with one in resetAttrs
+          case _ => checkUndesiredProperties(sym, tree.pos)
+        }
+        if (sym.isJavaDefined)
+          sym.typeParams foreach (_.cookJavaRawInfo())
+        if (!tp.isHigherKinded && !skipBounds)
+          checkBounds(tree, pre, sym.owner, sym.typeParams, args)
+      case _ =>
+    }
+
+    private def checkTypeRefBounds(tp: Type, tree: Tree) = {
+      var skipBounds = false
+      tp match {
+        case AnnotatedType(ann :: Nil, underlying) if ann.symbol == UncheckedBoundsClass =>
+          skipBounds = true
+          underlying
+        case TypeRef(pre, sym, args) =>
+          if (!tp.isHigherKinded && !skipBounds)
+            checkBounds(tree, pre, sym.owner, sym.typeParams, args)
+          tp
+        case _ =>
+          tp
+      }
+    }
+
+    private def checkAnnotations(tpes: List[Type], tree: Tree) = tpes foreach { tp =>
+      checkTypeRef(tp, tree, skipBounds = false)
+      checkTypeRefBounds(tp, tree)
+    }
+    private def doTypeTraversal(tree: Tree)(f: Type => Unit) = if (!inPattern) tree.tpe foreach f
+
+    private def applyRefchecksToAnnotations(tree: Tree)(using Context): Unit = {
+      def applyChecks(annots: List[Annotation]) = {
+        checkAnnotations(annots map (_.atp), tree)
+        transformTrees(annots flatMap (_.args))
+      }
+
+      tree match {
+        case m: MemberDef =>
+          val sym = m.symbol
+          applyChecks(sym.annotations)
+          // validate implicitNotFoundMessage
+          analyzer.ImplicitNotFoundMsg.check(sym) foreach { warn =>
+            unit.warning(tree.pos, f"Invalid implicitNotFound message for ${sym}%s${sym.locationString}%s:%n$warn")
+          }
+
+        case tpt@TypeTree() =>
+          if (tpt.original != null) {
+            tpt.original foreach {
+              case dc@TypeTreeWithDeferredRefCheck() =>
+                applyRefchecksToAnnotations(dc.check()) // #2416
+              case _ =>
+            }
+          }
+
+          doTypeTraversal(tree) {
+            case tp @ AnnotatedType(annots, _)  =>
+              applyChecks(annots)
+            case tp =>
+          }
+        case _ =>
+      }
+    }
+
+    private def transformCaseApply(tree: Tree, ifNot: => Unit) = {
+      val sym = tree.symbol
+
+      def isClassTypeAccessible(tree: Tree): Boolean = tree match {
+        case TypeApply(fun, targs) =>
+          isClassTypeAccessible(fun)
+        case Select(module, apply) =>
+          ( // SI-4859 `CaseClass1().InnerCaseClass2()` must not be rewritten to `new InnerCaseClass2()`;
+            //          {expr; Outer}.Inner() must not be rewritten to `new Outer.Inner()`.
+            treeInfo.isQualifierSafeToElide(module) &&
+            // SI-5626 Classes in refinement types cannot be constructed with `new`. In this case,
+            // the companion class is actually not a ClassSymbol, but a reference to an abstract type.
+            module.symbol.companionClass.isClass
+          )
+      }
+
+      val doTransform =
+        sym.isRealMethod &&
+        sym.isCase &&
+        sym.name == nme.apply &&
+        isClassTypeAccessible(tree)
+
+      if (doTransform) {
+        tree foreach {
+          case i@Ident(_) =>
+            enterReference(i.pos, i.symbol) // SI-5390 need to `enterReference` for `a` in `a.B()`
+          case _ =>
+        }
+        toConstructor(tree.pos, tree.tpe)
+      }
+      else {
+        ifNot
+        tree
+      }
+    }
+
+    private def transformApply(tree: Apply): Tree = tree match {
+      case Apply(
+        Select(qual, nme.filter | nme.withFilter),
+        List(Function(
+          List(ValDef(_, pname, tpt, _)),
+          Match(_, CaseDef(pat1, _, _) :: _))))
+        if ((pname startsWith nme.CHECK_IF_REFUTABLE_STRING) &&
+            isIrrefutable(pat1, tpt.tpe) && (qual.tpe <:< tree.tpe)) =>
+
+          transform(qual)
+
+      case Apply(fn, args) =>
+        // sensicality should be subsumed by the unreachability/exhaustivity/irrefutability
+        // analyses in the pattern matcher
+        if (!inPattern) {
+          checkImplicitViewOptionApply(tree.pos, fn, args)
+          checkSensible(tree.pos, fn, args)
+        }
+        currentApplication = tree
+        tree
+    }
+    private def transformSelect(tree: Select): Tree = {
+      val Select(qual, _) = tree
+      val sym = tree.symbol
+
+      checkUndesiredProperties(sym, tree.pos)
+      checkDelayedInitSelect(qual, sym, tree.pos)
+
+      if (!sym.exists)
+        devWarning("Select node has NoSymbol! " + tree + " / " + tree.tpe)
+      else if (sym.isLocalToThis)
+        varianceValidator.checkForEscape(sym, currentClass)
+
+      def checkSuper(mix: Name) =
+        // term should have been eliminated by super accessors
+        assert(!(qual.symbol.isTrait && sym.isTerm && mix == tpnme.EMPTY), (qual.symbol, sym, mix))
+
+      transformCaseApply(tree,
+        qual match {
+          case Super(_, mix)  => checkSuper(mix)
+          case _              =>
+        }
+      )
+    }
+    private def transformIf(tree: If): Tree = {
+      val If(cond, thenpart, elsepart) = tree
+      def unitIfEmpty(t: Tree): Tree =
+        if (t == EmptyTree) Literal(Constant(())).setPos(tree.pos).setType(UnitTpe) else t
+
+      cond.tpe match {
+        case ConstantType(value) =>
+          val res = if (value.booleanValue) thenpart else elsepart
+          unitIfEmpty(res)
+        case _ => tree
+      }
+    }
+
+    // Warning about nullary methods returning Unit. TODO: move to lint
+    private def checkNullaryMethodReturnType(sym: Symbol) = sym.tpe match {
+      case NullaryMethodType(restpe) if restpe.typeSymbol == UnitClass =>
+        // this may be the implementation of e.g. a generic method being parameterized
+        // on Unit, in which case we had better let it slide.
+        val isOk = (
+             sym.isGetter
+          || (sym.name containsName nme.DEFAULT_GETTER_STRING)
+          || sym.allOverriddenSymbols.exists(over => !(over.tpe.resultType =:= sym.tpe.resultType))
+        )
+        if (!isOk)
+          unit.warning(sym.pos, s"side-effecting nullary methods are discouraged: suggest defining as `def ${sym.name.decode}()` instead")
+      case _ => ()
+    }
+
+    /* Convert a reference to a case factory of type `tpe` to a new of the class it produces. */
+    def toConstructor(pos: Position, tpe: Type)(using Context): Tree = {
+      val rtpe = tpe.finalResultType
+      assert(rtpe.typeSymbol.is(Case), tpe)
+      New(rtpe).withPos(pos).select(rtpe.typeSymbol.primaryConstructor)
+    }
+    private def isIrrefutable(pat: Tree, seltpe: Type): Boolean = pat match {
+      case Apply(_, args) =>
+        val clazz = pat.tpe.typeSymbol
+        clazz == seltpe.typeSymbol &&
+        clazz.isCaseClass &&
+        (args corresponds clazz.primaryConstructor.tpe.asSeenFrom(seltpe, clazz).paramTypes)(isIrrefutable)
+      case Typed(pat, tpt) =>
+        seltpe <:< tpt.tpe
+      case Ident(tpnme.WILDCARD) =>
+        true
+      case Bind(_, pat) =>
+        isIrrefutable(pat, seltpe)
+      case _ =>
+        false
+    }
+    private def checkDelayedInitSelect(qual: Tree, sym: Symbol, pos: Position) = {
+      def isLikelyUninitialized = (
+           (sym.owner isSubClass DelayedInitClass)
+        && !qual.tpe.isInstanceOf[ThisType]
+        && sym.accessedOrSelf.isVal
+      )
+      if (settings.lint.value && isLikelyUninitialized)
+        unit.warning(pos, s"Selecting ${sym} from ${sym.owner}, which extends scala.DelayedInit, is likely to yield an uninitialized value")
+    }
+    private def lessAccessible(otherSym: Symbol, memberSym: Symbol): Boolean = (
+         (otherSym != NoSymbol)
+      && !otherSym.isProtected
+      && !otherSym.isTypeParameterOrSkolem
+      && !otherSym.isExistentiallyBound
+      && (otherSym isLessAccessibleThan memberSym)
+      && (otherSym isLessAccessibleThan memberSym.enclClass)
+    )
+    private def lessAccessibleSymsInType(other: Type, memberSym: Symbol): List[Symbol] = {
+      val extras = other match {
+        case TypeRef(pre, _, args) =>
+          // checking the prefix here gives us spurious errors on e.g. a private[process]
+          // object which contains a type alias, which normalizes to a visible type.
+          args filterNot (_ eq NoPrefix) flatMap (tp => lessAccessibleSymsInType(tp, memberSym))
+        case _ =>
+          Nil
+      }
+      if (lessAccessible(other.typeSymbol, memberSym)) other.typeSymbol :: extras
+      else extras
+    }
+    private def warnLessAccessible(otherSym: Symbol, memberSym: Symbol) {
+      val comparison = accessFlagsToString(memberSym) match {
+        case ""   => ""
+        case acc  => " is " + acc + " but"
+      }
+      val cannot =
+        if (memberSym.isDeferred) "may be unable to provide a concrete implementation of"
+        else "may be unable to override"
+
+      unit.warning(memberSym.pos,
+        "%s%s references %s %s.".format(
+          memberSym.fullLocationString, comparison,
+          accessFlagsToString(otherSym), otherSym
+        ) + "\nClasses which cannot access %s %s %s.".format(
+          otherSym.decodedName, cannot, memberSym.decodedName)
+      )
+    }
+
+    /** Warn about situations where a method signature will include a type which
+     *  has more restrictive access than the method itself.
+     */
+    private def checkAccessibilityOfReferencedTypes(tree: Tree) {
+      val member = tree.symbol
+
+      def checkAccessibilityOfType(tpe: Type) {
+        val inaccessible = lessAccessibleSymsInType(tpe, member)
+        // if the unnormalized type is accessible, that's good enough
+        if (inaccessible.isEmpty) ()
+        // or if the normalized type is, that's good too
+        else if ((tpe ne tpe.normalize) && lessAccessibleSymsInType(tpe.dealiasWiden, member).isEmpty) ()
+        // otherwise warn about the inaccessible syms in the unnormalized type
+        else inaccessible foreach (sym => warnLessAccessible(sym, member))
+      }
+
+      // types of the value parameters
+      mapParamss(member)(p => checkAccessibilityOfType(p.tpe))
+      // upper bounds of type parameters
+      member.typeParams.map(_.info.bounds.hi.widen) foreach checkAccessibilityOfType
+    }
+
+    private def checkByNameRightAssociativeDef(tree: DefDef) {
+      tree match {
+        case DefDef(_, name, _, params :: _, _, _) =>
+          if (settings.lint && name.decodedName.isRightAssocOperatorName && params.exists(p => isByName(p.symbol)))
+            unit.warning(tree.pos,
+              "by-name parameters will be evaluated eagerly when called as a right-associative infix operator. For more details, see SI-1980.")
+        case _ =>
+      }
+    }
+    override def transform(tree: Tree)(using Context): Tree = {
+      //val savedLocalTyper = localTyper
+      try {
+        val sym = tree.symbol
+        checkOverloadedRestrictions(ctx.owner)
+            checkAllOverrides(ctx.owner)
+            checkAnyValSubclass(ctx.owner)
+            if (ctx.owner.isDerivedValueClass)
+              ctx.owner.primaryConstructor.makeNotPrivateAfter(NoSymbol, thisPhase) // SI-6601, must be done *after* pickler!
+            tree
+
+
+        // Apply RefChecks to annotations. Makes sure the annotations conform to
+        // type bounds (bug #935), issues deprecation warnings for symbols used
+        // inside annotations.
+        // applyRefchecksToAnnotations(tree) ???
+        var result: Tree = tree match {
+          case tree: ValOrDefDef =>
+            // move to lint:
+            // if (settings.warnNullaryUnit)
+            //  checkNullaryMethodReturnType(sym)
+            // if (settings.warnInaccessible) {
+            //  if (!sym.isConstructor && !sym.isEffectivelyFinal && !sym.isSynthetic)
+            //    checkAccessibilityOfReferencedTypes(tree)
+            // }
+            // tree match {
+            //  case dd: DefDef => checkByNameRightAssociativeDef(dd)
+            //  case _          =>
+            // }
+            tree
+
+          case Template(constr, parents, self, body) =>
+            // localTyper = localTyper.atOwner(tree, currentOwner)
+            checkOverloadedRestrictions(ctx.owner)
+            checkAllOverrides(ctx.owner)
+            checkAnyValSubclass(ctx.owner)
+            if (ctx.owner.isDerivedValueClass)
+              ctx.owner.primaryConstructor.makeNotPrivateAfter(NoSymbol, thisPhase) // SI-6601, must be done *after* pickler!
+            tree
+
+          case tpt: TypeTree =>
+            transform(tpt.original)
+            tree
+
+          case TypeApply(fn, args) =>
+            checkBounds(tree, NoPrefix, NoSymbol, fn.tpe.typeParams, args map (_.tpe))
+            transformCaseApply(tree, ())
+
+          case x @ Apply(_, _)  =>
+            transformApply(x)
+
+          case x @ If(_, _, _)  =>
+            transformIf(x)
+
+          case New(tpt) =>
+            enterReference(tree.pos, tpt.tpe.typeSymbol)
+            tree
+
+          case treeInfo.WildcardStarArg(_) if !isRepeatedParamArg(tree) =>
+            unit.error(tree.pos, "no `: _*` annotation allowed here\n" +
+              "(such annotations are only allowed in arguments to *-parameters)")
+            tree
+
+          case Ident(name) =>
+            checkUndesiredProperties(sym, tree.pos)
+            transformCaseApply(tree,
+              if (name != nme.WILDCARD && name != tpnme.WILDCARD_STAR) {
+                assert(sym != NoSymbol, "transformCaseApply: name = " + name.debugString + " tree = " + tree + " / " + tree.getClass) //debug
+                enterReference(tree.pos, sym)
+              }
+            )
+
+          case x @ Select(_, _) =>
+            transformSelect(x)
+
+          case UnApply(fun, args) =>
+            transform(fun) // just make sure we enterReference for unapply symbols, note that super.transform(tree) would not transform(fun)
+                           // transformTrees(args) // TODO: is this necessary? could there be forward references in the args??
+                           // probably not, until we allow parameterised extractors
+            tree
+
+
+          case _ => tree
+        }
+
+        // skip refchecks in patterns....
+        result = result match {
+          case CaseDef(pat, guard, body) =>
+            val pat1 = savingInPattern {
+              inPattern = true
+              transform(pat)
+            }
+            treeCopy.CaseDef(tree, pat1, transform(guard), transform(body))
+          case LabelDef(_, _, _) if treeInfo.hasSynthCaseSymbol(result) =>
+            savingInPattern {
+              inPattern = true
+              deriveLabelDef(result)(transform)
+            }
+          case Apply(fun, args) if fun.symbol.isLabel && treeInfo.isSynthCaseSymbol(fun.symbol) =>
+            savingInPattern {
+              // SI-7756 If we were in a translated pattern, we can now switch out of pattern mode, as the label apply signals
+              //         that we are in the user-supplied code in the case body.
+              //
+              //         Relies on the translation of:
+              //            (null: Any) match { case x: List[?] => x; x.reverse; case _ => }'
+              //         to:
+              //            <synthetic> val x2: List[?] = (x1.asInstanceOf[List[?]]: List[?]);
+              //                  matchEnd4({ x2; x2.reverse}) // case body is an argument to a label apply.
+              inPattern = false
+              super.transform(result)
+            }
+          case ValDef(_, _, _, _) if treeInfo.hasSynthCaseSymbol(result) =>
+            deriveValDef(result)(transform) // SI-7716 Don't refcheck the tpt of the synthetic val that holds the selector.
+          case _ =>
+            super.transform(result)
+        }
+        result match {
+          case ClassDef(_, _, _, _)
+             | TypeDef(_, _, _, _) =>
+            if (result.symbol.isLocalToBlock || result.symbol.isTopLevel)
+              varianceValidator.traverse(result)
+          case tt @ TypeTree() if tt.original != null =>
+            varianceValidator.traverse(tt.original) // See SI-7872
+          case _ =>
+        }
+
+        checkUnexpandedMacro(result)
+
+        result
+      } catch {
+        case ex: TypeError =>
+          if (settings.debug) ex.printStackTrace()
+          unit.error(tree.pos, ex.toMessage)
+          tree
+      } finally {
+        localTyper = savedLocalTyper
+        currentApplication = savedCurrentApplication
+      }
+    }
+*/
diff --git a/tests/pos-with-compiler-cc/dotc/typer/Synthesizer.scala b/tests/pos-with-compiler-cc/dotc/typer/Synthesizer.scala
new file mode 100644
index 000000000000..b96d80345bc3
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/typer/Synthesizer.scala
@@ -0,0 +1,762 @@
+package dotty.tools
+package dotc
+package typer
+
+import core._
+import util.Spans.Span
+import Contexts._
+import Types._, Flags._, Symbols._, Names._, StdNames._, Constants._
+import TypeErasure.{erasure, hasStableErasure}
+import Decorators._
+import ProtoTypes._
+import Inferencing.{fullyDefinedType, isFullyDefined}
+import ast.untpd
+import transform.SymUtils._
+import transform.TypeUtils._
+import transform.SyntheticMembers._
+import util.Property
+import ast.Trees.genericEmptyTree
+import annotation.{tailrec, constructorOnly}
+import ast.tpd._
+import Synthesizer._
+import language.experimental.pureFunctions
+
+/** Synthesize terms for special classes */
+class Synthesizer(typer: Typer)(using @constructorOnly c: Context):
+
+  /** Handlers to synthesize implicits for special types */
+  type SpecialHandler = (Type, Span) -> Context ?-> TreeWithErrors
+  private type SpecialHandlers = List[(ClassSymbol, SpecialHandler)]
+
+  val synthesizedClassTag: SpecialHandler = (formal, span) =>
+    val tag = formal.argInfos match
+      case arg :: Nil if isFullyDefined(arg, ForceDegree.all) =>
+        arg match
+          case defn.ArrayOf(elemTp) =>
+            val etag = typer.inferImplicitArg(defn.ClassTagClass.typeRef.appliedTo(elemTp), span)
+            if etag.tpe.isError then EmptyTree else etag.select(nme.wrap)
+          case tp if hasStableErasure(tp) && !defn.isBottomClassAfterErasure(tp.typeSymbol) =>
+            val sym = tp.typeSymbol
+            val classTagModul = ref(defn.ClassTagModule)
+            if defn.SpecialClassTagClasses.contains(sym) then
+              classTagModul.select(sym.name.toTermName).withSpan(span)
+            else
+              def clsOfType(tp: Type): Type = tp.dealias.underlyingMatchType match
+                case matchTp: MatchType =>
+                  matchTp.alternatives.map(clsOfType) match
+                    case ct1 :: cts if cts.forall(ct1 == _) => ct1
+                    case _ => NoType
+                case _ =>
+                  escapeJavaArray(erasure(tp))
+              val ctype = clsOfType(tp)
+              if ctype.exists then
+                classTagModul.select(nme.apply)
+                  .appliedToType(tp)
+                  .appliedTo(clsOf(ctype))
+                  .withSpan(span)
+              else EmptyTree
+          case _ => EmptyTree
+      case _ => EmptyTree
+    (tag, Nil)
+  end synthesizedClassTag
+
+  val synthesizedTypeTest: SpecialHandler =
+    (formal, span) => formal.argInfos match {
+      case arg1 :: arg2 :: Nil if !defn.isBottomClass(arg2.typeSymbol) =>
+        val srcPos = ctx.source.atSpan(span)
+        val tp1 = fullyDefinedType(arg1, "TypeTest argument", srcPos)
+        val tp2 = fullyDefinedType(arg2, "TypeTest argument", srcPos).normalized
+        val sym2 = tp2.typeSymbol
+        if tp1 <:< tp2 then
+          // optimization when we know the typetest will always succeed
+          withNoErrors(ref(defn.TypeTestModule_identity).appliedToType(tp2).withSpan(span))
+        else if sym2 == defn.AnyValClass || sym2 == defn.AnyRefAlias || sym2 == defn.ObjectClass then
+          EmptyTreeNoError
+        else
+          // Generate SAM: (s: <tp1>) => if s.isInstanceOf[<tp2>] then Some(s.asInstanceOf[s.type & <tp2>]) else None
+          def body(args: List[Tree]): Tree = {
+            val arg :: Nil = args: @unchecked
+            val t = arg.tpe & tp2
+            If(
+              arg.isInstance(tp2),
+              ref(defn.SomeClass.companionModule.termRef).select(nme.apply)
+                .appliedToType(t)
+                .appliedTo(arg.select(nme.asInstanceOf_).appliedToType(t)),
+              ref(defn.NoneModule))
+          }
+          val tpe = MethodType(List(nme.s))(_ => List(tp1), mth => defn.OptionClass.typeRef.appliedTo(mth.newParamRef(0) & tp2))
+          val meth = newAnonFun(ctx.owner, tpe, coord = span)
+          val typeTestType = defn.TypeTestClass.typeRef.appliedTo(List(tp1, tp2))
+          withNoErrors(Closure(meth, tss => body(tss.head).changeOwner(ctx.owner, meth), targetType = typeTestType).withSpan(span))
+      case _ =>
+        EmptyTreeNoError
+    }
+  end synthesizedTypeTest
+
+  val synthesizedTupleFunction: SpecialHandler = (formal, span) =>
+    formal match
+      case AppliedType(_, funArgs @ fun :: tupled :: Nil) =>
+        def functionTypeEqual(baseFun: Type, actualArgs: List[Type],
+            actualRet: Type, expected: Type) =
+          expected =:= defn.FunctionOf(actualArgs, actualRet,
+            defn.isContextFunctionType(baseFun), defn.isErasedFunctionType(baseFun))
+        val arity: Int =
+          if defn.isErasedFunctionType(fun) || defn.isErasedFunctionType(fun) then -1 // TODO support?
+          else if defn.isFunctionType(fun) then
+            // TupledFunction[(...) => R, ?]
+            fun.dropDependentRefinement.dealias.argInfos match
+              case funArgs :+ funRet
+              if functionTypeEqual(fun, defn.tupleType(funArgs) :: Nil, funRet, tupled) =>
+                // TupledFunction[(...funArgs...) => funRet, ?]
+                funArgs.size
+              case _ => -1
+          else if defn.isFunctionType(tupled) then
+            // TupledFunction[?, (...) => R]
+            tupled.dropDependentRefinement.dealias.argInfos match
+              case tupledArgs :: funRet :: Nil =>
+                defn.tupleTypes(tupledArgs.dealias) match
+                  case Some(funArgs) if functionTypeEqual(tupled, funArgs, funRet, fun) =>
+                    // TupledFunction[?, ((...funArgs...)) => funRet]
+                    funArgs.size
+                  case _ => -1
+              case _ => -1
+          else
+            // TupledFunction[?, ?]
+            -1
+        if arity == -1 then
+          EmptyTreeNoError
+        else if arity <= Definitions.MaxImplementedFunctionArity then
+          withNoErrors(ref(defn.RuntimeTupleFunctionsModule)
+            .select(s"tupledFunction$arity".toTermName)
+            .appliedToTypes(funArgs))
+        else
+          withNoErrors(ref(defn.RuntimeTupleFunctionsModule)
+            .select("tupledFunctionXXL".toTermName)
+            .appliedToTypes(funArgs))
+      case _ =>
+        EmptyTreeNoError
+  end synthesizedTupleFunction
+
+  /** If `formal` is of the form CanEqual[T, U], try to synthesize an
+    *  `CanEqual.canEqualAny[T, U]` as solution.
+    */
+  val synthesizedCanEqual: SpecialHandler = (formal, span) =>
+
+    /** Is there an `CanEqual[T, T]` instance, assuming -strictEquality? */
+    def hasEq(tp: Type)(using Context): Boolean =
+      val inst = typer.inferImplicitArg(defn.CanEqualClass.typeRef.appliedTo(tp, tp), span)
+      !inst.isEmpty && !inst.tpe.isError
+
+    /** Can we assume the canEqualAny instance for `tp1`, `tp2`?
+      *  This is the case if assumedCanEqual(tp1, tp2), or
+      *  one of `tp1`, `tp2` has a reflexive `CanEqual` instance.
+      */
+    def validEqAnyArgs(tp1: Type, tp2: Type)(using Context) =
+      typer.assumedCanEqual(tp1, tp2)
+       || withMode(Mode.StrictEquality) {
+            !hasEq(tp1) && !hasEq(tp2)
+          }
+
+    /** Is an `CanEqual[cls1, cls2]` instance assumed for predefined classes `cls1`, cls2`? */
+    def canComparePredefinedClasses(cls1: ClassSymbol, cls2: ClassSymbol): Boolean =
+
+      def cmpWithBoxed(cls1: ClassSymbol, cls2: ClassSymbol) =
+        cls2 == defn.NothingClass
+        || cls2 == defn.boxedType(cls1.typeRef).symbol
+        || cls1.isNumericValueClass && cls2.derivesFrom(defn.BoxedNumberClass)
+
+      if cls1.isPrimitiveValueClass then
+        if cls2.isPrimitiveValueClass then
+          cls1 == cls2 || cls1.isNumericValueClass && cls2.isNumericValueClass
+        else
+          cmpWithBoxed(cls1, cls2)
+      else if cls2.isPrimitiveValueClass then
+        cmpWithBoxed(cls2, cls1)
+      else if ctx.mode.is(Mode.SafeNulls) then
+        // If explicit nulls is enabled, and unsafeNulls is not enabled,
+        // we want to disallow comparison between Object and Null.
+        // If we have to check whether a variable with a non-nullable type has null value
+        // (for example, a NotNull java method returns null for some reasons),
+        // we can still cast it to a nullable type then compare its value.
+        //
+        // Example:
+        // val x: String = null.asInstanceOf[String]
+        // if (x == null) {} // error: x is non-nullable
+        // if (x.asInstanceOf[String|Null] == null) {} // ok
+        cls1 == defn.NullClass && cls1 == cls2
+      else if cls1 == defn.NullClass then
+        cls1 == cls2 || cls2.derivesFrom(defn.ObjectClass)
+      else if cls2 == defn.NullClass then
+        cls1.derivesFrom(defn.ObjectClass)
+      else
+        cls1 == defn.NothingClass || cls2 == defn.NothingClass
+    end canComparePredefinedClasses
+
+    /** Some simulated `CanEqual` instances for predefined types. It's more efficient
+      *  to do this directly instead of setting up a lot of `CanEqual` instances to
+      *  interpret.
+      */
+    def canComparePredefined(tp1: Type, tp2: Type) =
+      tp1.classSymbols.exists(cls1 =>
+        tp2.classSymbols.exists(cls2 =>
+          canComparePredefinedClasses(cls1, cls2)))
+
+    formal.argTypes match
+      case args @ (arg1 :: arg2 :: Nil) =>
+        List(arg1, arg2).foreach(fullyDefinedType(_, "eq argument", ctx.source.atSpan(span)))
+        if canComparePredefined(arg1, arg2)
+            || !Implicits.strictEquality && explore(validEqAnyArgs(arg1, arg2))
+        then withNoErrors(ref(defn.CanEqual_canEqualAny).appliedToTypes(args).withSpan(span))
+        else EmptyTreeNoError
+      case _ => EmptyTreeNoError
+  end synthesizedCanEqual
+
+  /** Creates a tree that will produce a ValueOf instance for the requested type.
+   * An EmptyTreeNoError is returned if materialization fails.
+   */
+  val synthesizedValueOf: SpecialHandler = (formal, span) =>
+
+    def success(t: Tree) =
+      New(defn.ValueOfClass.typeRef.appliedTo(t.tpe), t :: Nil).withSpan(span)
+    formal.argInfos match
+      case arg :: Nil =>
+        fullyDefinedType(arg, "ValueOf argument", ctx.source.atSpan(span)).normalized.dealias match
+          case ConstantType(c: Constant) =>
+            withNoErrors(success(Literal(c)))
+          case tp: TypeRef if tp.isRef(defn.UnitClass) =>
+            withNoErrors(success(Literal(Constant(()))))
+          case n: TermRef =>
+            withNoErrors(success(ref(n)))
+          case tp =>
+            EmptyTreeNoError
+      case _ =>
+        EmptyTreeNoError
+  end synthesizedValueOf
+
+  /** Create an anonymous class `new Object { type MirroredMonoType = ... }`
+   *  and mark it with given attachment so that it is made into a mirror at PostTyper.
+   */
+  private def anonymousMirror(monoType: Type, impl: MirrorImpl, span: Span)(using Context) =
+    if ctx.isAfterTyper then ctx.compilationUnit.needsMirrorSupport = true
+    val monoTypeDef = untpd.TypeDef(tpnme.MirroredMonoType, untpd.TypeTree(monoType))
+    val newImpl = untpd.Template(
+      constr = untpd.emptyConstructor,
+      parents = untpd.TypeTree(defn.ObjectType) :: untpd.TypeTree(defn.JavaSerializableClass.typeRef) :: Nil,
+      derived = Nil,
+      self = EmptyValDef,
+      body = monoTypeDef :: Nil
+    ).withAttachment(ExtendsSumOrProductMirror, impl)
+    typer.typed(untpd.New(newImpl).withSpan(span))
+
+  /** The mirror type
+   *
+   *     <parent> {
+   *       MirroredMonoType = <monoType>
+   *       MirroredType = <mirroredType>
+   *       MirroredLabel = <label>
+   *     }
+   */
+  private def mirrorCore(parentClass: ClassSymbol, monoType: Type, mirroredType: Type, label: Name)(using Context) =
+    parentClass.typeRef
+      .refinedWith(tpnme.MirroredMonoType, TypeAlias(monoType))
+      .refinedWith(tpnme.MirroredType, TypeAlias(mirroredType))
+      .refinedWith(tpnme.MirroredLabel, TypeAlias(ConstantType(Constant(label.toString))))
+
+  /** A path referencing the companion of class type `clsType` */
+  private def companionPath(clsType: Type, span: Span)(using Context) =
+    val ref = pathFor(clsType.mirrorCompanionRef)
+    assert(ref.symbol.is(Module) && (clsType.classSymbol.is(ModuleClass) || (ref.symbol.companionClass == clsType.classSymbol)))
+    ref.withSpan(span)
+
+  private def checkFormal(formal: Type)(using Context): Boolean =
+    @tailrec
+    def loop(tp: Type): Boolean = tp match
+      case RefinedType(parent, _, _: TypeBounds) => loop(parent)
+      case RefinedType(_, _, _) => false
+      case _ => true
+    loop(formal)
+
+  private def checkRefinement(formal: Type, name: TypeName, expected: Type, span: Span)(using Context): Unit =
+    val actual = formal.lookupRefined(name)
+    if actual.exists && !(expected =:= actual)
+    then report.error(
+      em"$name mismatch, expected: $expected, found: $actual.", ctx.source.atSpan(span))
+
+  extension (formal: Type)
+    /** `tp := op; tp <:< formal; formal & tp` */
+    private def constrained_&(op: Context ?=> Type)(using Context): Type =
+      val tp = op
+      tp <:< formal
+      formal & tp
+
+  private def mkMirroredMonoType(mirroredType: HKTypeLambda)(using Context): Type =
+    val monoMap = new TypeMap:
+      def apply(t: Type) = t match
+        case TypeParamRef(lambda, n) if lambda eq mirroredType => mirroredType.paramInfos(n)
+        case t => mapOver(t)
+    monoMap(mirroredType.resultType)
+
+  private[Synthesizer] enum MirrorSource:
+    case ClassSymbol(pre: Type, cls: Symbol)
+    case Singleton(src: Symbol, tref: TermRef)
+    case GenericTuple(tps: List[Type])
+
+    /** Tests that both sides are tuples of the same arity */
+    infix def sameTuple(that: MirrorSource)(using Context): Boolean =
+      def arity(msrc: MirrorSource): Int = msrc match
+        case GenericTuple(tps) => tps.size
+        case ClassSymbol(_, cls) if defn.isTupleClass(cls) => cls.typeParams.size // tested in tests/pos/i13859.scala
+        case _ => -1
+      def equivalent(n: Int, m: Int) =
+        n == m && n > 0
+      equivalent(arity(this), arity(that))
+
+    /** A comparison that chooses the most specific MirrorSource, this is guided by what is necessary for
+     * `Mirror.Product.fromProduct`. i.e. its result type should be compatible with the erasure of `mirroredType`.
+     */
+    def isSub(that: MirrorSource)(using Context): Boolean =
+      (this, that) match
+        case (Singleton(src, _), ClassSymbol(_, cls)) => src.info.classSymbol.isSubClass(cls)
+        case (ClassSymbol(_, cls1), ClassSymbol(_, cls2)) => cls1.isSubClass(cls2)
+        case (Singleton(src1, _), Singleton(src2, _)) => src1 eq src2
+        case (_: ClassSymbol, _: Singleton) => false
+        case _ => this sameTuple that
+
+    def show(using Context): String = this match
+      case ClassSymbol(_, cls) => i"$cls"
+      case Singleton(src, _) => i"$src"
+      case GenericTuple(tps) =>
+        val arity = tps.size
+        if arity <= Definitions.MaxTupleArity then s"class Tuple$arity"
+        else s"trait Tuple { def size: $arity }"
+
+  private[Synthesizer] object MirrorSource:
+
+    /** Reduces a mirroredType to either its most specific ClassSymbol,
+     *  or a TermRef to a singleton value. These are
+     *  the base elements required to generate a mirror.
+     */
+    def reduce(mirroredType: Type)(using Context): Either[String, MirrorSource] = mirroredType match
+      case tp: TypeRef =>
+        val sym = tp.symbol
+        if sym.isClass then // direct ref to a class, not an alias
+          if sym.isAllOf(Case | Module) then
+            // correct widened module ref. Tested in tests/run/i15234.scala
+            val singleton = sym.sourceModule
+            Right(MirrorSource.Singleton(singleton, TermRef(tp.prefix, singleton)))
+          else
+            Right(MirrorSource.ClassSymbol(tp.prefix, sym))
+        else
+          reduce(tp.superType)
+      case tp: TermRef =>
+        /** Dealias a path type to extract the underlying definition when it is either
+         *  a singleton enum case or a case object.
+         */
+        def reduceToEnumOrCaseObject(tp: Type)(using Context): Symbol = tp match
+          case tp: TermRef =>
+            val sym = tp.termSymbol
+            if sym.isEnumCase || (sym.isClass && sym.isAllOf(Case | Module)) then sym
+            else if sym.exists && !tp.isOverloaded then reduceToEnumOrCaseObject(tp.underlying.widenExpr)
+            else NoSymbol
+          case _ => NoSymbol
+
+        // capture enum singleton types. Tested in tests/run/i15234.scala
+        val singleton = reduceToEnumOrCaseObject(tp)
+        if singleton.exists then
+          Right(MirrorSource.Singleton(singleton, tp))
+        else
+          reduce(tp.underlying)
+      case tp: HKTypeLambda if tp.resultType.isInstanceOf[HKTypeLambda] =>
+        Left(i"its subpart `$tp` is not a supported kind (either `*` or `* -> *`)")
+      case tp: TypeProxy =>
+        tp match
+          case tp @ AppliedType(tref: TypeRef, _) if tref.symbol == defn.PairClass =>
+            tp.tupleElementTypes match
+              case Some(types) =>
+                // avoid type aliases for tuples
+                Right(MirrorSource.GenericTuple(types))
+              case _ => reduce(tp.underlying)
+          case _ => reduce(tp.superType)
+      case tp @ AndType(l, r) =>
+        for
+          lsrc <- reduce(l)
+          rsrc <- reduce(r)
+          res <- locally {
+            if lsrc.isSub(rsrc) then Right(lsrc)
+            else if rsrc.isSub(lsrc) then Right(rsrc)
+            else Left(i"its subpart `$tp` is an intersection of unrelated definitions ${lsrc.show} and ${rsrc.show}.")
+          }
+        yield
+          res
+      case tp: OrType =>
+        Left(i"its subpart `$tp` is a top-level union type.")
+      case tp =>
+        Left(i"its subpart `$tp` is an unsupported type.")
+
+  end MirrorSource
+
+  private def productMirror(mirroredType: Type, formal: Type, span: Span)(using Context): TreeWithErrors =
+
+    /** `new scala.runtime.TupleMirror(arity)`
+     *  using TupleMirror avoids generating anonymous classes for tuple mirrors.
+     */
+    def newTupleMirror(arity: Int): Tree =
+      New(defn.RuntimeTupleMirrorTypeRef, Literal(Constant(arity)) :: Nil)
+
+    def makeProductMirror(pre: Type, cls: Symbol, tps: Option[List[Type]]): TreeWithErrors =
+      val accessors = cls.caseAccessors.filterNot(_.isAllOf(PrivateLocal))
+      val elemLabels = accessors.map(acc => ConstantType(Constant(acc.name.toString)))
+      val typeElems = tps.getOrElse(accessors.map(mirroredType.resultType.memberInfo(_).widenExpr))
+      val nestedPairs = TypeOps.nestedPairs(typeElems)
+      val (monoType, elemsType) = mirroredType match
+        case mirroredType: HKTypeLambda =>
+          (mkMirroredMonoType(mirroredType), mirroredType.derivedLambdaType(resType = nestedPairs))
+        case _ =>
+          (mirroredType, nestedPairs)
+      val elemsLabels = TypeOps.nestedPairs(elemLabels)
+      checkRefinement(formal, tpnme.MirroredElemTypes, elemsType, span)
+      checkRefinement(formal, tpnme.MirroredElemLabels, elemsLabels, span)
+      val mirrorType = formal.constrained_& {
+        mirrorCore(defn.Mirror_ProductClass, monoType, mirroredType, cls.name)
+          .refinedWith(tpnme.MirroredElemTypes, TypeAlias(elemsType))
+          .refinedWith(tpnme.MirroredElemLabels, TypeAlias(elemsLabels))
+      }
+      val mirrorRef =
+        if cls.useCompanionAsProductMirror then companionPath(mirroredType, span)
+        else if defn.isTupleClass(cls) then newTupleMirror(typeElems.size) // TODO: cls == defn.PairClass when > 22
+        else anonymousMirror(monoType, MirrorImpl.OfProduct(pre), span)
+      withNoErrors(mirrorRef.cast(mirrorType))
+    end makeProductMirror
+
+    MirrorSource.reduce(mirroredType) match
+      case Right(msrc) => msrc match
+        case MirrorSource.Singleton(_, tref) =>
+          val singleton = tref.termSymbol // prefer alias name over the orignal name
+          val singletonPath = pathFor(tref).withSpan(span)
+          if tref.classSymbol.is(Scala2x) then // could be Scala 3 alias of Scala 2 case object.
+            val mirrorType = formal.constrained_& {
+              mirrorCore(defn.Mirror_SingletonProxyClass, mirroredType, mirroredType, singleton.name)
+            }
+            val mirrorRef = New(defn.Mirror_SingletonProxyClass.typeRef, singletonPath :: Nil)
+            withNoErrors(mirrorRef.cast(mirrorType))
+          else
+            val mirrorType = formal.constrained_& {
+              mirrorCore(defn.Mirror_SingletonClass, mirroredType, mirroredType, singleton.name)
+            }
+            withNoErrors(singletonPath.cast(mirrorType))
+        case MirrorSource.GenericTuple(tps) =>
+          val maxArity = Definitions.MaxTupleArity
+          val arity = tps.size
+          if tps.size <= maxArity then
+            val tupleCls = defn.TupleType(arity).nn.classSymbol
+            makeProductMirror(tupleCls.owner.reachableThisType, tupleCls, Some(tps))
+          else
+            val reason = s"it reduces to a tuple with arity $arity, expected arity <= $maxArity"
+            withErrors(i"${defn.PairClass} is not a generic product because $reason")
+        case MirrorSource.ClassSymbol(pre, cls) =>
+          if cls.isGenericProduct then makeProductMirror(pre, cls, None)
+          else withErrors(i"$cls is not a generic product because ${cls.whyNotGenericProduct}")
+      case Left(msg) =>
+        withErrors(i"type `$mirroredType` is not a generic product because $msg")
+  end productMirror
+
+  private def sumMirror(mirroredType: Type, formal: Type, span: Span)(using Context): TreeWithErrors =
+
+    val (acceptableMsg, pre, cls) = MirrorSource.reduce(mirroredType) match
+      case Right(MirrorSource.Singleton(_, tp)) => (i"its subpart `$tp` is a term reference", NoType, NoSymbol)
+      case Right(MirrorSource.ClassSymbol(pre, cls)) => ("", pre, cls)
+      case Right(MirrorSource.GenericTuple(tps)) =>
+        val arity = tps.size
+        val cls = if arity <= Definitions.MaxTupleArity then defn.TupleType(arity).nn.classSymbol else defn.PairClass
+        ("", NoType, cls)
+      case Left(msg) => (msg, NoType, NoSymbol)
+
+    val clsIsGenericSum = cls.isGenericSum(pre)
+
+    if acceptableMsg.isEmpty && clsIsGenericSum then
+      val elemLabels = cls.children.map(c => ConstantType(Constant(c.name.toString)))
+
+      def internalError(msg: -> String)(using Context): Unit =
+        report.error(i"""Internal error when synthesizing sum mirror for $cls:
+                        |$msg""".stripMargin, ctx.source.atSpan(span))
+
+      def childPrefix(child: Symbol)(using Context): Type =
+        val symPre = TypeOps.childPrefix(pre, cls, child)
+        if !symPre.exists then
+          internalError(i"unable to refine child prefix for $child from $pre")
+        symPre
+
+      def refineAtPrefix(childPre: Type, child: Symbol, original: Type): Type =
+        if childPre.exists then original.asSeenFrom(childPre, child.owner) else original
+
+      def solve(childPre: Type, child: Symbol): Type = child match
+        case childClass: ClassSymbol =>
+          assert(childClass.isOneOf(Case | Sealed))
+          if childClass.is(Module) then
+            val module = childClass.sourceModule
+            refineAtPrefix(childPre, module, module.termRef)
+          else
+            refineAtPrefix(childPre, childClass, childClass.primaryConstructor.info) match
+              case info: PolyType =>
+                // Compute the the full child type by solving the subtype constraint
+                // `C[X1, ..., Xn] <: P`, where
+                //
+                //   - P is the current `mirroredType`
+                //   - C is the child class, with type parameters X1, ..., Xn
+                //
+                // Contravariant type parameters are minimized, all other type parameters are maximized.
+                def instantiate(using Context) =
+                  val poly = constrained(info, untpd.EmptyTree)._1
+                  val resType = poly.finalResultType
+                  val target = mirroredType match
+                    case tp: HKTypeLambda => tp.resultType
+                    case tp => tp
+                  resType <:< target
+                  val tparams = poly.paramRefs
+                  val variances = childClass.typeParams.map(_.paramVarianceSign)
+                  val instanceTypes = tparams.lazyZip(variances).map((tparam, variance) =>
+                    TypeComparer.instanceType(tparam, fromBelow = variance < 0, widenUnions = true)
+                  )
+                  val instanceType = resType.substParams(poly, instanceTypes)
+                  // this is broken in tests/run/i13332intersection.scala,
+                  // because type parameters are not correctly inferred.
+                  instanceType
+                end instantiate
+                instantiate(using ctx.fresh.setExploreTyperState().setOwner(childClass))
+              case methTpe =>
+                methTpe.finalResultType
+        case child => refineAtPrefix(childPre, child, child.termRef)
+      end solve
+
+      val (childPres, childTypes) = cls.children.map(c =>
+        val childPre = childPrefix(c)
+        childPre -> solve(childPre, c)
+      ).unzip
+
+      val (monoType, elemsType) = mirroredType match
+        case mirroredType: HKTypeLambda =>
+          val elems = mirroredType.derivedLambdaType(
+            resType = TypeOps.nestedPairs(childTypes)
+          )
+          (mkMirroredMonoType(mirroredType), elems)
+        case _ =>
+          val elems = TypeOps.nestedPairs(childTypes)
+          (mirroredType, elems)
+
+      val mirrorType =
+        val labels = TypeOps.nestedPairs(elemLabels)
+        formal.constrained_& {
+          mirrorCore(defn.Mirror_SumClass, monoType, mirroredType, cls.name)
+            .refinedWith(tpnme.MirroredElemTypes, TypeAlias(elemsType))
+            .refinedWith(tpnme.MirroredElemLabels, TypeAlias(labels))
+        }
+      val mirrorRef =
+        if cls.useCompanionAsSumMirror then companionPath(mirroredType, span)
+        else anonymousMirror(monoType, MirrorImpl.OfSum(childPres), span)
+      withNoErrors(mirrorRef.cast(mirrorType))
+    else if acceptableMsg.nonEmpty then
+      withErrors(i"type `$mirroredType` is not a generic sum because $acceptableMsg")
+    else if !clsIsGenericSum then
+      withErrors(i"$cls is not a generic sum because ${cls.whyNotGenericSum(pre)}")
+      else
+      EmptyTreeNoError
+  end sumMirror
+
+  def makeMirror
+      (synth: (Type, Type, Span) => Context ?=> TreeWithErrors, formal: Type, span: Span)
+      (using Context): TreeWithErrors =
+    if checkFormal(formal) then
+      formal.member(tpnme.MirroredType).info match
+        case TypeBounds(mirroredType, _) =>
+          val defined = fullyDefinedType(mirroredType, "Mirror.*Of argument", ctx.source.atSpan(span))
+          val stripped = TypeOps.stripTypeVars(defined)
+          synth(stripped, formal, span)
+        case other => EmptyTreeNoError
+    else EmptyTreeNoError
+
+  /** An implied instance for a type of the form `Mirror.Product { type MirroredType = T }`
+   *  where `T` is a generic product type or a case object or an enum case.
+   */
+  val synthesizedProductMirror: SpecialHandler = (formal, span) =>
+    makeMirror(productMirror, formal, span)
+
+  /** An implied instance for a type of the form `Mirror.Sum { type MirroredType = T }`
+   *  where `T` is a generic sum type.
+   */
+  val synthesizedSumMirror: SpecialHandler = (formal, span) =>
+    makeMirror(sumMirror, formal, span)
+
+  /** An implied instance for a type of the form `Mirror { type MirroredType = T }`
+   *  where `T` is a generic sum or product or singleton type.
+   */
+  val synthesizedMirror: SpecialHandler = (formal, span) =>
+    orElse(synthesizedProductMirror(formal, span), synthesizedSumMirror(formal, span))
+
+  private def escapeJavaArray(tp: Type)(using Context): Type = tp match
+    case JavaArrayType(elemTp) => defn.ArrayOf(escapeJavaArray(elemTp))
+    case _                     => tp
+
+  private enum ManifestKind extends caps.Pure: // !cc! should all enums be Pure?
+    case Full, Opt, Clss
+
+    /** The kind that should be used for an array element, if we are `OptManifest` then this
+     *  prevents wildcards arguments of Arrays being converted to `NoManifest`
+     */
+    def arrayElem = if this == Full then this else Clss
+
+  end ManifestKind
+
+  /** Manifest factory that does enough to satisfy the equality semantics for
+   *  - `scala.reflect.OptManifest` (only runtime class is recorded)
+   *  - `scala.reflect.Manifest` (runtime class of arguments are recorded, with wildcard upper bounds wrapped)
+   *  however,`toString` may be different.
+   *
+   * There are some differences to `ClassTag`,
+   *  e.g. in Scala 2 `manifest[Int @unchecked]` will fail, but `classTag[Int @unchecked]` succeeds.
+   */
+  private def manifestFactoryOf(kind: ManifestKind): SpecialHandler = (formal, span) =>
+    import ManifestKind.*
+
+    /* Creates a tree that calls the factory method called constructor in object scala.reflect.Manifest */
+    def factoryManifest(constructor: TermName, tparg: Type, args: Tree*): Tree =
+      if args.contains(EmptyTree) then
+        EmptyTree
+      else
+        val factory = if kind == Full then defn.ManifestFactoryModule else defn.ClassManifestFactoryModule
+        applyOverloaded(ref(factory), constructor, args.toList, tparg :: Nil, Types.WildcardType).withSpan(span)
+
+    /* Creates a tree representing one of the singleton manifests.*/
+    def singletonManifest(name: TermName) =
+      ref(defn.ManifestFactoryModule).select(name).ensureApplied.withSpan(span)
+
+    def synthArrayManifest(elemTp: Type, kind: ManifestKind, topLevel: Boolean): Tree =
+      factoryManifest(nme.arrayType, elemTp, synthesize(elemTp, kind.arrayElem, topLevel))
+
+    /** manifests generated from wildcards can not equal Int,Long,Any,AnyRef,AnyVal etc,
+     *  so we wrap their upper bound.
+     */
+    def synthWildcardManifest(tp: Manifestable, hi: Type, topLevel: Boolean): Tree =
+      factoryManifest(nme.wildcardType, tp, singletonManifest(nme.Nothing), synthesize(hi, Full, topLevel))
+
+    /** `Nil` if not full manifest */
+    def synthArgManifests(tp: Manifestable): List[Tree] = tp match
+      case AppliedType(_, args) if kind == Full && tp.typeSymbol.isClass =>
+        args.map(synthesize(_, Full, topLevel = false))
+      case _ =>
+        Nil
+
+    /** This type contains all top-level types supported by Scala 2's algorithm */
+    type Manifestable =
+      ThisType | TermRef | ConstantType | TypeRef | AppliedType | TypeBounds | RecType | RefinedType | AndType
+
+    def canManifest(tp: Manifestable, topLevel: Boolean) =
+      val sym = tp.typeSymbol
+      !sym.isAbstractType
+      && hasStableErasure(tp)
+      && !(topLevel && defn.isBottomClassAfterErasure(sym))
+
+    /** adapted from `syntheticClassTag` */
+    def synthManifest(tp: Manifestable, kind: ManifestKind, topLevel: Boolean) = tp match
+      case defn.ArrayOf(elemTp)              => synthArrayManifest(elemTp, kind, topLevel)
+      case TypeBounds(_, hi) if kind == Full => synthWildcardManifest(tp, hi, topLevel)
+
+      case tp if canManifest(tp, topLevel) =>
+        val sym = tp.typeSymbol
+        if sym.isPrimitiveValueClass || defn.SpecialManifestClasses.contains(sym) then
+          singletonManifest(sym.name.toTermName)
+        else
+          erasure(tp) match
+            case JavaArrayType(elemTp) =>
+              synthArrayManifest(escapeJavaArray(elemTp), kind, topLevel)
+
+            case etp =>
+              val clsArg = clsOf(etp).asInstance(defn.ClassType(tp)) // cast needed to resolve overloading
+              factoryManifest(nme.classType, tp, (clsArg :: synthArgManifests(tp))*)
+
+      case _ =>
+        EmptyTree
+
+    end synthManifest
+
+    def manifestOfType(tp0: Type, kind: ManifestKind, topLevel: Boolean): Tree = tp0.dealiasKeepAnnots match
+      case tp1: Manifestable => synthManifest(tp1, kind, topLevel)
+      case tp1               => EmptyTree
+
+    def synthesize(tp: Type, kind: ManifestKind, topLevel: Boolean): Tree =
+      manifestOfType(tp, kind, topLevel) match
+        case EmptyTree if kind == Opt => ref(defn.NoManifestModule)
+        case result                   => result
+
+    formal.argInfos match
+      case arg :: Nil =>
+        val manifest = synthesize(fullyDefinedType(arg, "Manifest argument", ctx.source.atSpan(span)), kind, topLevel = true)
+        if manifest != EmptyTree then
+          report.deprecationWarning(
+            i"""Compiler synthesis of Manifest and OptManifest is deprecated, instead
+               |replace with the type `scala.reflect.ClassTag[$arg]`.
+               |Alternatively, consider using the new metaprogramming features of Scala 3,
+               |see https://docs.scala-lang.org/scala3/reference/metaprogramming.html""", ctx.source.atSpan(span))
+        withNoErrors(manifest)
+      case _ =>
+        EmptyTreeNoError
+
+  end manifestFactoryOf
+
+  val synthesizedManifest: SpecialHandler = manifestFactoryOf(ManifestKind.Full)
+  val synthesizedOptManifest: SpecialHandler = manifestFactoryOf(ManifestKind.Opt)
+
+  val specialHandlers = List(
+    defn.ClassTagClass        -> synthesizedClassTag,
+    defn.TypeTestClass        -> synthesizedTypeTest,
+    defn.CanEqualClass        -> synthesizedCanEqual,
+    defn.ValueOfClass         -> synthesizedValueOf,
+    defn.TupledFunctionClass  -> synthesizedTupleFunction,
+    defn.Mirror_ProductClass  -> synthesizedProductMirror,
+    defn.Mirror_SumClass      -> synthesizedSumMirror,
+    defn.MirrorClass          -> synthesizedMirror,
+    defn.ManifestClass        -> synthesizedManifest,
+    defn.OptManifestClass     -> synthesizedOptManifest,
+  )
+
+  def tryAll(formal: Type, span: Span)(using Context): TreeWithErrors =
+    def recur(handlers: SpecialHandlers): TreeWithErrors = handlers match
+      case (cls, handler) :: rest =>
+        def baseWithRefinements(tp: Type): Type = tp.dealias match
+          case tp @ RefinedType(parent, rname, rinfo) =>
+            tp.derivedRefinedType(baseWithRefinements(parent), rname, rinfo)
+          case _ =>
+            tp.baseType(cls)
+        val base = baseWithRefinements(formal)
+        val result =
+          if (base <:< formal.widenExpr)
+            // With the subtype test we enforce that the searched type `formal` is of the right form
+            handler(base, span)
+          else EmptyTreeNoError
+        orElse(result, recur(rest))
+      case Nil =>
+        EmptyTreeNoError
+    val result = recur(specialHandlers)
+    clearErrorsIfNotEmpty(result)
+
+end Synthesizer
+
+object Synthesizer:
+
+  /** Tuple used to store the synthesis result with a list of errors.  */
+  type TreeWithErrors = (Tree, List[String])
+  private def withNoErrors(tree: Tree): TreeWithErrors = (tree, List.empty)
+  private def withErrors(errors: String*): TreeWithErrors = (EmptyTree, errors.toList)
+
+  private val EmptyTreeNoError: TreeWithErrors = withNoErrors(EmptyTree)
+
+  private def orElse(treeWithErrors1: TreeWithErrors, treeWithErrors2: => TreeWithErrors): TreeWithErrors = treeWithErrors1 match
+    case (tree, errors) if tree eq genericEmptyTree =>
+      val (tree2, errors2) = treeWithErrors2
+      (tree2, errors ::: errors2)
+    case _ => treeWithErrors1
+
+  private def clearErrorsIfNotEmpty(treeWithErrors: TreeWithErrors) = treeWithErrors match
+    case (tree, _) if tree eq genericEmptyTree => treeWithErrors
+    case (tree, _)                             => withNoErrors(tree)
+
+end Synthesizer
diff --git a/tests/pos-with-compiler-cc/dotc/typer/TypeAssigner.scala b/tests/pos-with-compiler-cc/dotc/typer/TypeAssigner.scala
new file mode 100644
index 000000000000..b90409e72364
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/typer/TypeAssigner.scala
@@ -0,0 +1,558 @@
+package dotty.tools
+package dotc
+package typer
+
+import core._
+import ast._
+import Contexts._, ContextOps._, Constants._, Types._, Symbols._, Names._, Flags._, Decorators._
+import ErrorReporting._, Annotations._, Denotations._, SymDenotations._, StdNames._
+import util.SrcPos
+import NameOps._
+import collection.mutable
+import reporting._
+import Checking.{checkNoPrivateLeaks, checkNoWildcard}
+import cc.CaptureSet
+
+trait TypeAssigner {
+  import tpd.*
+  import TypeAssigner.*
+
+  /** The qualifying class of a this or super with prefix `qual` (which might be empty).
+   *  @param packageOk   The qualifier may refer to a package.
+   */
+  def qualifyingClass(tree: untpd.Tree, qual: Name, packageOK: Boolean)(using Context): Symbol = {
+    def qualifies(sym: Symbol) =
+      sym.isClass && (
+          qual.isEmpty ||
+          sym.name == qual ||
+          sym.is(Module) && sym.name.stripModuleClassSuffix == qual)
+    ctx.outersIterator.map(_.owner).find(qualifies) match {
+      case Some(c) if packageOK || !c.is(Package) =>
+        c
+      case _ =>
+        report.error(
+          if (qual.isEmpty) tree.show + " can be used only in a class, object, or template"
+          else qual.show + " is not an enclosing class", tree.srcPos)
+        NoSymbol
+    }
+  }
+
+  def avoidingType(expr: Tree, bindings: List[Tree])(using Context): Type =
+    TypeOps.avoid(expr.tpe, localSyms(bindings).filterConserve(_.isTerm))
+
+  def avoidPrivateLeaks(sym: Symbol)(using Context): Type =
+    if sym.owner.isClass && !sym.isOneOf(JavaOrPrivateOrSynthetic)
+    then checkNoPrivateLeaks(sym)
+    else sym.info
+
+  private def toRepeated(tree: Tree, from: ClassSymbol)(using Context): Tree =
+    Typed(tree, TypeTree(tree.tpe.widen.translateToRepeated(from)))
+
+  def seqToRepeated(tree: Tree)(using Context): Tree = toRepeated(tree, defn.SeqClass)
+
+  def arrayToRepeated(tree: Tree)(using Context): Tree = toRepeated(tree, defn.ArrayClass)
+
+  /** A denotation exists really if it exists and does not point to a stale symbol. */
+  final def reallyExists(denot: Denotation)(using Context): Boolean = try
+    denot match {
+      case denot: SymDenotation =>
+        denot.exists && !denot.isAbsent()
+      case denot: SingleDenotation =>
+        val sym = denot.symbol
+        (sym eq NoSymbol) || reallyExists(sym.denot)
+      case _ =>
+        true
+    }
+  catch {
+    case ex: StaleSymbol => false
+  }
+
+  /** If `tpe` is a named type, return the type with those alternatives as denotations
+   *  which are accessible (or NoType, if no alternatives are accessible).
+   *
+   *  Also performs the following normalizations on the type `tpe`.
+   *  (1) if the owner of the denotation is a package object, it is assured
+   *      that the package object shows up as the prefix.
+   *  (2) in Java compilation units, `Object` is replaced by `defn.FromJavaObjectType`
+   */
+  def accessibleType(tpe: Type, superAccess: Boolean)(using Context): Type =
+    tpe match
+      case tpe: NamedType =>
+        val pre = tpe.prefix
+        val name = tpe.name
+        def postProcess(d: Denotation) =
+          if ctx.isJava && tpe.isAnyRef then defn.FromJavaObjectType
+          else TypeOps.makePackageObjPrefixExplicit(tpe withDenot d)
+        val d = tpe.denot.accessibleFrom(pre, superAccess)
+        if d.exists then postProcess(d)
+        else
+          // it could be that we found an inaccessible private member, but there is
+          // an inherited non-private member with the same name and signature.
+          val d2 = pre.nonPrivateMember(name).accessibleFrom(pre, superAccess)
+          if reallyExists(d2) then postProcess(d2)
+          else NoType
+      case tpe => tpe
+
+  /** Try to make `tpe` accessible, emit error if not possible */
+  def ensureAccessible(tpe: Type, superAccess: Boolean, pos: SrcPos)(using Context): Type =
+    val tpe1 = accessibleType(tpe, superAccess)
+    if tpe1.exists then tpe1
+    else tpe match
+      case tpe: NamedType => inaccessibleErrorType(tpe, superAccess, pos)
+      case NoType => tpe
+
+  /** Return a potentially skolemized version of `qualTpe` to be used
+   *  as a prefix when selecting `name`.
+   *
+   *  @see QualSkolemType, TypeOps#asSeenFrom
+   */
+  def maybeSkolemizePrefix(qualType: Type, name: Name)(using Context): Type =
+    if (name.isTermName && !TypeOps.isLegalPrefix(qualType))
+      QualSkolemType(qualType)
+    else
+      qualType
+
+  /** The type of the selection `tree`, where `qual1` is the typed qualifier part. */
+  def selectionType(tree: untpd.RefTree, qual1: Tree)(using Context): Type =
+    val qualType0 = qual1.tpe.widenIfUnstable
+    val qualType =
+      if !qualType0.hasSimpleKind && tree.name != nme.CONSTRUCTOR then
+        // constructors are selected on typeconstructor, type arguments are passed afterwards
+        errorType(em"$qualType0 takes type parameters", qual1.srcPos)
+      else if !qualType0.isInstanceOf[TermType] && !qualType0.isError then
+        errorType(em"$qualType0 is illegal as a selection prefix", qual1.srcPos)
+      else
+        qualType0
+
+    def arrayElemType = qual1.tpe.widen match
+      case JavaArrayType(elemtp) => elemtp
+      case qualType =>
+        report.error("Expected Array but was " + qualType.show, tree.srcPos)
+        defn.NothingType
+
+    val name = tree.name
+    val p = nme.primitive
+    name match
+      case p.arrayApply  => MethodType(defn.IntType :: Nil, arrayElemType)
+      case p.arrayUpdate => MethodType(defn.IntType :: arrayElemType :: Nil, defn.UnitType)
+      case p.arrayLength => MethodType(Nil, defn.IntType)
+      // Note that we do not need to handle calls to Array[T]#clone() specially:
+      // The JLS section 10.7 says "The return type of the clone method of an array type
+      // T[] is T[]", but the actual return type at the bytecode level is Object which
+      // is casted to T[] by javac. Since the return type of Array[T]#clone() is Array[T],
+      // this is exactly what Erasure will do.
+      case _ =>
+        val pre = maybeSkolemizePrefix(qualType, name)
+        val mbr =
+          if ctx.isJava then
+            ctx.javaFindMember(name, pre)
+          else
+            qualType.findMember(name, pre)
+
+        if reallyExists(mbr) then qualType.select(name, mbr)
+        else if qualType.isErroneous || name.toTermName == nme.ERROR then UnspecifiedErrorType
+        else NoType
+  end selectionType
+
+  def importSuggestionAddendum(pt: Type)(using Context): String = ""
+
+  def notAMemberErrorType(tree: untpd.Select, qual: Tree)(using Context): ErrorType =
+    val qualType = qual.tpe.widenIfUnstable
+    def kind = if tree.isType then "type" else "value"
+    val foundWithoutNull = qualType match
+      case OrNull(qualType1) if qualType1 <:< defn.ObjectType =>
+        val name = tree.name
+        val pre = maybeSkolemizePrefix(qualType1, name)
+        reallyExists(qualType1.findMember(name, pre))
+      case _ => false
+    def addendum = err.selectErrorAddendum(tree, qual, qualType, importSuggestionAddendum, foundWithoutNull)
+    val msg: Message =
+      if tree.name == nme.CONSTRUCTOR then ex"$qualType does not have a constructor".toMessage
+      else NotAMember(qualType, tree.name, kind, addendum)
+    errorType(msg, tree.srcPos)
+
+  def inaccessibleErrorType(tpe: NamedType, superAccess: Boolean, pos: SrcPos)(using Context): Type =
+    val pre = tpe.prefix
+    val name = tpe.name
+    val alts = tpe.denot.alternatives.map(_.symbol).filter(_.exists)
+    val whatCanNot = alts match
+      case Nil =>
+        em"$name cannot"
+      case sym :: Nil =>
+        em"${if (sym.owner == pre.typeSymbol) sym.show else sym.showLocated} cannot"
+      case _ =>
+        em"none of the overloaded alternatives named $name can"
+    val where = if (ctx.owner.exists) s" from ${ctx.owner.enclosingClass}" else ""
+    val whyNot = new StringBuffer
+    alts.foreach(_.isAccessibleFrom(pre, superAccess, whyNot))
+    if tpe.isError then tpe
+    else errorType(ex"$whatCanNot be accessed as a member of $pre$where.$whyNot", pos)
+
+  def processAppliedType(tree: untpd.Tree, tp: Type)(using Context): Type = tp match
+    case AppliedType(tycon, args) =>
+      val constr = tycon.typeSymbol
+      if constr == defn.andType then AndType(args(0), args(1))
+      else if constr == defn.orType then OrType(args(0), args(1), soft = false)
+      else tp
+    case _ => tp
+
+  /** Type assignment method. Each method takes as parameters
+   *   - an untpd.Tree to which it assigns a type,
+   *   - typed child trees it needs to access to cpmpute that type,
+   *   - any further information it needs to access to compute that type.
+   */
+  def assignType(tree: untpd.Ident, tp: Type)(using Context): Ident =
+    tree.withType(tp)
+
+  def assignType(tree: untpd.Select, tp: Type)(using Context): Select =
+    ConstFold.Select(tree.withType(tp))
+
+  def assignType(tree: untpd.Select, qual: Tree)(using Context): Select =
+    val rawType = selectionType(tree, qual)
+    val checkedType = ensureAccessible(rawType, qual.isInstanceOf[Super], tree.srcPos)
+    val ownType = checkedType.orElse(notAMemberErrorType(tree, qual))
+    assignType(tree, ownType)
+
+  /** Normalize type T appearing in a new T by following eta expansions to
+   *  avoid higher-kinded types.
+   */
+  def typeOfNew(tpt: Tree)(using Context): Type = tpt.tpe.dealias match {
+    case TypeApplications.EtaExpansion(tycon) => tycon
+    case t => tpt.tpe
+  }
+
+  def assignType(tree: untpd.New, tpt: Tree)(using Context): New =
+    tree.withType(typeOfNew(tpt))
+
+  def assignType(tree: untpd.Literal)(using Context): Literal =
+    tree.withType {
+      val value = tree.const
+      value.tag match {
+        case UnitTag => defn.UnitType
+        case NullTag => defn.NullType
+        case _ => if (ctx.erasedTypes) value.tpe else ConstantType(value)
+      }
+    }
+
+  def assignType(tree: untpd.This)(using Context): This = {
+    val cls = qualifyingClass(tree, tree.qual.name, packageOK = false)
+    tree.withType(
+        if (cls.isClass) cls.thisType
+        else errorType("not a legal qualifying class for this", tree.srcPos))
+  }
+
+  def superType(qualType: Type, mix: untpd.Ident, mixinClass: Symbol, pos: SrcPos)(using Context) =
+    qualType match
+      case err: ErrorType => err
+      case qtype @ ThisType(_) =>
+        val cls = qtype.cls
+        def findMixinSuper(site: Type): Type = site.parents filter (_.typeSymbol.name == mix.name) match {
+          case p :: Nil =>
+            p.typeConstructor
+          case Nil =>
+            errorType(SuperQualMustBeParent(mix, cls), pos)
+          case p :: q :: _ =>
+            errorType("ambiguous parent class qualifier", pos)
+        }
+        val owntype =
+          if (mixinClass.exists) mixinClass.typeRef
+          else if (!mix.isEmpty) findMixinSuper(cls.info)
+          else if (ctx.erasedTypes) cls.info.firstParent.typeConstructor
+          else {
+            val ps = cls.classInfo.parents
+            if (ps.isEmpty) defn.AnyType else ps.reduceLeft((x: Type, y: Type) => x & y)
+          }
+        SuperType(cls.thisType, owntype)
+
+  def assignType(tree: untpd.Super, qual: Tree, mixinClass: Symbol = NoSymbol)(using Context): Super =
+    untpd.cpy.Super(tree)(qual, tree.mix)
+      .withType(superType(qual.tpe, tree.mix, mixinClass, tree.srcPos))
+
+  /** Substitute argument type `argType` for parameter `pref` in type `tp`,
+   *  skolemizing the argument type if it is not stable and `pref` occurs in `tp`.
+   */
+  def safeSubstParam(tp: Type, pref: ParamRef, argType: Type)(using Context): Type = {
+    val tp1 = tp.substParam(pref, argType)
+    if ((tp1 eq tp) || argType.isStable) tp1
+    else tp.substParam(pref, SkolemType(argType.widen))
+  }
+
+  /** Substitute types of all arguments `args` for corresponding `params` in `tp`.
+   *  The number of parameters `params` may exceed the number of arguments.
+   *  In this case, only the common prefix is substituted.
+   */
+  def safeSubstParams(tp: Type, params: List[ParamRef], argTypes: List[Type])(using Context): Type = argTypes match {
+    case argType :: argTypes1 =>
+      val tp1 = safeSubstParam(tp, params.head, argType)
+      safeSubstParams(tp1, params.tail, argTypes1)
+    case Nil =>
+      tp
+  }
+
+  def safeSubstMethodParams(mt: MethodType, argTypes: List[Type])(using Context): Type =
+    if mt.isResultDependent then safeSubstParams(mt.resultType, mt.paramRefs, argTypes)
+    else if mt.isCaptureDependent then mt.resultType.substParams(mt, argTypes)
+    else mt.resultType
+
+  def assignType(tree: untpd.Apply, fn: Tree, args: List[Tree])(using Context): Apply = {
+    val ownType = fn.tpe.widen match {
+      case fntpe: MethodType =>
+        if (fntpe.paramInfos.hasSameLengthAs(args) || ctx.phase.prev.relaxedTyping)
+          safeSubstMethodParams(fntpe, args.tpes)
+        else
+          errorType(i"wrong number of arguments at ${ctx.phase.prev} for $fntpe: ${fn.tpe}, expected: ${fntpe.paramInfos.length}, found: ${args.length}", tree.srcPos)
+      case t =>
+        if (ctx.settings.Ydebug.value) new FatalError("").printStackTrace()
+        errorType(err.takesNoParamsStr(fn, ""), tree.srcPos)
+    }
+    ConstFold.Apply(tree.withType(ownType))
+  }
+
+  def assignType(tree: untpd.TypeApply, fn: Tree, args: List[Tree])(using Context): TypeApply = {
+    def fail = tree.withType(errorType(err.takesNoParamsStr(fn, "type "), tree.srcPos))
+    ConstFold(fn.tpe.widen match {
+      case pt: TypeLambda =>
+        tree.withType {
+          val paramNames = pt.paramNames
+          if (hasNamedArg(args)) {
+            val paramBoundsByName = paramNames.zip(pt.paramInfos).toMap
+
+            // Type arguments which are specified by name (immutable after this first loop)
+            val namedArgMap = new mutable.HashMap[Name, Type]
+            for (case NamedArg(name, arg) <- args)
+              if (namedArgMap.contains(name))
+                report.error(DuplicateNamedTypeParameter(name), arg.srcPos)
+              else if (!paramNames.contains(name))
+                report.error(UndefinedNamedTypeParameter(name, paramNames), arg.srcPos)
+              else
+                namedArgMap(name) = arg.tpe
+
+            // Holds indexes of non-named typed arguments in paramNames
+            val gapBuf = new mutable.ListBuffer[Int]
+            def nextPoly(idx: Int) = {
+              val newIndex = gapBuf.length
+              gapBuf += idx
+              // Re-index unassigned type arguments that remain after transformation
+              pt.paramRefs(newIndex)
+            }
+
+            // Type parameters after naming assignment, conserving paramNames order
+            val normArgs: List[Type] = paramNames.zipWithIndex.map { case (pname, idx) =>
+              namedArgMap.getOrElse(pname, nextPoly(idx))
+            }
+
+            val transform = new TypeMap {
+              def apply(t: Type) = t match {
+                case TypeParamRef(`pt`, idx) => normArgs(idx)
+                case _ => mapOver(t)
+              }
+            }
+            val resultType1 = transform(pt.resultType)
+            if (gapBuf.isEmpty) resultType1
+            else {
+              val gaps = gapBuf.toList
+              pt.derivedLambdaType(
+                gaps.map(paramNames),
+                gaps.map(idx => transform(pt.paramInfos(idx)).bounds),
+                resultType1)
+            }
+          }
+          else {
+            // Make sure arguments don't contain the type `pt` itself.
+            // make a copy of the argument if that's the case.
+            // This is done to compensate for the fact that normally every
+            // reference to a polytype would have to be a fresh copy of that type,
+            // but we want to avoid that because it would increase compilation cost.
+            // See pos/i6682a.scala for a test case where the defensive copying matters.
+            val ensureFresh = new TypeMap with CaptureSet.IdempotentCaptRefMap:
+              def apply(tp: Type) = mapOver(
+                if tp eq pt then pt.newLikeThis(pt.paramNames, pt.paramInfos, pt.resType)
+                else tp)
+            val argTypes = args.tpes.mapConserve(ensureFresh)
+            if (argTypes.hasSameLengthAs(paramNames)) pt.instantiate(argTypes)
+            else wrongNumberOfTypeArgs(fn.tpe, pt.typeParams, args, tree.srcPos)
+          }
+        }
+      case err: ErrorType =>
+        tree.withType(err)
+      case ref: TermRef if ref.isOverloaded =>
+        val disambiguated = ref.denot.suchThat(_.info.isInstanceOf[PolyType])
+        if (disambiguated.exists) {
+          val fn1 = fn.withType(ref.withDenot(disambiguated))
+          val tree1 = untpd.cpy.TypeApply(tree)(fn1, args)
+          assignType(tree1, fn1, args)
+        }
+        else fail
+      case _ =>
+        //println(i"bad type: $fn: ${fn.symbol} / ${fn.symbol.isType} / ${fn.symbol.info}") // DEBUG
+        fail
+    })
+  }
+
+  def assignType(tree: untpd.Typed, tpt: Tree)(using Context): Typed =
+    tree.withType(tpt.tpe)
+
+  def assignType(tree: untpd.NamedArg, arg: Tree)(using Context): NamedArg =
+    tree.withType(arg.tpe)
+
+  def assignType(tree: untpd.Assign)(using Context): Assign =
+    tree.withType(defn.UnitType)
+
+  def assignType(tree: untpd.Block, stats: List[Tree], expr: Tree)(using Context): Block =
+    tree.withType(avoidingType(expr, stats))
+
+  def assignType(tree: untpd.Inlined, bindings: List[Tree], expansion: Tree)(using Context): Inlined =
+    tree.withType(avoidingType(expansion, bindings))
+
+  def assignType(tree: untpd.If, thenp: Tree, elsep: Tree)(using Context): If =
+    tree.withType(thenp.tpe | elsep.tpe)
+
+  def assignType(tree: untpd.Closure, meth: Tree, target: Tree)(using Context): Closure =
+    tree.withType(
+      if (target.isEmpty) meth.tpe.widen.toFunctionType(isJava = meth.symbol.is(JavaDefined), tree.env.length)
+      else target.tpe)
+
+  def assignType(tree: untpd.CaseDef, pat: Tree, body: Tree)(using Context): CaseDef = {
+    val ownType =
+      if (body.isType) {
+        val getParams = new TreeAccumulator[mutable.ListBuffer[TypeSymbol]] {
+          def apply(ps: mutable.ListBuffer[TypeSymbol], t: Tree)(using Context) = t match {
+            case t: Bind if t.symbol.isType => foldOver(ps += t.symbol.asType, t)
+            case _ => foldOver(ps, t)
+          }
+        }
+        val params1 = getParams(new mutable.ListBuffer[TypeSymbol](), pat).toList
+        val params2 = pat.tpe match
+          case AppliedType(tycon, args) =>
+            val tparams = tycon.typeParamSymbols
+            params1.mapconserve { param =>
+              val info1 = param.info
+              val info2 = info1.subst(tparams, args)
+              if info2 eq info1 then param else param.copy(info = info2).asType
+            }
+          case _ => params1
+        val matchCase1 = defn.MatchCase(pat.tpe, body.tpe)
+        val matchCase2 = if params2 eq params1 then matchCase1 else matchCase1.substSym(params1, params2)
+        HKTypeLambda.fromParams(params2, matchCase2)
+      }
+      else body.tpe
+    tree.withType(ownType)
+  }
+
+  def assignType(tree: untpd.Match, scrutinee: Tree, cases: List[CaseDef])(using Context): Match =
+    tree.withType(TypeComparer.lub(cases.tpes))
+
+  def assignType(tree: untpd.Labeled)(using Context): Labeled =
+    tree.withType(tree.bind.symbol.info)
+
+  def assignType(tree: untpd.Return)(using Context): Return =
+    tree.withType(defn.NothingType)
+
+  def assignType(tree: untpd.WhileDo)(using Context): WhileDo =
+    tree.withType(if (tree.cond eq EmptyTree) defn.NothingType else defn.UnitType)
+
+  def assignType(tree: untpd.Try, expr: Tree, cases: List[CaseDef])(using Context): Try =
+    if (cases.isEmpty) tree.withType(expr.tpe)
+    else tree.withType(TypeComparer.lub(expr.tpe :: cases.tpes))
+
+  def assignType(tree: untpd.SeqLiteral, elems: List[Tree], elemtpt: Tree)(using Context): SeqLiteral =
+    tree.withType(seqLitType(tree, elemtpt.tpe))
+
+  def assignType(tree: untpd.SingletonTypeTree, ref: Tree)(using Context): SingletonTypeTree =
+    tree.withType(ref.tpe)
+
+  /** Assign type of RefinedType.
+   *  Refinements are typed as if they were members of refinement class `refineCls`.
+   */
+  def assignType(tree: untpd.RefinedTypeTree, parent: Tree, refinements: List[Tree], refineCls: ClassSymbol)(using Context): RefinedTypeTree = {
+    def addRefinement(parent: Type, refinement: Tree): Type = {
+      val rsym = refinement.symbol
+      val rinfo = if (rsym.is(Accessor)) rsym.info.resultType else rsym.info
+      if (rinfo.isError) rinfo
+      else if (!rinfo.exists) parent // can happen after failure in self type definition
+      else RefinedType(parent, rsym.name, rinfo)
+    }
+    val refined = refinements.foldLeft(parent.tpe)(addRefinement)
+    tree.withType(RecType.closeOver(rt => refined.substThis(refineCls, rt.recThis)))
+  }
+
+  def assignType(tree: untpd.AppliedTypeTree, tycon: Tree, args: List[Tree])(using Context): AppliedTypeTree = {
+    assert(!hasNamedArg(args) || ctx.reporter.errorsReported, tree)
+    val tparams = tycon.tpe.typeParams
+    val ownType =
+      if tparams.hasSameLengthAs(args) then
+        processAppliedType(tree, tycon.tpe.appliedTo(args.tpes))
+      else
+        wrongNumberOfTypeArgs(tycon.tpe, tparams, args, tree.srcPos)
+    tree.withType(ownType)
+  }
+
+  def assignType(tree: untpd.LambdaTypeTree, tparamDefs: List[TypeDef], body: Tree)(using Context): LambdaTypeTree =
+    val validParams = tparamDefs.filterConserve { tdef =>
+      val ok = tdef.symbol.isType
+      if !ok then assert(ctx.reporter.errorsReported)
+      ok
+    }
+    tree.withType(HKTypeLambda.fromParams(validParams.map(_.symbol.asType), body.tpe))
+
+  def assignType(tree: untpd.MatchTypeTree, bound: Tree, scrutinee: Tree, cases: List[CaseDef])(using Context): MatchTypeTree = {
+    val boundType = if (bound.isEmpty) defn.AnyType else bound.tpe
+    tree.withType(MatchType(boundType, scrutinee.tpe, cases.tpes))
+  }
+
+  def assignType(tree: untpd.ByNameTypeTree, result: Tree)(using Context): ByNameTypeTree =
+    tree.withType(ExprType(result.tpe))
+
+  def assignType(tree: untpd.TypeBoundsTree, lo: Tree, hi: Tree, alias: Tree)(using Context): TypeBoundsTree =
+    tree.withType(
+      if !alias.isEmpty then alias.tpe
+      else if lo eq hi then
+        if lo.tpe.isMatch then MatchAlias(lo.tpe)
+        else TypeAlias(lo.tpe)
+      else TypeBounds(lo.tpe, hi.tpe))
+
+  def assignType(tree: untpd.Bind, sym: Symbol)(using Context): Bind =
+    tree.withType(NamedType(NoPrefix, sym))
+
+  def assignType(tree: untpd.Alternative, trees: List[Tree])(using Context): Alternative =
+    tree.withType(TypeComparer.lub(trees.tpes))
+
+  def assignType(tree: untpd.UnApply, proto: Type)(using Context): UnApply =
+    tree.withType(proto)
+
+  def assignType(tree: untpd.ValDef, sym: Symbol)(using Context): ValDef =
+    tree.withType(if (sym.exists) assertExists(sym.termRef) else NoType)
+
+  def assignType(tree: untpd.DefDef, sym: Symbol)(using Context): DefDef =
+    tree.withType(sym.termRef)
+
+  def assignType(tree: untpd.TypeDef, sym: Symbol)(using Context): TypeDef =
+    tree.withType(sym.typeRef)
+
+  def assertExists(tp: Type): Type = { assert(tp != NoType); tp }
+
+  def assignType(tree: untpd.Import, sym: Symbol)(using Context): Import =
+    tree.withType(sym.termRef)
+
+  def assignType(tree: untpd.Export)(using Context): Export =
+    tree.withType(defn.UnitType)
+
+  def assignType(tree: untpd.Annotated, arg: Tree, annot: Tree)(using Context): Annotated = {
+    assert(tree.isType) // annotating a term is done via a Typed node, can't use Annotate directly
+    tree.withType(AnnotatedType(arg.tpe, Annotation(annot)))
+  }
+
+  def assignType(tree: untpd.PackageDef, pid: Tree)(using Context): PackageDef =
+    tree.withType(pid.symbol.termRef)
+
+  def assignType(tree: untpd.Hole, tpt: Tree)(using Context): Hole =
+    tree.withType(tpt.tpe)
+
+}
+
+object TypeAssigner extends TypeAssigner:
+  def seqLitType(tree: untpd.SeqLiteral, elemType: Type)(using Context) = tree match
+    case tree: untpd.JavaSeqLiteral => defn.ArrayOf(elemType)
+    case _ => if ctx.erasedTypes then defn.SeqType else defn.SeqType.appliedTo(elemType)
+
+
diff --git a/tests/pos-with-compiler-cc/dotc/typer/Typer.scala b/tests/pos-with-compiler-cc/dotc/typer/Typer.scala
new file mode 100644
index 000000000000..25776c07c8a0
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/typer/Typer.scala
@@ -0,0 +1,4254 @@
+package dotty.tools
+package dotc
+package typer
+
+import backend.sjs.JSDefinitions
+import core._
+import ast._
+import Trees._
+import Constants._
+import StdNames._
+import Scopes._
+import Denotations._
+import ProtoTypes._
+import Contexts._
+import Symbols._
+import Types._
+import SymDenotations._
+import Annotations._
+import Names._
+import NameOps._
+import NameKinds._
+import NamerOps._
+import ContextOps._
+import Flags._
+import Decorators._
+import ErrorReporting._
+import Checking._
+import Inferencing._
+import Dynamic.isDynamicExpansion
+import EtaExpansion.etaExpand
+import TypeComparer.CompareResult
+import inlines.{Inlines, PrepareInlineable}
+import util.Spans._
+import util.common._
+import util.{Property, SimpleIdentityMap, SrcPos}
+import Applications.{tupleComponentTypes, wrapDefs, defaultArgument}
+
+import collection.mutable
+import annotation.tailrec
+import Implicits._
+import util.Stats.record
+import config.Printers.{gadts, typr}
+import config.Feature
+import config.Feature.{sourceVersion, migrateTo3}
+import config.SourceVersion._
+import rewrites.Rewrites.patch
+import transform.SymUtils._
+import transform.TypeUtils._
+import reporting._
+import Nullables._
+import NullOpsDecorator._
+import cc.CheckCaptures
+import config.Config
+import language.experimental.pureFunctions
+
+import scala.annotation.constructorOnly
+
+object Typer {
+
+  /** The precedence of bindings which determines which of several bindings will be
+   *  accessed by an Ident.
+   */
+  enum BindingPrec {
+    case NothingBound, PackageClause, WildImport, NamedImport, Inheritance, Definition
+
+    def isImportPrec = this == NamedImport || this == WildImport
+  }
+
+  /** Assert tree has a position, unless it is empty or a typed splice */
+  def assertPositioned(tree: untpd.Tree)(using Context): Unit =
+    if (!tree.isEmpty && !tree.isInstanceOf[untpd.TypedSplice] && ctx.typerState.isGlobalCommittable)
+      assert(tree.span.exists, i"position not set for $tree # ${tree.uniqueId} of ${tree.getClass} in ${tree.source}")
+
+  /** An attachment for GADT constraints that were inferred for a pattern. */
+  val InferredGadtConstraints = new Property.StickyKey[core.GadtConstraint]
+
+  /** A context property that indicates the owner of any expressions to be typed in the context
+   *  if that owner is different from the context's owner. Typically, a context with a class
+   *  as owner would have a local dummy as ExprOwner value.
+   */
+  private val ExprOwner = new Property.Key[Symbol]
+
+  /** An attachment on a Select node with an `apply` field indicating that the `apply`
+   *  was inserted by the Typer.
+   */
+  private val InsertedApply = new Property.Key[Unit]
+
+  /** An attachment on a result of an implicit conversion or extension method
+   *  that was added by tryInsertImplicitOnQualifier. Needed to prevent infinite
+   *  expansions in error cases (e.g. in fuzzy/i9293.scala).
+   */
+  private val InsertedImplicitOnQualifier = new Property.Key[Unit]
+
+  /** An attachment on a tree `t` occurring as part of a `t()` where
+   *  the `()` was dropped by the Typer.
+   */
+  private val DroppedEmptyArgs = new Property.Key[Unit]
+
+  /** An attachment that indicates a failed conversion or extension method
+   *  search was tried on a tree. This will in some cases be reported in error messages
+   */
+  private[typer] val HiddenSearchFailure = new Property.Key[List[SearchFailure]]
+
+  /** Is tree a compiler-generated `.apply` node that refers to the
+   *  apply of a function class?
+   */
+  private[typer] def isSyntheticApply(tree: tpd.Tree): Boolean = tree match {
+    case tree: tpd.Select => tree.hasAttachment(InsertedApply)
+    case TypeApply(fn, targs) => isSyntheticApply(fn) && targs.forall(_.isInstanceOf[tpd.InferredTypeTree])
+    case _ => false
+  }
+
+  /** Add `fail` to the list of search failures attached to `tree` */
+  def rememberSearchFailure(tree: tpd.Tree, fail: SearchFailure) =
+    tree.putAttachment(HiddenSearchFailure,
+      fail :: tree.attachmentOrElse(HiddenSearchFailure, Nil))
+}
+/** Typecheck trees, the main entry point is `typed`.
+ *
+ *  @param nestingLevel The nesting level of the `scope` of this Typer.
+ */
+class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
+               with TypeAssigner
+               with Applications
+               with Implicits
+               with ImportSuggestions
+               with Inferencing
+               with Dynamic
+               with Checking
+               with QuotesAndSplices
+               with Deriving {
+
+  import Typer._
+  import tpd.{cpy => _, _}
+  import untpd.cpy
+
+  /** The scope of the typer.
+   *  For nested typers (cf `Namer#nestedTyper`), this is a place parameters are
+   *  entered during completion and where they survive until typechecking. A
+   *  context with this typer also has this scope.
+   */
+  val scope: MutableScope = newScope(nestingLevel)
+
+  /** A temporary data item valid for a single typed ident:
+   *  The set of all root import symbols that have been
+   *  encountered as a qualifier of an import so far.
+   *  Note: It would be more proper to move importedFromRoot into typedIdent.
+   *  We should check that this has no performance degradation, however.
+   */
+  private var unimported: Set[Symbol] = Set()
+
+  /** Temporary data item for single call to typed ident:
+   *  This symbol would be found under Scala2 mode, but is not
+   *  in dotty (because dotty conforms to spec section 2
+   *  wrt to package member resolution but scalac doe not).
+   */
+  private var foundUnderScala2: Type = NoType
+
+  // Overridden in derived typers
+  def newLikeThis(nestingLevel: Int): Typer = new Typer(nestingLevel)
+
+  /** Find the type of an identifier with given `name` in given context `ctx`.
+   *   @param name       the name of the identifier
+   *   @param pt         the expected type
+   *   @param required   flags the result's symbol must have
+   *   @param excluded   flags the result's symbol must not have
+   *   @param pos        indicates position to use for error reporting
+   */
+  def findRef(name: Name, pt: Type, required: FlagSet, excluded: FlagSet, pos: SrcPos)(using Context): Type = {
+    val refctx = ctx
+    val noImports = ctx.mode.is(Mode.InPackageClauseName)
+    def suppressErrors = excluded.is(ConstructorProxy)
+      // when searching for references shadowed by a constructor proxy, do not report errors
+    def fail(msg: Message) =
+      if !suppressErrors then report.error(msg, pos)
+
+    /** A symbol qualifies if it really exists and is not a package class.
+     *  Package classes are part of their parent's scope, because otherwise
+     *  we could not reload them via `_.member`. On the other hand, accessing a
+     *  package as a type from source is always an error.
+
+     *  In addition:
+     *    - if we are in a constructor of a pattern, we ignore all definitions
+     *      which are parameterized (including nullary) methods and not accessors
+     *      (note: if we don't do that case x :: xs in class List would return the :: method).
+     *    - Members of the empty package can be accessed only from within the empty package.
+     *      Note: it would be cleaner to never nest package definitions in empty package definitions,
+     *      but then we'd have to give up the fiction that a compilation unit consists of
+     *      a single tree (because a source file may have both toplevel classes which go
+     *      into the empty package and package definitions, which would have to stay outside).
+     *      Since the principle of a single tree per compilation unit is assumed by many
+     *      tools, we did not want to take that step.
+     */
+    def qualifies(denot: Denotation): Boolean =
+      def isRealMethod(sd: SingleDenotation): Boolean =
+        sd.symbol.is(Method, butNot = Accessor) && !sd.info.isParameterless
+      reallyExists(denot)
+      && (!pt.isInstanceOf[UnapplySelectionProto] || denot.hasAltWith(!isRealMethod(_)))
+      && !denot.symbol.is(PackageClass)
+      && {
+        var owner = denot.symbol.maybeOwner
+        if owner.isPackageObject then owner = owner.owner
+        !owner.isEmptyPackage || ctx.owner.enclosingPackageClass.isEmptyPackage
+      }
+
+    /** Find the denotation of enclosing `name` in given context `ctx`.
+     *  @param previous    A denotation that was found in a more deeply nested scope,
+     *                     or else `NoDenotation` if nothing was found yet.
+     *  @param prevPrec    The binding precedence of the previous denotation,
+     *                     or else `nothingBound` if nothing was found yet.
+     *  @param prevCtx     The context of the previous denotation,
+     *                     or else `NoContext` if nothing was found yet.
+     */
+    def findRefRecur(previous: Type, prevPrec: BindingPrec, prevCtx: Context)(using Context): Type = {
+      import BindingPrec._
+
+      /** Check that any previously found result from an inner context
+       *  does properly shadow the new one from an outer context.
+       *  @param found     The newly found result
+       *  @param newPrec   Its precedence
+       *  @param scala2pkg Special mode where we check members of the same package, but defined
+       *                   in different compilation units under Scala2. If set, and the
+       *                   previous and new contexts do not have the same scope, we select
+       *                   the previous (inner) definition. This models what scalac does.
+       */
+      def checkNewOrShadowed(found: Type, newPrec: BindingPrec, scala2pkg: Boolean = false)(using Context): Type =
+        if !previous.exists || TypeComparer.isSameRef(previous, found) then
+           found
+        else if (prevCtx.scope eq ctx.scope)
+                && (newPrec == Definition || newPrec == NamedImport && prevPrec == WildImport)
+        then
+          // special cases: definitions beat imports, and named imports beat
+          // wildcard imports, provided both are in contexts with same scope
+          found
+        else
+          if !scala2pkg && !previous.isError && !found.isError then
+            fail(AmbiguousReference(name, newPrec, prevPrec, prevCtx))
+          previous
+
+      /** Recurse in outer context. If final result is same as `previous`, check that it
+       *  is new or shadowed. This order of checking is necessary since an
+       *  outer package-level definition might trump two conflicting inner
+       *  imports, so no error should be issued in that case. See i7876.scala.
+       */
+      def recurAndCheckNewOrShadowed(previous: Type, prevPrec: BindingPrec, prevCtx: Context)(using Context): Type =
+        val found = findRefRecur(previous, prevPrec, prevCtx)
+        if found eq previous then checkNewOrShadowed(found, prevPrec)(using prevCtx)
+        else found
+
+      def selection(imp: ImportInfo, name: Name, checkBounds: Boolean): Type =
+        imp.importSym.info match
+          case ImportType(expr) =>
+            val pre = expr.tpe
+            var denot = pre.memberBasedOnFlags(name, required, excluded)
+              .accessibleFrom(pre)(using refctx)
+            // Pass refctx so that any errors are reported in the context of the
+            // reference instead of the context of the import scope
+            if denot.exists then
+              if checkBounds then
+                denot = denot.filterWithPredicate { mbr =>
+                  mbr.matchesImportBound(if mbr.symbol.is(Given) then imp.givenBound else imp.wildcardBound)
+                }
+              def isScalaJsPseudoUnion =
+                denot.name == tpnme.raw.BAR && ctx.settings.scalajs.value && denot.symbol == JSDefinitions.jsdefn.PseudoUnionClass
+              // Just like Scala2Unpickler reinterprets Scala.js pseudo-unions
+              // as real union types, we want references to `A | B` in sources
+              // to be typed as a real union even if `js.|` has been imported,
+              // so we ignore that import.
+              if reallyExists(denot) && !isScalaJsPseudoUnion then
+                if unimported.isEmpty || !unimported.contains(pre.termSymbol) then
+                  return pre.select(name, denot)
+          case _ =>
+            if imp.importSym.isCompleting then
+              report.warning(i"cyclic ${imp.importSym}, ignored", pos)
+        NoType
+
+      /** The type representing a named import with enclosing name when imported
+       *  from given `site` and `selectors`.
+       */
+      def namedImportRef(imp: ImportInfo)(using Context): Type = {
+        val termName = name.toTermName
+        def recur(selectors: List[untpd.ImportSelector]): Type = selectors match
+          case selector :: rest =>
+            def checkUnambiguous(found: Type) =
+              val other = recur(selectors.tail)
+              if other.exists && found.exists && found != other then
+                fail(em"reference to `$name` is ambiguous; it is imported twice".toMessage)
+              found
+
+            if selector.rename == termName && selector.rename != nme.WILDCARD then
+              val memberName =
+                if selector.name == termName then name
+                else if name.isTypeName then selector.name.toTypeName
+                else selector.name
+              checkUnambiguous(selection(imp, memberName, checkBounds = false))
+            else
+              recur(rest)
+
+          case nil =>
+            NoType
+
+        recur(imp.selectors)
+      }
+
+      /** The type representing a wildcard import with enclosing name when imported
+       *  from given import info
+       */
+      def wildImportRef(imp: ImportInfo)(using Context): Type =
+        if (imp.isWildcardImport && !imp.excluded.contains(name.toTermName) && name != nme.CONSTRUCTOR)
+          selection(imp, name, checkBounds = true)
+        else NoType
+
+      /** Is (some alternative of) the given predenotation `denot`
+       *  defined in current compilation unit?
+       */
+      def isDefinedInCurrentUnit(denot: Denotation)(using Context): Boolean = denot match {
+        case MultiDenotation(d1, d2) => isDefinedInCurrentUnit(d1) || isDefinedInCurrentUnit(d2)
+        case denot: SingleDenotation => (ctx.compilationUnit ne NoCompilationUnit) && denot.symbol.source == ctx.compilationUnit.source
+      }
+
+      /** Is `denot` the denotation of a self symbol? */
+      def isSelfDenot(denot: Denotation)(using Context) = denot match {
+        case denot: SymDenotation => denot.is(SelfName)
+        case _ => false
+      }
+
+      /** Would import of kind `prec` be not shadowed by a nested higher-precedence definition? */
+      def isPossibleImport(prec: BindingPrec)(using Context) =
+        !noImports &&
+        (prevPrec.ordinal < prec.ordinal || prevPrec == prec && (prevCtx.scope eq ctx.scope))
+
+      @tailrec def loop(lastCtx: Context)(using Context): Type =
+        if (ctx.scope eq EmptyScope) previous
+        else {
+          var result: Type = NoType
+
+          val curOwner = ctx.owner
+
+          /** Is curOwner a package object that should be skipped?
+           *  A package object should always be skipped if we look for a term.
+           *  That way we make sure we consider all overloaded alternatives of
+           *  a definition, even if they are in different source files.
+           *  If we are looking for a type, a package object should be skipped
+           *  only if it does not contain opaque definitions. Package objects
+           *  with opaque definitions are significant, since opaque aliases
+           *  are only seen if the prefix is the this-type of the package object.
+           */
+          def isTransparentPackageObject =
+            curOwner.isPackageObject && (name.isTermName || !curOwner.is(Opaque))
+
+          // Can this scope contain new definitions? This is usually the first
+          // context where either the scope or the owner changes wrt the
+          // context immediately nested in it. But for package contexts, it's
+          // the opposite: the last context before the package changes. This distinction
+          // is made so that top-level imports following a package clause are
+          // logically nested in that package clause. Finally, for the root package
+          // we switch back to the original test. This means that top-level packages in
+          // the root package take priority over root imports. For instance,
+          // a top-level io package takes priority over scala.io.
+          // It would be nice if we could drop all this complication, and
+          // always use the second condition. Unfortunately compileStdLib breaks
+          // with an error on CI which I cannot replicate locally (not even
+          // with the exact list of files given).
+          val isNewDefScope =
+            if curOwner.is(Package) && !curOwner.isRoot then
+              curOwner ne ctx.outer.owner
+            else
+              ((ctx.scope ne lastCtx.scope) || (curOwner ne lastCtx.owner))
+              && !isTransparentPackageObject
+
+          // Does reference `tp` refer only to inherited symbols?
+          def isInherited(denot: Denotation) =
+            def isCurrent(mbr: SingleDenotation): Boolean =
+              !mbr.symbol.exists || mbr.symbol.owner == ctx.owner
+            denot match
+              case denot: SingleDenotation => !isCurrent(denot)
+              case denot => !denot.hasAltWith(isCurrent)
+
+          def checkNoOuterDefs(denot: Denotation, last: Context, prevCtx: Context): Unit =
+            val outer = last.outer
+            val owner = outer.owner
+            if (owner eq last.owner) && (outer.scope eq last.scope) then
+              checkNoOuterDefs(denot, outer, prevCtx)
+            else if !owner.is(Package) then
+              val scope = if owner.isClass then owner.info.decls else outer.scope
+              val competing = scope.denotsNamed(name).filterWithFlags(required, excluded)
+              if competing.exists then
+                val symsMatch = competing
+                  .filterWithPredicate(sd => denot.containsSym(sd.symbol))
+                  .exists
+                if !symsMatch && !suppressErrors then
+                  report.errorOrMigrationWarning(
+                    AmbiguousReference(name, Definition, Inheritance, prevCtx)(using outer),
+                    pos, from = `3.0`)
+                  if migrateTo3 then
+                    patch(Span(pos.span.start),
+                      if prevCtx.owner == refctx.owner.enclosingClass then "this."
+                      else s"${prevCtx.owner.name}.this.")
+              else
+                checkNoOuterDefs(denot, outer, prevCtx)
+
+          if isNewDefScope then
+            val defDenot = ctx.denotNamed(name, required, excluded)
+            if (qualifies(defDenot)) {
+              val found =
+                if (isSelfDenot(defDenot)) curOwner.enclosingClass.thisType
+                else if (ctx.isJava && defDenot.symbol.isStatic) {
+                  defDenot.symbol.namedType
+                } else {
+                  val effectiveOwner =
+                    if (curOwner.isTerm && defDenot.symbol.maybeOwner.isType)
+                      // Don't mix NoPrefix and thisType prefixes, since type comparer
+                      // would not detect types to be compatible.
+                      defDenot.symbol.owner
+                    else
+                      curOwner
+                  effectiveOwner.thisType.select(name, defDenot)
+                }
+              if !curOwner.is(Package) || isDefinedInCurrentUnit(defDenot) then
+                result = checkNewOrShadowed(found, Definition) // no need to go further out, we found highest prec entry
+                found match
+                  case found: NamedType
+                  if curOwner.isClass && isInherited(found.denot) && !ctx.compilationUnit.isJava =>
+                    checkNoOuterDefs(found.denot, ctx, ctx)
+                  case _ =>
+              else
+                if migrateTo3 && !foundUnderScala2.exists then
+                  foundUnderScala2 = checkNewOrShadowed(found, Definition, scala2pkg = true)
+                if (defDenot.symbol.is(Package))
+                  result = checkNewOrShadowed(previous orElse found, PackageClause)
+                else if (prevPrec.ordinal < PackageClause.ordinal)
+                  result = findRefRecur(found, PackageClause, ctx)(using ctx.outer)
+            }
+
+          if result.exists then result
+          else {  // find import
+            val outer = ctx.outer
+            val curImport = ctx.importInfo
+            def updateUnimported() =
+              if (curImport.nn.unimported ne NoSymbol) unimported += curImport.nn.unimported
+            if (curOwner.is(Package) && curImport != null && curImport.isRootImport && previous.exists)
+              previous // no more conflicts possible in this case
+            else if (isPossibleImport(NamedImport) && (curImport nen outer.importInfo)) {
+              val namedImp = namedImportRef(curImport.uncheckedNN)
+              if (namedImp.exists)
+                recurAndCheckNewOrShadowed(namedImp, NamedImport, ctx)(using outer)
+              else if (isPossibleImport(WildImport) && !curImport.nn.importSym.isCompleting) {
+                val wildImp = wildImportRef(curImport.uncheckedNN)
+                if (wildImp.exists)
+                  recurAndCheckNewOrShadowed(wildImp, WildImport, ctx)(using outer)
+                else {
+                  updateUnimported()
+                  loop(ctx)(using outer)
+                }
+              }
+              else {
+                updateUnimported()
+                loop(ctx)(using outer)
+              }
+            }
+            else loop(ctx)(using outer)
+          }
+        }
+
+      // begin findRefRecur
+      loop(NoContext)
+    }
+
+    findRefRecur(NoType, BindingPrec.NothingBound, NoContext)
+  }
+
+  /** If `tree`'s type is a `TermRef` identified by flow typing to be non-null, then
+   *  cast away `tree`s nullability. Otherwise, `tree` remains unchanged.
+   *
+   *  Example:
+   *  If x is a trackable reference and we know x is not null at this point,
+   *  (x: T | Null) => x.$asInstanceOf$[x.type & T]
+   */
+  def toNotNullTermRef(tree: Tree, pt: Type)(using Context): Tree = tree.tpe match
+    case ref @ OrNull(tpnn) : TermRef
+    if pt != AssignProto && // Ensure it is not the lhs of Assign
+    ctx.notNullInfos.impliesNotNull(ref) &&
+    // If a reference is in the context, it is already trackable at the point we add it.
+    // Hence, we don't use isTracked in the next line, because checking use out of order is enough.
+    !ref.usedOutOfOrder =>
+      tree.cast(AndType(ref, tpnn))
+    case _ =>
+      tree
+
+  /** Attribute an identifier consisting of a simple name or wildcard
+   *
+   *  @param tree      The tree representing the identifier.
+   *  Transformations: (1) Prefix class members with this.
+   *                   (2) Change imported symbols to selections.
+   *                   (3) Change pattern Idents id (but not wildcards) to id @ _
+   */
+  def typedIdent(tree: untpd.Ident, pt: Type)(using Context): Tree =
+    record("typedIdent")
+    val name = tree.name
+    def kind = if (name.isTermName) "" else "type "
+    typr.println(s"typed ident $kind$name in ${ctx.owner}")
+    if ctx.mode.is(Mode.Pattern) then
+      if name == nme.WILDCARD then
+        return tree.withType(pt)
+      if name == tpnme.WILDCARD then
+        return tree.withType(defn.AnyType)
+      if untpd.isVarPattern(tree) && name.isTermName then
+        return typed(desugar.patternVar(tree), pt)
+    else if ctx.mode.is(Mode.QuotedPattern) then
+      if untpd.isVarPattern(tree) && name.isTypeName then
+        return typedQuotedTypeVar(tree, pt)
+    end if
+
+    // Shortcut for the root package, this is not just a performance
+    // optimization, it also avoids forcing imports thus potentially avoiding
+    // cyclic references.
+    if (name == nme.ROOTPKG)
+      return tree.withType(defn.RootPackage.termRef)
+
+    val rawType =
+      val saved1 = unimported
+      val saved2 = foundUnderScala2
+      unimported = Set.empty
+      foundUnderScala2 = NoType
+      try
+        val found = findRef(name, pt, EmptyFlags, EmptyFlags, tree.srcPos)
+        if foundUnderScala2.exists && !(foundUnderScala2 =:= found) then
+          report.migrationWarning(
+            ex"""Name resolution will change.
+              | currently selected                          : $foundUnderScala2
+              | in the future, without -source 3.0-migration: $found""", tree.srcPos)
+          foundUnderScala2
+        else found
+      finally
+      	unimported = saved1
+      	foundUnderScala2 = saved2
+
+    def checkNotShadowed(ownType: Type) = ownType match
+      case ownType: TermRef if ownType.symbol.is(ConstructorProxy) =>
+        val shadowed = findRef(name, pt, EmptyFlags, ConstructorProxy, tree.srcPos)
+        if shadowed.exists then
+          report.error(
+            em"""Reference to constructor proxy for ${ownType.symbol.companionClass.showLocated}
+                |shadows outer reference to ${shadowed.termSymbol.showLocated}""", tree.srcPos)
+      case _ =>
+
+    def setType(ownType: Type): Tree =
+      checkNotShadowed(ownType)
+      val tree1 = ownType match
+        case ownType: NamedType if !prefixIsElidable(ownType) =>
+          ref(ownType).withSpan(tree.span)
+        case _ =>
+          tree.withType(ownType)
+      val tree2 = toNotNullTermRef(tree1, pt)
+      checkLegalValue(tree2, pt)
+      tree2
+
+    def isLocalExtensionMethodRef: Boolean = rawType match
+      case rawType: TermRef =>
+        rawType.denot.hasAltWith(_.symbol.is(ExtensionMethod))
+        && !pt.isExtensionApplyProto
+        && {
+          val xmethod = ctx.owner.enclosingExtensionMethod
+          rawType.denot.hasAltWith { alt =>
+            alt.symbol.is(ExtensionMethod)
+            && alt.symbol.extensionParam.span == xmethod.extensionParam.span
+          }
+        }
+      case _ =>
+        false
+
+    if ctx.mode.is(Mode.InExtensionMethod) && isLocalExtensionMethodRef then
+      val xmethod = ctx.owner.enclosingExtensionMethod
+      val qualifier = untpd.ref(xmethod.extensionParam.termRef)
+      val selection = untpd.cpy.Select(tree)(qualifier, name)
+      typed(selection, pt)
+    else if rawType.exists then
+      setType(ensureAccessible(rawType, superAccess = false, tree.srcPos))
+    else if name == nme._scope then
+      // gross hack to support current xml literals.
+      // awaiting a better implicits based solution for library-supported xml
+      ref(defn.XMLTopScopeModule.termRef)
+    else if name.toTermName == nme.ERROR then
+      setType(UnspecifiedErrorType)
+    else if ctx.owner.isConstructor && !ctx.owner.isPrimaryConstructor
+        && ctx.owner.owner.unforcedDecls.lookup(tree.name).exists
+    then // we are in the arguments of a this(...) constructor call
+      errorTree(tree, ex"$tree is not accessible from constructor arguments")
+    else
+      errorTree(tree, MissingIdent(tree, kind, name))
+  end typedIdent
+
+  /** (1) If this reference is neither applied nor selected, check that it does
+   *      not refer to a package or Java companion object.
+   *  (2) Check that a stable identifier pattern is indeed stable (SLS 8.1.5)
+   */
+  private def checkLegalValue(tree: Tree, pt: Type)(using Context): Unit =
+    checkValue(tree, pt)
+    if ctx.mode.is(Mode.Pattern)
+       && !tree.isType
+       && !pt.isInstanceOf[ApplyingProto]
+       && !tree.tpe.isStable
+       && !isWildcardArg(tree)
+    then
+      report.error(StableIdentPattern(tree, pt), tree.srcPos)
+
+  def typedSelect(tree0: untpd.Select, pt: Type, qual: Tree)(using Context): Tree =
+    val selName = tree0.name
+    val tree = cpy.Select(tree0)(qual, selName)
+    val superAccess = qual.isInstanceOf[Super]
+    val rawType = selectionType(tree, qual)
+    val checkedType = accessibleType(rawType, superAccess)
+    if checkedType.exists then
+      val select = toNotNullTermRef(assignType(tree, checkedType), pt)
+      if selName.isTypeName then checkStable(qual.tpe, qual.srcPos, "type prefix")
+      checkLegalValue(select, pt)
+      ConstFold(select)
+    else if selName == nme.apply && qual.tpe.widen.isInstanceOf[MethodType] then
+      // Simplify `m.apply(...)` to `m(...)`
+      qual
+    else if couldInstantiateTypeVar(qual.tpe.widen) then
+       // there's a simply visible type variable in the result; try again with a more defined qualifier type
+       // There's a second trial where we try to instantiate all type variables in `qual.tpe.widen`,
+       // but that is done only after we search for extension methods or conversions.
+      typedSelect(tree, pt, qual)
+    else
+      val tree1 = tryExtensionOrConversion(
+          tree, pt, IgnoredProto(pt), qual, ctx.typerState.ownedVars, this, inSelect = true)
+      if !tree1.isEmpty then
+        tree1
+      else if canDefineFurther(qual.tpe.widen) then
+        typedSelect(tree, pt, qual)
+      else if qual.tpe.derivesFrom(defn.DynamicClass)
+        && selName.isTermName && !isDynamicExpansion(tree)
+      then
+        val tree2 = cpy.Select(tree0)(untpd.TypedSplice(qual), selName)
+        if pt.isInstanceOf[FunOrPolyProto] || pt == AssignProto then
+          assignType(tree2, TryDynamicCallType)
+        else
+          typedDynamicSelect(tree2, Nil, pt)
+      else
+        assignType(tree,
+          rawType match
+            case rawType: NamedType =>
+              inaccessibleErrorType(rawType, superAccess, tree.srcPos)
+            case _ =>
+              notAMemberErrorType(tree, qual))
+  end typedSelect
+
+  def typedSelect(tree: untpd.Select, pt: Type)(using Context): Tree = {
+    record("typedSelect")
+
+    def typeSelectOnTerm(using Context): Tree =
+      val qual = typedExpr(tree.qualifier, shallowSelectionProto(tree.name, pt, this))
+      typedSelect(tree, pt, qual).withSpan(tree.span).computeNullable()
+
+    def javaSelectOnType(qual: Tree)(using Context) =
+      // semantic name conversion for `O$` in java code
+      if !qual.symbol.is(JavaDefined) then
+        val tree2 = untpd.cpy.Select(tree)(qual, tree.name.unmangleClassName)
+        assignType(tree2, qual)
+      else
+        assignType(cpy.Select(tree)(qual, tree.name), qual)
+
+    def tryJavaSelectOnType(using Context): Tree = tree.qualifier match {
+      case sel @ Select(qual, name) =>
+        val qual1 = untpd.cpy.Select(sel)(qual, name.toTypeName)
+        val qual2 = typedType(qual1, WildcardType)
+        javaSelectOnType(qual2)
+
+      case id @ Ident(name) =>
+        val qual1 = untpd.cpy.Ident(id)(name.toTypeName)
+        val qual2 = typedType(qual1, WildcardType)
+        javaSelectOnType(qual2)
+
+      case _ =>
+        errorTree(tree, "cannot convert to type selection") // will never be printed due to fallback
+    }
+
+    def selectWithFallback(fallBack: Context ?-> Tree) =
+      tryAlternatively(typeSelectOnTerm)(fallBack)
+
+    if (tree.qualifier.isType) {
+      val qual1 = typedType(tree.qualifier, shallowSelectionProto(tree.name, pt, this))
+      assignType(cpy.Select(tree)(qual1, tree.name), qual1)
+    }
+    else if (ctx.isJava && tree.name.isTypeName)
+      // SI-3120 Java uses the same syntax, A.B, to express selection from the
+      // value A and from the type A. We have to try both.
+      selectWithFallback(tryJavaSelectOnType) // !!! possibly exponential bcs of qualifier retyping
+    else
+      typeSelectOnTerm
+  }
+
+  def typedThis(tree: untpd.This)(using Context): Tree = {
+    record("typedThis")
+    assignType(tree)
+  }
+
+  def typedSuper(tree: untpd.Super, pt: Type)(using Context): Tree = {
+    val qual1 = typed(tree.qual)
+    val enclosingInlineable = ctx.owner.ownersIterator.findSymbol(_.isInlineMethod)
+    if (enclosingInlineable.exists && !PrepareInlineable.isLocal(qual1.symbol, enclosingInlineable))
+      report.error(SuperCallsNotAllowedInlineable(enclosingInlineable), tree.srcPos)
+    pt match {
+      case pt: SelectionProto if pt.name.isTypeName =>
+        qual1 // don't do super references for types; they are meaningless anyway
+      case _ =>
+        assignType(cpy.Super(tree)(qual1, tree.mix), qual1)
+    }
+  }
+
+  def typedNumber(tree: untpd.Number, pt: Type)(using Context): Tree = {
+    import scala.util.FromDigits._
+    import untpd.NumberKind._
+    record("typedNumber")
+    val digits = tree.digits
+    val target = pt.dealias
+    def lit(value: Any) = Literal(Constant(value)).withSpan(tree.span)
+    try {
+      // Special case primitive numeric types
+      if (target.isRef(defn.IntClass) ||
+          target.isRef(defn.CharClass) ||
+          target.isRef(defn.ByteClass) ||
+          target.isRef(defn.ShortClass))
+        tree.kind match {
+          case Whole(radix) => return lit(intFromDigits(digits, radix))
+          case _ =>
+        }
+      else if (target.isRef(defn.LongClass))
+        tree.kind match {
+          case Whole(radix) => return lit(longFromDigits(digits, radix))
+          case _ =>
+        }
+      else if (target.isRef(defn.FloatClass))
+        tree.kind match {
+          case Whole(16) => // cant parse hex literal as float
+          case _         =>
+            val float = floatFromDigits(digits)
+            if digits.toIntOption.exists(_ != float.toInt) then
+              report.warning(LossyWideningConstantConversion(defn.IntType, target), tree.srcPos)
+            return lit(float)
+        }
+      else if (target.isRef(defn.DoubleClass))
+        tree.kind match {
+          case Whole(16) => // cant parse hex literal as double
+          case _         => return lit(doubleFromDigits(digits))
+        }
+      else if Feature.genericNumberLiteralsEnabled
+          && target.isValueType && isFullyDefined(target, ForceDegree.none)
+      then
+        // If expected type is defined with a FromDigits instance, use that one
+        val fromDigitsCls = tree.kind match {
+          case Whole(10) => defn.FromDigitsClass
+          case Whole(_) => defn.FromDigits_WithRadixClass
+          case Decimal => defn.FromDigits_DecimalClass
+          case Floating => defn.FromDigits_FloatingClass
+        }
+        inferImplicit(fromDigitsCls.typeRef.appliedTo(target), EmptyTree, tree.span) match {
+          case SearchSuccess(arg, _, _, _) =>
+            val fromDigits = untpd.Select(untpd.TypedSplice(arg), nme.fromDigits).withSpan(tree.span)
+            val firstArg = Literal(Constant(digits))
+            val otherArgs = tree.kind match {
+              case Whole(r) if r != 10 => Literal(Constant(r)) :: Nil
+              case _ => Nil
+            }
+            var app: untpd.Tree = untpd.Apply(fromDigits, firstArg :: otherArgs)
+            if (ctx.mode.is(Mode.Pattern)) app = untpd.Block(Nil, app)
+            return typed(app, pt)
+          case _ =>
+        }
+      // Otherwise convert to Int or Double according to digits format
+      tree.kind match {
+        case Whole(radix) => lit(intFromDigits(digits, radix))
+        case _ => lit(doubleFromDigits(digits))
+      }
+    }
+    catch {
+      case ex: FromDigitsException =>
+        report.error(ex.getMessage.nn, tree.srcPos)
+        tree.kind match {
+          case Whole(_) => lit(0)
+          case _ => lit(0.0)
+        }
+    }
+  }
+
+  def typedLiteral(tree: untpd.Literal)(using Context): Tree = {
+    val tree1 = assignType(tree)
+    if (ctx.mode.is(Mode.Type)) tpd.SingletonTypeTree(tree1) // this ensures that tree is classified as a type tree
+    else tree1
+  }
+
+  def typedNew(tree: untpd.New, pt: Type)(using Context): Tree =
+    tree.tpt match {
+      case templ: untpd.Template =>
+        import untpd._
+        var templ1 = templ
+        def isEligible(tp: Type) =
+        	tp.exists
+        	&& !tp.typeSymbol.is(Final)
+        	&& (!tp.isTopType || tp.isAnyRef) // Object is the only toplevel class that can be instantiated
+        if (templ1.parents.isEmpty &&
+            isFullyDefined(pt, ForceDegree.flipBottom) &&
+            isSkolemFree(pt) &&
+            isEligible(pt.underlyingClassRef(refinementOK = false)))
+          templ1 = cpy.Template(templ)(parents = untpd.TypeTree(pt) :: Nil)
+        templ1.parents foreach {
+          case parent: RefTree =>
+            typedAhead(parent, tree => inferTypeParams(typedType(tree), pt))
+          case _ =>
+        }
+        val x = tpnme.ANON_CLASS
+        val clsDef = TypeDef(x, templ1).withFlags(Final | Synthetic)
+        typed(cpy.Block(tree)(clsDef :: Nil, New(Ident(x), Nil)), pt)
+      case _ =>
+        var tpt1 = typedType(tree.tpt)
+        val tsym = tpt1.tpe.underlyingClassRef(refinementOK = false).typeSymbol
+        if tsym.is(Package) then
+          report error(em"$tsym cannot be instantiated", tpt1.srcPos)
+        tpt1 = tpt1.withType(ensureAccessible(tpt1.tpe, superAccess = false, tpt1.srcPos))
+        tpt1 match {
+          case AppliedTypeTree(_, targs) =>
+            for case targ: TypeBoundsTree <- targs do
+              report.error(WildcardOnTypeArgumentNotAllowedOnNew(), targ.srcPos)
+          case _ =>
+        }
+
+        assignType(cpy.New(tree)(tpt1), tpt1)
+    }
+
+  def typedTyped(tree: untpd.Typed, pt: Type)(using Context): Tree = {
+
+    /*  Handles three cases:
+     *  @param  ifPat    how to handle a pattern (_: T)
+     *  @param  ifExpr   how to handle an expression (e: T)
+     *  @param  wildName what name `w` to use in the rewriting of
+     *                   (x: T) to (x @ (w: T)). This is either `_` or `_*`.
+     */
+    def cases(ifPat: => Tree, ifExpr: => Tree, wildName: TermName) = tree.expr match {
+      case id: untpd.Ident if (ctx.mode is Mode.Pattern) && untpd.isVarPattern(id) =>
+        if (id.name == nme.WILDCARD || id.name == nme.WILDCARD_STAR) ifPat
+        else {
+          import untpd._
+          typed(Bind(id.name, Typed(Ident(wildName), tree.tpt)).withSpan(tree.span), pt)
+        }
+      case _ => ifExpr
+    }
+
+    def ascription(tpt: Tree, isWildcard: Boolean) = {
+      val underlyingTreeTpe =
+        if (isRepeatedParamType(tpt)) TypeTree(defn.SeqType.appliedTo(pt :: Nil))
+        else tpt
+      val expr1 =
+        if isWildcard then tree.expr.withType(underlyingTreeTpe.tpe)
+        else typed(tree.expr, underlyingTreeTpe.tpe.widenSkolem)
+      assignType(cpy.Typed(tree)(expr1, tpt), underlyingTreeTpe)
+        .withNotNullInfo(expr1.notNullInfo)
+    }
+
+    if (untpd.isWildcardStarArg(tree)) {
+      def typedWildcardStarArgExpr = {
+        // A sequence argument `xs: _*` can be either a `Seq[T]` or an `Array[_ <: T]`,
+        // irrespective of whether the method we're calling is a Java or Scala method,
+        // so the expected type is the union `Seq[T] | Array[_ <: T]`.
+        val ptArg =
+          // FIXME(#8680): Quoted patterns do not support Array repeated arguments
+          if ctx.mode.is(Mode.QuotedPattern) then
+            pt.translateFromRepeated(toArray = false, translateWildcard = true)
+          else
+            pt.translateFromRepeated(toArray = false, translateWildcard = true)
+            | pt.translateFromRepeated(toArray = true,  translateWildcard = true)
+        val expr0 = typedExpr(tree.expr, ptArg)
+        val expr1 = if ctx.explicitNulls && (!ctx.mode.is(Mode.Pattern)) then
+            if expr0.tpe.isNullType then
+              // If the type of the argument is `Null`, we cast it to array directly.
+              expr0.cast(pt.translateParameterized(defn.RepeatedParamClass, defn.ArrayClass))
+            else
+              // We need to make sure its type is no longer nullable
+              expr0.castToNonNullable
+          else expr0
+        val fromCls =
+          if expr1.tpe.derivesFrom(defn.ArrayClass)
+          then defn.ArrayClass
+          else defn.SeqClass
+        val tpt1 = TypeTree(expr1.tpe.widen.translateToRepeated(fromCls)).withSpan(tree.tpt.span)
+        assignType(cpy.Typed(tree)(expr1, tpt1), tpt1)
+      }
+      cases(
+        ifPat = ascription(TypeTree(defn.RepeatedParamType.appliedTo(pt)), isWildcard = true),
+        ifExpr = typedWildcardStarArgExpr,
+        wildName = nme.WILDCARD_STAR)
+    }
+    else {
+      def typedTpt = checkSimpleKinded(typedType(tree.tpt, mapPatternBounds = true))
+      def handlePattern: Tree = {
+        val tpt1 = typedTpt
+        if !ctx.isAfterTyper && pt != defn.ImplicitScrutineeTypeRef then
+          withMode(Mode.GadtConstraintInference) {
+            TypeComparer.constrainPatternType(tpt1.tpe, pt)
+          }
+        val matched = ascription(tpt1, isWildcard = true)
+        // special case for an abstract type that comes with a class tag
+        val result = tryWithTypeTest(matched, pt)
+        if (result eq matched)
+           && pt != defn.ImplicitScrutineeTypeRef
+           && !(pt <:< tpt1.tpe)
+        then
+          // no check for matchability if TestTest was applied
+          checkMatchable(pt, tree.srcPos, pattern = true)
+        result
+      }
+      cases(
+        ifPat = handlePattern,
+        ifExpr = ascription(typedTpt, isWildcard = false),
+        wildName = nme.WILDCARD)
+    }
+  }
+
+  /** For a typed tree `e: T`, if `T` is an abstract type for which an implicit type test or class tag `tt`
+   *  exists, rewrite to `tt(e)`.
+   *  @pre We are in pattern-matching mode (Mode.Pattern)
+   */
+  def tryWithTypeTest(tree: Typed, pt: Type)(using Context): Tree =
+    def withTag(tpe: Type): Option[Tree] = {
+      require(ctx.mode.is(Mode.Pattern))
+      withoutMode(Mode.Pattern)(
+        inferImplicit(tpe, EmptyTree, tree.tpt.span)
+      ) match
+        case SearchSuccess(clsTag, _, _, _) =>
+          withMode(Mode.InTypeTest) {
+            Some(typed(untpd.Apply(untpd.TypedSplice(clsTag), untpd.TypedSplice(tree.expr)), pt))
+          }
+        case _ =>
+          None
+    }
+    def tagged(tpe: Type) = {
+      val tag = withTag(defn.TypeTestClass.typeRef.appliedTo(pt, tpe))
+          .orElse(withTag(defn.ClassTagClass.typeRef.appliedTo(tpe)))
+          .getOrElse(tree)
+      if tag.symbol.maybeOwner == defn.ClassTagClass && config.Feature.sourceVersion.isAtLeast(config.SourceVersion.future) then
+        report.warning("Use of `scala.reflect.ClassTag` for type testing may be unsound. Consider using `scala.reflect.TypeTest` instead.", tree.srcPos)
+      tag
+    }
+    tree.tpt.tpe.dealias match {
+      case tpe @ AppliedType(tref: TypeRef, _) if !tref.symbol.isClass && !ctx.isAfterTyper && !(tpe =:= pt) => tagged(tpe)
+      case tref: TypeRef if !tref.symbol.isClass && !ctx.isAfterTyper && !(tref =:= pt) => tagged(tref)
+      case _ => tree
+    }
+
+
+  def typedNamedArg(tree: untpd.NamedArg, pt: Type)(using Context): NamedArg = {
+    /* Special case for resolving types for arguments of an annotation defined in Java.
+     * It allows that value of any type T can appear in positions where Array[T] is expected.
+     * For example, both `@Annot(5)` and `@Annot({5, 6}) are viable calls of the constructor
+     * of annotation defined as `@interface Annot { int[] value() }`
+     * We assume that calling `typedNamedArg` in context of Java implies that we are dealing
+     * with annotation contructor, as named arguments are not allowed anywhere else in Java.
+     * Under explicit nulls, the pt could be nullable. We need to strip `Null` type first.
+     */
+    val arg1 = pt.stripNull match {
+      case AppliedType(a, typ :: Nil) if ctx.isJava && a.isRef(defn.ArrayClass) =>
+        tryAlternatively { typed(tree.arg, pt) } {
+            val elemTp = untpd.TypedSplice(TypeTree(typ))
+            typed(untpd.JavaSeqLiteral(tree.arg :: Nil, elemTp), pt)
+        }
+      case _ => typed(tree.arg, pt)
+    }
+
+    assignType(cpy.NamedArg(tree)(tree.name, arg1), arg1)
+  }
+
+  def typedAssign(tree: untpd.Assign, pt: Type)(using Context): Tree =
+    tree.lhs match {
+      case lhs @ Apply(fn, args) =>
+        typed(untpd.Apply(untpd.Select(fn, nme.update), args :+ tree.rhs), pt)
+      case untpd.TypedSplice(Apply(MaybePoly(Select(fn, app), targs), args)) if app == nme.apply =>
+        val rawUpdate: untpd.Tree = untpd.Select(untpd.TypedSplice(fn), nme.update)
+        val wrappedUpdate =
+          if (targs.isEmpty) rawUpdate
+          else untpd.TypeApply(rawUpdate, targs map (untpd.TypedSplice(_)))
+        val appliedUpdate =
+          untpd.Apply(wrappedUpdate, (args map (untpd.TypedSplice(_))) :+ tree.rhs)
+        typed(appliedUpdate, pt)
+      case lhs =>
+        val locked = ctx.typerState.ownedVars
+        val lhsCore = typedUnadapted(lhs, AssignProto, locked)
+        def lhs1 = adapt(lhsCore, AssignProto, locked)
+
+        def reassignmentToVal =
+          errorTree(cpy.Assign(tree)(lhsCore, typed(tree.rhs, lhs1.tpe.widen)),
+            ReassignmentToVal(lhsCore.symbol.name))
+
+        def canAssign(sym: Symbol) =
+          sym.is(Mutable, butNot = Accessor) ||
+          ctx.owner.isPrimaryConstructor && !sym.is(Method) && sym.maybeOwner == ctx.owner.owner ||
+            // allow assignments from the primary constructor to class fields
+          ctx.owner.name.is(TraitSetterName) || ctx.owner.isStaticConstructor
+
+        lhsCore match
+          case Apply(fn, _) if fn.symbol.is(ExtensionMethod) =>
+            def toSetter(fn: Tree): untpd.Tree = fn match
+              case fn @ Ident(name: TermName) =>
+                untpd.cpy.Ident(fn)(name.setterName)
+              case fn @ Select(qual, name: TermName) =>
+                untpd.cpy.Select(fn)(untpd.TypedSplice(qual), name.setterName)
+              case fn @ TypeApply(fn1, targs) =>
+                untpd.cpy.TypeApply(fn)(toSetter(fn1), targs.map(untpd.TypedSplice(_)))
+              case fn @ Apply(fn1, args) =>
+                val result = untpd.cpy.Apply(fn)(
+                  toSetter(fn1),
+                  args.map(untpd.TypedSplice(_, isExtensionReceiver = true)))
+                fn1 match
+                  case Apply(_, _) => // current apply is to implicit arguments
+                    result.setApplyKind(ApplyKind.Using)
+                      // Note that we cannot copy the apply kind of `fn` since `fn` is a typed
+                      // tree and applyKinds are not preserved for those.
+                  case _ => result
+              case _ =>
+                EmptyTree
+
+            val setter = toSetter(lhsCore)
+            if setter.isEmpty then reassignmentToVal
+            else tryEither {
+              val assign = untpd.Apply(setter, tree.rhs :: Nil)
+              typed(assign, IgnoredProto(pt))
+            } {
+              (_, _) => reassignmentToVal
+            }
+          case _ => lhsCore.tpe match {
+            case ref: TermRef =>
+              val lhsVal = lhsCore.denot.suchThat(!_.is(Method))
+              if (canAssign(lhsVal.symbol)) {
+                // lhsBounds: (T .. Any) as seen from lhs prefix, where T is the type of lhsVal.symbol
+                // This ensures we do the as-seen-from on T with variance -1. Test case neg/i2928.scala
+                val lhsBounds =
+                  TypeBounds.lower(lhsVal.symbol.info).asSeenFrom(ref.prefix, lhsVal.symbol.owner)
+                assignType(cpy.Assign(tree)(lhs1, typed(tree.rhs, lhsBounds.loBound)))
+                  .computeAssignNullable()
+              }
+              else {
+                val pre = ref.prefix
+                val setterName = ref.name.setterName
+                val setter = pre.member(setterName)
+                lhsCore match {
+                  case lhsCore: RefTree if setter.exists =>
+                    val setterTypeRaw = pre.select(setterName, setter)
+                    val setterType = ensureAccessible(setterTypeRaw, isSuperSelection(lhsCore), tree.srcPos)
+                    val lhs2 = untpd.rename(lhsCore, setterName).withType(setterType)
+                    typedUnadapted(untpd.Apply(untpd.TypedSplice(lhs2), tree.rhs :: Nil), WildcardType, locked)
+                  case _ =>
+                    reassignmentToVal
+                }
+              }
+            case TryDynamicCallType =>
+              typedDynamicAssign(tree, pt)
+            case tpe =>
+              reassignmentToVal
+        }
+    }
+
+  def typedBlockStats(stats: List[untpd.Tree])(using Context): (List[tpd.Tree], Context) =
+    index(stats)
+    typedStats(stats, ctx.owner)
+
+  def typedBlock(tree: untpd.Block, pt: Type)(using Context): Tree = {
+    val (stats1, exprCtx) = withoutMode(Mode.Pattern) {
+      typedBlockStats(tree.stats)
+    }
+    var expr1 = typedExpr(tree.expr, pt.dropIfProto)(using exprCtx)
+
+    // If unsafe nulls is enabled inside a block but not enabled outside
+    // and the type does not conform the expected type without unsafe nulls,
+    // we will cast the last expression to the expected type.
+    // See: tests/explicit-nulls/pos/unsafe-block.scala
+    if ctx.mode.is(Mode.SafeNulls)
+      && !exprCtx.mode.is(Mode.SafeNulls)
+      && pt.isValueType
+      && !inContext(exprCtx.addMode(Mode.SafeNulls))(expr1.tpe <:< pt) then
+      expr1 = expr1.cast(pt)
+
+    ensureNoLocalRefs(
+      cpy.Block(tree)(stats1, expr1)
+        .withType(expr1.tpe)
+        .withNotNullInfo(stats1.foldRight(expr1.notNullInfo)(_.notNullInfo.seq(_))),
+      pt, localSyms(stats1))
+  }
+
+  def escapingRefs(block: Tree, localSyms: => List[Symbol])(using Context): List[NamedType] = {
+    lazy val locals = localSyms.toSet
+    block.tpe.namedPartsWith(tp => locals.contains(tp.symbol) && !tp.isErroneous)
+  }
+
+  /** Ensure that an expression's type can be expressed without references to locally defined
+   *  symbols. This is done by adding a type ascription of a widened type that does
+   *  not refer to the locally defined symbols. The widened type is computed using
+   *  `TyperAssigner#avoid`. However, if the expected type is fully defined and not
+   *  a supertype of the widened type, we ascribe with the expected type instead.
+   *
+   *  There's a special case having to do with anonymous classes. Sometimes the
+   *  expected type of a block is the anonymous class defined inside it. In that
+   *  case there's technically a leak which is not removed by the ascription.
+   */
+  protected def ensureNoLocalRefs(tree: Tree, pt: Type, localSyms: -> List[Symbol])(using Context): Tree = {
+    def ascribeType(tree: Tree, pt: Type): Tree = tree match {
+      case block @ Block(stats, expr) if !expr.isInstanceOf[Closure] =>
+        val expr1 = ascribeType(expr, pt)
+        cpy.Block(block)(stats, expr1) withType expr1.tpe // no assignType here because avoid is redundant
+      case _ =>
+        val target = pt.simplified
+        val targetTpt = InferredTypeTree().withType(target)
+        if tree.tpe <:< target then Typed(tree, targetTpt)
+        else
+          // This case should not normally arise. It currently does arise in test cases
+          // pos/t4080b.scala and pos/i7067.scala. In that case, a type ascription is wrong
+          // and would not pass Ycheck. We have to use a cast instead. TODO: follow-up why
+          // the cases arise and eliminate them, if possible.
+          tree.cast(targetTpt)
+    }
+    def noLeaks(t: Tree): Boolean = escapingRefs(t, localSyms).isEmpty
+    if (noLeaks(tree)) tree
+    else {
+      fullyDefinedType(tree.tpe, "block", tree.srcPos)
+      var avoidingType = TypeOps.avoid(tree.tpe, localSyms)
+      val ptDefined = isFullyDefined(pt, ForceDegree.none)
+      if (ptDefined && !(avoidingType.widenExpr <:< pt)) avoidingType = pt
+      val tree1 = ascribeType(tree, avoidingType)
+      assert(ptDefined || noLeaks(tree1) || tree1.tpe.isErroneous,
+          // `ptDefined` needed because of special case of anonymous classes
+          i"leak: ${escapingRefs(tree1, localSyms).toList}%, % in $tree1")
+      tree1
+    }
+  }
+
+  def typedIf(tree: untpd.If, pt: Type)(using Context): Tree =
+    if tree.isInline then checkInInlineContext("inline if", tree.srcPos)
+    val cond1 = typed(tree.cond, defn.BooleanType)
+
+    def isIncomplete(tree: untpd.If): Boolean = tree.elsep match
+      case EmptyTree => true
+      case elsep: untpd.If => isIncomplete(elsep)
+      case _ => false
+
+    // Insert a GADT cast if the type of the branch does not conform
+    //   to the type assigned to the whole if tree.
+    // This happens when the computation of the type of the if tree
+    //   uses GADT constraints. See #15646.
+    def gadtAdaptBranch(tree: Tree, branchPt: Type): Tree =
+      TypeComparer.testSubType(tree.tpe.widenExpr, branchPt) match {
+        case CompareResult.OKwithGADTUsed =>
+          insertGadtCast(tree, tree.tpe.widen, branchPt)
+        case _ => tree
+      }
+
+    val branchPt = if isIncomplete(tree) then defn.UnitType else pt.dropIfProto
+
+    val result =
+      if tree.elsep.isEmpty then
+        val thenp1 = typed(tree.thenp, branchPt)(using cond1.nullableContextIf(true))
+        val elsep1 = tpd.unitLiteral.withSpan(tree.span.endPos)
+        cpy.If(tree)(cond1, thenp1, elsep1).withType(defn.UnitType)
+      else
+        val thenp1 :: elsep1 :: Nil = harmonic(harmonize, pt) {
+          val thenp0 = typed(tree.thenp, branchPt)(using cond1.nullableContextIf(true))
+          val elsep0 = typed(tree.elsep, branchPt)(using cond1.nullableContextIf(false))
+          thenp0 :: elsep0 :: Nil
+        }: @unchecked
+
+        val resType = thenp1.tpe | elsep1.tpe
+        val thenp2 :: elsep2 :: Nil =
+          (thenp1 :: elsep1 :: Nil) map { t =>
+            // Adapt each branch to ensure that their types conforms to the
+            //   type assigned to the if tree by inserting GADT casts.
+            gadtAdaptBranch(t, resType)
+          }: @unchecked
+
+        cpy.If(tree)(cond1, thenp2, elsep2).withType(resType)
+
+    def thenPathInfo = cond1.notNullInfoIf(true).seq(result.thenp.notNullInfo)
+    def elsePathInfo = cond1.notNullInfoIf(false).seq(result.elsep.notNullInfo)
+    result.withNotNullInfo(
+      if result.thenp.tpe.isRef(defn.NothingClass) then elsePathInfo
+      else if result.elsep.tpe.isRef(defn.NothingClass) then thenPathInfo
+      else thenPathInfo.alt(elsePathInfo)
+    )
+  end typedIf
+
+  /** Decompose function prototype into a list of parameter prototypes and a result prototype
+   *  tree, using WildcardTypes where a type is not known.
+   *  For the result type we do this even if the expected type is not fully
+   *  defined, which is a bit of a hack. But it's needed to make the following work
+   *  (see typers.scala and printers/PlainPrinter.scala for examples).
+   *
+   *     def double(x: Char): String = s"$x$x"
+   *     "abc" flatMap double
+   */
+  private def decomposeProtoFunction(pt: Type, defaultArity: Int, pos: SrcPos)(using Context): (List[Type], untpd.Tree) = {
+    def typeTree(tp: Type) = tp match {
+      case _: WildcardType => new untpd.InferredTypeTree()
+      case _ => untpd.InferredTypeTree(tp)
+    }
+    def interpolateWildcards = new TypeMap {
+      def apply(t: Type): Type = t match
+        case WildcardType(bounds: TypeBounds) =>
+          newTypeVar(apply(bounds.orElse(TypeBounds.empty)).bounds)
+        case _ => mapOver(t)
+    }
+
+    val pt1 = pt.strippedDealias.normalized
+    if (pt1 ne pt1.dropDependentRefinement)
+       && defn.isContextFunctionType(pt1.nonPrivateMember(nme.apply).info.finalResultType)
+    then
+      report.error(
+        i"""Implementation restriction: Expected result type $pt1
+           |is a curried dependent context function type. Such types are not yet supported.""",
+        pos)
+    pt1 match {
+      case tp: TypeParamRef =>
+        decomposeProtoFunction(ctx.typerState.constraint.entry(tp).bounds.hi, defaultArity, pos)
+      case _ => pt1.findFunctionType match {
+        case pt1 if defn.isNonRefinedFunction(pt1) =>
+          // if expected parameter type(s) are wildcards, approximate from below.
+          // if expected result type is a wildcard, approximate from above.
+          // this can type the greatest set of admissible closures.
+          (pt1.argTypesLo.init, typeTree(interpolateWildcards(pt1.argTypesHi.last)))
+        case RefinedType(parent, nme.apply, mt @ MethodTpe(_, formals, restpe))
+        if defn.isNonRefinedFunction(parent) && formals.length == defaultArity =>
+          (formals, untpd.DependentTypeTree(syms => restpe.substParams(mt, syms.map(_.termRef))))
+        case SAMType(mt @ MethodTpe(_, formals, restpe)) =>
+          (formals,
+           if (mt.isResultDependent)
+             untpd.DependentTypeTree(syms => restpe.substParams(mt, syms.map(_.termRef)))
+           else
+             typeTree(restpe))
+        case _ =>
+          (List.tabulate(defaultArity)(alwaysWildcardType), untpd.TypeTree())
+      }
+    }
+  }
+
+  /** The parameter type for a parameter in a lambda that does
+   *  not have an explicit type given, and where the type is not known from the context.
+   *  In this case the parameter type needs to be inferred the "target type" T known
+   *  from the callee `f` if the lambda is of a form like `x => f(x)`.
+   *  If `T` exists, we know that `S <: I <: T`.
+   *
+   *  The inference makes two attempts:
+   *
+   *    1. Compute the target type `T` and make it known that `S <: T`.
+   *       If the expected type `S` can be fully defined under ForceDegree.flipBottom,
+   *       pick this one (this might use the fact that S <: T for an upper approximation).
+   *    2. Otherwise, if the target type `T` can be fully defined under ForceDegree.flipBottom,
+   *       pick this one.
+   *
+   *  If both attempts fail, return `NoType`.
+   */
+  def inferredFromTarget(
+      param: untpd.ValDef, formal: Type, calleeType: Type, paramIndex: Name => Int)(using Context): Type =
+    val target = calleeType.widen match
+      case mtpe: MethodType =>
+        val pos = paramIndex(param.name)
+        if pos < mtpe.paramInfos.length then
+          mtpe.paramInfos(pos)
+            // This works only if vararg annotations match up.
+            // See neg/i14367.scala for an example where the inferred type is mispredicted.
+            // Nevertheless, the alternative would be to give up completely, so this is
+            // defensible.
+        else NoType
+      case _ => NoType
+    if target.exists then formal <:< target
+    if isFullyDefined(formal, ForceDegree.flipBottom) then formal
+    else if target.exists && isFullyDefined(target, ForceDegree.flipBottom) then target
+    else NoType
+
+  def typedFunction(tree: untpd.Function, pt: Type)(using Context): Tree =
+    if (ctx.mode is Mode.Type) typedFunctionType(tree, pt)
+    else typedFunctionValue(tree, pt)
+
+  def typedFunctionType(tree: untpd.Function, pt: Type)(using Context): Tree = {
+    val untpd.Function(args, body) = tree
+    var funFlags = tree match {
+      case tree: untpd.FunctionWithMods => tree.mods.flags
+      case _ => EmptyFlags
+    }
+
+    assert(!funFlags.is(Erased) || !args.isEmpty, "An empty function cannot not be erased")
+
+    val numArgs = args.length
+    val isContextual = funFlags.is(Given)
+    val isErased = funFlags.is(Erased)
+    val isImpure = funFlags.is(Impure)
+    val funSym = defn.FunctionSymbol(numArgs, isContextual, isErased, isImpure)
+
+    /** If `app` is a function type with arguments that are all erased classes,
+     *  turn it into an erased function type.
+     */
+    def propagateErased(app: Tree): Tree = app match
+      case AppliedTypeTree(tycon: TypeTree, args)
+      if !isErased
+         && numArgs > 0
+         && args.indexWhere(!_.tpe.isErasedClass) == numArgs =>
+        val tycon1 = TypeTree(defn.FunctionSymbol(numArgs, isContextual, true, isImpure).typeRef)
+          .withSpan(tycon.span)
+        assignType(cpy.AppliedTypeTree(app)(tycon1, args), tycon1, args)
+      case _ =>
+        app
+
+    /** Typechecks dependent function type with given parameters `params` */
+    def typedDependent(params: List[untpd.ValDef])(using Context): Tree =
+      val fixThis = new untpd.UntypedTreeMap:
+        // pretype all references of this in outer context,
+        // so that they do not refer to the refined type being constructed
+        override def transform(tree: untpd.Tree)(using Context): untpd.Tree = tree match
+          case This(id) => untpd.TypedSplice(typedExpr(tree)(using ctx.outer))
+          case _ => super.transform(tree)
+
+      val params1 =
+        if funFlags.is(Given) then params.map(_.withAddedFlags(Given))
+        else params
+      val params2 = params1.map(fixThis.transformSub)
+      val appDef0 = untpd.DefDef(nme.apply, List(params2), body, EmptyTree).withSpan(tree.span)
+      index(appDef0 :: Nil)
+      val appDef = typed(appDef0).asInstanceOf[DefDef]
+      val mt = appDef.symbol.info.asInstanceOf[MethodType]
+      if (mt.isParamDependent)
+        report.error(i"$mt is an illegal function type because it has inter-parameter dependencies", tree.srcPos)
+      val resTpt = TypeTree(mt.nonDependentResultApprox).withSpan(body.span)
+      val typeArgs = appDef.termParamss.head.map(_.tpt) :+ resTpt
+      val tycon = TypeTree(funSym.typeRef)
+      val core = propagateErased(AppliedTypeTree(tycon, typeArgs))
+      RefinedTypeTree(core, List(appDef), ctx.owner.asClass)
+    end typedDependent
+
+    args match {
+      case ValDef(_, _, _) :: _ =>
+        typedDependent(args.asInstanceOf[List[untpd.ValDef]])(
+          using ctx.fresh.setOwner(newRefinedClassSymbol(tree.span)).setNewScope)
+      case _ =>
+        propagateErased(
+          typed(cpy.AppliedTypeTree(tree)(untpd.TypeTree(funSym.typeRef), args :+ body), pt))
+    }
+  }
+
+  def typedFunctionValue(tree: untpd.Function, pt: Type)(using Context): Tree = {
+    val untpd.Function(params: List[untpd.ValDef] @unchecked, _) = tree: @unchecked
+
+    val isContextual = tree match {
+      case tree: untpd.FunctionWithMods => tree.mods.is(Given)
+      case _ => false
+    }
+
+    /** The function body to be returned in the closure. Can become a TypedSplice
+     *  of a typed expression if this is necessary to infer a parameter type.
+     */
+    var fnBody = tree.body
+
+    def refersTo(arg: untpd.Tree, param: untpd.ValDef): Boolean = arg match
+      case Ident(name) => name == param.name
+      case Typed(arg1, _) if untpd.isWildcardStarArg(arg) => refersTo(arg1, param)
+      case _ => false
+
+    /** If parameter `param` appears exactly once as an argument in `args`,
+     *  the singleton list consisting of its position in `args`, otherwise `Nil`.
+     */
+    def paramIndices(param: untpd.ValDef, args: List[untpd.Tree]): List[Int] = {
+      def loop(args: List[untpd.Tree], start: Int): List[Int] = args match {
+        case arg :: args1 =>
+          val others = loop(args1, start + 1)
+          if (refersTo(arg, param)) start :: others else others
+        case _ => Nil
+      }
+      val allIndices = loop(args, 0)
+      if (allIndices.length == 1) allIndices else Nil
+    }
+
+    /** A map from parameter names to unique positions where the parameter
+     *  appears in the argument list of an application.
+     */
+    var paramIndex = Map[Name, Int]()
+
+    /** Infer parameter type from the body of the function
+     *
+     *  1. If function is of the form
+     *
+     *      (x1, ..., xN) => f(... x1, ..., XN, ...)
+     *
+     *  where each `xi` occurs exactly once in the argument list of `f` (in
+     *  any order), the type of `f`, otherwise NoType.
+     *
+     *  2. If the function is of the form
+     *
+     *     (using x1, ..., xN) => f
+     *
+     *  where `f` is a contextual function type of the form `(T1, ..., TN) ?=> T`,
+     *  then `xi` takes the type `Ti`.
+     *
+     *  Updates `fnBody` and `paramIndex` as a side effect.
+     *  @post: If result exists, `paramIndex` is defined for the name of
+     *         every parameter in `params`.
+     */
+    lazy val calleeType: Type = untpd.stripAnnotated(untpd.unsplice(fnBody)) match {
+      case ident: untpd.Ident if isContextual =>
+        val ident1 = typedIdent(ident, WildcardType)
+        val tp = ident1.tpe.widen
+        if defn.isContextFunctionType(tp) && params.size == defn.functionArity(tp) then
+          paramIndex = params.map(_.name).zipWithIndex.toMap
+          fnBody = untpd.TypedSplice(ident1)
+          tp.select(nme.apply)
+        else NoType
+      case app @ Apply(expr, args) =>
+        paramIndex = {
+          for (param <- params; idx <- paramIndices(param, args))
+          yield param.name -> idx
+        }.toMap
+        if (paramIndex.size == params.length)
+          expr match
+            case untpd.TypedSplice(expr1) =>
+              expr1.tpe
+            case _ =>
+              val outerCtx = ctx
+              val nestedCtx = outerCtx.fresh.setNewTyperState()
+              inContext(nestedCtx) {
+                val protoArgs = args map (_ withType WildcardType)
+                val callProto = FunProto(protoArgs, WildcardType)(this, app.applyKind)
+                val expr1 = typedExpr(expr, callProto)
+                if nestedCtx.reporter.hasErrors then NoType
+                else inContext(outerCtx) {
+                  nestedCtx.typerState.commit()
+                  fnBody = cpy.Apply(fnBody)(untpd.TypedSplice(expr1), args)
+                  expr1.tpe
+                }
+              }
+        else NoType
+      case _ =>
+        NoType
+    }
+
+    pt match {
+      case pt: TypeVar
+      if untpd.isFunctionWithUnknownParamType(tree) && !calleeType.exists =>
+        // try to instantiate `pt` if this is possible. If it does not
+        // work the error will be reported later in `inferredParam`,
+        // when we try to infer the parameter type.
+        isFullyDefined(pt, ForceDegree.flipBottom)
+      case _ =>
+    }
+
+    val (protoFormals, resultTpt) = decomposeProtoFunction(pt, params.length, tree.srcPos)
+
+    def protoFormal(i: Int): Type =
+      if (protoFormals.length == params.length) protoFormals(i)
+      else errorType(WrongNumberOfParameters(protoFormals.length), tree.srcPos)
+
+    /** Is `formal` a product type which is elementwise compatible with `params`? */
+    def ptIsCorrectProduct(formal: Type) =
+      isFullyDefined(formal, ForceDegree.flipBottom) &&
+      defn.isProductSubType(formal) &&
+      tupleComponentTypes(formal).corresponds(params) {
+        (argType, param) =>
+          param.tpt.isEmpty || argType.widenExpr <:< typedAheadType(param.tpt).tpe
+      }
+
+    var desugared: untpd.Tree = EmptyTree
+    if protoFormals.length == 1 && params.length != 1 && ptIsCorrectProduct(protoFormals.head) then
+      val isGenericTuple =
+        protoFormals.head.derivesFrom(defn.TupleClass)
+        && !defn.isTupleClass(protoFormals.head.typeSymbol)
+      desugared = desugar.makeTupledFunction(params, fnBody, isGenericTuple)
+    else if protoFormals.length > 1 && params.length == 1 then
+      def isParamRef(scrut: untpd.Tree): Boolean = scrut match
+        case untpd.Annotated(scrut1, _) => isParamRef(scrut1)
+        case untpd.Ident(id) => id == params.head.name
+      fnBody match
+        case untpd.Match(scrut, untpd.CaseDef(untpd.Tuple(elems), untpd.EmptyTree, rhs) :: Nil)
+        if scrut.span.isSynthetic && isParamRef(scrut) && elems.hasSameLengthAs(protoFormals) =>
+          // If `pt` is N-ary function type, convert synthetic lambda
+          //   x$1 => x$1 match case (a1, ..., aN) => e
+          // to
+          //   (a1, ..., aN) => e
+          val params1 = desugar.patternsToParams(elems)
+          if params1.hasSameLengthAs(elems) then
+            desugared = cpy.Function(tree)(params1, rhs)
+        case _ =>
+
+    if desugared.isEmpty then
+      val inferredParams: List[untpd.ValDef] =
+        for ((param, i) <- params.zipWithIndex) yield
+          if (!param.tpt.isEmpty) param
+          else
+            val formal = protoFormal(i)
+            val knownFormal = isFullyDefined(formal, ForceDegree.failBottom)
+            val paramType =
+              if knownFormal then formal
+              else inferredFromTarget(param, formal, calleeType, paramIndex)
+                .orElse(errorType(AnonymousFunctionMissingParamType(param, tree, formal), param.srcPos))
+            val paramTpt = untpd.TypedSplice(
+                (if knownFormal then InferredTypeTree() else untpd.TypeTree())
+                  .withType(paramType.translateFromRepeated(toArray = false))
+                  .withSpan(param.span.endPos)
+              )
+            cpy.ValDef(param)(tpt = paramTpt)
+      desugared = desugar.makeClosure(inferredParams, fnBody, resultTpt, isContextual, tree.span)
+
+    typed(desugared, pt)
+      .showing(i"desugared fun $tree --> $desugared with pt = $pt", typr)
+  }
+
+  def typedClosure(tree: untpd.Closure, pt: Type)(using Context): Tree = {
+    val env1 = tree.env mapconserve (typed(_))
+    val meth1 = typedUnadapted(tree.meth)
+    val target =
+      if (tree.tpt.isEmpty)
+        meth1.tpe.widen match {
+          case mt: MethodType =>
+            pt.findFunctionType match {
+              case pt @ SAMType(sam)
+              if !defn.isFunctionType(pt) && mt <:< sam =>
+                // SAMs of the form C[?] where C is a class cannot be conversion targets.
+                // The resulting class `class $anon extends C[?] {...}` would be illegal,
+                // since type arguments to `C`'s super constructor cannot be constructed.
+                def isWildcardClassSAM =
+                  !pt.classSymbol.is(Trait) && pt.argInfos.exists(_.isInstanceOf[TypeBounds])
+                val targetTpe =
+                  if isFullyDefined(pt, ForceDegree.all) && !isWildcardClassSAM then
+                    pt
+                  else if pt.isRef(defn.PartialFunctionClass) then
+                    // Replace the underspecified expected type by one based on the closure method type
+                    defn.PartialFunctionOf(mt.firstParamTypes.head, mt.resultType)
+                  else
+                    report.error(ex"result type of lambda is an underspecified SAM type $pt", tree.srcPos)
+                    pt
+                TypeTree(targetTpe)
+              case _ =>
+                if (mt.isParamDependent)
+                  errorTree(tree,
+                    i"""cannot turn method type $mt into closure
+                       |because it has internal parameter dependencies""")
+                else if ((tree.tpt `eq` untpd.ContextualEmptyTree) && mt.paramNames.isEmpty)
+                  // Note implicitness of function in target type since there are no method parameters that indicate it.
+                  TypeTree(defn.FunctionOf(Nil, mt.resType, isContextual = true, isErased = false))
+                else
+                  EmptyTree
+            }
+          case tp =>
+            if !tp.isErroneous then
+              throw new java.lang.Error(i"internal error: closing over non-method $tp, pos = ${tree.span}")
+            TypeTree(defn.AnyType)
+        }
+      else typed(tree.tpt)
+    //println(i"typing closure $tree : ${meth1.tpe.widen}")
+    assignType(cpy.Closure(tree)(env1, meth1, target), meth1, target)
+  }
+
+  def typedMatch(tree: untpd.Match, pt: Type)(using Context): Tree =
+    tree.selector match {
+      case EmptyTree =>
+        if (tree.isInline) {
+          checkInInlineContext("summonFrom", tree.srcPos)
+          val cases1 = tree.cases.mapconserve {
+            case cdef @ CaseDef(pat @ Typed(Ident(nme.WILDCARD), _), _, _) =>
+              // case _ : T  -->  case evidence$n : T
+              cpy.CaseDef(cdef)(pat = untpd.Bind(EvidenceParamName.fresh(), pat))
+            case cdef => cdef
+          }
+          typedMatchFinish(tree, tpd.EmptyTree, defn.ImplicitScrutineeTypeRef, cases1, pt)
+        }
+        else {
+          val (protoFormals, _) = decomposeProtoFunction(pt, 1, tree.srcPos)
+          val checkMode =
+            if (pt.isRef(defn.PartialFunctionClass)) desugar.MatchCheck.None
+            else desugar.MatchCheck.Exhaustive
+          typed(desugar.makeCaseLambda(tree.cases, checkMode, protoFormals.length).withSpan(tree.span), pt)
+        }
+      case _ =>
+        if tree.isInline then checkInInlineContext("inline match", tree.srcPos)
+        val sel1 = typedExpr(tree.selector)
+        val rawSelectorTpe = fullyDefinedType(sel1.tpe, "pattern selector", tree.srcPos)
+        val selType = rawSelectorTpe match
+          case c: ConstantType if tree.isInline => c
+          case otherTpe => otherTpe.widen
+
+        /** Does `tree` has the same shape as the given match type?
+         *  We only support typed patterns with empty guards, but
+         *  that could potentially be extended in the future.
+         */
+        def isMatchTypeShaped(mt: MatchType): Boolean =
+          mt.cases.size == tree.cases.size
+          && sel1.tpe.frozen_<:<(mt.scrutinee)
+          && tree.cases.forall(_.guard.isEmpty)
+          && tree.cases
+            .map(cas => untpd.unbind(untpd.unsplice(cas.pat)))
+            .zip(mt.cases)
+            .forall {
+              case (pat: untpd.Typed, pt) =>
+                // To check that pattern types correspond we need to type
+                // check `pat` here and throw away the result.
+                val gadtCtx: Context = ctx.fresh.setFreshGADTBounds
+                val pat1 = typedPattern(pat, selType)(using gadtCtx)
+                val Typed(_, tpt) = tpd.unbind(tpd.unsplice(pat1)): @unchecked
+                instantiateMatchTypeProto(pat1, pt) match {
+                  case defn.MatchCase(patternTp, _) => tpt.tpe frozen_=:= patternTp
+                  case _ => false
+                }
+              case (id @ Ident(nme.WILDCARD), pt) =>
+                pt match {
+                  case defn.MatchCase(patternTp, _) => defn.AnyType frozen_=:= patternTp
+                  case _ => false
+                }
+              case _ => false
+            }
+
+        val result = pt match {
+          case mt: MatchType if isMatchTypeShaped(mt) =>
+            typedDependentMatchFinish(tree, sel1, selType, tree.cases, mt)
+          case MatchType.InDisguise(mt) if isMatchTypeShaped(mt) =>
+            typedDependentMatchFinish(tree, sel1, selType, tree.cases, mt)
+          case _ =>
+            typedMatchFinish(tree, sel1, selType, tree.cases, pt)
+        }
+
+        /** Are some form of brackets necessary to annotate the tree `sel` as `@unchecked`?
+         *  If so, return a Some(opening bracket, closing bracket), otherwise None.
+         */
+        def uncheckedBrackets(sel: untpd.Tree): Option[(String, String)] = sel match
+          case _: untpd.If
+             | _: untpd.Match
+             | _: untpd.ForYield
+             | _: untpd.ParsedTry
+             | _: untpd.Try
+             | _: untpd.Typed => Some("(", ")")
+          case _: untpd.Block => Some("{", "}")
+          case _ => None
+
+        result match {
+          case result @ Match(sel, CaseDef(pat, _, _) :: _) =>
+            tree.selector.removeAttachment(desugar.CheckIrrefutable) match {
+              case Some(checkMode) if !sel.tpe.hasAnnotation(defn.UncheckedAnnot) =>
+                val isPatDef = checkMode == desugar.MatchCheck.IrrefutablePatDef
+                if !checkIrrefutable(sel, pat, isPatDef)
+                  && sourceVersion.isAtLeast(`3.2`)
+                  && sourceVersion.isMigrating
+                then
+                  if isPatDef then uncheckedBrackets(tree.selector) match
+                    case None =>
+                      patch(Span(tree.selector.span.end), ": @unchecked")
+                    case Some(bl, br) =>
+                      patch(Span(tree.selector.span.start), s"$bl")
+                      patch(Span(tree.selector.span.end), s"$br: @unchecked")
+                  else
+                    patch(Span(tree.span.start), "case ")
+
+                // skip exhaustivity check in later phase
+                // TODO: move the check above to patternMatcher phase
+                val uncheckedTpe = AnnotatedType(sel.tpe.widen, Annotation(defn.UncheckedAnnot))
+                tpd.cpy.Match(result)(
+                  selector = tpd.Typed(sel, tpd.TypeTree(uncheckedTpe)),
+                  cases = result.cases
+                )
+              case _ =>
+                result
+            }
+          case _ =>
+            result
+        }
+    }
+
+  /** Special typing of Match tree when the expected type is a MatchType,
+   *  and the patterns of the Match tree and the MatchType correspond.
+   */
+  def typedDependentMatchFinish(tree: untpd.Match, sel: Tree, wideSelType: Type, cases: List[untpd.CaseDef], pt: MatchType)(using Context): Tree = {
+    var caseCtx = ctx
+    val cases1 = tree.cases.zip(pt.cases)
+      .map { case (cas, tpe) =>
+        val case1 = typedCase(cas, sel, wideSelType, tpe)(using caseCtx)
+        caseCtx = Nullables.afterPatternContext(sel, case1.pat)
+        case1
+      }
+      .asInstanceOf[List[CaseDef]]
+    assignType(cpy.Match(tree)(sel, cases1), sel, cases1).cast(pt)
+  }
+
+  // Overridden in InlineTyper for inline matches
+  def typedMatchFinish(tree: untpd.Match, sel: Tree, wideSelType: Type, cases: List[untpd.CaseDef], pt: Type)(using Context): Tree = {
+    val cases1 = harmonic(harmonize, pt)(typedCases(cases, sel, wideSelType, pt.dropIfProto))
+      .asInstanceOf[List[CaseDef]]
+    assignType(cpy.Match(tree)(sel, cases1), sel, cases1)
+  }
+
+  def typedCases(cases: List[untpd.CaseDef], sel: Tree, wideSelType: Type, pt: Type)(using Context): List[CaseDef] =
+    var caseCtx = ctx
+    cases.mapconserve { cas =>
+      val case1 = typedCase(cas, sel, wideSelType, pt)(using caseCtx)
+      caseCtx = Nullables.afterPatternContext(sel, case1.pat)
+      case1
+    }
+
+  /** - strip all instantiated TypeVars from pattern types.
+    *    run/reducable.scala is a test case that shows stripping typevars is necessary.
+    *  - enter all symbols introduced by a Bind in current scope
+    */
+  private def indexPattern(cdef: untpd.CaseDef)(using Context) = new TreeMap {
+    val stripTypeVars = new TypeMap {
+      def apply(t: Type) = mapOver(t)
+    }
+    override def transform(trt: Tree)(using Context) =
+      super.transform(trt.withType(stripTypeVars(trt.tpe))) match {
+        case b: Bind =>
+          val sym = b.symbol
+          assert(sym.name != tpnme.WILDCARD)
+          if ctx.scope.lookup(b.name) == NoSymbol then ctx.enter(sym)
+          else report.error(new DuplicateBind(b, cdef), b.srcPos)
+          if (!ctx.isAfterTyper) {
+            val bounds = ctx.gadt.fullBounds(sym)
+            if (bounds != null) sym.info = bounds
+          }
+          b
+        case t: UnApply if t.symbol.is(Inline) => Inlines.inlinedUnapply(t)
+        case t => t
+      }
+  }
+
+  /** If the prototype `pt` is the type lambda (when doing a dependent
+   *  typing of a match), instantiate that type lambda with the pattern
+   *  variables found in the pattern `pat`.
+   */
+  def instantiateMatchTypeProto(pat: Tree, pt: Type)(using Context) = pt match {
+    case caseTp: HKTypeLambda =>
+      val bindingsSyms = tpd.patVars(pat).reverse
+      val bindingsTps = bindingsSyms.collect { case sym if sym.isType => sym.typeRef }
+      caseTp.appliedTo(bindingsTps)
+    case pt => pt
+  }
+
+  /** Type a case. */
+  def typedCase(tree: untpd.CaseDef, sel: Tree, wideSelType: Type, pt: Type)(using Context): CaseDef = {
+    val originalCtx = ctx
+    val gadtCtx: Context = ctx.fresh.setFreshGADTBounds.setNewScope
+
+    def caseRest(pat: Tree)(using Context) = {
+      val pt1 = instantiateMatchTypeProto(pat, pt) match {
+        case defn.MatchCase(_, bodyPt) => bodyPt
+        case pt => pt
+      }
+      val pat1 = indexPattern(tree).transform(pat)
+      val guard1 = typedExpr(tree.guard, defn.BooleanType)
+      var body1 = ensureNoLocalRefs(typedExpr(tree.body, pt1), pt1, ctx.scope.toList)
+      if ctx.gadt.isNarrowing then
+        // Store GADT constraint to later retrieve it (in PostTyper, for now).
+        // GADT constraints are necessary to correctly check bounds of type app,
+        // see tests/pos/i12226 and issue #12226. It might be possible that this
+        // will end up taking too much memory. If it does, we should just limit
+        // how much GADT constraints we infer - it's always sound to infer less.
+        pat1.putAttachment(InferredGadtConstraints, ctx.gadt)
+      if (pt1.isValueType) // insert a cast if body does not conform to expected type if we disregard gadt bounds
+        body1 = body1.ensureConforms(pt1)(using originalCtx)
+      assignType(cpy.CaseDef(tree)(pat1, guard1, body1), pat1, body1)
+    }
+
+    val pat1 = typedPattern(tree.pat, wideSelType)(using gadtCtx)
+    caseRest(pat1)(
+      using Nullables.caseContext(sel, pat1)(
+        using gadtCtx))
+  }
+
+  def typedLabeled(tree: untpd.Labeled)(using Context): Labeled = {
+    val bind1 = typedBind(tree.bind, WildcardType).asInstanceOf[Bind]
+    val expr1 = typed(tree.expr, bind1.symbol.info)
+    assignType(cpy.Labeled(tree)(bind1, expr1))
+  }
+
+  /** Type a case of a type match */
+  def typedTypeCase(cdef: untpd.CaseDef, selType: Type, pt: Type)(using Context): CaseDef = {
+    def caseRest(using Context) = {
+      val pat1 = withMode(Mode.Pattern) {
+        checkSimpleKinded(typedType(cdef.pat, mapPatternBounds = true))
+      }
+      if !ctx.isAfterTyper && pt != defn.ImplicitScrutineeTypeRef then
+        withMode(Mode.GadtConstraintInference) {
+          TypeComparer.constrainPatternType(pat1.tpe, selType)
+        }
+      val pat2 = indexPattern(cdef).transform(pat1)
+      var body1 = typedType(cdef.body, pt)
+      if !body1.isType then
+        assert(ctx.reporter.errorsReported)
+        body1 = TypeTree(errorType("<error: not a type>", cdef.srcPos))
+      assignType(cpy.CaseDef(cdef)(pat2, EmptyTree, body1), pat2, body1)
+    }
+    caseRest(using ctx.fresh.setFreshGADTBounds.setNewScope)
+  }
+
+  def typedReturn(tree: untpd.Return)(using Context): Return =
+
+    def enclMethInfo(cx: Context): (Tree, Type) =
+      val owner = cx.owner
+      if owner.isType then
+        report.error(ReturnOutsideMethodDefinition(owner), tree.srcPos)
+        (EmptyTree, WildcardType)
+      else if owner != cx.outer.owner && owner.isRealMethod then
+        if owner.isInlineMethod then
+          (EmptyTree, errorType(NoReturnFromInlineable(owner), tree.srcPos))
+        else if !owner.isCompleted then
+          (EmptyTree, errorType(MissingReturnTypeWithReturnStatement(owner), tree.srcPos))
+        else
+          (Ident(TermRef(NoPrefix, owner.asTerm)), owner.returnProto)
+      else enclMethInfo(cx.outer)
+
+    val (from, proto) =
+      if tree.from.isEmpty then enclMethInfo(ctx)
+      else
+        val from = tree.from.asInstanceOf[tpd.Tree]
+        val proto =
+          if (ctx.erasedTypes) from.symbol.info.finalResultType
+          else WildcardType // We cannot reliably detect the internal type view of polymorphic or dependent methods
+                            // because we do not know the internal type params and method params.
+                            // Hence no adaptation is possible, and we assume WildcardType as prototype.
+        (from, proto)
+    val expr1 = typedExpr(tree.expr orElse untpd.unitLiteral.withSpan(tree.span), proto)
+    assignType(cpy.Return(tree)(expr1, from))
+  end typedReturn
+
+  def typedWhileDo(tree: untpd.WhileDo)(using Context): Tree =
+    inContext(Nullables.whileContext(tree.span)) {
+      val cond1 =
+        if (tree.cond eq EmptyTree) EmptyTree
+        else typed(tree.cond, defn.BooleanType)
+      val body1 = typed(tree.body, defn.UnitType)(using cond1.nullableContextIf(true))
+      assignType(cpy.WhileDo(tree)(cond1, body1))
+        .withNotNullInfo(body1.notNullInfo.retractedInfo.seq(cond1.notNullInfoIf(false)))
+    }
+
+  /** Add givens reflecting `CanThrow` capabilities for all checked exceptions matched
+   *  by `cases`. The givens appear in nested blocks with earlier cases leading to
+   *  more deeply nested givens. This way, given priority will be the same as pattern priority.
+   *  The functionality is enabled if the experimental.saferExceptions language feature is enabled.
+   */
+  def addCanThrowCapabilities(expr: untpd.Tree, cases: List[CaseDef])(using Context): untpd.Tree =
+    def makeCanThrow(tp: Type): untpd.Tree =
+      untpd.ValDef(
+          EvidenceParamName.fresh(),
+          untpd.TypeTree(defn.CanThrowClass.typeRef.appliedTo(tp)),
+          untpd.ref(defn.Compiletime_erasedValue))
+        .withFlags(Given | Final | Erased)
+        .withSpan(expr.span)
+    val caughtExceptions =
+      if Feature.enabled(Feature.saferExceptions) then
+        for
+          CaseDef(pat, guard, _) <- cases
+          if pat.tpe.widen.isCheckedException
+        yield
+          checkCatch(pat, guard)
+          pat.tpe.widen
+      else Seq.empty
+
+    if caughtExceptions.isEmpty then expr
+    else
+      val capabilityProof = caughtExceptions.reduce(OrType(_, _, true))
+      untpd.Block(makeCanThrow(capabilityProof), expr)
+
+  def typedTry(tree: untpd.Try, pt: Type)(using Context): Try = {
+    val expr2 :: cases2x = harmonic(harmonize, pt) {
+      val cases1 = typedCases(tree.cases, EmptyTree, defn.ThrowableType, pt.dropIfProto)
+      val expr1 = typed(addCanThrowCapabilities(tree.expr, cases1), pt.dropIfProto)
+      expr1 :: cases1
+    }: @unchecked
+    val finalizer1 = typed(tree.finalizer, defn.UnitType)
+    val cases2 = cases2x.asInstanceOf[List[CaseDef]]
+    assignType(cpy.Try(tree)(expr2, cases2, finalizer1), expr2, cases2)
+  }
+
+  def typedTry(tree: untpd.ParsedTry, pt: Type)(using Context): Try =
+    val cases: List[untpd.CaseDef] = tree.handler match
+      case Match(EmptyTree, cases) => cases
+      case EmptyTree => Nil
+      case handler =>
+        val handler1 = typed(handler, defn.FunctionType(1).appliedTo(defn.ThrowableType, pt))
+        desugar.makeTryCase(handler1) :: Nil
+    typedTry(untpd.Try(tree.expr, cases, tree.finalizer).withSpan(tree.span), pt)
+
+  def typedThrow(tree: untpd.Throw)(using Context): Tree =
+    val expr1 = typed(tree.expr, defn.ThrowableType)
+    val cap = checkCanThrow(expr1.tpe.widen, tree.span)
+    val res = Throw(expr1).withSpan(tree.span)
+    if Feature.ccEnabled && !cap.isEmpty && !ctx.isAfterTyper then
+      // Record access to the CanThrow capabulity recovered in `cap` by wrapping
+      // the type of the `throw` (i.e. Nothing) in a `@requiresCapability` annotatoon.
+      Typed(res,
+        TypeTree(
+          AnnotatedType(res.tpe,
+            Annotation(defn.RequiresCapabilityAnnot, cap))))
+    else res
+
+  def typedSeqLiteral(tree: untpd.SeqLiteral, pt: Type)(using Context): SeqLiteral = {
+    val elemProto = pt.stripNull.elemType match {
+      case NoType => WildcardType
+      case bounds: TypeBounds => WildcardType(bounds)
+      case elemtp => elemtp
+    }
+
+    def assign(elems1: List[Tree], elemtpt1: Tree) =
+      assignType(cpy.SeqLiteral(tree)(elems1, elemtpt1), elems1, elemtpt1)
+
+    if (!tree.elemtpt.isEmpty) {
+      val elemtpt1 = typed(tree.elemtpt, elemProto)
+      val elems1 = tree.elems.mapconserve(typed(_, elemtpt1.tpe))
+      assign(elems1, elemtpt1)
+    }
+    else {
+      val elems1 = tree.elems.mapconserve(typed(_, elemProto))
+      val elemtptType =
+        if (isFullyDefined(elemProto, ForceDegree.none))
+          elemProto
+        else if (tree.elems.isEmpty && tree.isInstanceOf[Trees.JavaSeqLiteral[?]])
+          defn.ObjectType // generic empty Java varargs are of type Object[]
+        else
+          TypeComparer.lub(elems1.tpes)
+      val elemtpt1 = typed(tree.elemtpt, elemtptType)
+      assign(elems1, elemtpt1)
+    }
+  }
+
+  def typedInlined(tree: untpd.Inlined, pt: Type)(using Context): Tree = {
+    val (bindings1, exprCtx) = typedBlockStats(tree.bindings)
+    val expansion1 = typed(tree.expansion, pt)(using inlineContext(tree.call)(using exprCtx))
+    assignType(cpy.Inlined(tree)(tree.call, bindings1.asInstanceOf[List[MemberDef]], expansion1),
+        bindings1, expansion1)
+  }
+
+  def completeTypeTree(tree: untpd.TypeTree, pt: Type, original: untpd.Tree)(using Context): TypeTree =
+    tree.withSpan(original.span).withAttachmentsFrom(original)
+      .withType(
+        if isFullyDefined(pt, ForceDegree.flipBottom) then pt
+        else if ctx.reporter.errorsReported then UnspecifiedErrorType
+        else errorType(i"cannot infer type; expected type $pt is not fully defined", tree.srcPos))
+
+  def typedTypeTree(tree: untpd.TypeTree, pt: Type)(using Context): Tree =
+    tree match
+      case tree: untpd.DerivedTypeTree =>
+        tree.ensureCompletions
+        tree.getAttachment(untpd.OriginalSymbol) match {
+          case Some(origSym) =>
+            tree.derivedTree(origSym).withSpan(tree.span)
+            // btw, no need to remove the attachment. The typed
+            // tree is different from the untyped one, so the
+            // untyped tree is no longer accessed after all
+            // accesses with typedTypeTree are done.
+          case None =>
+            errorTree(tree, "Something's wrong: missing original symbol for type tree")
+        }
+      case _ =>
+        completeTypeTree(InferredTypeTree(), pt, tree)
+
+  def typedSingletonTypeTree(tree: untpd.SingletonTypeTree)(using Context): SingletonTypeTree = {
+    val ref1 = typedExpr(tree.ref)
+    checkStable(ref1.tpe, tree.srcPos, "singleton type")
+    assignType(cpy.SingletonTypeTree(tree)(ref1), ref1)
+  }
+
+  def typedRefinedTypeTree(tree: untpd.RefinedTypeTree)(using Context): TypTree = {
+    val tpt1 = if (tree.tpt.isEmpty) TypeTree(defn.ObjectType) else typedAheadType(tree.tpt)
+    val refineClsDef = desugar.refinedTypeToClass(tpt1, tree.refinements).withSpan(tree.span)
+    val refineCls = createSymbol(refineClsDef).asClass
+    val TypeDef(_, impl: Template) = typed(refineClsDef): @unchecked
+    val refinements1 = impl.body
+    assert(tree.refinements.hasSameLengthAs(refinements1), i"${tree.refinements}%, % > $refinements1%, %")
+    val seen = mutable.Set[Symbol]()
+    for (refinement <- refinements1) { // TODO: get clarity whether we want to enforce these conditions
+      typr.println(s"adding refinement $refinement")
+      checkRefinementNonCyclic(refinement, refineCls, seen)
+      val rsym = refinement.symbol
+      rsym.setTargetName(EmptyTermName)
+        // refinements can refine members with arbitrary target names, so we make their target names
+        // polymorphic here in order to avoid to trigger the `member.isOverloaded` test below.
+      val polymorphicRefinementAllowed =
+        tpt1.tpe.typeSymbol == defn.PolyFunctionClass && rsym.name == nme.apply
+      if (!polymorphicRefinementAllowed && rsym.info.isInstanceOf[PolyType] && rsym.allOverriddenSymbols.isEmpty)
+        report.error(PolymorphicMethodMissingTypeInParent(rsym, tpt1.symbol), refinement.srcPos)
+      val member = refineCls.info.member(rsym.name)
+      if (member.isOverloaded)
+        report.error(OverloadInRefinement(rsym), refinement.srcPos)
+    }
+    assignType(cpy.RefinedTypeTree(tree)(tpt1, refinements1), tpt1, refinements1, refineCls)
+  }
+
+  def typedAppliedTypeTree(tree: untpd.AppliedTypeTree)(using Context): Tree = {
+    tree.args match
+      case arg :: _ if arg.isTerm =>
+        if Feature.dependentEnabled then
+          return errorTree(tree, i"Not yet implemented: T(...)")
+        else
+          return errorTree(tree, dependentStr)
+      case _ =>
+
+    val tpt1 = withoutMode(Mode.Pattern) {
+      typed(tree.tpt, AnyTypeConstructorProto)
+    }
+    val tparams = tpt1.tpe.typeParams
+     if tpt1.tpe.isError then
+       val args1 = tree.args.mapconserve(typedType(_))
+       assignType(cpy.AppliedTypeTree(tree)(tpt1, args1), tpt1, args1)
+     else if (tparams.isEmpty) {
+      report.error(TypeDoesNotTakeParameters(tpt1.tpe, tree.args), tree.srcPos)
+      tpt1
+    }
+    else {
+      var args = tree.args
+      val args1 = {
+        if (args.length != tparams.length) {
+          wrongNumberOfTypeArgs(tpt1.tpe, tparams, args, tree.srcPos)
+          args = args.take(tparams.length)
+        }
+
+        // If type constructor is not a class type, we need to eliminate
+        // any references to other parameter types of the underlying hk lambda
+        // in order not to get orphan parameters. Test case in pos/i15564.scala.
+        // Note 1: It would be better to substitute actual arguments for corresponding
+        // formal paramaters, but it looks very hard to do this at the point where
+        // a bound type variable is created.
+        // Note 2: If the type constructor is a class type, no sanitization is needed
+        // since we can refer to the other paraeters with dependent types C[...]#X.
+        def sanitizeBounds(bounds: Type, tycon: Type): Type =
+          def underlyingLambda(tp: Type): Type = tp match
+            case tp: HKTypeLambda => tp
+            case tp: TypeProxy => underlyingLambda(tp.superType)
+            case _ => NoType
+          val tl = underlyingLambda(tycon)
+          val widenMap = new TypeOps.AvoidMap:
+            def toAvoid(tp: NamedType) = false
+            override def apply(tp: Type): Type = tp match
+              case tp: TypeParamRef if tp.binder == tl => emptyRange
+              case _ => super.apply(tp)
+          widenMap(bounds)
+
+        def typedArg(arg: untpd.Tree, tparam: ParamInfo) = {
+          def tparamBounds =
+            val bounds =
+              tparam.paramInfoAsSeenFrom(tpt1.tpe.appliedTo(tparams.map(_ => TypeBounds.empty)))
+            if tparam.isInstanceOf[Symbol] then bounds
+            else sanitizeBounds(bounds, tpt1.tpe)
+          val (desugaredArg, argPt) =
+            if ctx.mode.is(Mode.Pattern) then
+              (if (untpd.isVarPattern(arg)) desugar.patternVar(arg) else arg, tparamBounds)
+            else if ctx.mode.is(Mode.QuotedPattern) then
+              (arg, tparamBounds)
+            else
+              (arg, WildcardType)
+          if (tpt1.symbol.isClass)
+            tparam match {
+              case tparam: Symbol =>
+                tparam.ensureCompleted() // This is needed to get the test `compileParSetSubset` to work
+              case _ =>
+            }
+          if (desugaredArg.isType)
+            arg match {
+              case untpd.WildcardTypeBoundsTree()
+              if tparam.paramInfo.isLambdaSub &&
+                 tpt1.tpe.typeParamSymbols.nonEmpty =>
+                // An unbounded `_` automatically adapts to type parameter bounds. This means:
+                // If we have wildcard application C[?], where `C` is a class replace
+                // with C[? >: L <: H] where `L` and `H` are the bounds of the corresponding
+                // type parameter in `C`.
+                // The transform does not apply for patterns, where empty bounds translate to
+                // wildcard identifiers `_` instead.
+                TypeTree(tparamBounds).withSpan(arg.span)
+              case _ =>
+                typedType(desugaredArg, argPt, mapPatternBounds = true)
+            }
+          else desugaredArg.withType(UnspecifiedErrorType)
+        }
+        args.zipWithConserve(tparams)(typedArg)
+      }
+      val paramBounds = tparams.lazyZip(args).map {
+        case (tparam, untpd.WildcardTypeBoundsTree()) =>
+          // if type argument is a wildcard, suppress kind checking since
+          // there is no real argument.
+          NoType
+        case (tparam, _) =>
+          tparam.paramInfo.bounds
+      }
+      var checkedArgs = preCheckKinds(args1, paramBounds)
+        // check that arguments conform to bounds is done in phase PostTyper
+      val tycon = tpt1.symbol
+      if tycon == defn.andType || tycon == defn.orType then
+        checkedArgs = checkedArgs.mapconserve(arg =>
+          checkSimpleKinded(checkNoWildcard(arg)))
+      else if tycon.isProvisional then
+        // A type with Provisional flag is either an alias or abstract type.
+        // If it is an alias type, it would mean the type is cyclic
+        // If it is an abstract type, it would mean the type is an irreducible
+        // application of a higher-kinded type to a wildcard argument.
+        // Either way, the wildcard argument is illegal. The early test of
+        // `checkNoWildcard` here is needed, so that we do not accidentally reduce
+        // an application of a Provisional type away, which would mean that the type constructor
+        // is no longer present on the right hand side. See neg/i15507.scala.
+        checkedArgs = checkedArgs.mapconserve(checkNoWildcard)
+      else if tycon == defn.throwsAlias
+          && checkedArgs.length == 2
+          && checkedArgs(1).tpe.derivesFrom(defn.RuntimeExceptionClass)
+      then
+        report.error(em"throws clause cannot be defined for RuntimeException", checkedArgs(1).srcPos)
+      else if (ctx.isJava)
+        if tycon eq defn.ArrayClass then
+          checkedArgs match {
+            case List(arg) =>
+              val elemtp = arg.tpe.translateJavaArrayElementType
+              if (elemtp ne arg.tpe)
+                checkedArgs = List(TypeTree(elemtp).withSpan(arg.span))
+            case _ =>
+          }
+      assignType(cpy.AppliedTypeTree(tree)(tpt1, checkedArgs), tpt1, checkedArgs)
+    }
+  }
+
+  private def typeIndexedLambdaTypeTree(
+      tree: untpd.LambdaTypeTree, tparams: List[untpd.TypeDef], body: untpd.Tree)(using Context) =
+    val tparams1 = tparams.map(typed(_)).asInstanceOf[List[TypeDef]]
+    val body1 = typedType(body)
+    assignType(cpy.LambdaTypeTree(tree)(tparams1, body1), tparams1, body1)
+
+  def typedLambdaTypeTree(tree: untpd.LambdaTypeTree)(using Context): Tree =
+    val LambdaTypeTree(tparams, body) = tree
+    index(tparams)
+    typeIndexedLambdaTypeTree(tree, tparams, body)
+
+  def typedTermLambdaTypeTree(tree: untpd.TermLambdaTypeTree)(using Context): Tree =
+    if Feature.dependentEnabled then
+      errorTree(tree, i"Not yet implemented: (...) =>> ...")
+    else
+      errorTree(tree, dependentStr)
+
+  def typedMatchTypeTree(tree: untpd.MatchTypeTree, pt: Type)(using Context): Tree = {
+    val bound1 =
+      if (tree.bound.isEmpty && isFullyDefined(pt, ForceDegree.none)) TypeTree(pt)
+      else typed(tree.bound)
+    val sel1 = typed(tree.selector)
+    val pt1 = if (bound1.isEmpty) pt else bound1.tpe
+    val cases1 = tree.cases.mapconserve(typedTypeCase(_, sel1.tpe, pt1))
+    assignType(cpy.MatchTypeTree(tree)(bound1, sel1, cases1), bound1, sel1, cases1)
+  }
+
+  def typedByNameTypeTree(tree: untpd.ByNameTypeTree)(using Context): ByNameTypeTree = {
+    val result1 = typed(tree.result)
+    assignType(cpy.ByNameTypeTree(tree)(result1), result1)
+  }
+
+  def typedTypeBoundsTree(tree: untpd.TypeBoundsTree, pt: Type)(using Context): Tree =
+    val TypeBoundsTree(lo, hi, alias) = tree
+    val lo1 = typed(lo)
+    val hi1 = typed(hi)
+    val alias1 = typed(alias)
+    val lo2 = if (lo1.isEmpty) typed(untpd.TypeTree(defn.NothingType)) else lo1
+    val hi2 = if (hi1.isEmpty) typed(untpd.TypeTree(defn.AnyType)) else hi1
+    if !alias1.isEmpty then
+      val bounds = TypeBounds(lo2.tpe, hi2.tpe)
+      if !bounds.contains(alias1.tpe) then
+        report.error(em"type ${alias1.tpe} outside bounds $bounds", tree.srcPos)
+    assignType(cpy.TypeBoundsTree(tree)(lo2, hi2, alias1), lo2, hi2, alias1)
+
+  def typedBind(tree: untpd.Bind, pt: Type)(using Context): Tree = {
+    if !isFullyDefined(pt, ForceDegree.all) then
+      return errorTree(tree, i"expected type of $tree is not fully defined")
+    val body1 = typed(tree.body, pt)
+    body1 match {
+      case UnApply(fn, Nil, arg :: Nil)
+      if fn.symbol.exists && (fn.symbol.owner.derivesFrom(defn.TypeTestClass) || fn.symbol.owner == defn.ClassTagClass) && !body1.tpe.isError =>
+        // A typed pattern `x @ (e: T)` with an implicit `tt: TypeTest[T]` or `ctag: ClassTag[T]`
+        // was rewritten to `x @ tt(e)` `x @ ctag(e)` by `tryWithTypeTest`.
+        // Rewrite further to `tt(x @ e)` or `ctag(x @ e)`
+        tpd.cpy.UnApply(body1)(fn, Nil,
+            typed(untpd.Bind(tree.name, untpd.TypedSplice(arg)).withSpan(tree.span), arg.tpe) :: Nil)
+      case _ =>
+        var name = tree.name
+        if (name == nme.WILDCARD && tree.mods.is(Given)) {
+          val Typed(_, tpt) = tree.body: @unchecked
+          name = desugar.inventGivenOrExtensionName(tpt)
+        }
+        if (name == nme.WILDCARD) body1
+        else {
+          // In `x @ Nil`, `Nil` is a _stable identifier pattern_ and will be compiled
+          // to an `==` test, so the type of `x` is unrelated to the type of `Nil`.
+          // Similarly, in `x @ 1`, `1` is a _literal pattern_ and will also be compiled
+          // to an `==` test.
+          // See i3200*.scala and https://github.com/scala/bug/issues/1503.
+          val isStableIdentifierOrLiteral =
+            body1.isInstanceOf[RefTree] && !isWildcardArg(body1)
+            || body1.isInstanceOf[Literal]
+          val symTp =
+            if isStableIdentifierOrLiteral then pt
+            else if isWildcardStarArg(body1)
+                    || pt == defn.ImplicitScrutineeTypeRef
+                    || body1.tpe <:< pt  // There is some strange interaction with gadt matching.
+                                         // and implicit scopes.
+                                         // run/t2755.scala fails to compile if this subtype test is omitted
+                                         // and the else clause is changed to `body1.tpe & pt`. What
+                                         // happens is that we get either an Array[Float] or an Array[T]
+                                         // where T is GADT constrained to := Float. But the case body
+                                         // compiles only if the bound variable is Array[Float]. If
+                                         // it is Array[T] we get an implicit not found. To avoid fragility
+                                         // wrt to operand order for `&`, we include the explicit subtype test here.
+                                         // See also #5649.
+            then body1.tpe
+            else pt & body1.tpe
+          val sym = newPatternBoundSymbol(name, symTp, tree.span)
+          if (pt == defn.ImplicitScrutineeTypeRef || tree.mods.is(Given)) sym.setFlag(Given)
+          if (ctx.mode.is(Mode.InPatternAlternative))
+            report.error(IllegalVariableInPatternAlternative(sym.name), tree.srcPos)
+          assignType(cpy.Bind(tree)(name, body1), sym)
+        }
+    }
+  }
+
+  def typedAlternative(tree: untpd.Alternative, pt: Type)(using Context): Alternative = {
+    val nestedCtx = ctx.addMode(Mode.InPatternAlternative)
+    def ensureValueTypeOrWildcard(tree: Tree) =
+      if tree.tpe.isValueTypeOrWildcard then tree
+      else
+        assert(ctx.reporter.errorsReported)
+        tree.withType(defn.AnyType)
+    val trees1 = tree.trees.mapconserve(typed(_, pt)(using nestedCtx))
+      .mapconserve(ensureValueTypeOrWildcard)
+    assignType(cpy.Alternative(tree)(trees1), trees1)
+  }
+
+  /** The context to be used for an annotation of `mdef`.
+   *  This should be the context enclosing `mdef`, or if `mdef` defines a parameter
+   *  the context enclosing the owner of `mdef`.
+   *  Furthermore, we need to evaluate annotation arguments in an expression context,
+   *  since classes defined in a such arguments should not be entered into the
+   *  enclosing class.
+   */
+  def annotContext(mdef: untpd.Tree, sym: Symbol)(using Context): Context = {
+    def isInner(owner: Symbol) = owner == sym || sym.is(Param) && owner == sym.owner
+    val outer = ctx.outersIterator.dropWhile(c => isInner(c.owner)).next()
+    var adjusted = outer.property(ExprOwner) match {
+      case Some(exprOwner) if outer.owner.isClass => outer.exprContext(mdef, exprOwner)
+      case _ => outer
+    }
+    sym.owner.infoOrCompleter match
+      case completer: Namer#Completer if sym.is(Param) =>
+        val tparams = completer.completerTypeParams(sym)
+        if tparams.nonEmpty then
+          // Create a new local context with a dummy owner and a scope containing the
+          // type parameters of the enclosing method or class. Thus annotations can see
+          // these type parameters. See i12953.scala for a test case.
+          val dummyOwner = newLocalDummy(sym.owner)
+          adjusted = adjusted.fresh.setOwner(dummyOwner).setScope(newScopeWith(tparams*))
+      case _ =>
+    adjusted
+  }
+
+  def completeAnnotations(mdef: untpd.MemberDef, sym: Symbol)(using Context): Unit = {
+    // necessary to force annotation trees to be computed.
+    sym.annotations.foreach(_.ensureCompleted)
+    lazy val annotCtx = annotContext(mdef, sym)
+    // necessary in order to mark the typed ahead annotations as definitely typed:
+    for (annot <- mdef.mods.annotations)
+      val annot1 = typedAnnotation(annot)(using annotCtx)
+      checkAnnotApplicable(annot1, sym)
+      if Annotations.annotClass(annot1) == defn.NowarnAnnot then
+        registerNowarn(annot1, mdef)
+  }
+
+  def typedAnnotation(annot: untpd.Tree)(using Context): Tree =
+    checkAnnotArgs(typed(annot, defn.AnnotationClass.typeRef))
+
+  def registerNowarn(tree: Tree, mdef: untpd.Tree)(using Context): Unit =
+    val annot = Annotations.Annotation(tree)
+    def argPos = annot.argument(0).getOrElse(tree).sourcePos
+    var verbose = false
+    val filters = annot.argumentConstantString(0) match
+      case None => annot.argument(0) match
+        case Some(t: Select) if t.name.is(DefaultGetterName) =>
+          // default argument used for `@nowarn` and `@nowarn()`
+          List(MessageFilter.Any)
+        case _ =>
+          report.warning(s"filter needs to be a compile-time constant string", argPos)
+          List(MessageFilter.None)
+      case Some("") =>
+        List(MessageFilter.Any)
+      case Some("verbose") | Some("v") =>
+        verbose = true
+        List(MessageFilter.Any)
+      case Some(s) =>
+        WConf.parseFilters(s).left.map(parseErrors =>
+          report.warning (s"Invalid message filter\n${parseErrors.mkString ("\n")}", argPos)
+            List(MessageFilter.None)
+        ).merge
+    val range = mdef.sourcePos
+    val sup = Suppression(tree.sourcePos, filters, range.start, range.end, verbose)
+    // invalid suppressions, don't report as unused
+    if filters == List(MessageFilter.None) then sup.markUsed()
+    ctx.run.nn.suppressions.addSuppression(sup)
+
+  def typedValDef(vdef: untpd.ValDef, sym: Symbol)(using Context): Tree = {
+    val ValDef(name, tpt, _) = vdef
+    completeAnnotations(vdef, sym)
+    if (sym.isOneOf(GivenOrImplicit)) checkImplicitConversionDefOK(sym)
+    if sym.is(Module) then checkNoModuleClash(sym)
+    val tpt1 = checkSimpleKinded(typedType(tpt))
+    val rhs1 = vdef.rhs match {
+      case rhs @ Ident(nme.WILDCARD) => rhs withType tpt1.tpe
+      case rhs => typedExpr(rhs, tpt1.tpe.widenExpr)
+    }
+    val vdef1 = assignType(cpy.ValDef(vdef)(name, tpt1, rhs1), sym)
+    postProcessInfo(sym)
+    vdef1.setDefTree
+  }
+
+  def typedDefDef(ddef: untpd.DefDef, sym: Symbol)(using Context): Tree = {
+    if (!sym.info.exists) { // it's a discarded synthetic case class method, drop it
+      assert(sym.is(Synthetic) && desugar.isRetractableCaseClassMethodName(sym.name))
+      sym.owner.info.decls.openForMutations.unlink(sym)
+      return EmptyTree
+    }
+    // TODO: - Remove this when `scala.language.experimental.erasedDefinitions` is no longer experimental.
+    //       - Modify signature to `erased def erasedValue[T]: T`
+    if sym.eq(defn.Compiletime_erasedValue) then
+      // scala.compiletime.erasedValue should be `erased` but we cannot add this in the source.
+      // The library cannot use experimental language features,
+      // hence we special case it until `erased` is no longer experimental.
+      sym.setFlag(Erased)
+    val DefDef(name, paramss, tpt, _) = ddef
+    completeAnnotations(ddef, sym)
+    val paramss1 = paramss.nestedMapConserve(typed(_)).asInstanceOf[List[ParamClause]]
+    for case ValDefs(vparams) <- paramss1 do
+      checkNoForwardDependencies(vparams)
+    if (sym.isOneOf(GivenOrImplicit)) checkImplicitConversionDefOK(sym)
+    val tpt1 = checkSimpleKinded(typedType(tpt))
+
+    val rhsCtx = ctx.fresh
+    val tparamss = paramss1.collect {
+      case untpd.TypeDefs(tparams) => tparams
+    }
+
+    // Register GADT constraint for class type parameters from outer to inner class definition. (Useful when nested classes exist.) But do not cross a function definition.
+    if sym.flags.is(Method) then
+      rhsCtx.setFreshGADTBounds
+      ctx.outer.outersIterator.takeWhile(!_.owner.is(Method))
+        .filter(ctx => ctx.owner.isClass && ctx.owner.typeParams.nonEmpty)
+        .toList.reverse
+        .foreach(ctx => rhsCtx.gadt.addToConstraint(ctx.owner.typeParams))
+
+    if tparamss.nonEmpty then
+      rhsCtx.setFreshGADTBounds
+      val tparamSyms = tparamss.flatten.map(_.symbol)
+      if !sym.isConstructor then
+        // we're typing a polymorphic definition's body,
+        // so we allow constraining all of its type parameters
+        // constructors are an exception as we don't allow constraining type params of classes
+        rhsCtx.gadt.addToConstraint(tparamSyms)
+      else if !sym.isPrimaryConstructor then
+        linkConstructorParams(sym, tparamSyms, rhsCtx)
+
+    if sym.isInlineMethod then rhsCtx.addMode(Mode.InlineableBody)
+    if sym.is(ExtensionMethod) then rhsCtx.addMode(Mode.InExtensionMethod)
+    val rhs1 = PrepareInlineable.dropInlineIfError(sym,
+      if sym.isScala2Macro then typedScala2MacroBody(ddef.rhs)(using rhsCtx)
+      else typedExpr(ddef.rhs, tpt1.tpe.widenExpr)(using rhsCtx))
+
+    if sym.isInlineMethod then
+      if StagingContext.level > 0 then
+        report.error("inline def cannot be within quotes", sym.sourcePos)
+      val rhsToInline = PrepareInlineable.wrapRHS(ddef, tpt1, rhs1)
+      PrepareInlineable.registerInlineInfo(sym, rhsToInline)
+
+    if sym.isConstructor then
+      if sym.is(Inline) then
+        report.error("constructors cannot be `inline`", ddef)
+      if sym.isPrimaryConstructor then
+        if sym.owner.is(Case) then
+          for
+            params <- paramss1.dropWhile(TypeDefs.unapply(_).isDefined).take(1)
+            case param: ValDef <- params
+          do
+            if defn.isContextFunctionType(param.tpt.tpe) then
+              report.error("case class element cannot be a context function", param.srcPos)
+      else
+        if sym.targetName != sym.name then
+          report.error(em"@targetName annotation may not be used on a constructor", ddef.srcPos)
+
+        for params <- paramss1; param <- params do
+          checkRefsLegal(param, sym.owner, (name, sym) => sym.is(TypeParam), "secondary constructor")
+
+        def checkThisConstrCall(tree: Tree): Unit = tree match
+          case app: Apply if untpd.isSelfConstrCall(app) =>
+            if (sym.span.exists && app.symbol.span.exists && sym.span.start <= app.symbol.span.start)
+              report.error("secondary constructor must call a preceding constructor", app.srcPos)
+          case Block(call :: _, _) => checkThisConstrCall(call)
+          case _ =>
+
+        checkThisConstrCall(rhs1)
+      end if
+    end if
+
+    if sym.is(Method) && sym.owner.denot.isRefinementClass then
+      for annot <- sym.paramSymss.flatten.filter(_.isTerm).flatMap(_.getAnnotation(defn.ImplicitNotFoundAnnot)) do
+        report.warning(
+          i"The annotation ${defn.ImplicitNotFoundAnnot} is not allowed on parameters of methods defined inside a refinement and it will have no effect",
+          annot.tree.sourcePos
+        )
+
+    val ddef2 = assignType(cpy.DefDef(ddef)(name, paramss1, tpt1, rhs1), sym)
+
+    postProcessInfo(sym)
+    ddef2.setDefTree
+      //todo: make sure dependent method types do not depend on implicits or by-name params
+  }
+
+  /** (1) Check that the signature of the class member does not return a repeated parameter type
+   *  (2) If info is an erased class, set erased flag of member
+   */
+  private def postProcessInfo(sym: Symbol)(using Context): Unit =
+    if (!sym.isOneOf(Synthetic | InlineProxy | Param) && sym.info.finalResultType.isRepeatedParam)
+      report.error(em"Cannot return repeated parameter type ${sym.info.finalResultType}", sym.srcPos)
+    if !sym.is(Module) && !sym.isConstructor && sym.info.finalResultType.isErasedClass then
+      sym.setFlag(Erased)
+
+  def typedTypeDef(tdef: untpd.TypeDef, sym: Symbol)(using Context): Tree = {
+    val TypeDef(name, rhs) = tdef
+    completeAnnotations(tdef, sym)
+    val rhs1 = tdef.rhs match
+      case rhs @ LambdaTypeTree(tparams, body) =>
+        typeIndexedLambdaTypeTree(rhs, tparams, body)
+      case rhs =>
+        typedType(rhs)
+    checkFullyAppliedType(rhs1)
+    if sym.isOpaqueAlias then checkNoContextFunctionType(rhs1)
+    assignType(cpy.TypeDef(tdef)(name, rhs1), sym)
+  }
+
+  def typedClassDef(cdef: untpd.TypeDef, cls: ClassSymbol)(using Context): Tree = {
+    if (!cls.info.isInstanceOf[ClassInfo]) return EmptyTree.assertingErrorsReported
+
+    val TypeDef(name, impl @ Template(constr, _, self, _)) = cdef: @unchecked
+    val parents = impl.parents
+    val superCtx = ctx.superCallContext
+    val seenParents = mutable.Set[Symbol]()
+
+    def typedParent(tree: untpd.Tree): Tree =
+      val parent = tree match
+        case _: untpd.Apply => typedExpr(tree)(using superCtx)
+        case _ => typedType(tree)(using superCtx)
+      val psym = parent.tpe.dealias.typeSymbol
+      if seenParents.contains(psym) && !cls.isRefinementClass then
+        // Desugaring can add parents to classes, but we don't want to emit an
+        // error if the same parent was explicitly added in user code.
+        if !tree.span.isSourceDerived then
+          return EmptyTree
+        if !ctx.isAfterTyper then report.error(i"$psym is extended twice", tree.srcPos)
+      else
+        seenParents += psym
+      val result = ensureConstrCall(cls, parent, psym)(using superCtx)
+      if parent.isType then
+        if !result.symbol.info.takesImplicitParams then
+          checkSimpleKinded(parent)
+            // allow missing type parameters if there are implicit arguments to pass
+            // since we can infer type arguments from them
+      else
+        checkParentCall(result, cls)
+      if cls is Case then
+        checkCaseInheritance(psym, cls, tree.srcPos)
+      result
+
+    def ensureCorrectSuperClass(): Unit =
+      val parents0 = cls.classInfo.declaredParents
+      parents0 match
+        case AnnotatedType(sc, ann) :: rest if ann.symbol == defn.ProvisionalSuperClassAnnot =>
+          val parents1 = ensureFirstIsClass(cls, rest)
+          if parents1.head ne sc then
+            typr.println(i"improved provisional superclass $sc to ${parents1.head}")
+          cls.info = cls.classInfo.derivedClassInfo(declaredParents = parents1)
+        case _ =>
+
+    /** Augment `ptrees` to have the same class symbols as `parents`. Generate TypeTrees
+     *  or New trees to fill in any parents for which no tree exists yet.
+     */
+    def parentTrees(parents: List[Type], ptrees: List[Tree]): List[Tree] =
+      if ptrees.exists(_.tpe.isError) then ptrees
+      else parents match
+        case parent :: parents1 =>
+          val psym = parent.classSymbol
+          def hasSameParent(ptree: Tree) =
+            psym == (
+              if ptree.symbol.isConstructor then ptree.symbol.owner
+              else ptree.tpe.classSymbol
+            )
+          ptrees match
+            case ptree :: ptrees1 if hasSameParent(ptree) =>
+              ptree :: parentTrees(parents1, ptrees1)
+            case ptree :: ptrees1 if ptrees1.exists(hasSameParent) =>
+              ptree :: parentTrees(parents, ptrees1)
+            case _ =>
+              val added: Tree = ensureConstrCall(
+                cls, TypeTree(parent).withSpan(cdef.nameSpan.focus), psym)(using superCtx)
+              added :: parentTrees(parents1, ptrees)
+        case _ =>
+          ptrees
+
+    /** Checks if one of the decls is a type with the same name as class type member in selfType */
+    def classExistsOnSelf(decls: Scope, self: tpd.ValDef): Boolean = {
+      val selfType = self.tpt.tpe
+      if (!selfType.exists || (selfType.classSymbol eq cls)) false
+      else {
+        def memberInSelfButNotThis(decl: Symbol) =
+          selfType.member(decl.name).symbol.filter(other => other.isClass && other.owner != cls)
+        decls.iterator.filter(_.isType).foldLeft(false) { (foundRedef, decl) =>
+          val other = memberInSelfButNotThis(decl)
+          if (other.exists) {
+            val msg = CannotHaveSameNameAs(decl, other, CannotHaveSameNameAs.DefinedInSelf(self))
+            report.error(msg, decl.srcPos)
+          }
+          foundRedef || other.exists
+        }
+      }
+    }
+
+    ensureCorrectSuperClass()
+    completeAnnotations(cdef, cls)
+    val constr1 = typed(constr).asInstanceOf[DefDef]
+    val parents1 = parentTrees(
+        cls.classInfo.declaredParents,
+        parents.mapconserve(typedParent).filterConserve(!_.isEmpty))
+    val firstParentTpe = parents1.head.tpe.dealias
+    val firstParent = firstParentTpe.typeSymbol
+
+    checkEnumParent(cls, firstParent)
+
+    val self1 = typed(self)(using ctx.outer).asInstanceOf[ValDef] // outer context where class members are not visible
+    if (self1.tpt.tpe.isError || classExistsOnSelf(cls.unforcedDecls, self1))
+      // fail fast to avoid typing the body with an error type
+      cdef.withType(UnspecifiedErrorType)
+    else {
+      val dummy = localDummy(cls, impl)
+      val body1 = addAccessorDefs(cls, typedStats(impl.body, dummy)(using ctx.inClassContext(self1.symbol))._1)
+
+      checkNoDoubleDeclaration(cls)
+      val impl1 = cpy.Template(impl)(constr1, parents1, Nil, self1, body1)
+        .withType(dummy.termRef)
+      if (!cls.isOneOf(AbstractOrTrait) && !ctx.isAfterTyper)
+        checkRealizableBounds(cls, cdef.sourcePos.withSpan(cdef.nameSpan))
+      if cls.isEnum || firstParentTpe.classSymbol.isEnum then
+        checkEnum(cdef, cls, firstParent)
+      val cdef1 = assignType(cpy.TypeDef(cdef)(name, impl1), cls)
+
+      val reportDynamicInheritance =
+        ctx.phase.isTyper &&
+        cdef1.symbol.ne(defn.DynamicClass) &&
+        cdef1.tpe.derivesFrom(defn.DynamicClass) &&
+        !Feature.dynamicsEnabled
+      if (reportDynamicInheritance) {
+        val isRequired = parents1.exists(_.tpe.isRef(defn.DynamicClass))
+        report.featureWarning(nme.dynamics.toString, "extension of type scala.Dynamic", cls, isRequired, cdef.srcPos)
+      }
+
+      checkNonCyclicInherited(cls.thisType, cls.info.parents, cls.info.decls, cdef.srcPos)
+
+      // check value class constraints
+      checkDerivedValueClass(cls, body1)
+
+      val effectiveOwner = cls.owner.skipWeakOwner
+      if !cls.isRefinementClass
+         && !cls.isAllOf(PrivateLocal)
+         && effectiveOwner.is(Trait)
+         && !effectiveOwner.derivesFrom(defn.ObjectClass)
+      then
+        report.error(i"$cls cannot be defined in universal $effectiveOwner", cdef.srcPos)
+
+      // Temporarily set the typed class def as root tree so that we have at least some
+      // information in the IDE in case we never reach `SetRootTree`.
+      if (ctx.mode.is(Mode.Interactive) && ctx.settings.YretainTrees.value)
+        cls.rootTreeOrProvider = cdef1
+
+      for (deriver <- cdef.removeAttachment(AttachedDeriver))
+        cdef1.putAttachment(AttachedDeriver, deriver)
+
+      cdef1
+    }
+  }
+
+      // todo later: check that
+      //  1. If class is non-abstract, it is instantiatable:
+      //  - self type is s supertype of own type
+      //  - all type members have consistent bounds
+      // 2. all private type members have consistent bounds
+      // 3. Types do not override classes.
+      // 4. Polymorphic type defs override nothing.
+
+  protected def addAccessorDefs(cls: Symbol, body: List[Tree])(using Context): List[Tree] =
+    PrepareInlineable.addAccessorDefs(cls, body)
+
+  /** Turn a parent type into a constructor call where needed. This is the case where
+   *   - we are in a Scala class or module (not a Java class, nor a trait), and
+   *     - the parent symbol is a non-trait class, or
+   *     - the parent symbol is a trait that takes at least one (explicit or implicit) parameter
+   *       and the parent symbol is directly extended by the current class (i.e. not
+   *       extended by the superclass).
+   */
+  def ensureConstrCall(cls: ClassSymbol, parent: Tree, psym: Symbol)(using Context): Tree =
+    if parent.isType && !cls.is(Trait) && !cls.is(JavaDefined) && psym.isClass
+        && (!psym.is(Trait)
+            || psym.primaryConstructor.info.takesParams && !cls.superClass.isSubClass(psym))
+    then typed(untpd.New(untpd.TypedSplice(parent), Nil))
+    else parent
+
+  def localDummy(cls: ClassSymbol, impl: untpd.Template)(using Context): Symbol =
+    newLocalDummy(cls, impl.span)
+
+  inline private def typedSelectors(selectors: List[untpd.ImportSelector])(using Context): List[untpd.ImportSelector] =
+    selectors.mapConserve { sel =>
+      if sel.bound.isEmpty then sel
+      else cpy.ImportSelector(sel)(
+        sel.imported, sel.renamed, untpd.TypedSplice(typedType(sel.bound)))
+        .asInstanceOf[untpd.ImportSelector]
+    }
+
+  def typedImportQualifier(imp: untpd.Import, typd: (untpd.Tree, Type) => Tree)(using Context): Tree =
+    if imp.expr == untpd.EmptyTree then
+      assert(imp.selectors.length == 1, imp)
+      val from = imp.selectors.head.imported
+      val sel = tryAlternatively
+          (typedIdent(from, AnySelectionProto))
+          (typedIdent(cpy.Ident(from)(from.name.toTypeName), WildcardType))
+
+      sel.tpe match
+        case TermRef(prefix: SingletonType, _)  =>
+          singleton(prefix).withSpan(from.span)
+        case TypeRef(prefix: SingletonType, _)  =>
+          singleton(prefix).withSpan(from.span)
+        case _ =>
+          errorTree(from,
+            em"""Illegal import selector: $from
+                |The selector is not a member of an object or package.""")
+    else typd(imp.expr, AnySelectionProto)
+
+  def typedImport(imp: untpd.Import)(using Context): Tree =
+    val sym = retrieveSym(imp)
+    val expr1 = typedImportQualifier(imp, typedExpr(_, _)(using ctx.withOwner(sym)))
+    checkLegalImportPath(expr1)
+    val selectors1 = typedSelectors(imp.selectors)
+    checkImportSelectors(expr1.tpe, selectors1)
+    assignType(cpy.Import(imp)(expr1, selectors1), sym)
+
+  def typedExport(exp: untpd.Export)(using Context): Tree =
+    exp.expr.removeAttachment(TypedAhead) match
+      case Some(expr1) =>
+        val selectors1 = typedSelectors(exp.selectors)
+        assignType(cpy.Export(exp)(expr1, selectors1))
+      case _ =>
+        errorTree(exp, em"exports are only allowed from objects and classes, they can not belong to local blocks")
+
+  def typedPackageDef(tree: untpd.PackageDef)(using Context): Tree =
+    val pid1 = withMode(Mode.InPackageClauseName)(typedExpr(tree.pid, AnySelectionProto))
+    val pkg = pid1.symbol
+    pid1 match
+      case pid1: RefTree if pkg.is(Package) =>
+        inContext(ctx.packageContext(tree, pkg)) {
+          // If it exists, complete the class containing the top-level definitions
+          // before typing any statement in the package to avoid cycles as in i13669.scala
+          val topLevelClassName = desugar.packageObjectName(ctx.source).moduleClassName
+          pkg.moduleClass.info.decls.lookup(topLevelClassName).ensureCompleted()
+          var stats1 = typedStats(tree.stats, pkg.moduleClass)._1
+          if (!ctx.isAfterTyper)
+            stats1 = stats1 ++ typedBlockStats(MainProxies.proxies(stats1))._1
+          cpy.PackageDef(tree)(pid1, stats1).withType(pkg.termRef)
+        }
+      case _ =>
+        // Package will not exist if a duplicate type has already been entered, see `tests/neg/1708.scala`
+        errorTree(tree,
+          if pkg.exists then PackageNameAlreadyDefined(pkg)
+          else i"package ${tree.pid.name} does not exist".toMessage)
+  end typedPackageDef
+
+  def typedAnnotated(tree: untpd.Annotated, pt: Type)(using Context): Tree = {
+    val annot1 = typedExpr(tree.annot, defn.AnnotationClass.typeRef)
+    val annotCls = Annotations.annotClass(annot1)
+    if annotCls == defn.NowarnAnnot then
+      registerNowarn(annot1, tree)
+    val arg1 = typed(tree.arg, pt)
+    if (ctx.mode is Mode.Type) {
+      val cls = annot1.symbol.maybeOwner
+      if Feature.ccEnabled
+          && (cls == defn.RetainsAnnot || cls == defn.RetainsByNameAnnot)
+      then
+        CheckCaptures.checkWellformed(annot1)
+      if arg1.isType then
+        assignType(cpy.Annotated(tree)(arg1, annot1), arg1, annot1)
+      else
+        assert(ctx.reporter.errorsReported)
+        TypeTree(UnspecifiedErrorType)
+    }
+    else {
+      val arg2 = arg1 match {
+        case Typed(arg2, tpt: TypeTree) =>
+          tpt.tpe match {
+            case _: AnnotatedType =>
+              // Avoid creating a Typed tree for each type annotation that is added.
+              // Drop the outer Typed tree and use its type with the addition all annotation.
+              arg2
+            case _ => arg1
+          }
+        case _ => arg1
+      }
+      val argType =
+        if (arg1.isInstanceOf[Bind]) arg1.tpe.widen // bound symbol is not accessible outside of Bind node
+        else arg1.tpe.widenIfUnstable
+      val annotatedTpt = TypeTree(AnnotatedType(argType, Annotation(annot1)))
+      assignType(cpy.Typed(tree)(arg2, annotatedTpt), annotatedTpt)
+    }
+  }
+
+  def typedTypedSplice(tree: untpd.TypedSplice)(using Context): Tree =
+    tree.splice match {
+      case tree1: TypeTree => tree1  // no change owner necessary here ...
+      case tree1: Ident => tree1     // ... or here, since these trees cannot contain bindings
+      case tree1 =>
+        if (ctx.owner ne tree.owner) tree1.changeOwner(tree.owner, ctx.owner)
+        else tree1
+    }
+
+  def typedAsFunction(tree: untpd.PostfixOp, pt: Type)(using Context): Tree = {
+    val untpd.PostfixOp(qual, Ident(nme.WILDCARD)) = tree: @unchecked
+    val pt1 = if (defn.isFunctionType(pt)) pt else AnyFunctionProto
+    val nestedCtx = ctx.fresh.setNewTyperState()
+    val res = typed(qual, pt1)(using nestedCtx)
+    res match {
+      case closure(_, _, _) =>
+      case _ =>
+        val recovered = typed(qual)(using ctx.fresh.setExploreTyperState())
+        report.errorOrMigrationWarning(OnlyFunctionsCanBeFollowedByUnderscore(recovered.tpe.widen), tree.srcPos, from = `3.0`)
+        if (migrateTo3) {
+          // Under -rewrite, patch `x _` to `(() => x)`
+          patch(Span(tree.span.start), "(() => ")
+          patch(Span(qual.span.end, tree.span.end), ")")
+          return typed(untpd.Function(Nil, qual), pt)
+        }
+    }
+    nestedCtx.typerState.commit()
+    if sourceVersion.isAtLeast(future) then
+      lazy val (prefix, suffix) = res match {
+        case Block(mdef @ DefDef(_, vparams :: Nil, _, _) :: Nil, _: Closure) =>
+          val arity = vparams.length
+          if (arity > 0) ("", "") else ("(() => ", "())")
+        case _ =>
+          ("(() => ", ")")
+      }
+      def remedy =
+        if ((prefix ++ suffix).isEmpty) "simply leave out the trailing ` _`"
+        else s"use `$prefix<function>$suffix` instead"
+      report.errorOrMigrationWarning(
+        i"""The syntax `<function> _` is no longer supported;
+           |you can $remedy""",
+        tree.srcPos,
+        from = future)
+      if sourceVersion.isMigrating then
+        patch(Span(tree.span.start), prefix)
+        patch(Span(qual.span.end, tree.span.end), suffix)
+    end if
+    res
+  }
+
+  /** Translate infix operation expression `l op r` to
+   *
+   *    l.op(r)   			        if `op` is left-associative
+   *    { val x = l; r.op(x) }  if `op` is right-associative call-by-value and `l` is impure
+   *    r.op(l)                 if `op` is right-associative call-by-name or `l` is pure
+   *
+   *  Translate infix type    `l op r` to `op[l, r]`
+   *  Translate infix pattern `l op r` to `op(l, r)`
+   */
+  def typedInfixOp(tree: untpd.InfixOp, pt: Type)(using Context): Tree = {
+    val untpd.InfixOp(l, op, r) = tree
+    val result =
+      if (ctx.mode.is(Mode.Type))
+        typedAppliedTypeTree(
+          if op.name == tpnme.throws && Feature.enabled(Feature.saferExceptions)
+          then desugar.throws(l, op, r)
+          else cpy.AppliedTypeTree(tree)(op, l :: r :: Nil))
+      else if (ctx.mode.is(Mode.Pattern))
+        typedUnApply(cpy.Apply(tree)(op, l :: r :: Nil), pt)
+      else {
+        val app = typedApply(desugar.binop(l, op, r), pt)
+        if op.name.isRightAssocOperatorName then
+          val defs = new mutable.ListBuffer[Tree]
+          def lift(app: Tree): Tree = (app: @unchecked) match
+            case Apply(fn, args) =>
+              if (app.tpe.isError) app
+              else tpd.cpy.Apply(app)(fn, LiftImpure.liftArgs(defs, fn.tpe, args))
+            case Assign(lhs, rhs) =>
+              tpd.cpy.Assign(app)(lhs, lift(rhs))
+            case Block(stats, expr) =>
+              tpd.cpy.Block(app)(stats, lift(expr))
+          wrapDefs(defs, lift(app))
+        else app
+      }
+    // issue 10383: we stripBlock because e.g. default arguments desugar to blocks during typing,
+    // and the block itself doesn't have a symbol (because a Block isn't a ProxyTree),
+    // but the last expression in the block does have the right symbol
+    checkValidInfix(tree, stripBlock(result).symbol)
+    result
+  }
+
+  /** Translate tuples of all arities */
+  def typedTuple(tree: untpd.Tuple, pt: Type)(using Context): Tree = {
+    val arity = tree.trees.length
+    if (arity <= Definitions.MaxTupleArity)
+      typed(desugar.smallTuple(tree).withSpan(tree.span), pt)
+    else {
+      val pts =
+        pt.tupleElementTypes match
+          case Some(types) if types.size == arity => types
+          case _ => List.fill(arity)(defn.AnyType)
+      val elems = tree.trees.lazyZip(pts).map(
+        if ctx.mode.is(Mode.Type) then typedType(_, _, mapPatternBounds = true)
+        else typed(_, _))
+      if (ctx.mode.is(Mode.Type))
+        elems.foldRight(TypeTree(defn.EmptyTupleModule.termRef): Tree)((elemTpt, elemTpts) =>
+          AppliedTypeTree(TypeTree(defn.PairClass.typeRef), List(elemTpt, elemTpts)))
+          .withSpan(tree.span)
+      else {
+        val tupleXXLobj = untpd.ref(defn.TupleXXLModule.termRef)
+        val app = untpd.cpy.Apply(tree)(tupleXXLobj, elems.map(untpd.TypedSplice(_)))
+          .withSpan(tree.span)
+        val app1 = typed(app, defn.TupleXXLClass.typeRef)
+        if (ctx.mode.is(Mode.Pattern)) app1
+        else {
+          val elemTpes = elems.lazyZip(pts).map((elem, pt) =>
+            TypeComparer.widenInferred(elem.tpe, pt, widenUnions = true))
+          val resTpe = TypeOps.nestedPairs(elemTpes)
+          app1.cast(resTpe)
+        }
+      }
+    }
+  }
+
+  /** Retrieve symbol attached to given tree */
+  protected def retrieveSym(tree: untpd.Tree)(using Context): Symbol = tree.removeAttachment(SymOfTree) match {
+    case Some(sym) =>
+      sym.ensureCompleted()
+      sym
+    case none =>
+      NoSymbol
+  }
+
+  protected def localTyper(sym: Symbol): Typer = nestedTyper.remove(sym).get
+
+  def typedUnadapted(initTree: untpd.Tree, pt: Type = WildcardType)(using Context): Tree =
+    typedUnadapted(initTree, pt, ctx.typerState.ownedVars)
+
+  /** Typecheck tree without adapting it, returning a typed tree.
+   *  @param initTree    the untyped tree
+   *  @param pt          the expected result type
+   *  @param locked      the set of type variables of the current typer state that cannot be interpolated
+   *                     at the present time
+   */
+  def typedUnadapted(initTree: untpd.Tree, pt: Type, locked: TypeVars)(using Context): Tree = {
+    record("typedUnadapted")
+    val xtree = expanded(initTree)
+    xtree.removeAttachment(TypedAhead) match {
+      case Some(ttree) => ttree
+      case none =>
+
+        def typedNamed(tree: untpd.NameTree, pt: Type)(using Context): Tree = {
+          val sym = retrieveSym(xtree)
+          tree match {
+            case tree: untpd.Ident => typedIdent(tree, pt)
+            case tree: untpd.Select => typedSelect(tree, pt)
+            case tree: untpd.Bind => typedBind(tree, pt)
+            case tree: untpd.ValDef =>
+              if (tree.isEmpty) tpd.EmptyValDef
+              else typedValDef(tree, sym)(using ctx.localContext(tree, sym))
+            case tree: untpd.DefDef =>
+              val typer1 = localTyper(sym)
+              typer1.typedDefDef(tree, sym)(using ctx.localContext(tree, sym).setTyper(typer1))
+            case tree: untpd.TypeDef =>
+              // separate method to keep dispatching method `typedNamed` short which might help the JIT
+              def typedTypeOrClassDef: Tree =
+                if tree.name eq tpnme.? then
+                  val addendum = if sym.owner.is(TypeParam)
+                    then ", use `_` to denote a higher-kinded type parameter"
+                    else ""
+                  val namePos = tree.sourcePos.withSpan(tree.nameSpan)
+                  report.errorOrMigrationWarning(
+                    s"`?` is not a valid type name$addendum", namePos, from = `3.0`)
+                if tree.isClassDef then
+                  typedClassDef(tree, sym.asClass)(using ctx.localContext(tree, sym))
+                else
+                  typedTypeDef(tree, sym)(using ctx.localContext(tree, sym).setNewScope)
+
+              typedTypeOrClassDef
+            case tree: untpd.Labeled => typedLabeled(tree)
+            case _ => typedUnadapted(desugar(tree, pt), pt, locked)
+          }
+        }
+
+        def typedUnnamed(tree: untpd.Tree): Tree = tree match {
+          case tree: untpd.Apply =>
+            if (ctx.mode is Mode.Pattern) typedUnApply(tree, pt) else typedApply(tree, pt)
+          case tree: untpd.This => typedThis(tree)
+          case tree: untpd.Number => typedNumber(tree, pt)
+          case tree: untpd.Literal => typedLiteral(tree)
+          case tree: untpd.New => typedNew(tree, pt)
+          case tree: untpd.Typed => typedTyped(tree, pt)
+          case tree: untpd.NamedArg => typedNamedArg(tree, pt)
+          case tree: untpd.Assign => typedAssign(tree, pt)
+          case tree: untpd.Block => typedBlock(desugar.block(tree), pt)(using ctx.fresh.setNewScope)
+          case tree: untpd.If => typedIf(tree, pt)
+          case tree: untpd.Function => typedFunction(tree, pt)
+          case tree: untpd.Closure => typedClosure(tree, pt)
+          case tree: untpd.Import => typedImport(tree)
+          case tree: untpd.Export => typedExport(tree)
+          case tree: untpd.Match => typedMatch(tree, pt)
+          case tree: untpd.Return => typedReturn(tree)
+          case tree: untpd.WhileDo => typedWhileDo(tree)
+          case tree: untpd.Try => typedTry(tree, pt)
+          case tree: untpd.Throw => typedThrow(tree)
+          case tree: untpd.TypeApply => typedTypeApply(tree, pt)
+          case tree: untpd.Super => typedSuper(tree, pt)
+          case tree: untpd.SeqLiteral => typedSeqLiteral(tree, pt)
+          case tree: untpd.Inlined => typedInlined(tree, pt)
+          case tree: untpd.TypeTree => typedTypeTree(tree, pt)
+          case tree: untpd.SingletonTypeTree => typedSingletonTypeTree(tree)
+          case tree: untpd.RefinedTypeTree => typedRefinedTypeTree(tree)
+          case tree: untpd.AppliedTypeTree => typedAppliedTypeTree(tree)
+          case tree: untpd.LambdaTypeTree => typedLambdaTypeTree(tree)(using ctx.localContext(tree, NoSymbol).setNewScope)
+          case tree: untpd.TermLambdaTypeTree => typedTermLambdaTypeTree(tree)(using ctx.localContext(tree, NoSymbol).setNewScope)
+          case tree: untpd.MatchTypeTree => typedMatchTypeTree(tree, pt)
+          case tree: untpd.ByNameTypeTree => typedByNameTypeTree(tree)
+          case tree: untpd.TypeBoundsTree => typedTypeBoundsTree(tree, pt)
+          case tree: untpd.Alternative => typedAlternative(tree, pt)
+          case tree: untpd.PackageDef => typedPackageDef(tree)
+          case tree: untpd.Annotated => typedAnnotated(tree, pt)
+          case tree: untpd.TypedSplice => typedTypedSplice(tree)
+          case tree: untpd.UnApply => typedUnApply(tree, pt)
+          case tree: untpd.Tuple => typedTuple(tree, pt)
+          case tree: untpd.DependentTypeTree => completeTypeTree(untpd.TypeTree(), pt, tree)
+          case tree: untpd.InfixOp => typedInfixOp(tree, pt)
+          case tree: untpd.ParsedTry => typedTry(tree, pt)
+          case tree @ untpd.PostfixOp(qual, Ident(nme.WILDCARD)) => typedAsFunction(tree, pt)
+          case untpd.EmptyTree => tpd.EmptyTree
+          case tree: untpd.Quote => typedQuote(tree, pt)
+          case tree: untpd.Splice => typedSplice(tree, pt)
+          case tree: untpd.MacroTree => report.error("Unexpected macro", tree.srcPos); tpd.nullLiteral  // ill-formed code may reach here
+          case tree: untpd.Hole => typedHole(tree, pt)
+          case _ => typedUnadapted(desugar(tree, pt), pt, locked)
+        }
+
+        try
+          val ifpt = defn.asContextFunctionType(pt)
+          val result =
+            if ifpt.exists
+              && xtree.isTerm
+              && !untpd.isContextualClosure(xtree)
+              && !ctx.mode.is(Mode.Pattern)
+              && !ctx.isAfterTyper
+              && !ctx.isInlineContext
+            then
+              makeContextualFunction(xtree, ifpt)
+            else xtree match
+              case xtree: untpd.NameTree => typedNamed(xtree, pt)
+              case xtree => typedUnnamed(xtree)
+
+          simplify(result, pt, locked)
+        catch case ex: TypeError => errorTree(xtree, ex, xtree.srcPos.focus)
+          // use focussed sourcePos since tree might be a large definition
+          // and a large error span would hide all errors in interior.
+          // TODO: Not clear that hiding is what we want, actually
+    }
+  }
+
+  /** Interpolate and simplify the type of the given tree. */
+  protected def simplify(tree: Tree, pt: Type, locked: TypeVars)(using Context): tree.type =
+    if !tree.denot.isOverloaded then // for overloaded trees: resolve overloading before simplifying
+      if !tree.tpe.widen.isInstanceOf[MethodOrPoly] // wait with simplifying until method is fully applied
+         || tree.isDef                              // ... unless tree is a definition
+      then
+        interpolateTypeVars(tree, pt, locked)
+        val simplified = tree.tpe.simplified
+        if !MatchType.thatReducesUsingGadt(tree.tpe) then // needs a GADT cast. i15743
+          tree.overwriteType(simplified)
+    tree
+
+  protected def makeContextualFunction(tree: untpd.Tree, pt: Type)(using Context): Tree = {
+    val defn.FunctionOf(formals, _, true, _) = pt.dropDependentRefinement: @unchecked
+
+    // The getter of default parameters may reach here.
+    // Given the code below
+    //
+    //     class Foo[A](run: A ?=> Int) {
+    //        def foo[T](f: T ?=> Int = run) = ()
+    //     }
+    //
+    // it desugars to
+    //
+    //     class Foo[A](run: A ?=> Int) {
+    //        def foo$default$1[T] = run
+    //        def foo[T](f: T ?=> Int = run) = ()
+    //     }
+    //
+    // The expected type for checking `run` in `foo$default$1` is
+    //
+    //      <?> ?=> Int
+    //
+    // see tests/pos/i7778b.scala
+
+    val paramTypes = {
+      val hasWildcard = formals.exists(_.existsPart(_.isInstanceOf[WildcardType], StopAt.Static))
+      if hasWildcard then formals.map(_ => untpd.TypeTree())
+      else formals.map(untpd.TypeTree)
+    }
+
+    val ifun = desugar.makeContextualFunction(paramTypes, tree, defn.isErasedFunctionType(pt))
+    typr.println(i"make contextual function $tree / $pt ---> $ifun")
+    typedFunctionValue(ifun, pt)
+  }
+
+  /** Typecheck and adapt tree, returning a typed tree. Parameters as for `typedUnadapted` */
+  def typed(tree: untpd.Tree, pt: Type, locked: TypeVars)(using Context): Tree =
+    trace(i"typing $tree, pt = $pt", typr, show = true) {
+      record(s"typed $getClass")
+      record("typed total")
+      if ctx.phase.isTyper then
+        assertPositioned(tree)
+      if tree.source != ctx.source && tree.source.exists then
+        typed(tree, pt, locked)(using ctx.withSource(tree.source))
+      else if ctx.run.nn.isCancelled then
+        tree.withType(WildcardType)
+      else adapt(typedUnadapted(tree, pt, locked), pt, locked)
+    }
+
+  def typed(tree: untpd.Tree, pt: Type = WildcardType)(using Context): Tree =
+    typed(tree, pt, ctx.typerState.ownedVars)
+
+  def typedTrees(trees: List[untpd.Tree])(using Context): List[Tree] =
+    trees mapconserve (typed(_))
+
+  def typedStats(stats: List[untpd.Tree], exprOwner: Symbol)(using Context): (List[Tree], Context) = {
+    val buf = new mutable.ListBuffer[Tree]
+    var enumContexts: SimpleIdentityMap[Symbol, Context] = SimpleIdentityMap.empty
+    val initialNotNullInfos = ctx.notNullInfos
+      // A map from `enum` symbols to the contexts enclosing their definitions
+    @tailrec def traverse(stats: List[untpd.Tree])(using Context): (List[Tree], Context) = stats match {
+      case (imp: untpd.Import) :: rest =>
+        val imp1 = typed(imp)
+        buf += imp1
+        traverse(rest)(using ctx.importContext(imp, imp1.symbol))
+      case (mdef: untpd.DefTree) :: rest =>
+        mdef.removeAttachment(ExpandedTree) match {
+          case Some(xtree) =>
+            traverse(xtree :: rest)
+          case none =>
+            val newCtx = if (ctx.owner.isTerm && adaptCreationContext(mdef)) ctx
+              else ctx.withNotNullInfos(initialNotNullInfos)
+            typed(mdef)(using newCtx) match {
+              case mdef1: DefDef
+              if mdef1.symbol.is(Inline, butNot = Deferred) && !Inlines.bodyToInline(mdef1.symbol).isEmpty =>
+                buf ++= inlineExpansion(mdef1)
+                  // replace body with expansion, because it will be used as inlined body
+                  // from separately compiled files - the original BodyAnnotation is not kept.
+              case mdef1: TypeDef if mdef1.symbol.is(Enum, butNot = Case) =>
+                enumContexts = enumContexts.updated(mdef1.symbol, ctx)
+                buf += mdef1
+              case EmptyTree =>
+                // clashing synthetic case methods are converted to empty trees, drop them here
+              case mdef1 =>
+                buf += mdef1
+            }
+            traverse(rest)
+        }
+      case Thicket(stats) :: rest =>
+        traverse(stats ::: rest)
+      case (stat: untpd.Export) :: rest =>
+        buf +=  typed(stat)
+        buf ++= stat.attachmentOrElse(ExportForwarders, Nil)
+          // no attachment can happen in case of cyclic references
+        traverse(rest)
+      case (stat: untpd.ExtMethods) :: rest =>
+        val xtree = stat.removeAttachment(ExpandedTree).get
+        traverse(xtree :: rest)
+      case stat :: rest =>
+        val stat1 = typed(stat)(using ctx.exprContext(stat, exprOwner))
+        checkStatementPurity(stat1)(stat, exprOwner)
+        buf += stat1
+        traverse(rest)(using stat1.nullableContext)
+      case nil =>
+        (buf.toList, ctx)
+    }
+    val localCtx = {
+      val exprOwnerOpt = if (exprOwner == ctx.owner) None else Some(exprOwner)
+      ctx.withProperty(ExprOwner, exprOwnerOpt)
+    }
+    def finalize(stat: Tree)(using Context): Tree = stat match {
+      case stat: TypeDef if stat.symbol.is(Module) =>
+        val enumContext = enumContexts(stat.symbol.linkedClass)
+        if enumContext != null then
+          checkEnumCaseRefsLegal(stat, enumContext)
+        stat.removeAttachment(AttachedDeriver) match {
+          case Some(deriver) => deriver.finalize(stat)
+          case None => stat
+        }
+      case _ =>
+        stat
+    }
+    val (stats0, finalCtx) = traverse(stats)(using localCtx)
+    val stats1 = stats0.mapConserve(finalize)
+    if ctx.owner == exprOwner then checkNoTargetNameConflict(stats1)
+    (stats1, finalCtx)
+  }
+
+  /** Tries to adapt NotNullInfos from creation context to the DefTree,
+   *  returns whether the adaption took place. An adaption only takes place if the
+   *  DefTree has a symbol and it has not been completed (is not forward referenced).
+   */
+  def adaptCreationContext(mdef: untpd.DefTree)(using Context): Boolean =
+    // Keep preceding not null facts in the current context only if `mdef`
+    // cannot be executed out-of-sequence.
+    // We have to check the Completer of symbol befor typedValDef,
+    // otherwise the symbol is already completed using creation context.
+    mdef.getAttachment(SymOfTree) match {
+      case Some(sym) => sym.infoOrCompleter match {
+        case completer: Namer#Completer =>
+          if (completer.creationContext.notNullInfos ne ctx.notNullInfos)
+            // The RHS of a val def should know about not null facts established
+            // in preceding statements (unless the DefTree is completed ahead of time,
+            // then it is impossible).
+            sym.info = Completer(completer.original)(
+              completer.creationContext.withNotNullInfos(ctx.notNullInfos))
+          true
+        case _ =>
+          // If it has been completed, then it must be because there is a forward reference
+          // to the definition in the program. Hence, we don't Keep preceding not null facts
+          // in the current context.
+          false
+      }
+      case _ => false
+    }
+
+  /** Given an inline method `mdef`, the method rewritten so that its body
+   *  uses accessors to access non-public members. Also, if the inline method
+   *  is retained, add a method to record the retained version of the body.
+   *  Overwritten in Retyper to return `mdef` unchanged.
+   */
+  protected def inlineExpansion(mdef: DefDef)(using Context): List[Tree] =
+    tpd.cpy.DefDef(mdef)(rhs = Inlines.bodyToInline(mdef.symbol))
+    :: (if mdef.symbol.isRetainedInlineMethod then Inlines.bodyRetainer(mdef) :: Nil else Nil)
+
+  def typedExpr(tree: untpd.Tree, pt: Type = WildcardType)(using Context): Tree =
+    withoutMode(Mode.PatternOrTypeBits)(typed(tree, pt))
+
+  def typedType(tree: untpd.Tree, pt: Type = WildcardType, mapPatternBounds: Boolean = false)(using Context): Tree =
+    val tree1 = withMode(Mode.Type) { typed(tree, pt) }
+    if mapPatternBounds && ctx.mode.is(Mode.Pattern) && !ctx.isAfterTyper then
+      tree1 match
+        case tree1: TypeBoundsTree =>
+          // Associate a pattern-bound type symbol with the wildcard.
+          // The bounds of the type symbol can be constrained when comparing a pattern type
+          // with an expected type in typedTyped. The type symbol and the defining Bind node
+          // are eliminated once the enclosing pattern has been typechecked; see `indexPattern`
+          // in `typedCase`.
+          val boundName = WildcardParamName.fresh().toTypeName
+          val wildcardSym = newPatternBoundSymbol(boundName, tree1.tpe & pt, tree.span)
+          untpd.Bind(boundName, tree1).withType(wildcardSym.typeRef)
+        case tree1 =>
+          tree1
+    else tree1
+
+  def typedPattern(tree: untpd.Tree, selType: Type = WildcardType)(using Context): Tree =
+    withMode(Mode.Pattern)(typed(tree, selType))
+
+  def tryEither[T](op: Context ?-> T)(fallBack: (T, TyperState) => T)(using Context): T = {
+    val nestedCtx = ctx.fresh.setNewTyperState()
+    val result = op(using nestedCtx)
+    if (nestedCtx.reporter.hasErrors && !nestedCtx.reporter.hasStickyErrors) {
+      record("tryEither.fallBack")
+      fallBack(result, nestedCtx.typerState)
+    }
+    else {
+      record("tryEither.commit")
+      nestedCtx.typerState.commit()
+      result
+    }
+  }
+
+  /** Try `op1`, if there are errors, try `op2`, if `op2` also causes errors, fall back
+   *  to errors and result of `op1`.
+   */
+  def tryAlternatively[T](op1: Context ?-> T)(op2: Context ?-> T)(using Context): T =
+    tryEither(op1) { (failedVal, failedState) =>
+      tryEither(op2) { (_, _) =>
+        failedState.commit()
+        failedVal
+      }
+    }
+
+  /** Is `pt` a prototype of an `apply` selection, or a parameterless function yielding one? */
+  def isApplyProto(pt: Type)(using Context): Boolean = pt.revealIgnored match {
+    case pt: SelectionProto => pt.name == nme.apply
+    case pt: FunProto       => pt.args.isEmpty && isApplyProto(pt.resultType)
+    case _                  => false
+  }
+
+  /** Potentially add apply node or implicit conversions. Before trying either,
+   *  if the function is applied to an empty parameter list (), we try
+   *
+   *  0th strategy: If `tree` overrides a nullary method, mark the prototype
+   *                so that the argument is dropped and return `tree` itself.
+   *                (but do this at most once per tree).
+   *
+   *  After that, two strategies are tried, and the first that is successful is picked.
+   *
+   *  1st strategy: Try to insert `.apply` so that the result conforms to prototype `pt`.
+   *                This strategy is not tried if the prototype represents already
+   *                another `.apply` or `.apply()` selection.
+   *
+   *  2nd strategy: If tree is a select `qual.name`, try to insert an implicit conversion
+   *    around the qualifier part `qual` so that the result conforms to the expected type
+   *    with wildcard result type.
+   *
+   *  If neither of the strategies are successful, continues with the `apply` result
+   *  if an apply insertion was tried and `tree` has an `apply` method, or continues
+   *  with `fallBack` otherwise. `fallBack` is supposed to always give an error.
+   */
+  def tryInsertApplyOrImplicit(tree: Tree, pt: ProtoType, locked: TypeVars)(fallBack: => Tree)(using Context): Tree = {
+    def isMethod(tree: Tree) = tree.tpe match {
+      case ref: TermRef => ref.denot.alternatives.forall(_.info.widen.isInstanceOf[MethodicType])
+      case _ => false
+    }
+
+    var assumeApplyExists = false
+      // if true, issue any errors about the apply instead of `fallBack`,
+      // since they are more likely to be informative.
+
+    def tryApply(using Context) = {
+      val pt1 = pt.withContext(ctx)
+      val sel = typedSelect(untpd.Select(untpd.TypedSplice(tree), nme.apply), pt1)
+        .withAttachment(InsertedApply, ())
+      if sel.tpe.isError then
+        // assume the apply exists if qualifier has a hidden search failure of type
+        // FailedExtension or NestedFailure
+        sel match
+          case Select(qual, _) =>
+            assumeApplyExists = qual.getAttachment(Typer.HiddenSearchFailure).exists(
+              _.exists(_.reason.isInstanceOf[FailedExtension | NestedFailure]))
+          case _ =>
+        sel
+      else
+        assumeApplyExists = true
+        try adapt(simplify(sel, pt1, locked), pt1, locked) finally sel.removeAttachment(InsertedApply)
+    }
+
+    def tryImplicit(fallBack: => Tree) =
+      tryInsertImplicitOnQualifier(tree, pt.withContext(ctx), locked).getOrElse(fallBack)
+
+    if (ctx.mode.is(Mode.SynthesizeExtMethodReceiver))
+      // Suppress insertion of apply or implicit conversion on extension method receiver
+      tree
+    else pt match {
+      case pt @ FunProto(Nil, _)
+      if tree.symbol.allOverriddenSymbols.exists(_.info.isNullaryMethod) &&
+         !tree.hasAttachment(DroppedEmptyArgs) =>
+        tree.putAttachment(DroppedEmptyArgs, ())
+        pt.markAsDropped()
+        tree
+      case _ =>
+        if (isApplyProto(pt) || isMethod(tree) || isSyntheticApply(tree)) tryImplicit(fallBack)
+        else tryEither(tryApply) { (app, appState) =>
+          tryImplicit {
+            if assumeApplyExists then
+              appState.commit()
+              app
+            else fallBack
+          }
+        }
+    }
+  }
+
+  /** If this tree is a select node `qual.name` (possibly applied to type variables)
+   *  that does not conform to `pt`, try two mitigations:
+   *   1. Instantiate any TypeVars in the widened type of `tree` with their lower bounds.
+   *   2. Try to insert an implicit conversion `c` around `qual` so that
+   *   `c(qual).name` conforms to `pt`.
+   */
+  def tryInsertImplicitOnQualifier(tree: Tree, pt: Type, locked: TypeVars)(using Context): Option[Tree] = trace(i"try insert impl on qualifier $tree $pt") {
+    tree match
+      case tree @ Select(qual, name) if name != nme.CONSTRUCTOR =>
+        if couldInstantiateTypeVar(qual.tpe.widen, applied = true)
+        then
+          Some(adapt(tree, pt, locked))
+        else
+          val selProto = SelectionProto(name, pt, NoViewsAllowed, privateOK = false)
+          if selProto.isMatchedBy(qual.tpe) || tree.hasAttachment(InsertedImplicitOnQualifier) then
+            None
+          else
+            tryEither {
+              val tree1 = tryExtensionOrConversion(tree, pt, pt, qual, locked, NoViewsAllowed, inSelect = false)
+              if tree1.isEmpty then None
+              else
+                tree1.putAttachment(InsertedImplicitOnQualifier, ())
+                Some(adapt(tree1, pt, locked))
+            } { (_, _) => None
+            }
+      case TypeApply(fn, args) if args.forall(_.isInstanceOf[untpd.InferredTypeTree]) =>
+        tryInsertImplicitOnQualifier(fn, pt, locked)
+      case _ => None
+  }
+
+  /** Given a selection `qual.name`, try to convert to an extension method
+   *  application `name(qual)` or insert an implicit conversion `c(qual).name`.
+   *  @return The converted tree, or `EmptyTree` is not successful.
+   */
+  def tryExtensionOrConversion
+      (tree: untpd.Select, pt: Type, mbrProto: Type, qual: Tree, locked: TypeVars, compat: Compatibility, inSelect: Boolean)
+      (using Context): Tree =
+
+    def selectionProto = SelectionProto(tree.name, mbrProto, compat, privateOK = inSelect)
+
+    def tryExtension(using Context): Tree =
+      findRef(tree.name, WildcardType, ExtensionMethod, EmptyFlags, qual.srcPos) match
+        case ref: TermRef =>
+          extMethodApply(untpd.TypedSplice(tpd.ref(ref).withSpan(tree.nameSpan)), qual, pt)
+        case _ =>
+          EmptyTree
+
+    def nestedFailure(ex: TypeError) =
+      rememberSearchFailure(qual,
+        SearchFailure(qual.withType(NestedFailure(ex.toMessage, selectionProto))))
+
+    if qual.symbol.isNoValue then return EmptyTree
+
+    // try an extension method in scope
+    try
+      val nestedCtx = ctx.fresh.setNewTyperState()
+      val app = tryExtension(using nestedCtx)
+      if !app.isEmpty && !nestedCtx.reporter.hasErrors then
+        nestedCtx.typerState.commit()
+        return app
+      val errs = nestedCtx.reporter.allErrors
+      val remembered = // report AmbiguousReferences as priority, otherwise last error
+        (errs.filter(_.msg.isInstanceOf[AmbiguousReference]) ++ errs).take(1)
+      for err <- remembered do
+        rememberSearchFailure(qual,
+          SearchFailure(app.withType(FailedExtension(app, selectionProto, err.msg))))
+    catch case ex: TypeError => nestedFailure(ex)
+
+    // try an implicit conversion or given extension
+    if ctx.mode.is(Mode.ImplicitsEnabled) && !tree.name.isConstructorName && qual.tpe.isValueType then
+      try
+        val selProto = selectionProto
+        trace(i"try insert impl on qualifier $tree $pt") { inferView(qual, selProto) } match
+          case SearchSuccess(found, _, _, isExtension) =>
+            if isExtension then return found
+            else
+              checkImplicitConversionUseOK(found)
+              return withoutMode(Mode.ImplicitsEnabled)(typedSelect(tree, pt, found))
+          case failure: SearchFailure =>
+            if failure.isAmbiguous then
+              return
+                if !inSelect // in a selection we will do the canDefineFurther afterwards
+                    && canDefineFurther(qual.tpe.widen)
+                then
+                  tryExtensionOrConversion(tree, pt, mbrProto, qual, locked, compat, inSelect)
+                else
+                  err.typeMismatch(qual, selProto, failure.reason) // TODO: report NotAMember instead, but need to be aware of failure
+            rememberSearchFailure(qual, failure)
+      catch case ex: TypeError => nestedFailure(ex)
+
+    EmptyTree
+  end tryExtensionOrConversion
+
+  /** Perform the following adaptations of expression, pattern or type `tree` wrt to
+   *  given prototype `pt`:
+   *  (1) Resolve overloading
+   *  (2) Apply parameterless functions
+   *  (3) Apply polymorphic types to fresh instances of their type parameters and
+   *      store these instances in context.undetparams,
+   *      unless followed by explicit type application.
+   *  (4) Do the following to unapplied methods used as values:
+   *  (4.1) If the method has only implicit parameters pass implicit arguments
+   *  (4.2) otherwise, if `pt` is a function type and method is not a constructor,
+   *        convert to function by eta-expansion,
+   *  (4.3) otherwise, if the method is nullary with a result type compatible to `pt`
+   *        and it is not a constructor, apply it to ()
+   *  otherwise issue an error
+   *  (5) Convert constructors in a pattern as follows:
+   *  (5.1) If constructor refers to a case class factory, set tree's type to the unique
+   *        instance of its primary constructor that is a subtype of the expected type.
+   *  (5.2) If constructor refers to an extractor, convert to application of
+   *        unapply or unapplySeq method.
+   *
+   *  (6) Convert all other types to TypeTree nodes.
+   *  (7) When in TYPEmode but not FUNmode or HKmode, check that types are fully parameterized
+   *      (7.1) In HKmode, higher-kinded types are allowed, but they must have the expected kind-arity
+   *  (8) When in both EXPRmode and FUNmode, add apply method calls to values of object type.
+   *  (9) If there are undetermined type variables and not POLYmode, infer expression instance
+   *  Then, if tree's type is not a subtype of expected type, try the following adaptations:
+   *  (10) If the expected type is Byte, Short or Char, and the expression
+   *      is an integer fitting in the range of that type, convert it to that type.
+   *  (11) Widen numeric literals to their expected type, if necessary
+   *  (12) When in mode EXPRmode, convert E to { E; () } if expected type is scala.Unit.
+   *  (13) When in mode EXPRmode, apply AnnotationChecker conversion if expected type is annotated.
+   *  (14) When in mode EXPRmode, apply a view
+   *  If all this fails, error
+   *  Parameters as for `typedUnadapted`.
+   */
+  def adapt(tree: Tree, pt: Type, locked: TypeVars)(using Context): Tree =
+    try
+      trace(i"adapting $tree to $pt", typr, show = true) {
+        record("adapt")
+        adapt1(tree, pt, locked)
+      }
+    catch case ex: TypeError => errorTree(tree, ex, tree.srcPos.focus)
+
+  final def adapt(tree: Tree, pt: Type)(using Context): Tree =
+    adapt(tree, pt, ctx.typerState.ownedVars)
+
+  private def adapt1(tree: Tree, pt: Type, locked: TypeVars)(using Context): Tree = {
+    assert(pt.exists && !pt.isInstanceOf[ExprType] || ctx.reporter.errorsReported)
+    def methodStr = err.refStr(methPart(tree).tpe)
+
+    def readapt(tree: Tree)(using Context) = adapt(tree, pt, locked)
+    def readaptSimplified(tree: Tree)(using Context) = readapt(simplify(tree, pt, locked))
+
+    def missingArgs(mt: MethodType) =
+      ErrorReporting.missingArgs(tree, mt)
+      tree.withType(mt.resultType)
+
+    def adaptOverloaded(ref: TermRef) = {
+      val altDenots =
+        val allDenots = ref.denot.alternatives
+        if pt.isExtensionApplyProto then allDenots.filter(_.symbol.is(ExtensionMethod))
+        else allDenots
+      typr.println(i"adapt overloaded $ref with alternatives ${altDenots map (_.info)}%\n\n %")
+      def altRef(alt: SingleDenotation) = TermRef(ref.prefix, ref.name, alt)
+      val alts = altDenots.map(altRef)
+      resolveOverloaded(alts, pt) match {
+        case alt :: Nil =>
+          readaptSimplified(tree.withType(alt))
+        case Nil =>
+          // If alternative matches, there are still two ways to recover:
+          //  1. If context is an application, try to insert an apply or implicit
+          //  2. If context is not an application, pick a alternative that does
+          //     not take parameters.
+          def noMatches =
+            errorTree(tree, NoMatchingOverload(altDenots, pt))
+          def hasEmptyParams(denot: SingleDenotation) = denot.info.paramInfoss == ListOfNil
+          pt match {
+            case pt: FunOrPolyProto if pt.applyKind != ApplyKind.Using =>
+              // insert apply or convert qualifier, but only for a regular application
+              tryInsertApplyOrImplicit(tree, pt, locked)(noMatches)
+            case _ =>
+              alts.filter(_.info.isParameterless) match {
+                case alt :: Nil => readaptSimplified(tree.withType(alt))
+                case _ =>
+                  if (altDenots exists (_.info.paramInfoss == ListOfNil))
+                    typed(untpd.Apply(untpd.TypedSplice(tree), Nil), pt, locked)
+                  else
+                    noMatches
+              }
+          }
+        case ambiAlts =>
+          if tree.tpe.isErroneous || pt.isErroneous then tree.withType(UnspecifiedErrorType)
+          else
+            val remainingDenots = altDenots.filter(denot => ambiAlts.contains(altRef(denot)))
+            val addendum =
+              if ambiAlts.exists(!_.symbol.exists) then
+                i"""|
+                    |
+                    |Note: Overloaded definitions introduced by refinements cannot be resolved"""
+              else ""
+            errorTree(tree, AmbiguousOverload(tree, remainingDenots, pt, addendum))
+      }
+    }
+
+    def adaptToArgs(wtp: Type, pt: FunProto): Tree = wtp match {
+      case wtp: MethodOrPoly =>
+        def methodStr = methPart(tree).symbol.showLocated
+        if (matchingApply(wtp, pt))
+          if needsTupledDual(wtp, pt) then adapt(tree, pt.tupledDual, locked)
+          else tree
+        else if wtp.isContextualMethod then
+          def isContextBoundParams = wtp.stripPoly match
+            case MethodType(EvidenceParamName(_) :: _) => true
+            case _ => false
+          if sourceVersion == `future-migration` && isContextBoundParams && pt.args.nonEmpty
+          then // Under future-migration, don't infer implicit arguments yet for parameters
+               // coming from context bounds. Issue a warning instead and offer a patch.
+            def rewriteMsg = Message.rewriteNotice("This code", `future-migration`)
+            report.migrationWarning(
+              em"""Context bounds will map to context parameters.
+                  |A `using` clause is needed to pass explicit arguments to them.$rewriteMsg""", tree.srcPos)
+            patch(Span(pt.args.head.span.start), "using ")
+            tree
+          else
+            adaptNoArgs(wtp)  // insert arguments implicitly
+        else if (tree.symbol.isPrimaryConstructor && tree.symbol.info.firstParamTypes.isEmpty)
+          readapt(tree.appliedToNone) // insert () to primary constructors
+        else
+          errorTree(tree, em"Missing arguments for $methodStr")
+      case _ => tryInsertApplyOrImplicit(tree, pt, locked) {
+        errorTree(tree, MethodDoesNotTakeParameters(tree))
+      }
+    }
+
+    def adaptNoArgsImplicitMethod(wtp: MethodType): Tree = {
+      assert(wtp.isImplicitMethod)
+      val tvarsToInstantiate = tvarsInParams(tree, locked).distinct
+      def instantiate(tp: Type): Unit = {
+        instantiateSelected(tp, tvarsToInstantiate)
+        replaceSingletons(tp)
+      }
+      wtp.paramInfos.foreach(instantiate)
+      val saved = ctx.typerState.snapshot()
+
+      def dummyArg(tp: Type) = untpd.Ident(nme.???).withTypeUnchecked(tp)
+
+      def addImplicitArgs(using Context) = {
+        def hasDefaultParams = methPart(tree).symbol.hasDefaultParams
+        def implicitArgs(formals: List[Type], argIndex: Int, pt: Type): List[Tree] = formals match
+          case Nil => Nil
+          case formal :: formals1 =>
+            // If the implicit parameter list is dependent we must propagate inferred
+            // types through the remainder of the parameter list similarly to how it's
+            // done for non-implicit parameter lists in Applications#matchArgs#addTyped.
+            def inferArgsAfter(leading: Tree) =
+              val formals2 =
+                if wtp.isParamDependent && leading.tpe.exists then
+                  formals1.mapconserve(f1 => safeSubstParam(f1, wtp.paramRefs(argIndex), leading.tpe))
+                else formals1
+              implicitArgs(formals2, argIndex + 1, pt)
+
+            val arg = inferImplicitArg(formal, tree.span.endPos)
+            arg.tpe match
+              case failed: AmbiguousImplicits =>
+                val pt1 = pt.deepenProtoTrans
+                if (pt1 `ne` pt) && (pt1 ne sharpenedPt) && constrainResult(tree.symbol, wtp, pt1)
+                then implicitArgs(formals, argIndex, pt1)
+                else arg :: implicitArgs(formals1, argIndex + 1, pt1)
+              case failed: SearchFailureType =>
+                lazy val defaultArg =
+                  def appPart(t: Tree): Tree = t match
+                    case Block(stats, expr) => appPart(expr)
+                    case Inlined(_, _, expr) => appPart(expr)
+                    case _ => t
+                  defaultArgument(appPart(tree), argIndex, testOnly = false)
+                    .showing(i"default argument: for $formal, $tree, $argIndex = $result", typr)
+                if !hasDefaultParams || defaultArg.isEmpty then
+                  // no need to search further, the adapt fails in any case
+                  // the reason why we continue inferring arguments in case of an AmbiguousImplicits
+                  // is that we need to know whether there are further errors.
+                  // If there are none, we have to propagate the ambiguity to the caller.
+                  arg :: formals1.map(dummyArg)
+                else
+                  // This is tricky. On the one hand, we need the defaultArg to
+                  // correctly type subsequent formal parameters in the same using
+                  // clause in case there are parameter dependencies. On the other hand,
+                  // we cannot simply use `defaultArg` as inferred argument since some parts
+                  // of it might need lifting out. What we do instead is to use `defaultArg` for
+                  // computing parameter-dependent formals but leave the original erroneous
+                  // `arg` in place. We come back to this later in the code conditioned by
+                  // `if propFail.exists` where we re-type the whole using clause with named
+                  // arguments for all implicits that were found.
+                  arg :: inferArgsAfter(defaultArg)
+              case _ =>
+                arg :: inferArgsAfter(arg)
+        end implicitArgs
+
+        val args = implicitArgs(wtp.paramInfos, 0, pt)
+
+        def propagatedFailure(args: List[Tree]): Type = args match {
+          case arg :: args1 =>
+            arg.tpe match {
+              case ambi: AmbiguousImplicits =>
+                propagatedFailure(args1) match {
+                  case NoType | (_: AmbiguousImplicits) => ambi
+                  case failed => failed
+                }
+              case failed: SearchFailureType => failed
+              case _ => propagatedFailure(args1)
+            }
+          case Nil => NoType
+        }
+
+        val propFail = propagatedFailure(args)
+
+        def issueErrors(): Tree = {
+          def paramSymWithMethodTree(paramName: TermName) =
+            if tree.symbol.exists then
+              tree.symbol.paramSymss.flatten
+                .map(sym => sym.name -> sym)
+                .toMap
+                .get(paramName)
+                .map((_, tree))
+            else
+              None
+
+          wtp.paramNames.lazyZip(wtp.paramInfos).lazyZip(args).foreach { (paramName, formal, arg) =>
+            arg.tpe match {
+              case failure: SearchFailureType =>
+                report.error(
+                  missingArgMsg(arg, formal, implicitParamString(paramName, methodStr, tree), paramSymWithMethodTree(paramName)),
+                  tree.srcPos.endPos
+                )
+              case _ =>
+            }
+          }
+          untpd.Apply(tree, args).withType(propFail)
+        }
+
+        if (propFail.exists) {
+          // If there are several arguments, some arguments might already
+          // have influenced the context, binding variables, but later ones
+          // might fail. In that case the constraint and instantiated variables
+          // need to be reset.
+          ctx.typerState.resetTo(saved)
+
+          // If method has default params, fall back to regular application
+          // where all inferred implicits are passed as named args.
+          if hasDefaultParams && !propFail.isInstanceOf[AmbiguousImplicits] then
+            val namedArgs = wtp.paramNames.lazyZip(args).flatMap { (pname, arg) =>
+              if (arg.tpe.isError) Nil else untpd.NamedArg(pname, untpd.TypedSplice(arg)) :: Nil
+            }
+            val app = cpy.Apply(tree)(untpd.TypedSplice(tree), namedArgs)
+            if (wtp.isContextualMethod) app.setApplyKind(ApplyKind.Using)
+            typr.println(i"try with default implicit args $app")
+            typed(app, pt, locked)
+          else issueErrors()
+        }
+        else tree match {
+          case tree: Block =>
+            readaptSimplified(tpd.Block(tree.stats, tpd.Apply(tree.expr, args)))
+          case tree: NamedArg =>
+            readaptSimplified(tpd.NamedArg(tree.name, tpd.Apply(tree.arg, args)))
+          case _ =>
+            readaptSimplified(tpd.Apply(tree, args))
+        }
+      }
+      pt.revealIgnored match {
+        case pt: FunProto if pt.applyKind == ApplyKind.Using =>
+          // We can end up here if extension methods are called with explicit given arguments.
+          // See for instance #7119.
+          tree
+        case _ =>
+          addImplicitArgs(using argCtx(tree))
+      }
+    }
+
+    /** A synthetic apply should be eta-expanded if it is the apply of an implicit function
+      *  class, and the expected type is a function type. This rule is needed so we can pass
+      *  an implicit function to a regular function type. So the following is OK
+      *
+      *     val f: implicit A => B  =  ???
+      *     val g: A => B = f
+      *
+      *  and the last line expands to
+      *
+      *     val g: A => B  =  (x$0: A) => f.apply(x$0)
+      *
+      *  One could be tempted not to eta expand the rhs, but that would violate the invariant
+      *  that expressions of implicit function types are always implicit closures, which is
+      *  exploited by ShortcutImplicits.
+      *
+      *  On the other hand, the following would give an error if there is no implicit
+      *  instance of A available.
+      *
+      *     val x: AnyRef = f
+      *
+      *  That's intentional, we want to fail here, otherwise some unsuccessful implicit searches
+      *  would go undetected.
+      *
+      *  Examples for these cases are found in run/implicitFuns.scala and neg/i2006.scala.
+      */
+    def adaptNoArgsUnappliedMethod(wtp: MethodType, functionExpected: Boolean, arity: Int): Tree = {
+      /** Is reference to this symbol `f` automatically expanded to `f()`? */
+      def isAutoApplied(sym: Symbol): Boolean =
+        sym.isConstructor
+        || sym.matchNullaryLoosely
+        || Feature.warnOnMigration(MissingEmptyArgumentList(sym.show), tree.srcPos, version = `3.0`)
+           && { patch(tree.span.endPos, "()"); true }
+
+      /** If this is a selection prototype of the form `.apply(...): R`, return the nested
+       *  function prototype `(...)R`. Otherwise `pt`.
+       */
+      def ptWithoutRedundantApply: Type = pt.revealIgnored match
+        case SelectionProto(nme.apply, mpt, _, _) =>
+          mpt.revealIgnored match
+            case fpt: FunProto => fpt
+            case _ => pt
+        case _ => pt
+
+      // Reasons NOT to eta expand:
+      //  - we reference a constructor
+      //  - we reference a typelevel method
+      //  - we are in a pattern
+      //  - the current tree is a synthetic apply which is not expandable (eta-expasion would simply undo that)
+      if arity >= 0
+         && !tree.symbol.isConstructor
+         && !tree.symbol.isAllOf(InlineMethod)
+         && !ctx.mode.is(Mode.Pattern)
+         && !(isSyntheticApply(tree) && !functionExpected)
+      then
+        val pt1 = ptWithoutRedundantApply
+        if pt1 ne pt then
+          // Ignore `.apply` in `m.apply(...)`; it will later be simplified in typedSelect to `m(...)`
+          adapt1(tree, pt1, locked)
+        else
+          if (!defn.isFunctionType(pt))
+            pt match {
+              case SAMType(_) if !pt.classSymbol.hasAnnotation(defn.FunctionalInterfaceAnnot) =>
+                report.warning(ex"${tree.symbol} is eta-expanded even though $pt does not have the @FunctionalInterface annotation.", tree.srcPos)
+              case _ =>
+            }
+          simplify(typed(etaExpand(tree, wtp, arity), pt), pt, locked)
+      else if (wtp.paramInfos.isEmpty && isAutoApplied(tree.symbol))
+        readaptSimplified(tpd.Apply(tree, Nil))
+      else if (wtp.isImplicitMethod)
+        err.typeMismatch(tree, pt)
+      else
+        missingArgs(wtp)
+    }
+
+    def adaptNoArgsOther(wtp: Type, functionExpected: Boolean): Tree = {
+      val implicitFun = defn.isContextFunctionType(wtp) && !untpd.isContextualClosure(tree)
+      def caseCompanion =
+          functionExpected &&
+          tree.symbol.is(Module) &&
+          tree.symbol.companionClass.is(Case) &&
+          !tree.tpe.baseClasses.exists(defn.isFunctionClass) && {
+            report.warning("The method `apply` is inserted. The auto insertion will be deprecated, please write `" + tree.show + ".apply` explicitly.", tree.sourcePos)
+            true
+          }
+
+      if ((implicitFun || caseCompanion) &&
+          !isApplyProto(pt) &&
+          pt != AssignProto &&
+          !ctx.mode.is(Mode.Pattern) &&
+          !ctx.isAfterTyper &&
+          !ctx.isInlineContext) {
+        typr.println(i"insert apply on implicit $tree")
+        val sel = untpd.Select(untpd.TypedSplice(tree), nme.apply).withAttachment(InsertedApply, ())
+        try typed(sel, pt, locked) finally sel.removeAttachment(InsertedApply)
+      }
+      else if (ctx.mode is Mode.Pattern) {
+        checkEqualityEvidence(tree, pt)
+        tree
+      }
+      else
+        val meth = methPart(tree).symbol
+        if meth.isAllOf(DeferredInline) && !Inlines.inInlineMethod then
+          errorTree(tree, i"Deferred inline ${meth.showLocated} cannot be invoked")
+        else if Inlines.needsInlining(tree) then
+          tree.tpe <:< wildApprox(pt)
+          val errorCount = ctx.reporter.errorCount
+          val inlined = Inlines.inlineCall(tree)
+          if ((inlined ne tree) && errorCount == ctx.reporter.errorCount) readaptSimplified(inlined)
+          else inlined
+        else if (tree.symbol.isScala2Macro &&
+                // `raw`, `f` and `s` are eliminated by the StringInterpolatorOpt phase
+                tree.symbol != defn.StringContext_raw &&
+                tree.symbol != defn.StringContext_f &&
+                tree.symbol != defn.StringContext_s)
+          if (ctx.settings.XignoreScala2Macros.value) {
+            report.warning("Scala 2 macro cannot be used in Dotty, this call will crash at runtime. See https://docs.scala-lang.org/scala3/reference/dropped-features/macros.html", tree.srcPos.startPos)
+            Throw(New(defn.MatchErrorClass.typeRef, Literal(Constant(s"Reached unexpanded Scala 2 macro call to ${tree.symbol.showFullName} compiled with -Xignore-scala2-macros.")) :: Nil))
+              .withType(tree.tpe)
+              .withSpan(tree.span)
+          }
+          else {
+            report.error(
+              """Scala 2 macro cannot be used in Dotty. See https://docs.scala-lang.org/scala3/reference/dropped-features/macros.html
+                |To turn this error into a warning, pass -Xignore-scala2-macros to the compiler""".stripMargin, tree.srcPos.startPos)
+            tree
+          }
+        else TypeComparer.testSubType(tree.tpe.widenExpr, pt) match
+          case CompareResult.Fail =>
+            wtp match
+              case wtp: MethodType => missingArgs(wtp)
+              case _ =>
+                typr.println(i"adapt to subtype ${tree.tpe} !<:< $pt")
+                //typr.println(TypeComparer.explained(tree.tpe <:< pt))
+                adaptToSubType(wtp)
+          case CompareResult.OKwithGADTUsed
+          if pt.isValueType
+             && !inContext(ctx.fresh.setGadt(GadtConstraint.empty)) {
+               val res = (tree.tpe.widenExpr frozen_<:< pt)
+               if res then
+                 // we overshot; a cast is not needed, after all.
+                 gadts.println(i"unnecessary GADTused for $tree: ${tree.tpe.widenExpr} vs $pt in ${ctx.source}")
+               res
+              } =>
+            insertGadtCast(tree, wtp, pt)
+          case _ =>
+            //typr.println(i"OK ${tree.tpe}\n${TypeComparer.explained(_.isSubType(tree.tpe, pt))}") // uncomment for unexpected successes
+            tree
+    }
+
+    // Follow proxies and approximate type paramrefs by their upper bound
+    // in the current constraint in order to figure out robustly
+    // whether an expected type is some sort of function type.
+    def underlyingApplied(tp: Type): Type = tp.stripTypeVar match {
+      case tp: RefinedType => tp
+      case tp: AppliedType => tp
+      case tp: TypeParamRef => underlyingApplied(TypeComparer.bounds(tp).hi)
+      case tp: TypeProxy => underlyingApplied(tp.superType)
+      case _ => tp
+    }
+
+    // If the expected type is a selection of an extension method, deepen it
+    // to also propagate the argument type (which is the receiver we have
+    // typechecked already). This is needed for i8311.scala. Doing so
+    // for all expected types does not work since it would block the case
+    // where we have an argument that must be converted with another
+    // implicit conversion to the receiver type.
+    def sharpenedPt = pt match
+      case pt: SelectionProto
+      if pt.memberProto.revealIgnored.isExtensionApplyProto => pt.deepenProto
+      case _ => pt
+
+    def adaptNoArgs(wtp: Type): Tree = {
+      val ptNorm = underlyingApplied(pt)
+      def functionExpected = defn.isFunctionType(ptNorm)
+      def needsEta = pt.revealIgnored match
+        case _: SingletonType | _: FunOrPolyProto => false
+        case _ => true
+      var resMatch: Boolean = false
+      wtp match {
+        case wtp: ExprType =>
+          readaptSimplified(tree.withType(wtp.resultType))
+        case wtp: MethodType if wtp.isImplicitMethod &&
+          ({ resMatch = constrainResult(tree.symbol, wtp, sharpenedPt); resMatch } || !functionExpected) =>
+          if (resMatch || ctx.mode.is(Mode.ImplicitsEnabled))
+            adaptNoArgsImplicitMethod(wtp)
+          else
+            // Don't proceed with implicit search if result type cannot match - the search
+            // will likely be under-constrained, which means that an unbounded number of alternatives
+            // is tried. See strawman-contrib MapDecoratorTest.scala for an example where this happens.
+            err.typeMismatch(tree, pt)
+        case wtp: MethodType if needsEta =>
+          val funExpected = functionExpected
+          val arity =
+            if funExpected then
+              if !isFullyDefined(pt, ForceDegree.none) && isFullyDefined(wtp, ForceDegree.none) then
+                // if method type is fully defined, but expected type is not,
+                // prioritize method parameter types as parameter types of the eta-expanded closure
+                0
+              else defn.functionArity(ptNorm)
+            else
+              val nparams = wtp.paramInfos.length
+              if nparams > 0 || pt.eq(AnyFunctionProto) then nparams
+              else -1 // no eta expansion in this case
+          adaptNoArgsUnappliedMethod(wtp, funExpected, arity)
+        case _ =>
+          adaptNoArgsOther(wtp, functionExpected)
+      }
+    }
+
+    /** Adapt an expression of constant type to a different constant type `tpe`. */
+    def adaptConstant(tree: Tree, tpe: ConstantType): Tree = {
+      def lit = Literal(tpe.value).withSpan(tree.span)
+      tree match {
+        case Literal(c) => lit
+        case tree @ Block(stats, expr) => tpd.cpy.Block(tree)(stats, adaptConstant(expr, tpe))
+        case tree =>
+          if (isIdempotentExpr(tree)) lit // See discussion in phase Literalize why we demand isIdempotentExpr
+          else Block(tree :: Nil, lit)
+      }
+    }
+
+    def toSAM(tree: Tree): Tree = tree match {
+      case tree: Block => tpd.cpy.Block(tree)(tree.stats, toSAM(tree.expr))
+      case tree: Closure => cpy.Closure(tree)(tpt = TypeTree(pt)).withType(pt)
+    }
+
+    def adaptToSubType(wtp: Type): Tree =
+      // try converting a constant to the target type
+      ConstFold(tree).tpe.widenTermRefExpr.normalized match
+        case ConstantType(x) =>
+          val converted = x.convertTo(pt)
+          if converted != null && (converted ne x) then
+            val cls = pt.classSymbol
+            if x.tag == IntTag && cls == defn.FloatClass && x.intValue.toFloat.toInt != x.intValue
+              || x.tag == LongTag && cls == defn.FloatClass  && x.longValue.toFloat.toLong != x.longValue
+              || x.tag == LongTag && cls == defn.DoubleClass && x.longValue.toDouble.toLong != x.longValue
+            then
+              report.warning(LossyWideningConstantConversion(x.tpe, pt), tree.srcPos)
+            return adaptConstant(tree, ConstantType(converted))
+        case _ =>
+
+      val captured = captureWildcards(wtp)
+      if (captured `ne` wtp)
+        return readapt(tree.cast(captured))
+
+      // drop type if prototype is Unit
+      if (pt isRef defn.UnitClass) {
+        // local adaptation makes sure every adapted tree conforms to its pt
+        // so will take the code path that decides on inlining
+        val tree1 = adapt(tree, WildcardType, locked)
+        checkStatementPurity(tree1)(tree, ctx.owner)
+        return tpd.Block(tree1 :: Nil, Literal(Constant(())))
+      }
+
+      // convert function literal to SAM closure
+      tree match {
+        case closure(Nil, id @ Ident(nme.ANON_FUN), _)
+        if defn.isFunctionType(wtp) && !defn.isFunctionType(pt) =>
+          pt match {
+            case SAMType(sam)
+            if wtp <:< sam.toFunctionType(isJava = pt.classSymbol.is(JavaDefined)) =>
+              // was ... && isFullyDefined(pt, ForceDegree.flipBottom)
+              // but this prevents case blocks from implementing polymorphic partial functions,
+              // since we do not know the result parameter a priori. Have to wait until the
+              // body is typechecked.
+              return toSAM(tree)
+            case _ =>
+          }
+        case _ =>
+      }
+
+      // try an Any -> Matchable conversion
+      if pt.isMatchableBound && !wtp.derivesFrom(defn.MatchableClass) then
+        checkMatchable(wtp, tree.srcPos, pattern = false)
+        val target = AndType(tree.tpe.widenExpr, defn.MatchableType)
+        if target <:< pt then
+          return readapt(tree.cast(target))
+
+      // if unsafeNulls is enabled, try to strip nulls from Java function calls
+      if Nullables.unsafeNullsEnabled then
+        tree match
+          case _: Apply | _: Select if tree.symbol.is(JavaDefined) =>
+            wtp match
+              case OrNull(wtp1) => return readapt(tree.cast(wtp1))
+              case _ =>
+          case _ =>
+
+      def recover(failure: SearchFailureType) =
+        if canDefineFurther(wtp) || canDefineFurther(pt) then readapt(tree)
+        else err.typeMismatch(tree, pt, failure)
+
+      pt match
+        case pt: SelectionProto =>
+          if ctx.gadt.isNarrowing then
+            // try GADT approximation if we're trying to select a member
+            // Member lookup cannot take GADTs into account b/c of cache, so we
+            // approximate types based on GADT constraints instead. For an example,
+            // see MemberHealing in gadt-approximation-interaction.scala.
+            gadts.println(i"Trying to heal member selection by GADT-approximating $wtp")
+            val gadtApprox = Inferencing.approximateGADT(wtp)
+            gadts.println(i"GADT-approximated $wtp ~~ $gadtApprox")
+            if pt.isMatchedBy(gadtApprox) then
+              gadts.println(i"Member selection healed by GADT approximation")
+              tree.cast(gadtApprox)
+            else tree
+          else if tree.tpe.derivesFrom(defn.PairClass) && !defn.isTupleNType(tree.tpe.widenDealias) then
+            // If this is a generic tuple we need to cast it to make the TupleN/ members accessible.
+            // This works only for generic tuples of known size up to 22.
+            defn.tupleTypes(tree.tpe.widenTermRefExpr) match
+              case Some(elems) if elems.length <= Definitions.MaxTupleArity =>
+                tree.cast(defn.tupleType(elems))
+              case _ => tree
+          else tree // other adaptations for selections are handled in typedSelect
+        case _ if ctx.mode.is(Mode.ImplicitsEnabled) && tree.tpe.isValueType =>
+          if pt.isRef(defn.AnyValClass, skipRefined = false)
+              || pt.isRef(defn.ObjectClass, skipRefined = false)
+          then
+            recover(TooUnspecific(pt))
+          else inferView(tree, pt) match
+            case SearchSuccess(found, _, _, isExtension) =>
+              if isExtension then found
+              else
+                checkImplicitConversionUseOK(found)
+                withoutMode(Mode.ImplicitsEnabled)(readapt(found))
+            case failure: SearchFailure =>
+              if (pt.isInstanceOf[ProtoType] && !failure.isAmbiguous) then
+                // don't report the failure but return the tree unchanged. This
+                // will cause a failure at the next level out, which usually gives
+                // a better error message. To compensate, store the encountered failure
+                // as an attachment, so that it can be reported later as an addendum.
+                rememberSearchFailure(tree, failure)
+                tree
+              else recover(failure.reason)
+        case _ =>
+          recover(NoMatchingImplicits)
+    end adaptToSubType
+
+    def adaptType(tp: Type): Tree = {
+      val tree1 =
+        if ((pt eq AnyTypeConstructorProto) || tp.typeParamSymbols.isEmpty) tree
+        else {
+          val tp1 =
+            if (ctx.isJava)
+              // Cook raw type
+              AppliedType(tree.tpe, tp.typeParams.map(Function.const(TypeBounds.empty)))
+            else
+              // Eta-expand higher-kinded type
+              tree.tpe.EtaExpand(tp.typeParamSymbols)
+          tree.withType(tp1)
+        }
+      if (ctx.mode.is(Mode.Pattern) || ctx.mode.is(Mode.QuotedPattern) || tree1.tpe <:< pt) tree1
+      else err.typeMismatch(tree1, pt)
+    }
+
+    /** If tree has an error type but no errors are reported yet, issue
+     *  the error message stored in the type.
+     *  One way this can happen is if implicit search causes symbols and types
+     *  to be completed. The types are stored by `typedAhead` so that they can be
+     *  retrieved later and thus avoid duplication of typechecking work.
+     *  But if the implicit search causing the `typedAhead` fails locally but
+     *  another alternative succeeds we can be left with an ErrorType in the
+     *  tree that went unreported. A scenario where this happens is i1802.scala.
+     */
+    def ensureReported(tp: Type) = tp match {
+      case err: ErrorType if !ctx.reporter.errorsReported => report.error(err.msg, tree.srcPos)
+      case _ =>
+    }
+
+    /** Convert constructor proxy reference to a new expression */
+    def newExpr =
+      val qual = qualifier(tree)
+      val tpt = qual match
+        case Ident(name) =>
+          cpy.Ident(qual)(name.toTypeName)
+        case Select(pre, name) =>
+          cpy.Select(qual)(pre, name.toTypeName)
+        case qual: This if qual.symbol.is(ModuleClass) =>
+          cpy.Ident(qual)(qual.symbol.name.sourceModuleName.toTypeName)
+        case _ =>
+          errorTree(tree, em"cannot convert from $tree to an instance creation expression")
+      val tycon = tree.tpe.widen.finalResultType.underlyingClassRef(refinementOK = false)
+      typed(
+        untpd.Select(
+          untpd.New(untpd.TypedSplice(tpt.withType(tycon))),
+          nme.CONSTRUCTOR),
+        pt)
+        .showing(i"convert creator $tree -> $result", typr)
+
+    def isApplyProxy(tree: Tree) = tree match
+      case Select(_, nme.apply) => tree.symbol.isAllOf(ApplyProxyFlags)
+      case _ => false
+
+    tree match {
+      case _: MemberDef | _: PackageDef | _: Import | _: WithoutTypeOrPos[?] | _: Closure => tree
+      case _ => tree.tpe.widen match {
+        case tp: FlexType =>
+          ensureReported(tp)
+          tree
+        case ref: TermRef =>
+          pt match {
+            case pt: FunProto
+            if needsTupledDual(ref, pt) && Feature.autoTuplingEnabled =>
+              adapt(tree, pt.tupledDual, locked)
+            case _ =>
+              adaptOverloaded(ref)
+          }
+        case poly: PolyType if !(ctx.mode is Mode.Type) =>
+          if isApplyProxy(tree) then newExpr
+          else if pt.isInstanceOf[PolyProto] then tree
+          else
+            var typeArgs = tree match
+              case Select(qual, nme.CONSTRUCTOR) => qual.tpe.widenDealias.argTypesLo.map(TypeTree(_))
+              case _ => Nil
+            if typeArgs.isEmpty then typeArgs = constrained(poly, tree)._2
+            convertNewGenericArray(readapt(tree.appliedToTypeTrees(typeArgs)))
+        case wtp =>
+          val isStructuralCall = wtp.isValueType && isStructuralTermSelectOrApply(tree)
+          if (isStructuralCall)
+            readaptSimplified(handleStructural(tree))
+          else pt match {
+            case pt: FunProto =>
+              if isApplyProxy(tree) then newExpr
+              else adaptToArgs(wtp, pt)
+            case pt: PolyProto if !wtp.isImplicitMethod =>
+              tryInsertApplyOrImplicit(tree, pt, locked)(tree) // error will be reported in typedTypeApply
+            case _ =>
+              if (ctx.mode is Mode.Type) adaptType(tree.tpe)
+              else adaptNoArgs(wtp)
+          }
+      }
+    }
+  }
+
+  /** True if this inline typer has already issued errors */
+  def hasInliningErrors(using Context): Boolean = false
+
+  /** Does the "contextuality" of the method type `methType` match the one of the prototype `pt`?
+   *  This is the case if
+   *   - both are contextual, or
+   *   - neither is contextual, or
+   *   - the prototype is contextual and the method type is implicit.
+   *  The last rule is there for a transition period; it allows to mix `with` applications
+   *  with old-style context functions.
+   *  Overridden in `ReTyper`, where all applications are treated the same
+   */
+  protected def matchingApply(methType: MethodOrPoly, pt: FunProto)(using Context): Boolean =
+    val isUsingApply = pt.applyKind == ApplyKind.Using
+    methType.isContextualMethod == isUsingApply
+    || methType.isImplicitMethod && isUsingApply // for a transition allow `with` arguments for regular implicit parameters
+
+  /** Check that `tree == x: pt` is typeable. Used when checking a pattern
+   *  against a selector of type `pt`. This implementation accounts for
+   *  user-defined definitions of `==`.
+   *
+   *  Overwritten to no-op in ReTyper.
+   */
+  protected def checkEqualityEvidence(tree: tpd.Tree, pt: Type)(using Context) : Unit =
+    tree match
+      case _: RefTree | _: Literal
+      if !isVarPattern(tree) && !(pt <:< tree.tpe) =>
+        withMode(Mode.GadtConstraintInference) {
+          TypeComparer.constrainPatternType(tree.tpe, pt)
+        }
+
+        // approximate type params with bounds
+        def approx = new ApproximatingTypeMap {
+          var alreadyExpanding: List[TypeRef] = Nil
+          def apply(tp: Type) = tp.dealias match
+            case tp: TypeRef if !tp.symbol.isClass =>
+              if alreadyExpanding contains tp then tp else
+                val saved = alreadyExpanding
+                alreadyExpanding ::= tp
+                val res = expandBounds(tp.info.bounds)
+                alreadyExpanding = saved
+                res
+            case _ =>
+              mapOver(tp)
+        }
+
+        // Is it certain that a value of `tree.tpe` is never a subtype of `pt`?
+        // It is true if either
+        // - the class of `tree.tpe` and class of `pt` cannot have common subclass, or
+        // - `tree` is an object or enum value, which cannot possibly be a subtype of `pt`
+        val isDefiniteNotSubtype = {
+          val clsA = tree.tpe.widenDealias.classSymbol
+          val clsB = pt.dealias.classSymbol
+          clsA.exists && clsB.exists
+            && clsA != defn.NullClass
+            && (!clsA.isNumericValueClass && !clsB.isNumericValueClass) // approximation for numeric conversion and boxing
+            && !clsA.asClass.mayHaveCommonChild(clsB.asClass)
+          || tree.symbol.isOneOf(Module | Enum)
+             && !(tree.tpe frozen_<:< pt) // fast track
+             && !(tree.tpe frozen_<:< approx(pt))
+        }
+
+        if isDefiniteNotSubtype then
+          // We could check whether `equals` is overridden.
+          // Reasons for not doing so:
+          // - it complicates the protocol
+          // - such code patterns usually implies hidden errors in the code
+          // - it's safe/sound to reject the code
+          report.error(TypeMismatch(tree.tpe, pt, Some(tree), "\npattern type is incompatible with expected type"), tree.srcPos)
+        else
+          val cmp =
+            untpd.Apply(
+              untpd.Select(untpd.TypedSplice(tree), nme.EQ),
+              untpd.TypedSplice(dummyTreeOfType(pt)))
+          typedExpr(cmp, defn.BooleanType)
+      case _ =>
+
+  private def checkStatementPurity(tree: tpd.Tree)(original: untpd.Tree, exprOwner: Symbol)(using Context): Unit =
+    if !tree.tpe.isErroneous
+      && !ctx.isAfterTyper
+      && !tree.isInstanceOf[Inlined]
+      && isPureExpr(tree)
+      && !isSelfOrSuperConstrCall(tree)
+    then tree match
+      case closureDef(meth)
+      if meth.span == meth.rhs.span.toSynthetic && !untpd.isFunction(original) =>
+        // It's a synthesized lambda, for instance via an eta expansion: report a hard error
+        // There are two tests for synthetic lambdas which both have to be true.
+        // The first test compares spans of closure definition with the closure's right hand
+        // side. This is usually accurate but can fail for compiler-generated test code.
+        // See repl.DocTests for two failing tests. The second tests rules out closures
+        // if the original tree was a lambda. This does not work always either since
+        // sometimes we do not have the original anymore and use the transformed tree instead.
+        // But taken together, the two criteria are quite accurate.
+        missingArgs(tree, tree.tpe.widen)
+      case _ =>
+        report.warning(PureExpressionInStatementPosition(original, exprOwner), original.srcPos)
+
+  /** Types the body Scala 2 macro declaration `def f = macro <body>` */
+  protected def typedScala2MacroBody(call: untpd.Tree)(using Context): Tree =
+    // TODO check that call is to a method with valid signature
+    def typedPrefix(tree: untpd.RefTree)(splice: Context ?-> Tree -> Tree)(using Context): Tree = {
+      tryAlternatively {
+        splice(typedExpr(tree, defn.AnyType))
+      } {
+        // Try to type as a macro bundle
+        val ref = tree match
+          case Ident(name) => untpd.Ident(name.toTypeName).withSpan(tree.span)
+          case Select(qual, name) => untpd.Select(qual, name.toTypeName).withSpan(tree.span)
+        val bundle = untpd.Apply(untpd.Select(untpd.New(ref), nme.CONSTRUCTOR), untpd.Literal(Constant(null))).withSpan(call.span)
+        val bundle1 = typedExpr(bundle, defn.AnyType)
+        val bundleVal = SyntheticValDef(NameKinds.UniqueName.fresh(nme.bundle), bundle1).withSpan(call.span)
+        tpd.Block(List(bundleVal), splice(tpd.ref(bundleVal.symbol))).withSpan(call.span)
+      }
+    }
+    if ctx.phase.isTyper then
+      call match
+        case untpd.Ident(nme.???) => // Instinsic macros ignored
+        case _ =>
+          if !config.Feature.scala2ExperimentalMacroEnabled then
+            report.error(
+              """Scala 2 macro definition needs to be enabled
+                |by making the implicit value scala.language.experimental.macros visible.
+                |This can be achieved by adding the import clause 'import scala.language.experimental.macros'
+                |or by setting the compiler option -language:experimental.macros.
+              """.stripMargin, call.srcPos)
+      call match
+        case call: untpd.Ident =>
+          typedIdent(call, defn.AnyType)
+        case untpd.Select(qual: untpd.RefTree, name) =>
+          typedPrefix(qual) { qual =>
+            val call2 = untpd.Select(untpd.TypedSplice(qual), name).withSpan(call.span)
+            typedSelect(call2, defn.AnyType)
+          }
+        case untpd.TypeApply(untpd.Select(qual: untpd.RefTree, name), targs) =>
+          typedPrefix(qual) { qual =>
+            val call2 = untpd.TypeApply(untpd.Select(untpd.TypedSplice(qual), name), targs).withSpan(call.span)
+            typedTypeApply(call2, defn.AnyType)
+          }
+        case _ =>
+          report.error("Invalid Scala 2 macro " + call.show, call.srcPos)
+          EmptyTree
+    else typedExpr(call, defn.AnyType)
+
+  /** Insert GADT cast to target type `pt` on the `tree`
+    *   so that -Ycheck in later phases succeeds.
+    *  The check "safeToInstantiate" in `maximizeType` works to prevent unsound GADT casts.
+    */
+  private def insertGadtCast(tree: Tree, wtp: Type, pt: Type)(using Context): Tree =
+    val target =
+      if tree.tpe.isSingleton then
+        // In the target type, when the singleton type is intersected, we also intersect
+        //   the GADT-approximated type of the singleton to avoid the loss of
+        //   information. See #15646.
+        val gadtApprox = Inferencing.approximateGADT(wtp)
+        gadts.println(i"gadt approx $wtp ~~~ $gadtApprox")
+        val conj =
+          TypeComparer.testSubType(gadtApprox, pt) match {
+            case CompareResult.OK =>
+              // GADT approximation of the tree type is a subtype of expected type under empty GADT
+              //   constraints, so it is enough to only have the GADT approximation.
+              AndType(tree.tpe, gadtApprox)
+            case _ =>
+              // In other cases, we intersect both the approximated type and the expected type.
+              AndType(AndType(tree.tpe, gadtApprox), pt)
+          }
+        if tree.tpe.isStable && !conj.isStable then
+          // this is needed for -Ycheck. Without the annotation Ycheck will
+          // skolemize the result type which will lead to different types before
+          // and after checking. See i11955.scala.
+          AnnotatedType(conj, Annotation(defn.UncheckedStableAnnot))
+        else conj
+      else pt
+    gadts.println(i"insert GADT cast from $tree to $target")
+    tree.cast(target)
+  end insertGadtCast
+}
diff --git a/tests/pos-with-compiler-cc/dotc/typer/TyperPhase.scala b/tests/pos-with-compiler-cc/dotc/typer/TyperPhase.scala
new file mode 100644
index 000000000000..60f0c043b435
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/typer/TyperPhase.scala
@@ -0,0 +1,108 @@
+package dotty.tools
+package dotc
+package typer
+
+import core._
+import Phases._
+import Contexts._
+import Symbols._
+import ImportInfo.withRootImports
+import parsing.{Parser => ParserPhase}
+import config.Printers.typr
+import inlines.PrepareInlineable
+import util.Stats._
+
+/**
+ *
+ * @param addRootImports Set to false in the REPL. Calling [[ImportInfo.withRootImports]] on the [[Context]]
+ *                       for each [[CompilationUnit]] causes dotty.tools.repl.ScriptedTests to fail.
+ */
+class TyperPhase(addRootImports: Boolean = true) extends Phase {
+
+  override def phaseName: String = TyperPhase.name
+
+  override def description: String = TyperPhase.description
+
+  override def isTyper: Boolean = true
+
+
+  override def allowsImplicitSearch: Boolean = true
+
+  // Run regardless of parsing errors
+  override def isRunnable(implicit ctx: Context): Boolean = true
+
+  def enterSyms(using Context): Unit = monitor("indexing") {
+    val unit = ctx.compilationUnit
+    ctx.typer.index(unit.untpdTree)
+    typr.println("entered: " + unit.source)
+  }
+
+  def typeCheck(using Context): Unit = monitor("typechecking") {
+    val unit = ctx.compilationUnit
+    try
+      if !unit.suspended then
+        unit.tpdTree = ctx.typer.typedExpr(unit.untpdTree)
+        typr.println("typed: " + unit.source)
+        record("retained untyped trees", unit.untpdTree.treeSize)
+        record("retained typed trees after typer", unit.tpdTree.treeSize)
+        ctx.run.nn.suppressions.reportSuspendedMessages(unit.source)
+    catch
+      case ex: CompilationUnit.SuspendException =>
+      case ex: Throwable =>
+        println(s"$ex while typechecking $unit")
+        throw ex
+  }
+
+  def javaCheck(using Context): Unit = monitor("checking java") {
+    val unit = ctx.compilationUnit
+    if unit.isJava then
+      JavaChecks.check(unit.tpdTree)
+  }
+
+  protected def discardAfterTyper(unit: CompilationUnit)(using Context): Boolean =
+    unit.isJava || unit.suspended
+
+  override def runOn(units: List[CompilationUnit])(using Context): List[CompilationUnit] =
+    val unitContexts =
+      for unit <- units yield
+        val newCtx0 = ctx.fresh.setPhase(this.start).setCompilationUnit(unit)
+        val newCtx = PrepareInlineable.initContext(newCtx0)
+        report.inform(s"typing ${unit.source}")
+        if (addRootImports)
+          newCtx.withRootImports
+        else
+          newCtx
+
+    unitContexts.foreach(enterSyms(using _))
+
+    ctx.base.parserPhase match {
+      case p: ParserPhase =>
+        if p.firstXmlPos.exists && !defn.ScalaXmlPackageClass.exists then
+          report.error(
+            """To support XML literals, your project must depend on scala-xml.
+              |See https://github.com/scala/scala-xml for more information.""".stripMargin,
+            p.firstXmlPos)
+      case _ =>
+    }
+
+    unitContexts.foreach(typeCheck(using _))
+    record("total trees after typer", ast.Trees.ntrees)
+    unitContexts.foreach(javaCheck(using _)) // after typechecking to avoid cycles
+
+    val newUnits = unitContexts.map(_.compilationUnit).filterNot(discardAfterTyper)
+    ctx.run.nn.checkSuspendedUnits(newUnits)
+    newUnits
+
+  def run(using Context): Unit = unsupported("run")
+}
+
+object TyperPhase {
+  val name: String = "typer"
+  val description: String = "type the trees"
+}
+
+@deprecated(message = "FrontEnd has been split into TyperPhase and Parser. Refer to one or the other.")
+object FrontEnd {
+  // For backwards compatibility: some plugins refer to FrontEnd so that they can schedule themselves after it.
+  val name: String = TyperPhase.name
+}
diff --git a/tests/pos-with-compiler-cc/dotc/typer/VarianceChecker.scala b/tests/pos-with-compiler-cc/dotc/typer/VarianceChecker.scala
new file mode 100644
index 000000000000..53646558cf5c
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/typer/VarianceChecker.scala
@@ -0,0 +1,209 @@
+package dotty.tools.dotc
+package typer
+
+import dotty.tools.dotc.ast.{ Trees, tpd }
+import core._
+import Types._, Contexts._, Flags._, Symbols._, Trees._
+import Decorators._
+import Variances._
+import NameKinds._
+import util.SrcPos
+import config.Printers.variances
+import config.Feature.migrateTo3
+import reporting.trace
+import printing.Formatting.hl
+
+/** Provides `check` method to check that all top-level definitions
+ *  in tree are variance correct. Does not recurse inside methods.
+ *  The method should be invoked once for each Template.
+ */
+object VarianceChecker {
+  case class VarianceError(tvar: Symbol, required: Variance)
+  def check(tree: tpd.Tree)(using Context): Unit =
+    VarianceChecker().Traverser.traverse(tree)
+
+  /** Check that variances of type lambda correspond to their occurrences in its body.
+   *  Note: this is achieved by a mechanism separate from checking class type parameters.
+   *  Question: Can the two mechanisms be combined in one?
+   */
+  def checkLambda(tree: tpd.LambdaTypeTree, bounds: TypeBounds)(using Context): Unit =
+    def checkType(tpe: Type): Unit = tpe match
+      case tl: HKTypeLambda if tl.isDeclaredVarianceLambda =>
+        val checkOK = new TypeAccumulator[Boolean] {
+          def paramVarianceSign(tref: TypeParamRef) =
+            tl.typeParams(tref.paramNum).paramVarianceSign
+          def error(tref: TypeParamRef) = {
+            val paramName = tl.paramNames(tref.paramNum).toTermName
+            val v = paramVarianceSign(tref)
+            val pos = tree.tparams
+              .find(_.name.toTermName == paramName)
+              .map(_.srcPos)
+              .getOrElse(tree.srcPos)
+            report.error(em"${varianceLabel(v)} type parameter $paramName occurs in ${varianceLabel(variance)} position in ${tl.resType}", pos)
+          }
+          def apply(x: Boolean, t: Type) = x && {
+            t match {
+              case tref: TypeParamRef if tref.binder `eq` tl =>
+                varianceConforms(variance, paramVarianceSign(tref))
+                || { error(tref); false }
+              case AnnotatedType(_, annot) if annot.symbol == defn.UncheckedVarianceAnnot =>
+                x
+              case _ =>
+                foldOver(x, t)
+            }
+          }
+        }
+        checkOK(true, tl.resType)
+      case _ =>
+    end checkType
+
+    checkType(bounds.lo)
+    checkType(bounds.hi)
+  end checkLambda
+}
+
+class VarianceChecker(using Context) {
+  import VarianceChecker._
+  import tpd._
+
+  private object Validator extends TypeAccumulator[Option[VarianceError]] {
+    private var base: Symbol = _
+
+    /** The variance of a symbol occurrence of `tvar` seen at the level of the definition of `base`.
+     *  The search proceeds from `base` to the owner of `tvar`.
+     *  Initially the state is covariant, but it might change along the search.
+     */
+    def relativeVariance(tvar: Symbol, base: Symbol, v: Variance = Covariant): Variance = /*trace(i"relative variance of $tvar wrt $base, so far: $v")*/
+      if base == tvar.owner then
+        v
+      else if base.is(Param) && base.owner.isTerm && !base.owner.isAllOf(PrivateLocal) then
+        relativeVariance(tvar, paramOuter(base.owner), flip(v))
+      else if base.owner.isTerm || base.owner.is(Package) || base.isAllOf(PrivateLocal) then
+        Bivariant
+      else if base.isAliasType then
+        relativeVariance(tvar, base.owner, Invariant)
+      else
+        relativeVariance(tvar, base.owner, v)
+
+    /** The next level to take into account when determining the
+     *  relative variance with a method parameter as base. The method
+     *  is always skipped. If the method is a constructor, we also skip
+     *  its class owner, because constructors are not checked for variance
+     *  relative to the type parameters of their own class. On the other
+     *  hand constructors do count for checking the variance of type parameters
+     *  of enclosing classes. I believe the Scala 2 rules are too lenient in
+     *  that respect.
+     */
+    private def paramOuter(meth: Symbol) =
+      if (meth.isConstructor) meth.owner.owner else meth.owner
+
+    /** Check variance of abstract type `tvar` when referred from `base`. */
+    private def checkVarianceOfSymbol(tvar: Symbol): Option[VarianceError] = {
+      val relative = relativeVariance(tvar, base)
+      if (relative == Bivariant) None
+      else {
+        val required = if variance == 1 then relative else if variance == -1 then flip(relative) else Invariant
+        def tvar_s = s"$tvar (${varianceLabel(tvar.flags)} ${tvar.showLocated})"
+        def base_s = s"$base in ${base.owner}" + (if (base.owner.isClass) "" else " in " + base.owner.enclosingClass)
+        report.log(s"verifying $tvar_s is ${varianceLabel(required)} at $base_s")
+        report.log(s"relative variance: ${varianceLabel(relative)}")
+        report.log(s"current variance: ${this.variance}")
+        report.log(s"owner chain: ${base.ownersIterator.toList}")
+        if (tvar.isOneOf(required)) None
+        else Some(VarianceError(tvar, required))
+      }
+    }
+
+    /** For PolyTypes, type parameters are skipped because they are defined
+     *  explicitly (their TypeDefs will be passed here.) For MethodTypes, the
+     *  same is true of the parameters (ValDefs).
+     */
+    def apply(status: Option[VarianceError], tp: Type): Option[VarianceError] = trace(s"variance checking $tp of $base at $variance", variances) {
+      try
+        if (status.isDefined) status
+        else tp match {
+          case tp: TypeRef =>
+            val sym = tp.symbol
+            if (sym.isOneOf(VarianceFlags) && base.isContainedIn(sym.owner)) checkVarianceOfSymbol(sym)
+            else sym.info match {
+              case MatchAlias(_) => foldOver(status, tp)
+              case TypeAlias(alias) => this(status, alias)
+              case _ => foldOver(status, tp)
+            }
+          case tp: MethodOrPoly =>
+            this(status, tp.resultType) // params will be checked in their TypeDef or ValDef nodes.
+          case AnnotatedType(_, annot) if annot.symbol == defn.UncheckedVarianceAnnot =>
+            status
+          case tp: ClassInfo =>
+            foldOver(status, tp.parents)
+          case _ =>
+            foldOver(status, tp)
+        }
+      catch {
+        case ex: Throwable => handleRecursive("variance check of", tp.show, ex)
+      }
+    }
+
+    def validateDefinition(base: Symbol): Option[VarianceError] = {
+      val saved = this.base
+      this.base = base
+      try apply(None, base.info)
+      finally this.base = saved
+    }
+  }
+
+  private object Traverser extends TreeTraverser {
+    def checkVariance(sym: Symbol, pos: SrcPos) = Validator.validateDefinition(sym) match {
+      case Some(VarianceError(tvar, required)) =>
+        def msg =
+          val enumAddendum =
+            val towner = tvar.owner
+            if towner.isAllOf(EnumCase) && towner.isClass && tvar.is(Synthetic) then
+              val example =
+                "See an example at https://docs.scala-lang.org/scala3/reference/enums/adts.html#parameter-variance-of-enums"
+              i"\n${hl("enum case")} ${towner.name} requires explicit declaration of $tvar to resolve this issue.\n$example"
+            else
+              ""
+          i"${varianceLabel(tvar.flags)} $tvar occurs in ${varianceLabel(required)} position in type ${sym.info} of $sym$enumAddendum"
+        if (migrateTo3 &&
+            (sym.owner.isConstructor || sym.ownersIterator.exists(_.isAllOf(ProtectedLocal))))
+          report.migrationWarning(
+            s"According to new variance rules, this is no longer accepted; need to annotate with @uncheckedVariance:\n$msg",
+            pos)
+            // patch(Span(pos.end), " @scala.annotation.unchecked.uncheckedVariance")
+            // Patch is disabled until two TODOs are solved:
+            // TODO use an import or shorten if possible
+            // TODO need to use a `:' if annotation is on term
+        else report.error(msg, pos)
+      case None =>
+    }
+
+    override def traverse(tree: Tree)(using Context) = {
+      def sym = tree.symbol
+      // No variance check for private/protected[this] methods/values.
+      def skip = !sym.exists
+        || sym.name.is(InlineAccessorName) // TODO: should we exclude all synthetic members?
+        || sym.isAllOf(LocalParamAccessor) // local class parameters are construction only
+        || sym.is(TypeParam) && sym.owner.isClass // already taken care of in primary constructor of class
+      try tree match {
+        case defn: MemberDef if skip =>
+          report.debuglog(s"Skipping variance check of ${sym.showDcl}")
+        case tree: TypeDef =>
+          checkVariance(sym, tree.srcPos)
+          tree.rhs match {
+            case rhs: Template => traverseChildren(rhs)
+            case _ =>
+          }
+        case tree: ValDef =>
+          checkVariance(sym, tree.srcPos)
+        case DefDef(_, paramss, _, _) =>
+          checkVariance(sym, tree.srcPos)
+          paramss.foreach(_.foreach(traverse))
+        case _ =>
+      }
+      catch {
+        case ex: TypeError => report.error(ex, tree.srcPos.focus)
+      }
+    }
+  }
+}
diff --git a/tests/pos-with-compiler-cc/dotc/util/Attachment.scala b/tests/pos-with-compiler-cc/dotc/util/Attachment.scala
new file mode 100644
index 000000000000..d545c3631f20
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/util/Attachment.scala
@@ -0,0 +1,128 @@
+package dotty.tools.dotc
+package util
+
+import core.Contexts.Context
+
+/** A class inheriting from Attachment.Container supports
+ *  adding, removing and lookup of attachments. Attachments are typed key/value pairs.
+ *
+ *  Attachments whose key is an instance of `StickyKey` will be kept when the attachments
+ *  are copied using `withAttachmentsFrom`.
+ */
+object Attachment {
+  import Property.{Key, StickyKey}
+
+  /** An implementation trait for attachments.
+   *  Clients should inherit from Container instead.
+   */
+  trait LinkSource {
+    private[Attachment] var next: Link[?] | Null
+
+    /** Optionally get attachment corresponding to `key` */
+    final def getAttachment[V](key: Key[V]): Option[V] = {
+      val nx = next
+      if (nx == null) None
+      else if (nx.key eq key) Some(nx.value.asInstanceOf[V])
+      else nx.getAttachment[V](key)
+    }
+
+    /** Does an attachment corresponding to `key` exist? */
+    final def hasAttachment[V](key: Key[V]): Boolean = {
+      val nx = next
+      if (nx == null) false
+      else if (nx.key eq key) true
+      else nx.hasAttachment[V](key)
+    }
+
+    /** The attachment corresponding to `key`.
+     *  @throws NoSuchElementException  if no attachment with key exists
+     */
+    final def attachment[V](key: Key[V]): V = {
+      val nx = next
+      if (nx == null) throw new NoSuchElementException
+      else if (nx.key eq key) nx.value.asInstanceOf[V]
+      else nx.attachment(key)
+    }
+
+    /** The attachment corresponding to `key`, or `default`
+     *  if no attachment with `key` exists.
+     */
+    final def attachmentOrElse[V](key: Key[V], default: V): V = {
+      val nx = next
+      if (nx == null) default
+      else if (nx.key eq key) nx.value.asInstanceOf[V]
+      else nx.attachmentOrElse(key, default)
+    }
+
+    /** Add attachment with given `key` and `value`.
+     *  @return  Optionally, the old attachment with given `key` if one existed before.
+     *  The new attachment is added at the position of the old one, or at the end
+     *  if no attachment with same `key` existed.
+     */
+    final def putAttachment[V](key: Key[V], value: V): Option[V] = {
+      val nx = next
+      if (nx == null) {
+        next = new Link(key, value, null)
+        None
+      }
+      else if (nx.key eq key) {
+        next = new Link(key, value, nx.next)
+        Some(nx.value.asInstanceOf[V])
+      }
+      else nx.putAttachment(key, value)
+    }
+
+    /** Remove attachment with given `key`, if it exists.
+     *  @return  Optionally, the removed attachment with given `key` if one existed before.
+     */
+    final def removeAttachment[V](key: Key[V]): Option[V] = {
+      val nx = next
+      if (nx == null)
+        None
+      else if (nx.key eq key) {
+        next = nx.next
+        Some(nx.value.asInstanceOf[V])
+      }
+      else nx.removeAttachment(key)
+    }
+
+    /** The list of all keys and values attached to this container. */
+    final def allAttachments: List[(Key[?], Any)] = {
+      val nx = next
+      if (nx == null) Nil else (nx.key, nx.value) :: nx.allAttachments
+    }
+  }
+
+  /** A private, concrete implementation class linking attachments.
+   */
+  private[Attachment] class Link[+V](val key: Key[V], val value: V, var next: Link[?] | Null)
+      extends LinkSource
+
+  /** A trait for objects that can contain attachments */
+  trait Container extends LinkSource {
+    private[Attachment] var next: Link[?] | Null = null
+
+    /** Copy the sticky attachments from `container` to this container. */
+    final def withAttachmentsFrom(container: Container): this.type = {
+      var current: Link[?] | Null = container.next
+      while (current != null) {
+        if (current.key.isInstanceOf[StickyKey[?]]) putAttachment(current.key, current.value)
+        current = current.next
+      }
+      this
+    }
+
+    def withAttachment[V](key: Key[V], value: V): this.type = {
+      putAttachment(key, value)
+      this
+    }
+
+    final def pushAttachment[V](key: Key[V], value: V)(using ctx: Context): Unit = {
+      assert(!hasAttachment(key) || ctx.base.errorsToBeReported, s"duplicate attachment for key $key")
+      next = new Link(key, value, next)
+    }
+
+    final def removeAllAttachments(): Unit =
+      next = null
+  }
+}
diff --git a/tests/pos-with-compiler-cc/dotc/util/CharBuffer.scala b/tests/pos-with-compiler-cc/dotc/util/CharBuffer.scala
new file mode 100644
index 000000000000..ad51702ca7f1
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/util/CharBuffer.scala
@@ -0,0 +1,28 @@
+package dotty.tools
+package dotc
+package util
+
+/** A character buffer that exposes the internal array for reading.
+ *  That way we can avoid copying when converting to names.
+ */
+class CharBuffer(initialSize: Int = 1024):
+  private var cs: Array[Char] = new Array[Char](initialSize)
+  private var len: Int = 0
+
+  def append(ch: Char): Unit =
+    if len == cs.length then
+      val cs1 = new Array[Char](len * 2)
+      Array.copy(cs, 0, cs1, 0, len)
+      cs = cs1
+    cs(len) = ch
+    len += 1
+
+  def chars = cs
+  def length = len
+  def isEmpty: Boolean = len == 0
+  def last: Char = cs(len - 1)
+  def clear(): Unit = len = 0
+
+  override def toString = String(cs, 0, len)
+
+
diff --git a/tests/pos-with-compiler-cc/dotc/util/Chars.scala b/tests/pos-with-compiler-cc/dotc/util/Chars.scala
new file mode 100644
index 000000000000..471b68d6247e
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/util/Chars.scala
@@ -0,0 +1,99 @@
+package dotty.tools.dotc.util
+
+import scala.annotation.switch
+import java.lang.{Character => JCharacter}
+import java.lang.Character.LETTER_NUMBER
+import java.lang.Character.LOWERCASE_LETTER
+import java.lang.Character.OTHER_LETTER
+import java.lang.Character.TITLECASE_LETTER
+import java.lang.Character.UPPERCASE_LETTER
+
+/** Contains constants and classifier methods for characters */
+object Chars {
+
+  inline val LF = '\u000A'
+  inline val FF = '\u000C'
+  inline val CR = '\u000D'
+  inline val SU = '\u001A'
+
+  /** Convert a character digit to an Int according to given base,
+    *  -1 if no success
+    */
+  def digit2int(ch: Char, base: Int): Int = {
+    val num = (
+      if (ch <= '9') ch - '0'
+      else if ('a' <= ch && ch <= 'z') ch - 'a' + 10
+      else if ('A' <= ch && ch <= 'Z') ch - 'A' + 10
+      else -1
+      )
+    if (0 <= num && num < base) num else -1
+  }
+  /** Buffer for creating '\ u XXXX' strings. */
+  private[this] val char2uescapeArray = Array[Char]('\\', 'u', 0, 0, 0, 0)
+
+  /** Convert a character to a backslash-u escape */
+  def char2uescape(c: Char): String = {
+    inline def hexChar(ch: Int): Char =
+      (( if (ch < 10) '0' else 'A' - 10 ) + ch).toChar
+
+    char2uescapeArray(2) = hexChar((c >> 12)     )
+    char2uescapeArray(3) = hexChar((c >>  8) % 16)
+    char2uescapeArray(4) = hexChar((c >>  4) % 16)
+    char2uescapeArray(5) = hexChar((c      ) % 16)
+
+    new String(char2uescapeArray)
+  }
+
+  /** Is character a line break? */
+  def isLineBreakChar(c: Char): Boolean = (c: @switch) match {
+    case LF|FF|CR|SU  => true
+    case _            => false
+  }
+
+  /** Is character a whitespace character (but not a new line)? */
+  def isWhitespace(c: Char): Boolean =
+    c == ' ' || c == '\t' || c == CR
+
+  /** Can character form part of a doc comment variable $xxx? */
+  def isVarPart(c: Char): Boolean =
+    '0' <= c && c <= '9' || 'A' <= c && c <= 'Z' || 'a' <= c && c <= 'z'
+
+  /** Can character start an alphanumeric Scala identifier? */
+  def isIdentifierStart(c: Char): Boolean =
+    (c == '_') || (c == '$') || JCharacter.isUnicodeIdentifierStart(c)
+
+  /** Can character form part of an alphanumeric Scala identifier? */
+  def isIdentifierPart(c: Char): Boolean =
+    (c == '$') || JCharacter.isUnicodeIdentifierPart(c)
+
+  /** Is character a math or other symbol in Unicode?  */
+  def isSpecial(c: Char): Boolean = {
+    val chtp = JCharacter.getType(c)
+    chtp == JCharacter.MATH_SYMBOL.toInt || chtp == JCharacter.OTHER_SYMBOL.toInt
+  }
+
+  def isValidJVMChar(c: Char): Boolean =
+    !(c == '.' || c == ';' || c =='[' || c == '/')
+
+  def isValidJVMMethodChar(c: Char): Boolean =
+    !(c == '.' || c == ';' || c =='[' || c == '/' || c == '<' || c == '>')
+
+  private final val otherLetters = Set[Char]('\u0024', '\u005F')  // '$' and '_'
+  private final val letterGroups = {
+    import JCharacter._
+    Set[Byte](LOWERCASE_LETTER, UPPERCASE_LETTER, OTHER_LETTER, TITLECASE_LETTER, LETTER_NUMBER)
+  }
+  def isScalaLetter(ch: Char): Boolean = letterGroups(JCharacter.getType(ch).toByte) || otherLetters(ch)
+
+  /** Can character form part of a Scala operator name? */
+  def isOperatorPart(c : Char) : Boolean = (c: @switch) match {
+    case '~' | '!' | '@' | '#' | '%' |
+         '^' | '*' | '+' | '-' | '<' |
+         '>' | '?' | ':' | '=' | '&' |
+         '|' | '/' | '\\' => true
+    case c => isSpecial(c)
+  }
+
+  /** Would the character be encoded by `NameTransformer.encode`? */
+  def willBeEncoded(c : Char) : Boolean = !JCharacter.isJavaIdentifierPart(c)
+}
diff --git a/tests/pos-with-compiler-cc/dotc/util/ClasspathFromClassloader.scala b/tests/pos-with-compiler-cc/dotc/util/ClasspathFromClassloader.scala
new file mode 100644
index 000000000000..25def103083d
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/util/ClasspathFromClassloader.scala
@@ -0,0 +1,53 @@
+package dotty.tools.dotc.util
+
+import scala.language.unsafeNulls
+
+import java.net.URLClassLoader
+import java.nio.file.Paths
+
+import dotty.tools.repl.AbstractFileClassLoader
+
+object ClasspathFromClassloader {
+
+  /** Attempt to recreate a classpath from a classloader.
+   *
+   *  BEWARE: with exotic enough classloaders, this may not work at all or do
+   *  the wrong thing.
+   */
+  def apply(cl: ClassLoader): String = {
+    val classpathBuff = List.newBuilder[String]
+    def collectClassLoaderPaths(cl: ClassLoader): Unit = {
+      if (cl != null) {
+        cl match {
+          case cl: URLClassLoader =>
+            // This is wrong if we're in a subclass of URLClassLoader
+            // that filters loading classes from its parent ¯\_(ツ)_/¯
+            collectClassLoaderPaths(cl.getParent)
+            // Parent classloaders are searched before their child, so the part of
+            // the classpath coming from the child is added at the _end_ of the
+            // classpath.
+            classpathBuff ++=
+              cl.getURLs.iterator.map(url => Paths.get(url.toURI).toAbsolutePath.toString)
+          case _ =>
+            if cl.getClass.getName == classOf[AbstractFileClassLoader].getName then
+              // HACK: We can't just collect the classpath from arbitrary parent
+              // classloaders since the current classloader might intentionally
+              // filter loading classes from its parent (for example
+              // BootFilteredLoader in the sbt launcher does this and we really
+              // don't want to include the scala-library that sbt depends on
+              // here), but we do need to look at the parent of the REPL
+              // classloader, so we special case it. We can't do this using a type
+              // test since the REPL classloader class itself is normally loaded
+              // with a different classloader.
+              collectClassLoaderPaths(cl.getParent)
+            else if cl eq ClassLoader.getSystemClassLoader then
+              // HACK: For Java 9+, if the classloader is an AppClassLoader then use the classpath from the system
+              // property `java.class.path`.
+              classpathBuff += System.getProperty("java.class.path")
+        }
+      }
+    }
+    collectClassLoaderPaths(cl)
+    classpathBuff.result().mkString(java.io.File.pathSeparator)
+  }
+}
diff --git a/tests/pos-with-compiler-cc/dotc/util/CommentParsing.scala b/tests/pos-with-compiler-cc/dotc/util/CommentParsing.scala
new file mode 100644
index 000000000000..b4af59c09310
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/util/CommentParsing.scala
@@ -0,0 +1,256 @@
+/*
+ * Port of DocStrings.scala from nsc
+ * @author Martin Odersky
+ * @author Felix Mulder
+ */
+package dotty.tools.dotc.util
+
+import scala.language.unsafeNulls
+
+import scala.collection.mutable
+
+/** The comment parsing in `dotc` is used by both the comment cooking and the
+  * scaladoc tool.
+  *
+  * The comment cooking is used to expand comments with `@inheritdoc` and
+  * `@define` annotations. The rest of the comment is untouched and later
+  * handled by scaladoc.
+  */
+object CommentParsing {
+  import Chars._
+
+  /** Returns index of string `str` following `start` skipping longest
+   *  sequence of whitespace characters characters (but no newlines)
+   */
+  def skipWhitespace(str: String, start: Int): Int =
+    if (start < str.length && isWhitespace(str charAt start)) skipWhitespace(str, start + 1)
+    else start
+
+  /** Returns index of string `str` following `start` skipping
+   *  sequence of identifier characters.
+   */
+  def skipIdent(str: String, start: Int): Int =
+    if (start < str.length && isIdentifierPart(str charAt start)) skipIdent(str, start + 1)
+    else start
+
+  /** Returns index of string `str` following `start` skipping
+   *  sequence of identifier characters.
+   */
+  def skipTag(str: String, start: Int): Int =
+    if (start < str.length && (str charAt start) == '@') skipIdent(str, start + 1)
+    else start
+
+
+  /** Returns index of string `str` after `start` skipping longest
+   *  sequence of space and tab characters, possibly also containing
+   *  a single `*` character or the `/``**` sequence.
+   *  @pre  start == str.length || str(start) == `\n`
+   */
+  def skipLineLead(str: String, start: Int): Int =
+    if (start == str.length) start
+    else {
+      val idx = skipWhitespace(str, start + 1)
+      if (idx < str.length && (str charAt idx) == '*') skipWhitespace(str, idx + 1)
+      else if (idx + 2 < str.length && (str charAt idx) == '/' && (str charAt (idx + 1)) == '*' && (str charAt (idx + 2)) == '*')
+        skipWhitespace(str, idx + 3)
+      else idx
+    }
+
+  /** Skips to next occurrence of `\n` or to the position after the `/``**` sequence following index `start`.
+   */
+  def skipToEol(str: String, start: Int): Int =
+    if (start + 2 < str.length && (str charAt start) == '/' && (str charAt (start + 1)) == '*' && (str charAt (start + 2)) == '*') start + 3
+    else if (start < str.length && (str charAt start) != '\n') skipToEol(str, start + 1)
+    else start
+
+  /** Returns first index following `start` and starting a line (i.e. after skipLineLead) or starting the comment
+   *  which satisfies predicate `p`.
+   */
+  def findNext(str: String, start: Int)(p: Int => Boolean): Int = {
+    val idx = skipLineLead(str, skipToEol(str, start))
+    if (idx < str.length && !p(idx)) findNext(str, idx)(p)
+    else idx
+  }
+
+  /** Return first index following `start` and starting a line (i.e. after skipLineLead)
+   *  which satisfies predicate `p`.
+   */
+  def findAll(str: String, start: Int)(p: Int => Boolean): List[Int] = {
+    val idx = findNext(str, start)(p)
+    if (idx == str.length) List()
+    else idx :: findAll(str, idx)(p)
+  }
+
+  /** Produces a string index, which is a list of `sections`, i.e
+   *  pairs of start/end positions of all tagged sections in the string.
+   *  Every section starts with an at sign and extends to the next at sign,
+   *  or to the end of the comment string, but excluding the final two
+   *  characters which terminate the comment.
+   *
+   *  Also take usecases into account - they need to expand until the next
+   *  usecase or the end of the string, as they might include other sections
+   *  of their own
+   */
+  def tagIndex(str: String, p: Int => Boolean = (idx => true)): List[(Int, Int)] = {
+    var indices = findAll(str, 0) (idx => str(idx) == '@' && p(idx))
+    indices = mergeUsecaseSections(str, indices)
+    indices = mergeInheritdocSections(str, indices)
+
+    indices match {
+      case List() => List()
+      case idxs   => idxs zip (idxs.tail ::: List(str.length - 2))
+    }
+  }
+
+  /**
+   * Merge sections following an usecase into the usecase comment, so they
+   * can override the parent symbol's sections
+   */
+  def mergeUsecaseSections(str: String, idxs: List[Int]): List[Int] =
+    idxs.indexWhere(str.startsWith("@usecase", _)) match {
+      case firstUCIndex if firstUCIndex != -1 =>
+        val commentSections = idxs.take(firstUCIndex)
+        val usecaseSections = idxs.drop(firstUCIndex).filter(str.startsWith("@usecase", _))
+        commentSections ::: usecaseSections
+      case _ =>
+        idxs
+    }
+
+  /**
+   * Merge the inheritdoc sections, as they never make sense on their own
+   */
+  def mergeInheritdocSections(str: String, idxs: List[Int]): List[Int] =
+    idxs.filterNot(str.startsWith("@inheritdoc", _))
+
+  /** Does interval `iv` start with given `tag`?
+   */
+  def startsWithTag(str: String, section: (Int, Int), tag: String): Boolean =
+    startsWithTag(str, section._1, tag)
+
+  def startsWithTag(str: String, start: Int, tag: String): Boolean =
+    str.startsWith(tag, start) && !isIdentifierPart(str charAt (start + tag.length))
+
+  /** The first start tag of a list of tag intervals,
+   *  or the end of the whole comment string - 2 if list is empty
+   */
+  def startTag(str: String, sections: List[(Int, Int)]): Int = sections match {
+    case Nil             => str.length - 2
+    case (start, _) :: _ => start
+  }
+
+  /** A map from parameter names to start/end indices describing all parameter
+   *  sections in `str` tagged with `tag`, where `sections` is the index of `str`.
+   */
+  def paramDocs(str: String, tag: String, sections: List[(Int, Int)]): Map[String, (Int, Int)] =
+    Map() ++ {
+      for (section <- sections if startsWithTag(str, section, tag)) yield {
+        val start = skipWhitespace(str, section._1 + tag.length)
+        str.substring(start, skipIdent(str, start)) -> section
+      }
+    }
+
+  /** Optionally start and end index of return section in `str`, or `None`
+   *  if `str` does not have a @group. */
+  def groupDoc(str: String, sections: List[(Int, Int)]): Option[(Int, Int)] =
+    sections find (startsWithTag(str, _, "@group"))
+
+
+  /** Optionally start and end index of return section in `str`, or `None`
+   *  if `str` does not have a @return.
+   */
+  def returnDoc(str: String, sections: List[(Int, Int)]): Option[(Int, Int)] =
+    sections find (startsWithTag(str, _, "@return"))
+
+  /** Extracts variable name from a string, stripping any pair of surrounding braces */
+  def variableName(str: String): String =
+    if (str.length >= 2 && (str charAt 0) == '{' && (str charAt (str.length - 1)) == '}')
+      str.substring(1, str.length - 1)
+    else
+      str
+
+  /** Returns index following variable, or start index if no variable was recognized
+   */
+  def skipVariable(str: String, start: Int): Int = {
+    var idx = start
+    if (idx < str.length && (str charAt idx) == '{') {
+      while ({
+        idx += 1
+        idx < str.length && (str charAt idx) != '}'
+      })
+      ()
+      if (idx < str.length) idx + 1 else start
+    }
+    else {
+      while (idx < str.length && isVarPart(str charAt idx))
+        idx += 1
+      idx
+    }
+  }
+
+  /** A map from the section tag to section parameters */
+  def sectionTagMap(str: String, sections: List[(Int, Int)]): Map[String, (Int, Int)] =
+    Map() ++ {
+      for (section <- sections) yield
+        extractSectionTag(str, section) -> section
+    }
+
+  /** Extract the section tag, treating the section tag as an identifier */
+  def extractSectionTag(str: String, section: (Int, Int)): String =
+    str.substring(section._1, skipTag(str, section._1))
+
+  /** Extract the section parameter */
+  def extractSectionParam(str: String, section: (Int, Int)): String = {
+    val (beg, _) = section
+    assert(str.startsWith("@param", beg) ||
+           str.startsWith("@tparam", beg) ||
+           str.startsWith("@throws", beg))
+
+    val start = skipWhitespace(str, skipTag(str, beg))
+    val finish = skipIdent(str, start)
+
+    str.substring(start, finish)
+  }
+
+  /** Extract the section text, except for the tag and comment newlines */
+  def extractSectionText(str: String, section: (Int, Int)): (Int, Int) = {
+    val (beg, end) = section
+    if (str.startsWith("@param", beg) ||
+        str.startsWith("@tparam", beg) ||
+        str.startsWith("@throws", beg))
+      (skipWhitespace(str, skipIdent(str, skipWhitespace(str, skipTag(str, beg)))), end)
+    else
+      (skipWhitespace(str, skipTag(str, beg)), end)
+  }
+
+  /** Cleanup section text */
+  def cleanupSectionText(str: String): String = {
+    var result = str.trim.replaceAll("\n\\s+\\*\\s+", " \n")
+    while (result.endsWith("\n"))
+      result = result.substring(0, str.length - 1)
+    result
+  }
+
+  /** A map from tag name to all boundaries for this tag */
+  def groupedSections(str: String, sections: List[(Int, Int)]): Map[String, List[(Int, Int)]] = {
+    val map = mutable.Map.empty[String, List[(Int, Int)]].withDefaultValue(Nil)
+    sections.reverse.foreach { bounds =>
+      val tag = extractSectionTag(str, bounds)
+      map.update(tag, (skipTag(str, bounds._1), bounds._2) :: map(tag))
+    }
+    map.toMap
+  }
+
+  def removeSections(raw: String, xs: String*): String = {
+    val sections = tagIndex(raw)
+
+    val toBeRemoved = for {
+      section <- xs
+      lines = sections filter { startsWithTag(raw, _, section) }
+    }
+    yield lines
+
+    val end = startTag(raw, toBeRemoved.flatten.sortBy(_._1).toList)
+
+    if (end == raw.length - 2) raw else raw.substring(0, end) + "*/"
+  }
+}
diff --git a/tests/pos-with-compiler-cc/dotc/util/DiffUtil.scala b/tests/pos-with-compiler-cc/dotc/util/DiffUtil.scala
new file mode 100644
index 000000000000..cec86fa84443
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/util/DiffUtil.scala
@@ -0,0 +1,234 @@
+package dotty.tools.dotc.util
+
+import scala.language.unsafeNulls
+
+import scala.annotation.tailrec
+import scala.collection.mutable
+
+object DiffUtil {
+
+  val EOF: String = new String("EOF") // Unique string up to reference
+
+  val ansiColorToken: Char = '\u001b'
+
+  @tailrec private def splitTokens(str: String, acc: List[String] = Nil): List[String] =
+      if (str == "")
+        acc.reverse
+      else {
+        val head = str.charAt(0)
+        val (token, rest) =
+          if (head == ansiColorToken) { // ansi color token
+            val splitIndex = str.indexOf('m') + 1
+            (str.substring(0, splitIndex), str.substring(splitIndex))
+          }
+          else if (Character.isAlphabetic(head) || Character.isDigit(head))
+            str.span(c => Character.isAlphabetic(c) || Character.isDigit(c) && c != ansiColorToken)
+          else if (Character.isMirrored(head) || Character.isWhitespace(head))
+            str.splitAt(1)
+          else
+            str.span { c =>
+              !Character.isAlphabetic(c) && !Character.isDigit(c) &&
+                !Character.isMirrored(c) && !Character.isWhitespace(c) && c != ansiColorToken
+            }
+        splitTokens(rest, token :: acc)
+      }
+
+
+  /** @return a tuple of the (found, expected, changedPercentage) diffs as strings */
+  def mkColoredTypeDiff(found: String, expected: String): (String, String, Double) = {
+    var totalChange = 0
+    val foundTokens   = splitTokens(found, Nil).toArray
+    val expectedTokens = splitTokens(expected, Nil).toArray
+
+    val diffExp = hirschberg(foundTokens, expectedTokens)
+    val diffAct = hirschberg(expectedTokens, foundTokens)
+
+    val exp = diffExp.collect {
+      case Unmodified(str) => str
+      case Inserted(str) =>
+        totalChange += str.length
+        added(str)
+    }.mkString
+
+    val fnd = diffAct.collect {
+      case Unmodified(str) => str
+      case Inserted(str) =>
+        totalChange += str.length
+        deleted(str)
+    }.mkString
+
+    (fnd, exp, totalChange.toDouble / (expected.length + found.length))
+  }
+
+  /**
+   * Return a colored diff between the tokens of every line in `expected` and `actual`. Each line of
+   * output contains the expected value on the left and the actual value on the right.
+   *
+   * @param expected The expected lines
+   * @param actual   The actual lines
+   * @return A string with one element of `expected` and `actual` on each lines, where
+   *         differences are highlighted.
+   */
+  def mkColoredLineDiff(expected: Seq[String], actual: Seq[String]): String = {
+    val expectedSize = EOF.length max expected.maxBy(_.length).length
+    actual.padTo(expected.length, "").zip(expected.padTo(actual.length, "")).map { case (act, exp) =>
+      mkColoredLineDiff(exp, act, expectedSize)
+    }.mkString(System.lineSeparator)
+  }
+
+  def mkColoredLineDiff(expected: String, actual: String, expectedSize: Int): String = {
+    lazy val diff = {
+      val tokens = splitTokens(expected, Nil).toArray
+      val lastTokens = splitTokens(actual, Nil).toArray
+      hirschberg(lastTokens, tokens)
+    }
+
+    val expectedDiff =
+      if (expected eq EOF) eof()
+      else diff.collect {
+        case Unmodified(str) => str
+        case Inserted(str) => added(str)
+        case Modified(_, str) => added(str)
+        case Deleted(_) => ""
+      }.mkString
+
+    val actualDiff =
+      if (actual eq EOF) eof()
+      else diff.collect {
+        case Unmodified(str) => str
+        case Inserted(_) => ""
+        case Modified(str, _) => deleted(str)
+        case Deleted(str) => deleted(str)
+      }.mkString
+
+    val pad = " " * 0.max(expectedSize - expected.length)
+
+    expectedDiff + pad + "  |  " + actualDiff
+  }
+
+  def mkColoredCodeDiff(code: String, lastCode: String, printDiffDel: Boolean): String = {
+    val tokens = splitTokens(code, Nil).toArray
+    val lastTokens = splitTokens(lastCode, Nil).toArray
+
+    val diff = hirschberg(lastTokens, tokens)
+
+    diff.collect {
+      case Unmodified(str) => str
+      case Inserted(str)                      => added(str)
+      case Modified(old, str) if printDiffDel => deleted(str) + added(str)
+      case Modified(_, str)                   => added(str)
+      case Deleted(str) if printDiffDel       => deleted(str)
+    }.mkString
+  }
+
+  private def added(str: String): String = bgColored(str, Console.GREEN)
+  private def deleted(str: String) = bgColored(str, Console.RED)
+  private def bgColored(str: String, color: String): String =
+    if (str.isEmpty) ""
+    else {
+      val (spaces, rest) = str.span(_ == '\n')
+      if (spaces.isEmpty) {
+        val (text, rest2) = str.span(_ != '\n')
+        Console.BOLD + color + text + Console.RESET + bgColored(rest2, color)
+      }
+      else spaces + bgColored(rest, color)
+    }
+  private def eof() = "\u001B[51m" + "EOF" + Console.RESET
+
+  private sealed trait Patch
+  private final case class Unmodified(str: String) extends Patch
+  private final case class Modified(original: String, str: String) extends Patch
+  private final case class Deleted(str: String) extends Patch
+  private final case class Inserted(str: String) extends Patch
+
+  private def hirschberg(a: Array[String], b: Array[String]): Array[Patch] = {
+    def build(x: Array[String], y: Array[String], builder: mutable.ArrayBuilder[Patch]): Unit =
+      if (x.isEmpty)
+        builder += Inserted(y.mkString)
+      else if (y.isEmpty)
+        builder += Deleted(x.mkString)
+      else if (x.length == 1 || y.length == 1)
+        needlemanWunsch(x, y, builder)
+      else {
+        val xlen = x.length
+        val xmid = xlen / 2
+        val ylen = y.length
+
+        val (x1, x2) = x.splitAt(xmid)
+        val leftScore = nwScore(x1, y)
+        val rightScore = nwScore(x2.reverse, y.reverse)
+        val scoreSum = (leftScore zip rightScore.reverse).map {
+          case (left, right) => left + right
+        }
+        val max = scoreSum.max
+        val ymid = scoreSum.indexOf(max)
+
+        val (y1, y2) = y.splitAt(ymid)
+        build(x1, y1, builder)
+        build(x2, y2, builder)
+      }
+    val builder = Array.newBuilder[Patch]
+    build(a, b, builder)
+    builder.result()
+  }
+
+  private def nwScore(x: Array[String], y: Array[String]): Array[Int] = {
+    def ins(s: String) = -2
+    def del(s: String) = -2
+    def sub(s1: String, s2: String) = if (s1 == s2) 2 else -1
+
+    val score = Array.fill(x.length + 1, y.length + 1)(0)
+    for (j <- 1 to y.length)
+      score(0)(j) = score(0)(j - 1) + ins(y(j - 1))
+    for (i <- 1 to x.length) {
+      score(i)(0) = score(i - 1)(0) + del(x(i - 1))
+      for (j <- 1 to y.length) {
+        val scoreSub = score(i - 1)(j - 1) + sub(x(i - 1), y(j - 1))
+        val scoreDel = score(i - 1)(j) + del(x(i - 1))
+        val scoreIns = score(i)(j - 1) + ins(y(j - 1))
+        score(i)(j) = scoreSub max scoreDel max scoreIns
+      }
+    }
+    Array.tabulate(y.length + 1)(j => score(x.length)(j))
+  }
+
+  private def needlemanWunsch(x: Array[String], y: Array[String], builder: mutable.ArrayBuilder[Patch]): Unit = {
+    def similarity(a: String, b: String) = if (a == b) 3 else -1
+    val d = 1
+    val score = Array.tabulate(x.length + 1, y.length + 1) { (i, j) =>
+      if (i == 0) d * j
+      else if (j == 0) d * i
+      else 0
+    }
+    for (i <- 1 to x.length)
+      for (j <- 1 to y.length) {
+        val mtch = score(i - 1)(j - 1) + similarity(x(i - 1), y(j - 1))
+        val delete = score(i - 1)(j) + d
+        val insert = score(i)(j - 1) + d
+        score(i)(j) = mtch max insert max delete
+      }
+
+    var alignment = List.empty[Patch]
+    var i = x.length
+    var j = y.length
+    while (i > 0 || j > 0)
+      if (i > 0 && j > 0 && score(i)(j) == score(i - 1)(j - 1) + similarity(x(i - 1), y(j - 1))) {
+        val newHead =
+          if (x(i - 1) == y(j - 1)) Unmodified(x(i - 1))
+          else Modified(x(i - 1), y(j - 1))
+        alignment = newHead :: alignment
+        i = i - 1
+        j = j - 1
+      }
+      else if (i > 0 && score(i)(j) == score(i - 1)(j) + d) {
+        alignment = Deleted(x(i - 1)) :: alignment
+        i = i - 1
+      }
+      else {
+        alignment = Inserted(y(j - 1)) :: alignment
+        j = j - 1
+      }
+    builder ++= alignment
+  }
+}
+
diff --git a/tests/pos-with-compiler-cc/dotc/util/DotClass.scala b/tests/pos-with-compiler-cc/dotc/util/DotClass.scala
new file mode 100644
index 000000000000..f9e7e97a219d
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/util/DotClass.scala
@@ -0,0 +1,8 @@
+package dotty.tools.dotc.util
+
+/** Adds standard functionality to a class.
+ *  For now: Just the `unsupported` method.
+ */
+class DotClass {
+
+}
diff --git a/tests/pos-with-compiler-cc/dotc/util/EqHashMap.scala b/tests/pos-with-compiler-cc/dotc/util/EqHashMap.scala
new file mode 100644
index 000000000000..ea049acba02b
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/util/EqHashMap.scala
@@ -0,0 +1,80 @@
+package dotty.tools.dotc.util
+
+/** A specialized implementation of GenericHashMap with identity hash and `eq`
+ *  as comparison.
+ */
+class EqHashMap[Key, Value]
+    (initialCapacity: Int = 8, capacityMultiple: Int = 2)
+extends GenericHashMap[Key, Value](initialCapacity, capacityMultiple):
+
+  /** Hashcode is identityHashCode left-shifted by 1, so lowest bit is not lost
+   *  when taking the index.
+   */
+  final def hash(x: Key): Int = System.identityHashCode(x) << 1
+
+  /** Equality, by default `eq`,  but can be overridden */
+  final def isEqual(x: Key, y: Key): Boolean = x.asInstanceOf[AnyRef] eq y.asInstanceOf[AnyRef]
+
+  // The following methods are duplicated from GenericHashMap
+  // to avoid polymorphic dispatches.
+  // Aside: It would be nice to have a @specialized annotation that does
+  // this automatically
+
+  private def index(x: Int): Int = x & (table.length - 2)
+
+  private def firstIndex(key: Key) = if isDense then 0 else index(hash(key))
+  private def nextIndex(idx: Int) =
+    Stats.record(statsItem("miss"))
+    index(idx + 2)
+
+  private def keyAt(idx: Int): Key = table(idx).asInstanceOf[Key]
+  private def valueAt(idx: Int): Value = table(idx + 1).asInstanceOf[Value]
+
+  private def setKey(idx: Int, key: Key) = table(idx) = key.asInstanceOf[AnyRef]
+  private def setValue(idx: Int, value: Value) = table(idx + 1) = value.asInstanceOf[AnyRef]
+
+  override def lookup(key: Key): Value | Null =
+    Stats.record(statsItem("lookup"))
+    var idx = firstIndex(key)
+    var k = keyAt(idx)
+    while k != null do
+      if isEqual(k, key) then return valueAt(idx)
+      idx = nextIndex(idx)
+      k = keyAt(idx)
+    null
+
+  override def update(key: Key, value: Value): Unit =
+    Stats.record(statsItem("update"))
+    var idx = firstIndex(key)
+    var k = keyAt(idx)
+    while k != null do
+      if isEqual(k, key) then
+        setValue(idx, value)
+        return
+      idx = nextIndex(idx)
+      k = keyAt(idx)
+    setKey(idx, key)
+    setValue(idx, value)
+    used += 1
+    if used > limit then growTable()
+
+  private def addOld(key: Key, value: Value): Unit =
+    Stats.record(statsItem("re-enter"))
+    var idx = firstIndex(key)
+    var k = keyAt(idx)
+    while k != null do
+      idx = nextIndex(idx)
+      k = keyAt(idx)
+    setKey(idx, key)
+    setValue(idx, value)
+
+  override def copyFrom(oldTable: Array[AnyRef | Null]): Unit =
+    if isDense then
+      Array.copy(oldTable, 0, table, 0, oldTable.length)
+    else
+      var idx = 0
+      while idx < oldTable.length do
+        val key = oldTable(idx).asInstanceOf[Key]
+        if key != null then addOld(key, oldTable(idx + 1).asInstanceOf[Value])
+        idx += 2
+end EqHashMap
diff --git a/tests/pos-with-compiler-cc/dotc/util/FreshNameCreator.scala b/tests/pos-with-compiler-cc/dotc/util/FreshNameCreator.scala
new file mode 100644
index 000000000000..f3375028c95f
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/util/FreshNameCreator.scala
@@ -0,0 +1,30 @@
+package dotty.tools
+package dotc
+package util
+
+import scala.collection.mutable
+import core.Names.TermName
+import core.NameKinds.UniqueNameKind
+import core.StdNames.str
+
+abstract class FreshNameCreator {
+  def newName(prefix: TermName, unique: UniqueNameKind): TermName
+}
+
+object FreshNameCreator {
+  class Default extends FreshNameCreator {
+    protected var counter: Int = 0
+    protected val counters: mutable.Map[String, Int] = mutable.AnyRefMap() withDefaultValue 0
+
+    /**
+     * Create a fresh name with the given prefix. It is guaranteed
+     * that the returned name has never been returned by a previous
+     * call to this function (provided the prefix does not end in a digit).
+     */
+    def newName(prefix: TermName, unique: UniqueNameKind): TermName = {
+      val key = str.sanitize(prefix.toString) + unique.separator
+      counters(key) += 1
+      prefix.derived(unique.NumberedInfo(counters(key)))
+    }
+  }
+}
diff --git a/tests/pos-with-compiler-cc/dotc/util/GenericHashMap.scala b/tests/pos-with-compiler-cc/dotc/util/GenericHashMap.scala
new file mode 100644
index 000000000000..fd6518fcc15c
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/util/GenericHashMap.scala
@@ -0,0 +1,192 @@
+package dotty.tools
+package dotc.util
+
+object GenericHashMap:
+
+  /** The number of elements up to which dense packing is used.
+   *  If the number of elements reaches `DenseLimit` a hash table is used instead
+   */
+  inline val DenseLimit = 8
+
+/** A hash table using open hashing with linear scan which is also very space efficient
+ *  at small sizes. The implementations of `hash` and `isEqual` are left open. They have
+ *  to be provided by subclasses.
+ *
+ *  @param  initialCapacity  Indicates the initial number of slots in the hash table.
+ *                           The actual number of slots is always a power of 2, so the
+ *                           initial size of the table will be the smallest power of two
+ *                           that is equal or greater than the given `initialCapacity`.
+ *                           Minimum value is 4.
+ *  @param  capacityMultiple The minimum multiple of capacity relative to used elements.
+ *                           The hash table will be re-sized once the number of elements
+ *                           multiplied by capacityMultiple exceeds the current size of the hash table.
+ *                           However, a table of size up to DenseLimit will be re-sized only
+ *                           once the number of elements reaches the table's size.
+ */
+abstract class GenericHashMap[Key, Value]
+    (initialCapacity: Int, capacityMultiple: Int) extends MutableMap[Key, Value]:
+  import GenericHashMap.DenseLimit
+
+  protected var used: Int = _
+  protected var limit: Int = _
+  protected var table: Array[AnyRef | Null] = _
+  clear()
+
+  private def allocate(capacity: Int) =
+    table = new Array[AnyRef | Null](capacity * 2)
+    limit = if capacity <= DenseLimit then capacity - 1 else capacity / capacityMultiple
+
+  private def roundToPower(n: Int) =
+    if n < 4 then 4
+    else if Integer.bitCount(n) == 1 then n
+    else 1 << (32 - Integer.numberOfLeadingZeros(n))
+
+  /** Remove all elements from this table and set back to initial configuration */
+  def clear(): Unit =
+    used = 0
+    allocate(roundToPower(initialCapacity))
+
+  /** The number of elements in the set */
+  def size: Int = used
+
+  protected def isDense = limit < DenseLimit
+
+  /** Hashcode, to be implemented in subclass */
+  protected def hash(x: Key): Int
+
+  /** Equality, to be implemented in subclass */
+  protected def isEqual(x: Key, y: Key): Boolean
+
+  /** Turn successor index or hash code `x` into a table index */
+  private def index(x: Int): Int = x & (table.length - 2)
+
+  private def firstIndex(key: Key) = if isDense then 0 else index(hash(key))
+  private def nextIndex(idx: Int) =
+    Stats.record(statsItem("miss"))
+    index(idx + 2)
+
+  private def keyAt(idx: Int): Key = table(idx).asInstanceOf[Key]
+  private def valueAt(idx: Int): Value = table(idx + 1).asInstanceOf[Value]
+
+  private def setKey(idx: Int, key: Key) =
+    table(idx) = key.asInstanceOf[AnyRef]
+  private def setValue(idx: Int, value: Value) =
+    table(idx + 1) = value.asInstanceOf[AnyRef]
+
+  def lookup(key: Key): Value | Null =
+    Stats.record(statsItem("lookup"))
+    var idx = firstIndex(key)
+    var k = keyAt(idx)
+    while k != null do
+      if isEqual(k, key) then return valueAt(idx)
+      idx = nextIndex(idx)
+      k = keyAt(idx)
+    null
+
+  def update(key: Key, value: Value): Unit =
+    Stats.record(statsItem("update"))
+    var idx = firstIndex(key)
+    var k = keyAt(idx)
+    while k != null do
+      if isEqual(k, key) then
+        setValue(idx, value)
+        return
+      idx = nextIndex(idx)
+      k = keyAt(idx)
+    setKey(idx, key)
+    setValue(idx, value)
+    used += 1
+    if used > limit then growTable()
+
+  def remove(key: Key): Value | Null =
+    Stats.record(statsItem("remove"))
+    var idx = firstIndex(key)
+    var k = keyAt(idx)
+    while k != null do
+      if isEqual(k, key) then
+        val result = valueAt(idx)
+        var hole = idx
+        while
+          idx = nextIndex(idx)
+          k = keyAt(idx)
+          k != null
+        do
+          val eidx = index(hash(k))
+          if isDense
+            || index(eidx - (hole + 2)) > index(idx - (hole + 2))
+               // entry `e` at `idx` can move unless `index(hash(e))` is in
+               // the (ring-)interval [hole + 2 .. idx]
+          then
+            setKey(hole, k)
+            setValue(hole, valueAt(idx))
+            hole = idx
+        table(hole) = null
+        used -= 1
+        return result
+      idx = nextIndex(idx)
+      k = keyAt(idx)
+    null
+
+  def getOrElseUpdate(key: Key, value: => Value): Value =
+    var v: Value | Null = lookup(key)
+    if v == null then
+      val v1 = value
+      v = v1
+      update(key, v1)
+    v.uncheckedNN
+
+  private def addOld(key: Key, value: Value): Unit =
+    Stats.record(statsItem("re-enter"))
+    var idx = firstIndex(key)
+    var k = keyAt(idx)
+    while k != null do
+      idx = nextIndex(idx)
+      k = keyAt(idx)
+    setKey(idx, key)
+    setValue(idx, value)
+
+  def copyFrom(oldTable: Array[AnyRef | Null]): Unit =
+    if isDense then
+      Array.copy(oldTable, 0, table, 0, oldTable.length)
+    else
+      var idx = 0
+      while idx < oldTable.length do
+        val key = oldTable(idx)
+        if key != null then addOld(key.asInstanceOf[Key], oldTable(idx + 1).asInstanceOf[Value])
+        idx += 2
+
+  protected def growTable(): Unit =
+    val oldTable = table
+    val newLength =
+      if table.length == DenseLimit * 2 then table.length * roundToPower(capacityMultiple)
+      else table.length
+    allocate(newLength)
+    copyFrom(oldTable)
+
+  private abstract class EntryIterator[T] extends Iterator[T]:
+    def entry(idx: Int): T
+    private var idx = 0
+    def hasNext =
+      while idx < table.length && table(idx) == null do idx += 2
+      idx < table.length
+    def next() =
+      require(hasNext)
+      try entry(idx) finally idx += 2
+
+  def iterator: Iterator[(Key, Value)] = new EntryIterator:
+    def entry(idx: Int) = (keyAt(idx), valueAt(idx))
+
+  def keysIterator: Iterator[Key] = new EntryIterator:
+    def entry(idx: Int) = keyAt(idx)
+
+  def valuesIterator: Iterator[Value] = new EntryIterator:
+    def entry(idx: Int) = valueAt(idx)
+
+  override def toString: String =
+    iterator.map((k, v) => s"$k -> $v").mkString("HashMap(", ", ", ")")
+
+  protected def statsItem(op: String) =
+    val prefix = if isDense then "HashMap(dense)." else "HashMap."
+    val suffix = getClass.getSimpleName
+    s"$prefix$op $suffix"
+end GenericHashMap
diff --git a/tests/pos-with-compiler-cc/dotc/util/HashMap.scala b/tests/pos-with-compiler-cc/dotc/util/HashMap.scala
new file mode 100644
index 000000000000..aaae781c310a
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/util/HashMap.scala
@@ -0,0 +1,85 @@
+package dotty.tools.dotc.util
+
+import scala.language.unsafeNulls
+
+/** A specialized implementation of GenericHashMap with standard hashCode and equals
+ *  as comparison
+ */
+class HashMap[Key, Value]
+    (initialCapacity: Int = 8, capacityMultiple: Int = 2)
+extends GenericHashMap[Key, Value](initialCapacity, capacityMultiple):
+
+  /** Hashcode is left-shifted by 1, so lowest bit is not lost
+   *  when taking the index.
+   */
+  final def hash(key: Key): Int =
+    val h = key.hashCode
+    // Part of the MurmurHash3 32 bit finalizer
+    val i = (h ^ (h >>> 16)) * 0x85EBCA6B
+    val j = (i ^ (i >>> 13)) & 0x7FFFFFFF
+    (if j==0 then 0x41081989 else j) << 1
+
+  final def isEqual(x: Key, y: Key): Boolean = x.equals(y)
+
+  // The following methods are duplicated from GenericHashMap
+  // to avoid polymorphic dispatches
+  private def index(x: Int): Int = x & (table.length - 2)
+
+  private def firstIndex(key: Key) = if isDense then 0 else index(hash(key))
+  private def nextIndex(idx: Int) =
+    Stats.record(statsItem("miss"))
+    index(idx + 2)
+
+  private def keyAt(idx: Int): Key = table(idx).asInstanceOf[Key]
+  private def valueAt(idx: Int): Value = table(idx + 1).asInstanceOf[Value]
+
+  private def setKey(idx: Int, key: Key) =
+    table(idx) = key.asInstanceOf[AnyRef]
+  private def setValue(idx: Int, value: Value) =
+    table(idx + 1) = value.asInstanceOf[AnyRef]
+
+  override def lookup(key: Key): Value | Null =
+    Stats.record(statsItem("lookup"))
+    var idx = firstIndex(key)
+    var k = keyAt(idx)
+    while k != null do
+      if isEqual(k, key) then return valueAt(idx)
+      idx = nextIndex(idx)
+      k = keyAt(idx)
+    null
+
+  override def update(key: Key, value: Value): Unit =
+    Stats.record(statsItem("update"))
+    var idx = firstIndex(key)
+    var k = keyAt(idx)
+    while k != null do
+      if isEqual(k, key) then
+        setValue(idx, value)
+        return
+      idx = nextIndex(idx)
+      k = keyAt(idx)
+    setKey(idx, key)
+    setValue(idx, value)
+    used += 1
+    if used > limit then growTable()
+
+  private def addOld(key: Key, value: Value): Unit =
+    Stats.record(statsItem("re-enter"))
+    var idx = firstIndex(key)
+    var k = keyAt(idx)
+    while k != null do
+      idx = nextIndex(idx)
+      k = keyAt(idx)
+    setKey(idx, key)
+    setValue(idx, value)
+
+  override def copyFrom(oldTable: Array[AnyRef | Null]): Unit =
+    if isDense then
+      Array.copy(oldTable, 0, table, 0, oldTable.length)
+    else
+      var idx = 0
+      while idx < oldTable.length do
+        val key = oldTable(idx).asInstanceOf[Key]
+        if key != null then addOld(key, oldTable(idx + 1).asInstanceOf[Value])
+        idx += 2
+end HashMap
diff --git a/tests/pos-with-compiler-cc/dotc/util/HashSet.scala b/tests/pos-with-compiler-cc/dotc/util/HashSet.scala
new file mode 100644
index 000000000000..a524dd39a594
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/util/HashSet.scala
@@ -0,0 +1,190 @@
+package dotty.tools.dotc.util
+
+import dotty.tools.uncheckedNN
+
+object HashSet:
+
+  /** The number of elements up to which dense packing is used.
+   *  If the number of elements reaches `DenseLimit` a hash table is used instead
+   */
+  inline val DenseLimit = 8
+
+  def from[T](xs: IterableOnce[T]): HashSet[T] =
+    val set = new HashSet[T]()
+    set ++= xs
+    set
+
+/** A hash set that allows some privileged protected access to its internals
+ *  @param  initialCapacity  Indicates the initial number of slots in the hash table.
+ *                           The actual number of slots is always a power of 2, so the
+ *                           initial size of the table will be the smallest power of two
+ *                           that is equal or greater than the given `initialCapacity`.
+ *                           Minimum value is 4.
+*  @param  capacityMultiple The minimum multiple of capacity relative to used elements.
+ *                           The hash table will be re-sized once the number of elements
+ *                           multiplied by capacityMultiple exceeds the current size of the hash table.
+ *                           However, a table of size up to DenseLimit will be re-sized only
+ *                           once the number of elements reaches the table's size.
+ */
+class HashSet[T](initialCapacity: Int = 8, capacityMultiple: Int = 2) extends MutableSet[T] {
+  import HashSet.DenseLimit
+
+  private var used: Int = _
+  private var limit: Int = _
+  private var table: Array[AnyRef | Null] = _
+
+  clear()
+
+  private def allocate(capacity: Int) =
+    table = new Array[AnyRef | Null](capacity)
+    limit = if capacity <= DenseLimit then capacity - 1 else capacity / capacityMultiple
+
+  private def roundToPower(n: Int) =
+    if n < 4 then 4
+    else if Integer.bitCount(n) == 1 then n
+    else 1 << (32 - Integer.numberOfLeadingZeros(n))
+
+  /** Remove all elements from this set and set back to initial configuration */
+  def clear(): Unit = {
+    used = 0
+    allocate(roundToPower(initialCapacity))
+  }
+
+  /** The number of elements in the set */
+  def size: Int = used
+
+  protected def isDense = limit < DenseLimit
+
+  /** Hashcode, by default a processed `x.hashCode`, can be overridden */
+  protected def hash(key: T): Int =
+    val h = key.hashCode
+    // Part of the MurmurHash3 32 bit finalizer
+    val i = (h ^ (h >>> 16)) * 0x85EBCA6B
+    val j = (i ^ (i >>> 13)) & 0x7FFFFFFF
+    if j==0 then 0x41081989 else j
+
+  /** Hashcode, by default `equals`, can be overridden */
+  protected def isEqual(x: T, y: T): Boolean = x.equals(y)
+
+  /** Turn hashcode `x` into a table index */
+  protected def index(x: Int): Int = x & (table.length - 1)
+
+  protected def currentTable: Array[AnyRef | Null] = table
+
+  protected def firstIndex(x: T) = if isDense then 0 else index(hash(x))
+  protected def nextIndex(idx: Int) =
+    Stats.record(statsItem("miss"))
+    index(idx + 1)
+
+  protected def entryAt(idx: Int): T | Null = table(idx).asInstanceOf[T | Null]
+  protected def setEntry(idx: Int, x: T) = table(idx) = x.asInstanceOf[AnyRef | Null]
+
+  def lookup(x: T): T | Null =
+    Stats.record(statsItem("lookup"))
+    var idx = firstIndex(x)
+    var e: T | Null = entryAt(idx)
+    while e != null do
+      if isEqual(e.uncheckedNN, x) then return e
+      idx = nextIndex(idx)
+      e = entryAt(idx)
+    null
+
+  /** Add entry at `x` at index `idx` */
+  protected def addEntryAt(idx: Int, x: T): T =
+    Stats.record(statsItem("addEntryAt"))
+    setEntry(idx, x)
+    used += 1
+    if used > limit then growTable()
+    x
+
+  def put(x: T): T =
+    Stats.record(statsItem("put"))
+    var idx = firstIndex(x)
+    var e: T | Null = entryAt(idx)
+    while e != null do
+      // TODO: remove uncheckedNN when explicit-nulls is enabled for regule compiling
+      if isEqual(e.uncheckedNN, x) then return e.uncheckedNN
+      idx = nextIndex(idx)
+      e = entryAt(idx)
+    addEntryAt(idx, x)
+
+  def +=(x: T): Unit = put(x)
+
+  def remove(x: T): Boolean =
+    Stats.record(statsItem("remove"))
+    var idx = firstIndex(x)
+    var e: T | Null = entryAt(idx)
+    while e != null do
+      if isEqual(e.uncheckedNN, x) then
+        var hole = idx
+        while
+          idx = nextIndex(idx)
+          e = entryAt(idx)
+          e != null
+        do
+          val eidx = index(hash(e.uncheckedNN))
+          if isDense
+            || index(eidx - (hole + 1)) > index(idx - (hole + 1))
+               // entry `e` at `idx` can move unless `index(hash(e))` is in
+               // the (ring-)interval [hole + 1 .. idx]
+          then
+            setEntry(hole, e.uncheckedNN)
+            hole = idx
+        table(hole) = null
+        used -= 1
+        return true
+      idx = nextIndex(idx)
+      e = entryAt(idx)
+    false
+
+  def -=(x: T): Unit =
+    remove(x)
+
+  private def addOld(x: T) =
+    Stats.record(statsItem("re-enter"))
+    var idx = firstIndex(x)
+    var e = entryAt(idx)
+    while e != null do
+      idx = nextIndex(idx)
+      e = entryAt(idx)
+    setEntry(idx, x)
+
+  def copyFrom(oldTable: Array[AnyRef | Null]): Unit =
+    if isDense then
+      Array.copy(oldTable, 0, table, 0, oldTable.length)
+    else
+      var idx = 0
+      while idx < oldTable.length do
+        val e: T | Null = oldTable(idx).asInstanceOf[T | Null]
+        if e != null then addOld(e.uncheckedNN)
+        idx += 1
+
+  protected def growTable(): Unit =
+    val oldTable = table
+    val newLength =
+      if oldTable.length == DenseLimit then DenseLimit * 2 * roundToPower(capacityMultiple)
+      else table.length * 2
+    allocate(newLength)
+    copyFrom(oldTable)
+
+  abstract class EntryIterator extends Iterator[T]:
+    def entry(idx: Int): T | Null
+    private var idx = 0
+    def hasNext =
+      while idx < table.length && table(idx) == null do idx += 1
+      idx < table.length
+    def next() =
+      require(hasNext)
+      try entry(idx).uncheckedNN finally idx += 1
+
+  def iterator: Iterator[T] = new EntryIterator():
+    def entry(idx: Int) = entryAt(idx)
+
+  override def toString: String =
+    iterator.mkString("HashSet(", ", ", ")")
+
+  protected def statsItem(op: String) =
+    val prefix = if isDense then "HashSet(dense)." else "HashSet."
+    val suffix = getClass.getSimpleName
+    s"$prefix$op $suffix"
+}
diff --git a/tests/pos-with-compiler-cc/dotc/util/IntMap.scala b/tests/pos-with-compiler-cc/dotc/util/IntMap.scala
new file mode 100644
index 000000000000..008ea866f70e
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/util/IntMap.scala
@@ -0,0 +1,57 @@
+package dotty.tools.dotc.util
+
+/** A dense map from some `Key` type to `Int. Dense means: All keys and values
+ *  are stored in arrays from 0 up to the size of the map. Keys and values
+ *  can be obtained by index using `key(index)` and `value(index)`. Values
+ *  can also be stored using `setValue(index, value)`.
+ *
+ *  ome privileged protected access to its internals
+ *  @param  initialCapacity  Indicates the initial number of slots in the hash table.
+ *                           The actual number of slots is always a power of 2, so the
+ *                           initial size of the table will be the smallest power of two
+ *                           that is equal or greater than the given `initialCapacity`.
+ *                           Minimum value is 4.
+ *  @param  capacityMultiple The minimum multiple of capacity relative to used elements.
+ *                           The hash table will be re-sized once the number of elements
+ *                           multiplied by capacityMultiple exceeds the current size of the hash table.
+ *                           However, a table of size up to DenseLimit will be re-sized only
+ *                           once the number of elements reaches the table's size.
+ */
+final class IntMap[Key](initialCapacity: Int = 8, capacityMultiple: Int = 2)
+extends PerfectHashing[Key](initialCapacity, capacityMultiple):
+  private var values: Array[Int] = _
+
+  def default: Int = -1
+
+  protected override def allocate(capacity: Int) =
+    super.allocate(capacity)
+    values = new Array[Int](capacity)
+
+  /** The value associated with key `k`, or else `default`. */
+  def apply(k: Key): Int =
+    val idx = index(k)
+    if idx < 0 then default else values(idx)
+
+  /** Associate key `k` with value `v` */
+  def update(k: Key, v: Int): Unit =
+    val idx = add(k) // don't merge the two statements, `add` might change `values`.
+    values(idx) = v
+
+  protected override def growTable() =
+    val oldValues = values
+    super.growTable()
+    Array.copy(oldValues, 0, values, 0, oldValues.length)
+
+  def valuesIterator = values.iterator.take(size)
+
+  def iterator: Iterator[(Key, Int)] = keysIterator.zip(valuesIterator)
+
+  /** The value stored at index `i` */
+  def value(i: Int) = values(i)
+
+  /** Change the value stored at index `i` to `v` */
+  def setValue(i: Int, v: Int) = values(i) = v
+
+  override def toString =
+    iterator.map((k, v) => s"$k -> $v").mkString("IntMap(", ", ", ")")
+end IntMap
diff --git a/tests/pos-with-compiler-cc/dotc/util/LRUCache.scala b/tests/pos-with-compiler-cc/dotc/util/LRUCache.scala
new file mode 100644
index 000000000000..99ee8a80227b
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/util/LRUCache.scala
@@ -0,0 +1,104 @@
+package dotty.tools.dotc.util
+
+import scala.language.unsafeNulls
+
+import reflect.ClassTag
+import annotation.tailrec
+
+/** A least-recently-used cache for Key -> Value computations
+ *  It currently keeps the last 8 associations, but this can be
+ *  changed to anywhere between 2 and 16 by changing `LRUCache.Retained`.
+ *
+ *  Implementation: We keep a ring of eight places, linked
+ *  with the `next` data structure. The ring models a priority queue.
+ *  `last` points to the last element of the queue, and
+ *  `next(last)` to the first one. Lookups compare keys
+ *  sequentially from first to last. Elements with successful lookup
+ *  get promoted to be first in the queue. Elements are evicted
+ *  at the `last` position.
+ */
+class LRUCache[Key >: Null <: AnyRef : ClassTag, Value >: Null: ClassTag] {
+  import LRUCache._
+  val keys: Array[Key] = new Array[Key](Retained)
+  val values: Array[Value] = new Array(Retained)
+  var next: SixteenNibbles = new SixteenNibbles(initialRing.bits)
+  var last: Int = Retained - 1 // value is arbitrary
+  var lastButOne: Int = last - 1
+
+  def first: Int = next(last)
+
+  /** Lookup key, returning value or `null` for not found.
+   *  As a side effect, sets `lastButOne` to the element before `last`
+   *  if key was not found.
+   */
+  def lookup(key: Key): Value = {
+    @tailrec
+    def lookupNext(prev: Int, current: Int, nx: SixteenNibbles): Value = {
+      val follow = nx(current)
+      if (keys(current) eq key) {
+        // arrange so that found element is at position `first`.
+        if (current == last) last = prev
+        else if (prev != last) {
+          next = next.updated(prev, follow)
+          next = next.updated(current, first)
+          next = next.updated(last, current)
+        }
+        values(current)
+      }
+      else if (current == last) {
+        lastButOne = prev
+        null
+      }
+      else
+        lookupNext(current, follow, nx)
+    }
+    lookupNext(last, first, next)
+  }
+
+  /** Enter key/value in cache at position `last`.
+   *  As a side effect, sets `last` to `lastButOne`.
+   *  If `lastButOne` was set by a preceding unsuccessful `lookup`
+   *  for the same key, this means that the new element is now the
+   *  first in the queue. If there was no preceding lookup, the element
+   *  is inserted at a random position in the queue.
+   */
+  def enter(key: Key, value: Value): Unit = {
+    keys(last) = key
+    values(last) = value
+    last = lastButOne
+  }
+
+  /** Invalidate key. The invalidated element becomes
+   *  the last in the queue.
+   */
+  def invalidate(key: Key): Unit =
+    if (lookup(key) != null) {
+      keys(first) = null
+      last = first
+    }
+
+  def indices: Iterator[Int] = Iterator.iterate(first)(next.apply)
+
+  def keysIterator: Iterator[Key] =
+    indices take Retained map keys filter (_ != null)
+
+  override def toString: String = {
+    val assocs = keysIterator
+      .toList  // double reverse so that lookups do not perturb order
+      .reverse
+      .map(key => s"$key -> ${lookup(key)}")
+      .reverse
+    s"LRUCache(${assocs.mkString(", ")})"
+  }
+}
+
+object LRUCache {
+
+  /** The number of retained elements in the cache; must be at most 16. */
+  val Retained: Int = 16
+
+  /** The initial ring: 0 -> 1 -> ... -> 7 -> 0 */
+  val initialRing: SixteenNibbles =
+    (0 until Retained).foldLeft(new SixteenNibbles(0L))((nibbles, idx) =>
+      nibbles.updated(idx, (idx + 1) % Retained))
+}
diff --git a/tests/pos-with-compiler-cc/dotc/util/LinearMap.scala b/tests/pos-with-compiler-cc/dotc/util/LinearMap.scala
new file mode 100644
index 000000000000..28a5daaefdba
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/util/LinearMap.scala
@@ -0,0 +1,43 @@
+package dotty.tools.dotc.util
+
+import collection.immutable
+
+/** A linear map is a map where after an `updated` the previous map
+ *  value cannot be used anymore. The map is implemented as an immutable
+ *  map for sizes <= 4 (where immutable maps have specialized, compact
+ *  representations) and as a HashMap for larger sizes.
+ */
+opaque type LinearMap[K <: AnyRef, V <: AnyRef | Null] =
+  immutable.Map[K, V] | HashMap[K, V]
+
+object LinearMap:
+
+  def empty[K <: AnyRef, V <: AnyRef | Null]: LinearMap[K, V] =
+    immutable.Map.empty[K, V]
+
+  extension [K <: AnyRef, V <: AnyRef | Null](m: LinearMap[K, V])
+
+    def lookup(key: K): V | Null = (m: @unchecked) match
+      case m: immutable.AbstractMap[K, V] @unchecked =>
+        if m.contains(key) then m(key) else null
+      case m: HashMap[K, V] @unchecked =>
+        m.lookup(key)
+
+    def updated(key: K, value: V): LinearMap[K, V] = (m: @unchecked) match
+      case m: immutable.AbstractMap[K, V] @unchecked =>
+        if m.size < 4 then
+          m.updated(key, value)
+        else
+          val m1 = HashMap[K, V]()
+          m.foreach(m1(_) = _)
+          m1(key) = value
+          m1
+      case m: HashMap[K, V] @unchecked =>
+        m(key) = value
+        m
+
+    def size = (m: @unchecked) match
+      case m: immutable.AbstractMap[K, V] @unchecked => m.size
+      case m: HashMap[K, V] @unchecked => m.size
+
+end LinearMap
\ No newline at end of file
diff --git a/tests/pos-with-compiler-cc/dotc/util/LinearSet.scala b/tests/pos-with-compiler-cc/dotc/util/LinearSet.scala
new file mode 100644
index 000000000000..d057c4ebeda9
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/util/LinearSet.scala
@@ -0,0 +1,46 @@
+package dotty.tools.dotc.util
+
+import collection.immutable
+
+/** A linear set is a set where after a `+` the previous set value cannot be
+ *  used anymore. The set is implemented as an immutable set for sizes <= 4
+ *  and as a HashSet for larger sizes.
+ */
+opaque type LinearSet[Elem <: AnyRef | Null] =
+  immutable.Set[Elem] | HashSet[Elem]
+
+object LinearSet:
+
+  def empty[Elem <: AnyRef | Null]: LinearSet[Elem] = immutable.Set.empty[Elem]
+
+  extension [Elem <: AnyRef | Null](s: LinearSet[Elem])
+
+    def contains(elem: Elem): Boolean = (s: @unchecked) match
+      case s: immutable.AbstractSet[Elem] @unchecked => s.contains(elem)
+      case s: HashSet[Elem] @unchecked => s.contains(elem)
+
+    def + (elem: Elem): LinearSet[Elem] = (s: @unchecked) match
+      case s: immutable.AbstractSet[Elem] @unchecked =>
+        if s.size < 4 then
+          s + elem
+        else
+          val s1 = HashSet[Elem](initialCapacity = 8)
+          s.foreach(s1 += _)
+          s1 += elem
+          s1
+      case s: HashSet[Elem] @unchecked =>
+        s += elem
+        s
+
+    def - (elem: Elem): LinearSet[Elem] = (s: @unchecked) match
+      case s: immutable.AbstractSet[Elem] @unchecked =>
+        s - elem
+      case s: HashSet[Elem] @unchecked =>
+        s -= elem
+        s
+
+    def size = (s: @unchecked) match
+      case s: immutable.AbstractSet[Elem] @unchecked => s.size
+      case s: HashSet[Elem] @unchecked => s.size
+
+end LinearSet
\ No newline at end of file
diff --git a/tests/pos-with-compiler-cc/dotc/util/MutableMap.scala b/tests/pos-with-compiler-cc/dotc/util/MutableMap.scala
new file mode 100644
index 000000000000..ba912a312aea
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/util/MutableMap.scala
@@ -0,0 +1,18 @@
+package dotty.tools
+package dotc.util
+
+/** A common class for lightweight mutable maps.
+ */
+abstract class MutableMap[Key, Value] extends ReadOnlyMap[Key, Value]:
+
+  def update(k: Key, v: Value): Unit
+
+  def remove(k: Key): Value | Null
+
+  def -=(k: Key): this.type =
+    remove(k)
+    this
+
+  def clear(): Unit
+
+  def getOrElseUpdate(key: Key, value: => Value): Value
diff --git a/tests/pos-with-compiler-cc/dotc/util/MutableSet.scala b/tests/pos-with-compiler-cc/dotc/util/MutableSet.scala
new file mode 100644
index 000000000000..6e3ae7628eb6
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/util/MutableSet.scala
@@ -0,0 +1,25 @@
+package dotty.tools.dotc.util
+
+/** A common class for lightweight mutable sets.
+ */
+abstract class MutableSet[T] extends ReadOnlySet[T]:
+
+  /** Add element `x` to the set */
+  def +=(x: T): Unit
+
+  /** Like `+=` but return existing element equal to `x` of it exists,
+   *  `x` itself otherwise.
+   */
+  def put(x: T): T
+
+  /** Remove element `x` from the set */
+  def -=(x: T): Unit
+
+  def clear(): Unit
+
+  def ++= (xs: IterableOnce[T]): Unit =
+    xs.iterator.foreach(this += _)
+
+  def --= (xs: IterableOnce[T]): Unit =
+    xs.iterator.foreach(this -= _)
+
diff --git a/tests/pos-with-compiler-cc/dotc/util/NameTransformer.scala b/tests/pos-with-compiler-cc/dotc/util/NameTransformer.scala
new file mode 100644
index 000000000000..61cf238fbc7f
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/util/NameTransformer.scala
@@ -0,0 +1,151 @@
+package dotty.tools
+package dotc
+package util
+
+import scala.language.unsafeNulls
+
+import core.Names._
+
+import scala.annotation.internal.sharable
+
+/** Provides functions to encode and decode Scala symbolic names.
+ */
+object NameTransformer {
+
+  private val nops = 128
+  private val ncodes = 26 * 26
+
+  private class OpCodes(val op: Char, val code: String, val next: OpCodes)
+
+  @sharable private val op2code = new Array[String](nops)
+  @sharable private val code2op = new Array[OpCodes](ncodes)
+  private def enterOp(op: Char, code: String) = {
+    op2code(op.toInt) = code
+    val c = (code.charAt(1) - 'a') * 26 + code.charAt(2) - 'a'
+    code2op(c.toInt) = new OpCodes(op, code, code2op(c))
+  }
+
+  /* Note: decoding assumes opcodes are only ever lowercase. */
+  enterOp('~', "$tilde")
+  enterOp('=', "$eq")
+  enterOp('<', "$less")
+  enterOp('>', "$greater")
+  enterOp('!', "$bang")
+  enterOp('#', "$hash")
+  enterOp('%', "$percent")
+  enterOp('^', "$up")
+  enterOp('&', "$amp")
+  enterOp('|', "$bar")
+  enterOp('*', "$times")
+  enterOp('/', "$div")
+  enterOp('+', "$plus")
+  enterOp('-', "$minus")
+  enterOp(':', "$colon")
+  enterOp('\\', "$bslash")
+  enterOp('?', "$qmark")
+  enterOp('@', "$at")
+
+  /** Replace operator symbols by corresponding expansion strings, and replace
+   *  characters that are not valid Java identifiers by "$u" followed by the
+   *  character's unicode expansion.
+   *  Note that no attempt is made to escape the use of '$' in `name`: blindly
+   *  escaping them might make it impossible to call some platform APIs. This
+   *  unfortunately means that `decode(encode(name))` might not be equal to
+   *  `name`, this is considered acceptable since '$' is a reserved character in
+   *  the Scala spec as well as the Java spec.
+   */
+  def encode(name: SimpleName): SimpleName = {
+    var buf: StringBuilder = null
+    val len = name.length
+    var i = 0
+    while (i < len) {
+      val c = name(i)
+      if (c < nops && (op2code(c.toInt) ne null)) {
+        if (buf eq null) {
+          buf = new StringBuilder()
+          buf.append(name.sliceToString(0, i))
+        }
+        buf.append(op2code(c.toInt))
+      /* Handle glyphs that are not valid Java/JVM identifiers */
+      }
+      else if (!Character.isJavaIdentifierPart(c)) {
+        if (buf eq null) {
+          buf = new StringBuilder()
+          buf.append(name.sliceToString(0, i))
+        }
+        buf.append("$u%04X".format(c.toInt))
+      }
+      else if (buf ne null) {
+        buf.append(c)
+      }
+      i += 1
+    }
+    if (buf eq null) name else termName(buf.toString)
+  }
+
+  /** Replace operator expansions by the operators themselves,
+   *  and decode `$u....` expansions into unicode characters.
+   */
+  def decode(name: SimpleName): SimpleName = {
+    //System.out.println("decode: " + name);//DEBUG
+    var buf: StringBuilder = null
+    val len = name.length
+    var i = 0
+    while (i < len) {
+      var ops: OpCodes = null
+      var unicode = false
+      val c = name(i)
+      if (c == '$' && i + 2 < len) {
+        val ch1 = name(i + 1)
+        if ('a' <= ch1 && ch1 <= 'z') {
+          val ch2 = name(i + 2)
+          if ('a' <= ch2 && ch2 <= 'z') {
+            ops = code2op((ch1 - 'a') * 26 + ch2 - 'a')
+            while ((ops ne null) && !name.startsWith(ops.code, i)) ops = ops.next
+            if (ops ne null) {
+              if (buf eq null) {
+                buf = new StringBuilder()
+                buf.append(name.sliceToString(0, i))
+              }
+              buf.append(ops.op)
+              i += ops.code.length()
+            }
+            /* Handle the decoding of Unicode glyphs that are
+             * not valid Java/JVM identifiers */
+          } else if ((len - i) >= 6 && // Check that there are enough characters left
+                     ch1 == 'u' &&
+                     ((Character.isDigit(ch2)) ||
+                     ('A' <= ch2 && ch2 <= 'F'))) {
+            /* Skip past "$u", next four should be hexadecimal */
+            val hex = name.sliceToString(i+2, i+6)
+            try {
+              val str = Integer.parseInt(hex, 16).toChar
+              if (buf eq null) {
+                buf = new StringBuilder()
+                buf.append(name.sliceToString(0, i))
+              }
+              buf.append(str)
+              /* 2 for "$u", 4 for hexadecimal number */
+              i += 6
+              unicode = true
+            } catch {
+              case _:NumberFormatException =>
+                /* `hex` did not decode to a hexadecimal number, so
+                 * do nothing. */
+            }
+          }
+        }
+      }
+      /* If we didn't see an opcode or encoded Unicode glyph, and the
+        buffer is non-empty, write the current character and advance
+         one */
+      if ((ops eq null) && !unicode) {
+        if (buf ne null)
+          buf.append(c)
+        i += 1
+      }
+    }
+    //System.out.println("= " + (if (buf == null) name else buf.toString()));//DEBUG
+    if (buf eq null) name else termName(buf.toString)
+  }
+}
diff --git a/tests/pos-with-compiler-cc/dotc/util/ParsedComment.scala b/tests/pos-with-compiler-cc/dotc/util/ParsedComment.scala
new file mode 100644
index 000000000000..ac724f7e336f
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/util/ParsedComment.scala
@@ -0,0 +1,224 @@
+package dotty.tools.dotc.util
+
+import scala.language.unsafeNulls
+
+import dotty.tools.dotc.core.Comments.{Comment, CommentsContext}
+import dotty.tools.dotc.core.Contexts._
+import dotty.tools.dotc.core.Names.TermName
+import dotty.tools.dotc.core.Symbols._
+import dotty.tools.dotc.printing.SyntaxHighlighting
+
+import scala.Console.{BOLD, RESET}
+import scala.collection.immutable.ListMap
+
+/**
+ * A parsed doc comment.
+ *
+ * @param comment The doc comment to parse
+ */
+class ParsedComment(val comment: Comment) {
+
+  /**
+   * The bounds of a section that represents the [start; end[ char offset
+   * of the section within this comment's `content`.
+   */
+  private type Bounds = (Int, Int)
+
+  /** The content of this comment, after expansion if possible. */
+  val content: String = comment.expandedBody.getOrElse(comment.raw)
+
+  /** An index that marks all sections boundaries */
+  private lazy val tagIndex: List[Bounds] = CommentParsing.tagIndex(content)
+
+  /**
+   * Maps a parameter name to the bounds of its doc
+   *
+   * @see paramDoc
+   */
+  private lazy val paramDocs: Map[String, Bounds] = CommentParsing.paramDocs(content, "@param", tagIndex)
+
+  /**
+   * The "main" documentation for this comment. That is, the comment before any section starts.
+   */
+  lazy val mainDoc: String = {
+    val doc = tagIndex match {
+      case Nil => content.stripSuffix("*/")
+      case (start, _) :: _ => content.slice(0, start)
+    }
+    clean(doc.stripPrefix("/**"))
+  }
+
+  /**
+   * Renders this comment as markdown.
+   *
+   * The different sections are formatted according to the mapping in `knownTags`.
+   */
+  def renderAsMarkdown(using Context): String =
+    val buf = new StringBuilder
+    buf.append(mainDoc)
+    val groupedSections = CommentParsing.groupedSections(content, tagIndex)
+
+    val sections = for {
+      (tag, formatter) <- ParsedComment.knownTags
+      boundss <- groupedSections.get(tag)
+      texts = boundss.map { case (start, end) => clean(content.slice(start, end)) }
+      formatted <- formatter(texts)
+    } yield formatted
+
+    if sections.nonEmpty then
+      buf.append(System.lineSeparator + System.lineSeparator)
+      sections.foreach { section =>
+        buf.append(section)
+        buf.append(System.lineSeparator)
+      }
+    buf.toString
+  end renderAsMarkdown
+
+  /**
+   * The `@param` section corresponding to `name`.
+   *
+   * @param name The parameter name whose documentation to extract.
+   * @return The formatted documentation corresponding to `name`.
+   */
+  def paramDoc(name: TermName): Option[String] = paramDocs.get(name.toString).map { case (start, end) =>
+    val rawContent = content.slice(start, end)
+    val docContent = ParsedComment.prefixRegex.replaceFirstIn(rawContent, "")
+    clean(docContent)
+  }
+
+  /**
+   * Cleans `str`: remove prefixing `*` and trim the string.
+   *
+   * @param str The string to clean
+   * @return The cleaned string.
+   */
+  private def clean(str: String): String = str.stripMargin('*').trim
+}
+
+object ParsedComment {
+
+  /**
+   * Return the `ParsedComment` associated with `symbol`, if it exists.
+   *
+   * @param symbol The symbol for which to retrieve the documentation
+   * @return If it exists, the `ParsedComment` for `symbol`.
+   */
+  def docOf(symbol: Symbol)(using Context): Option[ParsedComment] = {
+    val documentedSymbol = if (symbol.isPrimaryConstructor) symbol.owner else symbol
+    for {
+      docCtx <- ctx.docCtx
+      comment <- docCtx.docstring(documentedSymbol)
+    }
+    yield new ParsedComment(comment)
+  }
+
+  @scala.annotation.internal.sharable
+  private val prefixRegex = """@param\s+\w+\s+""".r
+
+  /** A mapping from tag name to `TagFormatter` */
+  private val knownTags: ListMap[String, TagFormatter] = ListMap(
+    "@tparam"  -> TagFormatter("Type Parameters", toDescriptionList),
+    "@param"   -> TagFormatter("Parameters", toDescriptionList),
+    "@return"  -> TagFormatter("Returns", toMarkdownList),
+    "@throws"  -> TagFormatter("Throws", toDescriptionList),
+    "@see"     -> TagFormatter("See Also", toMarkdownList),
+    "@example" -> TagFormatter("Examples", toCodeFences("scala")),
+    "@note"    -> TagFormatter("Note", toMarkdownList),
+    "@author"  -> TagFormatter("Authors", toMarkdownList),
+    "@since"   -> TagFormatter("Since", toMarkdownList),
+    "@version" -> TagFormatter("Version", toMarkdownList)
+  )
+
+  /**
+   * Formats a list of items into a list describing them.
+   *
+   * Each element is assumed to consist of a first word, which is the item being described. The rest
+   * is the description of the item.
+   *
+   * @param items The items to format into a list.
+   * @return A markdown list of descriptions.
+   */
+  private def toDescriptionList(ctx: Context, items: List[String]): String = inContext(ctx) {
+    val formattedItems = items.map { p =>
+      val name :: rest = p.split(" ", 2).toList: @unchecked
+      s"${bold(name)} ${rest.mkString("").trim}"
+    }
+    toMarkdownList(ctx, formattedItems)
+  }
+
+  /**
+   * Formats a list of items into a markdown list.
+   *
+   * @param items The items to put in a list.
+   * @return The list of items, in markdown.
+   */
+  private def toMarkdownList(ctx: Context, items: List[String]): String = {
+    val formattedItems = items.map(_.linesIterator.mkString(System.lineSeparator + "   "))
+    formattedItems.mkString(" - ", System.lineSeparator + " - ", "")
+  }
+
+  /**
+   * If the color is enabled, add syntax highlighting to each of `snippets`, otherwise wrap each
+   * of them in a markdown code fence.
+   * The results are put into a markdown list.
+   *
+   * @param language The language to use for the code fences
+   * @param snippets The list of snippets to format.
+   * @return A markdown list of code fences.
+   * @see toCodeFence
+   */
+  private def toCodeFences(language: String)(ctx: Context, snippets: List[String]): String =
+    toMarkdownList(ctx, snippets.map(toCodeFence(language)(ctx, _)))
+
+  /**
+   * Formats `snippet` for display. If the color is enabled, the syntax is highlighted,
+   * otherwise the snippet is wrapped in a markdown code fence.
+   *
+   * @param language The language to use.
+   * @param snippet  The code snippet
+   * @return `snippet`, wrapped in a code fence.
+   */
+  private def toCodeFence(language: String)(ctx: Context, snippet: String): String = inContext(ctx) {
+    if colorEnabled then
+      SyntaxHighlighting.highlight(snippet)
+    else
+      s"""```$language
+         |$snippet
+         |```""".stripMargin
+  }
+
+  /**
+   * Format the elements of documentation associated with a given tag using `fn`, and starts the
+   * section with `title`.
+   *
+   * @param title The title to give to the formatted items.
+   * @param fn    The formatting function to use.
+   */
+  private case class TagFormatter(title: String, fn: (Context, List[String]) => String) {
+
+    /**
+     * Format `item` using `fn` if `items` is not empty.
+     *
+     * @param items The items to format
+     * @return If items is not empty, the items formatted using `fn`.
+     */
+    def apply(items: List[String])(using Context): Option[String] = items match {
+      case Nil =>
+        None
+      case items =>
+        Some(s"""${bold(title)}
+                |${fn(ctx, items)}
+                |""".stripMargin)
+    }
+  }
+
+  /** Is the color enabled in the context? */
+  private def colorEnabled(using Context): Boolean =
+    ctx.settings.color.value != "never"
+
+  /** Show `str` in bold */
+  private def bold(str: String)(using Context): String =
+    if (colorEnabled) s"$BOLD$str$RESET"
+    else s"**$str**"
+}
+
diff --git a/tests/pos-with-compiler-cc/dotc/util/PerfectHashing.scala b/tests/pos-with-compiler-cc/dotc/util/PerfectHashing.scala
new file mode 100644
index 000000000000..fca790837959
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/util/PerfectHashing.scala
@@ -0,0 +1,136 @@
+package dotty.tools.dotc.util
+
+object PerfectHashing:
+
+  /** The number of elements up to which dense packing is used.
+   *  If the number of elements reaches `DenseLimit` a hash table is used instead
+   */
+  inline val DenseLimit = 16
+
+/** A map that maps keys to unique integers in a dense interval starting at 0.
+ *  @param  initialCapacity  Indicates the initial number of slots in the hash table.
+ *                           The actual number of slots is always a power of 2, so the
+ *                           initial size of the table will be the smallest power of two
+ *                           that is equal or greater than the given `initialCapacity`.
+ *                           Minimum value is 4.
+ *  @param  capacityMultiple The minimum multiple of capacity relative to used elements.
+ *                           The hash table will be re-sized once the number of elements
+ *                           multiplied by capacityMultiple exceeds the current size of the hash table.
+ *                           However, a table of size up to DenseLimit will be re-sized only
+ *                           once the number of elements reaches the table's size.
+ */
+class PerfectHashing[Key](initialCapacity: Int = 8, capacityMultiple: Int = 2):
+  import PerfectHashing.DenseLimit
+
+  private var used: Int = _
+  private var table: Array[Int] = _
+  private var keys: Array[AnyRef] = _
+
+  clear()
+
+  protected def allocate(capacity: Int) =
+    keys = new Array[AnyRef](capacity)
+    if !isDense then
+      table = new Array[Int](capacity * roundToPower(capacityMultiple))
+
+  private def roundToPower(n: Int) =
+    if Integer.bitCount(n) == 1 then n
+    else 1 << (32 - Integer.numberOfLeadingZeros(n))
+
+  /** Remove keys from this map and set back to initial configuration */
+  def clear(): Unit =
+    used = 0
+    allocate(roundToPower(initialCapacity max 4))
+
+  /** The number of keys */
+  final def size: Int = used
+
+  /** The number of keys that can be stored without growing the tables */
+  final def capacity: Int = keys.length
+
+  private final def isDense = capacity <= DenseLimit
+
+  /** Hashcode, by default a post-processed versoon of `k.hashCode`,
+   *  can be overridden
+   */
+  protected def hash(k: Key): Int =
+    val h = k.hashCode
+    // Part of the MurmurHash3 32 bit finalizer
+    val i = (h ^ (h >>> 16)) * 0x85EBCA6B
+    val j = (i ^ (i >>> 13)) & 0x7FFFFFFF
+    if (j==0) 0x41081989 else j
+
+  /** Equality test, by default `equals`, can be overridden */
+  protected def isEqual(x: Key, y: Key): Boolean = x.equals(y)
+
+  private def matches(entry: Int, k: Key) = isEqual(key(entry), k)
+
+  private def tableIndex(x: Int): Int = x & (table.length - 1)
+  private def firstIndex(k: Key) = tableIndex(hash(k))
+  private def nextIndex(idx: Int) = tableIndex(idx + 1)
+
+  /** The key at index `idx` */
+  def key(idx: Int) = keys(idx).asInstanceOf[Key]
+  private def setKey(e: Int, k: Key) = keys(e) = k.asInstanceOf[AnyRef]
+
+  private def entry(idx: Int): Int = table(idx) - 1
+  private def setEntry(idx: Int, entry: Int) = table(idx) = entry + 1
+
+  /** An index `idx` such that `key(idx) == k`, or -1 if no such index exists */
+  def index(k: Key): Int =
+    if isDense then
+      var e = 0
+      while e < used do
+        if matches(e, k) then return e
+        e += 1
+      -1
+    else
+      var idx = firstIndex(k)
+      var e = entry(idx)
+      while e >= 0 && !matches(e, k) do
+        idx = nextIndex(idx)
+        e = entry(idx)
+      e
+
+  /** An index `idx` such that key(idx) == k.
+   *  If no such index exists, create an entry with an index one
+   *  larger than the previous one.
+   */
+  def add(k: Key): Int =
+    if isDense then
+      var e = 0
+      while e < used do
+        if matches(e, k) then return e
+        e += 1
+    else
+      var idx = firstIndex(k)
+      var e = entry(idx)
+      while e >= 0 do
+        if matches(e, k) then return e
+        idx = nextIndex(idx)
+        e = entry(idx)
+      setEntry(idx, used)
+    end if
+    setKey(used, k)
+    used = used + 1
+    if used == capacity then growTable()
+    used - 1
+
+  private def rehash(): Unit =
+    var e = 0
+    while e < used do
+      var idx = firstIndex(key(e))
+      while entry(idx) >= 0 do idx = nextIndex(idx)
+      setEntry(idx, e)
+      e += 1
+
+  /** Grow backing arrays */
+  protected def growTable(): Unit =
+    val oldKeys = keys
+    allocate(capacity * 2)
+    Array.copy(oldKeys, 0, keys, 0, oldKeys.length)
+    if !isDense then rehash()
+
+  def keysIterator: Iterator[Key] =
+    keys.iterator.take(used).asInstanceOf[Iterator[Key]]
+end PerfectHashing
diff --git a/tests/pos-with-compiler-cc/dotc/util/Property.scala b/tests/pos-with-compiler-cc/dotc/util/Property.scala
new file mode 100644
index 000000000000..ebcd43ae5a11
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/util/Property.scala
@@ -0,0 +1,18 @@
+package dotty.tools.dotc.util
+
+/** Defines a key type with which to tag properties, such as attachments
+ *  or context properties
+ */
+object Property {
+
+  /** The class of keys for properties of type V */
+  class Key[+V]
+
+  /**
+   * The class of keys for sticky properties of type V
+   *
+   * Sticky properties are properties that should be copied over when their container
+   * is copied.
+   */
+  class StickyKey[+V] extends Key[V]
+}
diff --git a/tests/pos-with-compiler-cc/dotc/util/ReadOnlyMap.scala b/tests/pos-with-compiler-cc/dotc/util/ReadOnlyMap.scala
new file mode 100644
index 000000000000..d24a9ab3ddb2
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/util/ReadOnlyMap.scala
@@ -0,0 +1,41 @@
+package dotty.tools
+package dotc.util
+
+/** A class for the reading part of mutable or immutable maps.
+ */
+abstract class ReadOnlyMap[Key, Value] extends caps.Pure:
+
+  def lookup(x: Key): Value | Null
+
+  def size: Int
+
+  def iterator: Iterator[(Key, Value)]
+  def keysIterator: Iterator[Key]
+  def valuesIterator: Iterator[Value]
+
+  def isEmpty: Boolean = size == 0
+
+  def get(key: Key): Option[Value] = lookup(key) match
+    case null => None
+    case v => Some(v.uncheckedNN)
+
+  def getOrElse(key: Key, value: => Value) = lookup(key) match
+    case null => value
+    case v => v.uncheckedNN
+
+  def contains(key: Key): Boolean = lookup(key) != null
+
+  def apply(key: Key): Value = lookup(key) match
+    case null => throw new NoSuchElementException(s"$key")
+    case v => v.uncheckedNN
+
+  def toArray: Array[(Key, Value)] =
+    val result = new Array[(Key, Value)](size)
+    var idx = 0
+    for pair <- iterator do
+      result(idx) = pair
+      idx += 1
+    result
+
+  def toSeq: Seq[(Key, Value)] = toArray.toSeq
+
diff --git a/tests/pos-with-compiler-cc/dotc/util/ReadOnlySet.scala b/tests/pos-with-compiler-cc/dotc/util/ReadOnlySet.scala
new file mode 100644
index 000000000000..318a04e846fe
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/util/ReadOnlySet.scala
@@ -0,0 +1,24 @@
+package dotty.tools.dotc.util
+
+/** A class for the readonly part of mutable sets.
+ */
+abstract class ReadOnlySet[T] extends caps.Pure:
+
+  /** The entry in the set such that `isEqual(x, entry)`, or else `null`. */
+  def lookup(x: T): T | Null
+
+  def size: Int
+
+  def iterator: Iterator[T]
+
+  def contains(x: T): Boolean = lookup(x) != null
+
+  def foreach[U](f: T => U): Unit = iterator.foreach(f)
+
+  def toList: List[T] = iterator.toList
+
+  def isEmpty = size == 0
+
+object ReadOnlySet:
+  def empty[T]: ReadOnlySet[T] = HashSet[T](4)
+
diff --git a/tests/pos-with-compiler-cc/dotc/util/ReusableInstance.scala b/tests/pos-with-compiler-cc/dotc/util/ReusableInstance.scala
new file mode 100644
index 000000000000..75addc916b78
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/util/ReusableInstance.scala
@@ -0,0 +1,34 @@
+package dotty.tools.dotc.util
+
+import scala.collection.mutable.ArrayBuffer
+import scala.util.chaining._
+import language.experimental.pureFunctions
+
+/** A wrapper for a list of cached instances of a type `T`.
+  * The wrapper is recursion-reentrant: several instances are kept, so
+  * at each depth of reentrance we are reusing the instance for that.
+  *
+  * An instance is created upon creating this object, and more instances
+  * are allocated dynamically, on demand, when reentrance occurs.
+  *
+  * Not thread safe.
+  *
+  * Ported from scala.reflect.internal.util.ReusableInstance
+  */
+final class ReusableInstance[T <: AnyRef] private (make: -> T) {
+  private[this] val cache = new ArrayBuffer[T](ReusableInstance.InitialSize).tap(_.addOne(make))
+  private[this] var taken = 0
+
+  inline def withInstance[R](action: T => R): R ={
+    if (taken == cache.size)
+      cache += make
+    taken += 1
+    try action(cache(taken-1)) finally taken -= 1
+  }
+}
+
+object ReusableInstance {
+  private inline val InitialSize = 4
+
+  def apply[T <: AnyRef](make: -> T): ReusableInstance[T] = new ReusableInstance[T](make)
+}
diff --git a/tests/pos-with-compiler-cc/dotc/util/ShowPickled.scala b/tests/pos-with-compiler-cc/dotc/util/ShowPickled.scala
new file mode 100644
index 000000000000..f85a57a8f812
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/util/ShowPickled.scala
@@ -0,0 +1,287 @@
+package dotty.tools.dotc
+package util
+
+import java.io.PrintStream
+import java.nio.charset.StandardCharsets
+import java.lang.Long.toHexString
+import java.lang.Float.intBitsToFloat
+import java.lang.Double.longBitsToDouble
+
+import core.unpickleScala2.PickleBuffer
+import core.Names._
+
+object ShowPickled {
+  import core.unpickleScala2.PickleFormat._
+
+  case class PickleBufferEntry(num: Int, startIndex: Int, tag: Int, bytes: Array[Byte]) {
+    def isName: Boolean = tag == TERMname || tag == TYPEname
+    def hasName: Boolean = tag match {
+      case TYPEsym | ALIASsym | CLASSsym | MODULEsym | VALsym | EXTref | EXTMODCLASSref => true
+      case _                                                                            => false
+    }
+    def readName: String =
+      if (isName) new String(bytes, StandardCharsets.UTF_8)
+      else sys.error("%s is no name" format tagName)
+    def nameIndex: Int =
+      if (hasName) readNat(bytes, 0)
+      else sys.error("%s has no name" format tagName)
+
+    def tagName: String = tag2string(tag)
+    override def toString: String = "%d,%d: %s".format(num, startIndex, tagName)
+  }
+
+  case class PickleBufferEntryList(entries: IndexedSeq[PickleBufferEntry]) {
+    def nameAt(idx: Int): String = {
+      val entry = entries(idx)
+      if (entry.isName) entry.readName
+      else if (entry.hasName) entries(entry.nameIndex).readName
+      else "?"
+    }
+  }
+
+  def makeEntryList(buf: PickleBuffer, index: Array[Int]): PickleBufferEntryList = {
+    val entries = buf.toIndexedSeq.zipWithIndex map {
+      case ((tag, data), num) => PickleBufferEntry(num, index(num), tag, data)
+    }
+
+    PickleBufferEntryList(entries)
+  }
+
+  def tag2string(tag: Int): String = tag match {
+    case TERMname       => "TERMname"
+    case TYPEname       => "TYPEname"
+    case NONEsym        => "NONEsym"
+    case TYPEsym        => "TYPEsym"
+    case ALIASsym       => "ALIASsym"
+    case CLASSsym       => "CLASSsym"
+    case MODULEsym      => "MODULEsym"
+    case VALsym         => "VALsym"
+    case EXTref         => "EXTref"
+    case EXTMODCLASSref => "EXTMODCLASSref"
+    case NOtpe          => "NOtpe"
+    case NOPREFIXtpe    => "NOPREFIXtpe"
+    case THIStpe        => "THIStpe"
+    case SINGLEtpe      => "SINGLEtpe"
+    case CONSTANTtpe    => "CONSTANTtpe"
+    case TYPEREFtpe     => "TYPEREFtpe"
+    case TYPEBOUNDStpe  => "TYPEBOUNDStpe"
+    case REFINEDtpe     => "REFINEDtpe"
+    case CLASSINFOtpe   => "CLASSINFOtpe"
+    case METHODtpe      => "METHODtpe"
+    case POLYtpe        => "POLYtpe"
+    case IMPLICITMETHODtpe => "METHODtpe" // IMPLICITMETHODtpe no longer used.
+    case SUPERtpe       => "SUPERtpe"
+    case LITERALunit    => "LITERALunit"
+    case LITERALboolean => "LITERALboolean"
+    case LITERALbyte    => "LITERALbyte"
+    case LITERALshort   => "LITERALshort"
+    case LITERALchar    => "LITERALchar"
+    case LITERALint     => "LITERALint"
+    case LITERALlong    => "LITERALlong"
+    case LITERALfloat   => "LITERALfloat"
+    case LITERALdouble  => "LITERALdouble"
+    case LITERALstring  => "LITERALstring"
+    case LITERALnull    => "LITERALnull"
+    case LITERALclass   => "LITERALclass"
+    case LITERALenum    => "LITERALenum"
+    case SYMANNOT       => "SYMANNOT"
+    case CHILDREN       => "CHILDREN"
+    case ANNOTATEDtpe   => "ANNOTATEDtpe"
+    case ANNOTINFO      => "ANNOTINFO"
+    case ANNOTARGARRAY  => "ANNOTARGARRAY"
+    // case DEBRUIJNINDEXtpe => "DEBRUIJNINDEXtpe"
+    case EXISTENTIALtpe => "EXISTENTIALtpe"
+    case TREE           => "TREE"
+    case MODIFIERS      => "MODIFIERS"
+
+    case _ => "***BAD TAG***(" + tag + ")"
+  }
+
+  /** Extremely regrettably, essentially copied from PickleBuffer.
+   */
+  def readNat(data: Array[Byte], index: Int): Int = {
+    var idx = index
+    var result = 0L
+    var b = 0L
+    while ({
+      b = data(idx)
+      idx += 1
+      result = (result << 7) + (b & 0x7f)
+      (b & 0x80) != 0L
+    })
+    ()
+    result.toInt
+  }
+
+  def printFile(buf: PickleBuffer, out: PrintStream = System.out.nn): Unit = {
+    out.println("Version " + buf.readNat() + "." + buf.readNat())
+    val index = buf.createIndex
+    val entryList = makeEntryList(buf, index)
+    buf.readIndex = 0
+
+    def p(s: String) = out print s
+
+    def printNameRef(): Unit = {
+      val idx = buf.readNat()
+      val name = entryList nameAt idx
+      val toPrint = " %s(%s)".format(idx, name)
+
+      out print toPrint
+    }
+
+    def printNat() = p(" " + buf.readNat())
+    def printReadNat(x: Int) = p(" " + x)
+
+    def printSymbolRef() = printNat()
+    def printTypeRef() = printNat()
+    def printConstantRef() = printNat()
+    def printAnnotInfoRef() = printNat()
+    def printConstAnnotArgRef() = printNat()
+    def printAnnotArgRef() = printNat()
+
+    def printSymInfo(end: Int, isType: Boolean): Unit = {
+      printNameRef()
+      printSymbolRef()
+      val pflags = buf.readLongNat()
+      def printFlags(privateWithin: Option[Int]) = {
+        val accessBoundary = (
+          for (idx <- privateWithin) yield {
+            val s = entryList nameAt idx
+            s"$idx($s)"
+          }
+        )
+        val flagString = PickleBuffer.unpickleScalaFlags(pflags, isType).toString
+        out.print(" %s[%s]".format(toHexString(pflags), flagString))
+      }
+
+      /** Might be info or privateWithin */
+      val x = buf.readNat()
+      if (buf.readIndex == end) {
+        printFlags(None)
+        printReadNat(x)
+      }
+      else {
+        printFlags(Some(x))
+        printTypeRef()
+      }
+    }
+
+    /** Note: the entries which require some semantic analysis to be correctly
+     *  interpreted are for the most part going to tell you the wrong thing.
+     *  It's not so easy to duplicate the logic applied in the UnPickler.
+     */
+    def printEntry(i: Int): Unit = {
+      buf.readIndex = index(i)
+      p(s"$i,${buf.readIndex}: ")
+      val tag = buf.readByte()
+      out.print(tag2string(tag))
+      val len = buf.readNat()
+      val end = len + buf.readIndex
+      p(s" $len:")
+      tag match {
+        case TERMname =>
+          out.print(" ")
+          out.print(termName(buf.bytes, buf.readIndex, len).toString)
+          buf.readIndex = end
+        case TYPEname =>
+          out.print(" ")
+          out.print(typeName(buf.bytes, buf.readIndex, len))
+          buf.readIndex = end
+        case TYPEsym | ALIASsym | CLASSsym | MODULEsym | VALsym =>
+          printSymInfo(end, tag == TYPEsym || tag == ALIASsym || tag == CLASSsym)
+          if (tag == CLASSsym && (buf.readIndex < end)) printTypeRef()
+        case EXTref | EXTMODCLASSref =>
+          printNameRef()
+          if (buf.readIndex < end) { printSymbolRef() }
+        case THIStpe =>
+          printSymbolRef()
+        case SINGLEtpe =>
+          printTypeRef(); printSymbolRef()
+        case CONSTANTtpe =>
+          printTypeRef(); printConstantRef()
+        case TYPEREFtpe =>
+          printTypeRef(); printSymbolRef(); buf.until(end, () =>  printTypeRef())
+        case TYPEBOUNDStpe =>
+          printTypeRef(); printTypeRef()
+        case REFINEDtpe =>
+          printSymbolRef(); buf.until(end, () =>  printTypeRef())
+        case CLASSINFOtpe =>
+          printSymbolRef(); buf.until(end, () =>  printTypeRef())
+        case METHODtpe | IMPLICITMETHODtpe =>
+          printTypeRef(); buf.until(end, () =>  printTypeRef())
+        case POLYtpe =>
+          printTypeRef(); buf.until(end, () => printSymbolRef())
+        case LITERALboolean =>
+          out.print(if (buf.readLong(len) == 0L) " false" else " true")
+        case LITERALbyte    =>
+          out.print(" " + buf.readLong(len).toByte)
+        case LITERALshort   =>
+          out.print(" " + buf.readLong(len).toShort)
+        case LITERALchar    =>
+          out.print(" " + buf.readLong(len).toChar)
+        case LITERALint     =>
+          out.print(" " + buf.readLong(len).toInt)
+        case LITERALlong    =>
+          out.print(" " + buf.readLong(len))
+        case LITERALfloat   =>
+          out.print(" " + intBitsToFloat(buf.readLong(len).toInt))
+        case LITERALdouble  =>
+          out.print(" " + longBitsToDouble(buf.readLong(len)))
+        case LITERALstring  =>
+          printNameRef()
+        case LITERALenum    =>
+          printSymbolRef()
+        case LITERALnull    =>
+          out.print(" <null>")
+        case LITERALclass   =>
+          printTypeRef()
+        case CHILDREN       =>
+          printSymbolRef(); buf.until(end, () => printSymbolRef())
+        case SYMANNOT       =>
+          printSymbolRef(); printTypeRef(); buf.until(end, () =>  printAnnotArgRef())
+        case ANNOTATEDtpe   =>
+          printTypeRef(); buf.until(end, () => printAnnotInfoRef())
+        case ANNOTINFO      =>
+          printTypeRef(); buf.until(end, () =>  printAnnotArgRef())
+        case ANNOTARGARRAY  =>
+          buf.until(end, () => printConstAnnotArgRef())
+        case EXISTENTIALtpe =>
+          printTypeRef(); buf.until(end, () => printSymbolRef())
+
+        case _ =>
+      }
+      out.println()
+      if (buf.readIndex != end)
+        out.println("BAD ENTRY END: computed = %d, actual = %d, bytes = %s".format(
+          end, buf.readIndex, buf.bytes.slice(index(i), (end max buf.readIndex)).mkString(", ")
+        ))
+    }
+
+    for (i <- 0 until index.length) printEntry(i)
+  }
+}
+
+/*
+ *
+  def fromFile(path: String) = fromBytes(io.File(path).toByteArray)
+  def fromName(name: String) = fromBytes(scalaSigBytesForPath(name) getOrElse Array())
+  def fromBytes(data: => Array[Byte]): Option[PickleBuffer] =
+    try Some(new PickleBuffer(data, 0, data.length))
+    catch { case _: Exception => None }
+
+  def show(what: String, pickle: PickleBuffer) = {
+    Console.println(what)
+    val saved = pickle.readIndex
+    pickle.readIndex = 0
+    printFile(pickle, Console.out)
+    pickle.readIndex = saved
+  }
+
+  def main(args: Array[String]) {
+    args foreach { arg =>
+      (fromFile(arg) orElse fromName(arg)) match {
+        case Some(pb) => show(arg + ":", pb)
+        case _        => Console.println("Cannot read " + arg)
+      }
+    }
+  }*/
diff --git a/tests/pos-with-compiler-cc/dotc/util/Signatures.scala b/tests/pos-with-compiler-cc/dotc/util/Signatures.scala
new file mode 100644
index 000000000000..ddf89e7dd04d
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/util/Signatures.scala
@@ -0,0 +1,549 @@
+package dotty.tools.dotc
+package util
+
+import ast.Trees._
+import ast.tpd
+import core.Constants.Constant
+import core.Contexts._
+import core.Denotations.{SingleDenotation, Denotation}
+import core.Flags
+import core.NameOps.isUnapplyName
+import core.Names._
+import core.NameKinds
+import core.Types._
+import core.Symbols.NoSymbol
+import interactive.Interactive
+import util.Spans.Span
+import reporting._
+
+
+object Signatures {
+
+  /**
+   * Represent a method signature.
+   *
+   * @param name       The name of the method
+   * @param tparams    The type parameters and their bounds
+   * @param paramss    The parameter lists of this method
+   * @param returnType The return type of this method, if this is not a constructor.
+   * @param doc        The documentation for this method.
+   * @param denot      The function denotation
+   */
+  case class Signature(
+    name: String,
+    tparams: List[String],
+    paramss: List[List[Param]],
+    returnType: Option[String],
+    doc: Option[String] = None,
+    denot: Option[SingleDenotation] = None
+  )
+
+  /**
+   * Represent a method's parameter.
+   *
+   * @param name       The name of the parameter
+   * @param tpe        The type of the parameter
+   * @param doc        The documentation of this parameter
+   * @param isImplicit Is this parameter implicit?
+   */
+  case class Param(name: String, tpe: String, doc: Option[String] = None, isImplicit: Boolean = false) {
+    def show: String = if name.nonEmpty then s"$name: $tpe" else tpe
+  }
+
+  /**
+   * Extract (current parameter index, function index, functions) method call for given position.
+   *
+   * @param path The path to the function application
+   * @param span The position of the cursor
+   *
+   * @return     A triple containing the index of the parameter being edited, the index of functeon
+   *         being called, the list of overloads of this function).
+   */
+  def signatureHelp(path: List[tpd.Tree], pos: Span)(using Context): (Int, Int, List[Signature]) =
+    computeSignatureHelp(path, pos)
+
+  /**
+   * Extract (current parameter index, function index, functions) out of a method call.
+   *
+   * @param path The path to the function application
+   * @param span The position of the cursor
+   *
+   * @return     A triple containing the index of the parameter being edited, the index of the function
+   *         being called, the list of overloads of this function).
+   */
+  @deprecated(
+    """This method is deprecated in favor of `signatureHelp`.
+       Returned denotation cannot be distinguished if its unapply or apply context""",
+    "3.1.3"
+  )
+  def callInfo(path: List[tpd.Tree], span: Span)(using Context): (Int, Int, List[SingleDenotation]) =
+    val (paramN, funN, signatures) = computeSignatureHelp(path, span)
+    (paramN, funN, signatures.flatMap(_.denot))
+
+  /**
+   * Computes call info (current parameter index, function index, functions) for a method call.
+   *
+   * @param path The path to the function application
+   * @param span The position of the cursor
+   *
+   * @return A triple containing the index of the parameter being edited, the index of the function
+   *         being called, the list of overloads of this function).
+   */
+  def computeSignatureHelp(path: List[tpd.Tree], span: Span)(using Context): (Int, Int, List[Signature]) =
+    findEnclosingApply(path, span) match
+      case Apply(fun, params) => applyCallInfo(span, params, fun)
+      case UnApply(fun, _, patterns) => unapplyCallInfo(span, fun, patterns)
+      case appliedTypeTree @ AppliedTypeTree(_, types) => appliedTypeTreeCallInfo(appliedTypeTree, types)
+      case tp @ TypeApply(fun, types) => applyCallInfo(span, types, fun, true)
+      case _ => (0, 0, Nil)
+
+  /**
+   * Finds enclosing application from given `path` for `span`.
+   *
+   * @param path The path to the function application
+   * @param span The position of the cursor
+   *
+   * @return Tree which encloses closest application containing span.
+   *         In case if cursor is pointing on closing parenthesis and
+   *         next subsequent application exists, it returns the latter
+   */
+  private def findEnclosingApply(path: List[tpd.Tree], span: Span)(using Context): tpd.Tree =
+    path.filterNot {
+      case apply @ Apply(fun, _) => fun.span.contains(span) || isValid(apply)
+      case unapply @ UnApply(fun, _, _) => fun.span.contains(span) || isValid(unapply)
+      case typeTree @ AppliedTypeTree(fun, _) => fun.span.contains(span) || isValid(typeTree)
+      case typeApply @ TypeApply(fun, _) => fun.span.contains(span) || isValid(typeApply)
+      case _ => true
+    } match {
+      case Nil => tpd.EmptyTree
+      case direct :: enclosing :: _ if isClosingSymbol(direct.source(span.end -1)) => enclosing
+      case direct :: _ => direct
+    }
+
+  private def isClosingSymbol(ch: Char) = ch == ')' || ch == ']'
+
+  /**
+   * Extracts call information for applied type tree:
+   *
+   * @param types Currently applied function type parameters
+   * @param fun   Function tree which is being applied
+   */
+  private def appliedTypeTreeCallInfo(
+    fun: tpd.Tree,
+    types: List[tpd.Tree]
+  )(using Context): (Int, Int, List[Signature]) =
+    val typeName = fun.symbol.name.show
+    val typeParams = fun.symbol.typeRef.typeParams.map(_.paramName.show)
+    val denot = fun.denot.asSingleDenotation
+    val activeParameter = (types.length - 1) max 0
+
+    val signature = Signature(typeName, typeParams, Nil, Some(typeName) , None, Some(denot))
+    (activeParameter, 0, List(signature))
+
+  /**
+   * Extracts call information for a function application and type application.
+   *
+   * @param span        The position of the cursor
+   * @param params      Current function parameters
+   * @param fun         Function tree which is being applied
+   * @param isTypeApply Is a type application
+   * @return A triple containing the index of the parameter being edited, the index of the function
+   *         being called, the list of overloads of this function).
+   */
+  private def applyCallInfo(
+    span: Span,
+    params: List[tpd.Tree],
+    fun: tpd.Tree,
+    isTypeApply: Boolean = false
+  )(using Context): (Int, Int, List[Signature]) =
+    def treeQualifier(tree: tpd.Tree): tpd.Tree = tree match
+        case Apply(qual, _) => treeQualifier(qual)
+        case TypeApply(qual, _) => treeQualifier(qual)
+        case AppliedTypeTree(qual, _) => treeQualifier(qual)
+        case Select(qual, _) => qual
+        case _ => tree
+
+    val (alternativeIndex, alternatives) = fun.tpe match
+      case err: ErrorType =>
+        val (alternativeIndex, alternatives) = alternativesFromError(err, params) match
+          // if we have no alternatives from error, we have to fallback to function denotation
+          // Check `partialyFailedCurriedFunctions` test for example
+          case (_, Nil) =>
+            val denot = fun.denot
+            if denot.exists then
+              (0, List(denot.asSingleDenotation))
+            else
+              (0, Nil)
+          case other => other
+        (alternativeIndex, alternatives)
+      case _ =>
+        val funSymbol = fun.symbol
+        val alternatives = funSymbol.owner.info.member(funSymbol.name).alternatives
+        val alternativeIndex = alternatives.map(_.symbol).indexOf(funSymbol) max 0
+        (alternativeIndex, alternatives)
+
+    if alternativeIndex < alternatives.length then
+      val curriedArguments = countParams(fun, alternatives(alternativeIndex))
+      // We have to shift all arguments by number of type parameters to properly show activeParameter index
+      val typeParamsShift = if !isTypeApply then fun.symbol.denot.paramSymss.flatten.filter(_.isType).length else 0
+      val paramIndex = params.indexWhere(_.span.contains(span)) match
+        case -1 => (params.length - 1 max 0) + curriedArguments + typeParamsShift
+        case n => n + curriedArguments + typeParamsShift
+
+      val pre = treeQualifier(fun)
+      val alternativesWithTypes = alternatives.map(_.asSeenFrom(pre.tpe.widenTermRefExpr))
+      val alternativeSignatures = alternativesWithTypes.flatMap(toApplySignature)
+
+      (paramIndex, alternativeIndex, alternativeSignatures)
+    else
+      (0, 0, Nil)
+
+  /**
+   * Extracts call informatioin for function in unapply context.
+   *
+   * @param span   The position of the cursor
+   * @param params Current function parameters
+   * @param fun    Unapply function tree
+   *
+   * @return A triple containing the index of the parameter being edited, the index of the function
+   *         being called, the list of overloads of this function).
+   */
+  private def unapplyCallInfo(
+    span: Span,
+    fun: tpd.Tree,
+    patterns: List[tpd.Tree]
+  )(using Context): (Int, Int, List[Signature]) =
+    val resultType = unapplyMethodResult(fun)
+    val isUnapplySeq = fun.denot.name == core.Names.termName("unapplySeq")
+    val denot = fun.denot.mapInfo(_ => resultType)
+
+    val paramTypes = extractParamTypess(resultType, denot, patterns.size).flatten.map(stripAllAnnots)
+    val paramNames = extractParamNamess(resultType, denot).flatten
+
+    val activeParameter = unapplyParameterIndex(patterns, span, paramTypes.length)
+    val unapplySignature = toUnapplySignature(denot.asSingleDenotation, paramNames, paramTypes).toList
+
+    (activeParameter, 0, unapplySignature)
+
+
+  private def isUnapplySeq(denot: Denotation)(using Context): Boolean =
+    denot.name == core.Names.termName("unapplySeq")
+
+  /**
+   * Extract parameter names from `resultType` only if `resultType` is case class and `denot` is synthetic.
+   *
+   * @param resultType Function result type
+   * @param denot      Function denotation
+   *
+   * @return List of lists of names of parameters if `resultType` is case class without overriden unapply
+   */
+  private def extractParamNamess(resultType: Type, denot: Denotation)(using Context): List[List[Name]] =
+    if resultType.typeSymbol.flags.is(Flags.CaseClass) && denot.symbol.flags.is(Flags.Synthetic) then
+      resultType.typeSymbol.primaryConstructor.paramInfo.paramNamess
+    else
+      Nil
+
+  /**
+   * Extract parameter types from `resultType` in unapply context.
+   *
+   * @param resultType   Function result type
+   * @param denot        Function denotation
+   * @param patternsSize Number of pattern trees present in function tree
+   *
+   * @return List of lists of types present in unapply clause
+   */
+  private def extractParamTypess(
+    resultType: Type,
+    denot: Denotation,
+    patternsSize: Int
+  )(using Context): List[List[Type]] =
+    resultType match
+      // unapply(_$1: Any): CustomClass
+      case ref: TypeRef if !ref.symbol.isPrimitiveValueClass => mapOptionLessUnapply(ref, patternsSize, isUnapplySeq(denot))
+      // unapply(_$1: Any): Option[T[_]]
+      case AppliedType(TypeRef(_, cls), (appliedType @ AppliedType(tycon, args)) :: Nil)
+          if (cls == ctx.definitions.OptionClass || cls == ctx.definitions.SomeClass) =>
+        tycon match
+          // unapply[T](_$1: Any): Option[(T1, T2 ... Tn)]
+          case typeRef: TypeRef if ctx.definitions.isTupleClass(typeRef.symbol) => List(args)
+          case _ => List(List(appliedType))
+      // unapply[T](_$1: Any): CustomClass[T]
+      case appliedType: AppliedType => mapOptionLessUnapply(appliedType, patternsSize, isUnapplySeq(denot))
+      case _ => Nil
+
+  /**
+   * Recursively strips annotations from given type
+   *
+   * @param tpe Type to strip annotations from
+   * @return Type with stripped annotations
+   */
+  private def stripAllAnnots(tpe: Type)(using Context): Type = tpe match
+    case AppliedType(t, args) => AppliedType(stripAllAnnots(t), args.map(stripAllAnnots))
+    case other => other.stripAnnots
+
+  /**
+   * Get index of currently edited parameter in unapply context.
+   *
+   * @param patterns Currently applied patterns for unapply method
+   * @param span The position of the cursor
+   * @param maximumParams Number of parameters taken by unapply method
+   * @return Index of currently edited parameter
+   */
+  private def unapplyParameterIndex(patterns: List[tpd.Tree], span: Span, maximumParams: Int)(using Context): Int =
+    val patternPosition = patterns.indexWhere(_.span.contains(span))
+    (patternPosition, patterns.length) match
+      case (-1, 0) => 0 // there are no patterns yet so it must be first one
+      case (-1, pos) => -1 // there are patterns, we must be outside range so we set no active parameter
+      case _ => (maximumParams - 1) min patternPosition max 0 // handle unapplySeq to always highlight Seq[A] on elements
+
+  /**
+   * Checks if tree is valid for signatureHelp. Skipped trees are either tuple type or function type
+   *
+   * @param tree tree to validate
+   */
+  private def isValid(tree: tpd.Tree)(using Context): Boolean =
+    ctx.definitions.isTupleNType(tree.tpe) || ctx.definitions.isFunctionType(tree.tpe)
+
+  /**
+   * Get unapply method result type omiting unknown types and another method calls.
+   *
+   * @param fun Unapply tree
+   *
+   * @return Proper unapply method type after extracting result from method types and omiting unknown types.
+   */
+  private def unapplyMethodResult(fun: tpd.Tree)(using Context): Type =
+    val typeWithoutBinds = fun match
+      case TypeApply(_, Bind(_, _) :: _) => fun.symbol.asSingleDenotation.info
+      case other => other.tpe
+
+    typeWithoutBinds.finalResultType.widenDealias match
+      case methodType: MethodType => methodType.resultType.widen
+      case other => other
+
+  /**
+   *  Maps type by checking if given match is single match, name-based match, sequence match or product sequence match.
+   *  The precedence in higher priority - higher index order for fixed-arity extractors is:
+   *    1. Single match
+   *    2. Name based match
+   *  For variadic extractors:
+   *    1. Sequence match
+   *    2. Product sequence match
+   *
+   *  @see [[https://docs.scala-lang.org/scala3/reference/changed-features/pattern-matching.html]]
+   *
+   *  @param resultType   Final result type for unapply
+   *  @param patternCount Currently applied patterns to unapply function
+   *  @param isUnapplySeq true if unapply name equals "unapplySeq", false otherwise
+   *
+   *  @return List of List of types dependent on option less extractor type.
+   */
+  private def mapOptionLessUnapply(
+    resultType: Type,
+    patternCount: Int,
+    isUnapplySeq: Boolean
+  )(using Context): List[List[Type]] =
+    val productAccessors = resultType.memberDenots(
+      underscoreMembersFilter,
+      (name, buf) => buf += resultType.member(name).asSingleDenotation
+    )
+
+    val getMethod = resultType.member(core.Names.termName("get"))
+    val dropMethod = resultType.member(core.Names.termName("drop"))
+
+    val availableExtractors =
+      if isUnapplySeq && dropMethod.exists then
+        List(dropMethod)
+      else if getMethod.exists && patternCount <= 1 then
+        List(getMethod)
+      else
+        productAccessors
+
+    List(availableExtractors.map(_.info.finalResultType).toList)
+
+  /**
+   * Filter returning only members starting with underscore followed with number
+   */
+  private object underscoreMembersFilter extends NameFilter {
+    def apply(pre: Type, name: Name)(using Context): Boolean =
+      name.startsWith("_") && name.toString.drop(1).toIntOption.isDefined
+    def isStable = true
+  }
+
+  /**
+   * Creates signature for apply method.
+   *
+   * @param denot Function denotation for which apply signature is returned.
+   *
+   * @return Signature if denot is a function, None otherwise
+   */
+  private def toApplySignature(denot: SingleDenotation)(using Context): Option[Signature] = {
+    val symbol = denot.symbol
+    val docComment = ParsedComment.docOf(symbol)
+
+    def isDummyImplicit(res: MethodType): Boolean =
+      res.resultType.isParameterless &&
+        res.isImplicitMethod &&
+        res.paramInfos.forall(info =>
+          info.classSymbol.derivesFrom(ctx.definitions.DummyImplicitClass))
+
+    def toParamss(tp: Type)(using Context): List[List[Param]] =
+      val rest = tp.resultType match
+        case res: MethodType => if isDummyImplicit(res) then Nil else toParamss(res)
+        case _ => Nil
+
+      val currentParams = (tp.paramNamess, tp.paramInfoss) match
+        case (params :: _, infos :: _) => params zip infos
+        case _ => Nil
+
+      val params = currentParams.map { (name, info) =>
+          Signatures.Param(
+            name.show,
+            info.widenTermRefExpr.show,
+            docComment.flatMap(_.paramDoc(name)),
+            isImplicit = tp.isImplicitMethod
+          )
+        }
+
+      (params :: rest)
+
+    def isSyntheticEvidence(name: String) =
+      if !name.startsWith(NameKinds.EvidenceParamName.separator) then false else
+        symbol.paramSymss.flatten.find(_.name.show == name).exists(_.flags.is(Flags.Implicit))
+
+    denot.info.stripPoly match
+      case tpe: (MethodType | AppliedType | TypeRef | TypeParamRef) =>
+        val paramss = toParamss(tpe).map(_.filterNot(param => isSyntheticEvidence(param.name)))
+        val evidenceParams = (tpe.paramNamess.flatten zip tpe.paramInfoss.flatten).flatMap {
+          case (name, AppliedType(tpe, (ref: TypeParamRef) :: _)) if isSyntheticEvidence(name.show) =>
+            Some(ref.paramName -> tpe)
+          case _ => None
+        }
+
+        val typeParams = denot.info match
+          case poly: PolyType =>
+            val tparams = poly.paramNames.zip(poly.paramInfos)
+            tparams.map { (name, info) =>
+              evidenceParams.find((evidenceName: TypeName, _: Type) => name == evidenceName).flatMap {
+                case (_, tparam) => tparam.show.split('.').lastOption
+              } match {
+                case Some(evidenceTypeName) => s"${name.show}: ${evidenceTypeName}"
+                case None => name.show + info.show
+              }
+            }
+          case _ => Nil
+        val (name, returnType) =
+          if (symbol.isConstructor) then
+            (symbol.owner.name.show, None)
+          else
+            (denot.name.show, Some(tpe.finalResultType.widenTermRefExpr.show))
+        Some(Signatures.Signature(name, typeParams, paramss, returnType, docComment.map(_.mainDoc), Some(denot)))
+      case other => None
+  }
+
+  @deprecated("Deprecated in favour of `signatureHelp` which now returns Signature along SingleDenotation", "3.1.3")
+  def toSignature(denot: SingleDenotation)(using Context): Option[Signature] = {
+    if denot.name.isUnapplyName then
+      val resultType = denot.info.stripPoly.finalResultType match
+        case methodType: MethodType => methodType.resultType.widen
+        case other => other
+
+      // We can't get already applied patterns so we won't be able to get proper signature in case when
+      // it can be both name-based or single match extractor. See test `nameBasedTest`
+      val paramTypes = extractParamTypess(resultType, denot, 0).flatten.map(stripAllAnnots)
+      val paramNames = extractParamNamess(resultType, denot).flatten
+
+      toUnapplySignature(denot.asSingleDenotation, paramNames, paramTypes)
+    else
+      toApplySignature(denot)
+  }
+
+  /**
+   * Creates signature for unapply method. It is different from apply one as it should not show function name,
+   * return type and type parameters. Instead we show function in the following pattern (_$1: T1, _$2: T2, _$n: Tn),
+   * where _$n is only present for synthetic product extractors such as case classes.
+   * In rest of cases signature skips them resulting in pattern (T1, T2, T3, Tn)
+   *
+   * @param denot      Unapply denotation
+   * @param paramNames Parameter names for unapply final result type.
+   *                     It non empty only when unapply returns synthetic product as for case classes.
+   * @param paramTypes Parameter types for unapply final result type.
+   *
+   * @return Signature if paramTypes is non empty, None otherwise
+   */
+  private def toUnapplySignature(denot: SingleDenotation, paramNames: List[Name], paramTypes: List[Type])(using Context): Option[Signature] =
+    val params = if paramNames.length == paramTypes.length then
+      (paramNames zip paramTypes).map((name, info) => Param(name.show, info.show))
+    else
+      paramTypes.map(info => Param("", info.show))
+
+    if params.nonEmpty then
+      Some(Signature("", Nil, List(params), None, None, Some(denot)))
+    else
+      None
+
+  /**
+   * The number of parameters before `tree` application. It is necessary to properly show
+   * parameter number for erroneous applications before current one.
+   *
+   * This handles currying, so for an application such as `foo(1, 2)(3)`, the result of
+   * `countParams` should be 3. It also takes into considerations unapplied arguments so for `foo(1)(3)`
+   * we will still get 3, as first application `foo(1)` takes 2 parameters with currently only 1 applied.
+   *
+   * @param tree           The tree to inspect.
+   * @param denot          Denotation of function we are trying to apply
+   * @param alreadyCurried Number of subsequent Apply trees before current tree
+   *
+   * @return The number of parameters that are passed.
+   */
+  private def countParams(tree: tpd.Tree, denot: SingleDenotation, alreadyCurried: Int = 0)(using Context): Int =
+    tree match
+      case Apply(fun, params) =>
+         countParams(fun, denot, alreadyCurried + 1) + denot.symbol.paramSymss(alreadyCurried).length
+      case _ => 0
+
+  /**
+   * Inspect `err` to determine, if it is an error related to application of an overloaded
+   * function, what were the possible alternatives.
+   *
+   * If several alternatives are found, determines what is the best suited alternatives
+   * given the parameters `params`: The alternative that has the most formal parameters
+   * matching the given arguments is chosen.
+   *
+   * @param err    The error message to inspect.
+   * @param params The parameters that were given at the call site.
+   *
+   * @return A pair composed of the index of the best alternative (0 if no alternatives
+   *         were found), and the list of alternatives.
+   */
+  private def alternativesFromError(err: ErrorType, params: List[tpd.Tree])(using Context): (Int, List[SingleDenotation]) = {
+    val alternatives =
+      err.msg match
+        case msg: AmbiguousOverload  => msg.alternatives
+        case msg: NoMatchingOverload => msg.alternatives
+        case _                       => Nil
+
+    // If the user writes `foo(bar, <cursor>)`, the typer will insert a synthetic
+    // `null` parameter: `foo(bar, null)`. This may influence what's the "best"
+    // alternative, so we discard it.
+    val userParams = params match
+      case xs :+ (nul @ Literal(Constant(null))) if nul.span.isZeroExtent => xs
+      case _ => params
+    val userParamsTypes = userParams.map(_.tpe)
+
+    // Assign a score to each alternative (how many parameters are correct so far), and
+    // use that to determine what is the current active signature.
+    val alternativesScores = alternatives.map { alt =>
+      alt.info.stripPoly match
+        case tpe: MethodType =>
+          userParamsTypes.zip(tpe.paramInfos).takeWhile{ case (t0, t1) => t0 <:< t1 }.size
+        case _ => 0
+    }
+    val bestAlternative =
+      if (alternativesScores.isEmpty) 0
+      else alternativesScores.zipWithIndex.maxBy(_._1)._2
+
+    (bestAlternative, alternatives)
+  }
+}
+
+
diff --git a/tests/pos-with-compiler-cc/dotc/util/SimpleIdentityMap.scala b/tests/pos-with-compiler-cc/dotc/util/SimpleIdentityMap.scala
new file mode 100644
index 000000000000..2b4aa6eda48e
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/util/SimpleIdentityMap.scala
@@ -0,0 +1,246 @@
+package dotty.tools.dotc.util
+
+import collection.mutable.ListBuffer
+
+/** A simple linked map with `eq` as the key comparison, optimized for small maps.
+ *  It has linear complexity for `apply`, `updated`, and `remove`.
+ */
+sealed abstract class SimpleIdentityMap[K <: AnyRef, +V <: AnyRef] extends (K => V | Null) {
+  final def isEmpty: Boolean = this eq SimpleIdentityMap.myEmpty
+  def size: Int
+  def apply(k: K): V | Null
+  def remove(k: K): SimpleIdentityMap[K, V]
+  def updated[V1 >: V <: AnyRef](k: K, v: V1): SimpleIdentityMap[K, V1]
+  def contains(k: K): Boolean = apply(k) != null
+  def mapValuesNow[V1 >: V <: AnyRef](f: (K, V1) => V1): SimpleIdentityMap[K, V1]
+  def foreachBinding(f: (K, V) => Unit): Unit
+  def forallBinding(f: (K, V) => Boolean): Boolean
+  def map2[T](f: (K, V) => T): List[T] = {
+    val buf = new ListBuffer[T]
+    foreachBinding((k, v) => buf += f(k, v))
+    buf.toList
+  }
+  def keys: List[K] = map2((k, v) => k)
+  def toList: List[(K, V)] = map2((k, v) => (k, v))
+  override def toString: String = {
+    def assocToString(key: K, value: V) = s"$key -> $value"
+    map2(assocToString) mkString ("(", ", ", ")")
+  }
+}
+
+object SimpleIdentityMap {
+
+  private val CompactifyThreshold = 4
+
+  private object myEmpty extends SimpleIdentityMap[AnyRef, Nothing] {
+    def size = 0
+    def apply(k: AnyRef) = null
+    def remove(k: AnyRef) = this
+    def updated[V1 <: AnyRef](k: AnyRef, v: V1) = new Map1(k, v)
+    def mapValuesNow[V1 <: AnyRef](f: (AnyRef, V1) => V1) = this
+    def foreachBinding(f: (AnyRef, Nothing) => Unit) = ()
+    def forallBinding(f: (AnyRef, Nothing) => Boolean) = true
+  }
+
+  def empty[K <: AnyRef]: SimpleIdentityMap[K, Nothing] = myEmpty.asInstanceOf[SimpleIdentityMap[K, Nothing]]
+
+  class Map1[K <: AnyRef, +V <: AnyRef] (k1: K, v1: V) extends SimpleIdentityMap[K, V] {
+    def size: Int = 1
+    def apply(k: K): V | Null =
+      if (k eq k1) v1
+      else null
+    def remove(k: K): SimpleIdentityMap[K, V] =
+      if (k eq k1) empty
+      else this
+    def updated[V1 >: V <: AnyRef](k: K, v: V1): SimpleIdentityMap[K, V1] =
+      if (k eq k1) new Map1(k, v)
+      else new Map2(k1, v1, k, v)
+    def mapValuesNow[V1 >: V <: AnyRef](f: (K, V1) => V1): SimpleIdentityMap[K, V1] = {
+      val w1 = f(k1, v1)
+      if (v1 eq w1) this else new Map1(k1, w1)
+    }
+    def foreachBinding(f: (K, V) => Unit): Unit = f(k1, v1)
+    def forallBinding(f: (K, V) => Boolean): Boolean = f(k1, v1)
+  }
+
+  class Map2[K <: AnyRef, +V <: AnyRef] (k1: K, v1: V, k2: K, v2: V) extends SimpleIdentityMap[K, V] {
+    def size: Int = 2
+    def apply(k: K): V | Null =
+      if (k eq k1) v1
+      else if (k eq k2) v2
+      else null
+    def remove(k: K): SimpleIdentityMap[K, V] =
+      if (k eq k1) new Map1(k2, v2)
+      else if (k eq k2) new Map1(k1, v1)
+      else this
+    def updated[V1 >: V <: AnyRef](k: K, v: V1): SimpleIdentityMap[K, V1] =
+      if (k eq k1) new Map2(k, v, k2, v2)
+      else if (k eq k2) new Map2(k1, v1, k, v)
+      else new Map3(k1, v1, k2, v2, k, v)
+    def mapValuesNow[V1 >: V <: AnyRef](f: (K, V1) => V1): SimpleIdentityMap[K, V1] = {
+      val w1 = f(k1, v1); val w2 = f(k2, v2)
+      if ((v1 eq w1) && (v2 eq w2)) this
+      else new Map2(k1, w1, k2, w2)
+    }
+    def foreachBinding(f: (K, V) => Unit): Unit = { f(k1, v1); f(k2, v2) }
+    def forallBinding(f: (K, V) => Boolean): Boolean = f(k1, v1) && f(k2, v2)
+  }
+
+  class Map3[K <: AnyRef, +V <: AnyRef] (k1: K, v1: V, k2: K, v2: V, k3: K, v3: V) extends SimpleIdentityMap[K, V] {
+    def size: Int = 3
+    def apply(k: K): V | Null =
+      if (k eq k1) v1
+      else if (k eq k2) v2
+      else if (k eq k3) v3
+      else null
+    def remove(k: K): SimpleIdentityMap[K, V] =
+      if (k eq k1) new Map2(k2, v2, k3, v3)
+      else if (k eq k2) new Map2(k1, v1, k3, v3)
+      else if (k eq k3) new Map2(k1, v1, k2, v2)
+      else this
+    def updated[V1 >: V <: AnyRef](k: K, v: V1): SimpleIdentityMap[K, V1] =
+      if (k eq k1) new Map3(k, v, k2, v2, k3, v3)
+      else if (k eq k2) new Map3(k1, v1, k, v, k3, v3)
+      else if (k eq k3) new Map3(k1, v1, k2, v2, k, v)
+      else new Map4(k1, v1, k2, v2, k3, v3, k, v)
+    def mapValuesNow[V1 >: V <: AnyRef](f: (K, V1) => V1): SimpleIdentityMap[K, V1] = {
+      val w1 = f(k1, v1); val w2 = f(k2, v2); val w3 = f(k3, v3)
+      if ((v1 eq w1) && (v2 eq w2) && (v3 eq w3)) this
+      else new Map3(k1, w1, k2, w2, k3, w3)
+    }
+    def foreachBinding(f: (K, V) => Unit): Unit = { f(k1, v1); f(k2, v2); f(k3, v3) }
+    def forallBinding(f: (K, V) => Boolean): Boolean = f(k1, v1) && f(k2, v2) && f(k3, v3)
+  }
+
+  class Map4[K <: AnyRef, +V <: AnyRef] (k1: K, v1: V, k2: K, v2: V, k3: K, v3: V, k4: K, v4: V) extends SimpleIdentityMap[K, V] {
+    def size: Int = 4
+    def apply(k: K): V | Null =
+      if (k eq k1) v1
+      else if (k eq k2) v2
+      else if (k eq k3) v3
+      else if (k eq k4) v4
+      else null
+    def remove(k: K): SimpleIdentityMap[K, V] =
+      if (k eq k1) new Map3(k2, v2, k3, v3, k4, v4)
+      else if (k eq k2) new Map3(k1, v1, k3, v3, k4, v4)
+      else if (k eq k3) new Map3(k1, v1, k2, v2, k4, v4)
+      else if (k eq k4) new Map3(k1, v1, k2, v2, k3, v3)
+      else this
+    def updated[V1 >: V <: AnyRef](k: K, v: V1): SimpleIdentityMap[K, V1] =
+      if (k eq k1) new Map4(k, v, k2, v2, k3, v3, k4, v4)
+      else if (k eq k2) new Map4(k1, v1, k, v, k3, v3, k4, v4)
+      else if (k eq k3) new Map4(k1, v1, k2, v2, k, v, k4, v4)
+      else if (k eq k4) new Map4(k1, v1, k2, v2, k3, v3, k, v)
+      else new MapMore(Array[AnyRef](k1, v1, k2, v2, k3, v3, k4, v4, k, v))
+    def mapValuesNow[V1 >: V <: AnyRef](f: (K, V1) => V1): SimpleIdentityMap[K, V1] = {
+      val w1 = f(k1, v1); val w2 = f(k2, v2); val w3 = f(k3, v3); val w4 = f(k4, v4)
+      if ((v1 eq w1) && (v2 eq w2) && (v3 eq w3) && (v4 eq w4)) this
+      else new Map4(k1, w1, k2, w2, k3, w3, k4, w4)
+    }
+    def foreachBinding(f: (K, V) => Unit): Unit = { f(k1, v1); f(k2, v2); f(k3, v3); f(k4, v4) }
+    def forallBinding(f: (K, V) => Boolean): Boolean = f(k1, v1) && f(k2, v2) && f(k3, v3) && f(k4, v4)
+  }
+
+  class MapMore[K <: AnyRef, +V <: AnyRef](bindings: Array[AnyRef]) extends SimpleIdentityMap[K, V] {
+    private def key(i: Int): K = bindings(i).asInstanceOf[K]
+    private def value(i: Int): V = bindings(i + 1).asInstanceOf[V]
+
+    def size: Int = bindings.length / 2
+    Stats.record(s"SimpleIdentityMap/$size")
+
+    def apply(k: K): V | Null = {
+      var i = 0
+      while (i < bindings.length) {
+        if (bindings(i) eq k) return value(i)
+        i += 2
+      }
+      null
+    }
+
+    def remove(k: K): SimpleIdentityMap[K, V] = {
+      var i = 0
+      while (i < bindings.length) {
+        if (bindings(i) eq k)
+          return {
+            if (size == CompactifyThreshold) {
+              var m: SimpleIdentityMap[K, V] = empty[K]
+              for (j <- 0 until bindings.length by 2)
+                if (j != i) m = m.updated(key(j), value(j))
+              m
+            }
+            else {
+              val bindings1 = new Array[AnyRef](bindings.length - 2)
+              System.arraycopy(bindings, 0, bindings1, 0, i)
+              System.arraycopy(bindings, i + 2, bindings1, i, bindings1.length - i)
+              new MapMore(bindings1)
+            }
+          }
+        i += 2
+      }
+      this
+    }
+
+    def updated[V1 >: V <: AnyRef](k: K, v: V1): SimpleIdentityMap[K, V] = {
+      var i = 0
+      while (i < bindings.length) {
+        if (bindings(i) eq k)
+          return {
+            if (v eq bindings(i + 1)) this
+            else {
+              val bindings1 = bindings.clone
+              bindings1(i + 1) = v
+              new MapMore(bindings1)
+            }
+          }
+        i += 2
+      }
+      val bindings2 = new Array[AnyRef](bindings.length + 2)
+      System.arraycopy(bindings, 0, bindings2, 0, bindings.length)
+      bindings2(bindings.length) = k
+      bindings2(bindings.length + 1) = v
+      new MapMore(bindings2)
+    }
+
+    override def contains(k: K): Boolean = {
+      var i = 0
+      while (i < bindings.length) {
+        if (bindings(i) eq k) return true
+        i += 2
+      }
+      false
+    }
+
+    def mapValuesNow[V1 >: V <: AnyRef](f: (K, V1) => V1): SimpleIdentityMap[K, V1] = {
+      var bindings1: Array[AnyRef] = bindings
+      var i = 0
+      while (i < bindings.length) {
+        val v = value(i)
+        val v1 = f(key(i), v)
+        if ((v1 ne v) && (bindings1 eq bindings))
+          bindings1 = bindings.clone
+        bindings1(i) = bindings(i)
+        bindings1(i + 1) = v1
+        i += 2
+      }
+      if (bindings1 eq bindings) this else new MapMore(bindings1)
+    }
+
+    def foreachBinding(f: (K, V) => Unit): Unit = {
+      var i = 0
+      while (i < bindings.length) {
+        f(key(i), value(i))
+        i += 2
+      }
+    }
+
+    def forallBinding(f: (K, V) => Boolean): Boolean = {
+      var i = 0
+      while (i < bindings.length) {
+        if (!f(key(i), value(i)))
+          return false
+        i += 2
+      }
+      return true
+    }
+  }
+}
diff --git a/tests/pos-with-compiler-cc/dotc/util/SimpleIdentitySet.scala b/tests/pos-with-compiler-cc/dotc/util/SimpleIdentitySet.scala
new file mode 100644
index 000000000000..32851fd823d5
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/util/SimpleIdentitySet.scala
@@ -0,0 +1,261 @@
+package dotty.tools.dotc.util
+
+import scala.language.unsafeNulls
+
+import collection.mutable
+
+/** A simple linked set with `eq` as the comparison, optimized for small sets.
+ *  It has linear complexity for `contains`, `+`, and `-`.
+ */
+sealed abstract class SimpleIdentitySet[+Elem <: AnyRef] {
+  def size: Int
+  def + [E >: Elem <: AnyRef](x: E): SimpleIdentitySet[E]
+  def - [E >: Elem <: AnyRef](x: E): SimpleIdentitySet[Elem]
+  def contains[E >: Elem <: AnyRef](x: E): Boolean
+  def foreach(f: Elem => Unit): Unit
+  def exists[E >: Elem <: AnyRef](p: E => Boolean): Boolean
+  def map[B <: AnyRef](f: Elem => B): SimpleIdentitySet[B]
+  def /: [A, E >: Elem <: AnyRef](z: A)(f: (A, E) => A): A
+  def toList: List[Elem]
+  def iterator: Iterator[Elem]
+
+  final def isEmpty: Boolean = size == 0
+
+  def forall[E >: Elem <: AnyRef](p: E => Boolean): Boolean = !exists(!p(_))
+
+  def filter(p: Elem => Boolean): SimpleIdentitySet[Elem] =
+    val z: SimpleIdentitySet[Elem] = SimpleIdentitySet.empty
+    (z /: this)((s, x) => if p(x) then s + x else s)
+
+  def ++ [E >: Elem <: AnyRef](that: SimpleIdentitySet[E]): SimpleIdentitySet[E] =
+    if (this.size == 0) that
+    else if (that.size == 0) this
+    else ((this: SimpleIdentitySet[E]) /: that)(_ + _)
+
+  def -- [E >: Elem <: AnyRef](that: SimpleIdentitySet[E]): SimpleIdentitySet[E] =
+    if (that.size == 0) this
+    else
+      ((SimpleIdentitySet.empty: SimpleIdentitySet[E]) /: this) { (s, x) =>
+        if (that.contains(x)) s else s + x
+      }
+
+  def == [E >: Elem <: AnyRef](that: SimpleIdentitySet[E]): Boolean =
+    this.size == that.size && forall(that.contains)
+
+  override def toString: String = toList.mkString("{", ", ", "}")
+}
+
+object SimpleIdentitySet {
+
+  def apply[Elem <: AnyRef](elems: Elem*): SimpleIdentitySet[Elem] =
+    elems.foldLeft(empty: SimpleIdentitySet[Elem])(_ + _)
+
+  extension [E <: AnyRef](xs: SimpleIdentitySet[E])
+    def intersect(ys: SimpleIdentitySet[E]): SimpleIdentitySet[E] =
+      xs.filter(ys.contains)
+
+  object empty extends SimpleIdentitySet[Nothing] {
+    def size: Int = 0
+    def + [E <: AnyRef](x: E): SimpleIdentitySet[E] =
+      new Set1[E](x)
+    def - [E <: AnyRef](x: E): SimpleIdentitySet[Nothing] =
+      this
+    def contains[E <: AnyRef](x: E): Boolean = false
+    def foreach(f: Nothing => Unit): Unit = ()
+    def exists[E <: AnyRef](p: E => Boolean): Boolean = false
+    def map[B <: AnyRef](f: Nothing => B): SimpleIdentitySet[B] = empty
+    def /: [A, E <: AnyRef](z: A)(f: (A, E) => A): A = z
+    def toList = Nil
+    def iterator = Iterator.empty
+  }
+
+  private class Set1[+Elem <: AnyRef](x0: AnyRef) extends SimpleIdentitySet[Elem] {
+    def size = 1
+    def + [E >: Elem <: AnyRef](x: E): SimpleIdentitySet[E] =
+      if (contains(x)) this else new Set2[E](x0, x)
+    def - [E >: Elem <: AnyRef](x: E): SimpleIdentitySet[Elem] =
+      if (x `eq` x0) empty else this
+    def contains[E >: Elem <: AnyRef](x: E): Boolean = x `eq` x0
+    def foreach(f: Elem => Unit): Unit = f(x0.asInstanceOf[Elem])
+    def exists[E >: Elem <: AnyRef](p: E => Boolean): Boolean =
+      p(x0.asInstanceOf[E])
+    def map[B <: AnyRef](f: Elem => B): SimpleIdentitySet[B] =
+      Set1(f(x0.asInstanceOf[Elem]))
+    def /: [A, E >: Elem <: AnyRef](z: A)(f: (A, E) => A): A =
+      f(z, x0.asInstanceOf[E])
+    def toList = x0.asInstanceOf[Elem] :: Nil
+    def iterator = Iterator.single(x0.asInstanceOf[Elem])
+  }
+
+  private class Set2[+Elem <: AnyRef](x0: AnyRef, x1: AnyRef) extends SimpleIdentitySet[Elem] {
+    def size = 2
+    def + [E >: Elem <: AnyRef](x: E): SimpleIdentitySet[E] =
+      if (contains(x)) this else new Set3(x0, x1, x)
+    def - [E >: Elem <: AnyRef](x: E): SimpleIdentitySet[Elem] =
+      if (x `eq` x0) new Set1(x1)
+      else if (x `eq` x1) new Set1(x0)
+      else this
+    def contains[E >: Elem <: AnyRef](x: E): Boolean = (x `eq` x0) || (x `eq` x1)
+    def foreach(f: Elem => Unit): Unit = { f(x0.asInstanceOf[Elem]); f(x1.asInstanceOf[Elem]) }
+    def exists[E >: Elem <: AnyRef](p: E => Boolean): Boolean =
+      p(x0.asInstanceOf[E]) || p(x1.asInstanceOf[E])
+    def map[B <: AnyRef](f: Elem => B): SimpleIdentitySet[B] =
+      Set2(f(x0.asInstanceOf[Elem]), f(x1.asInstanceOf[Elem]))
+    def /: [A, E >: Elem <: AnyRef](z: A)(f: (A, E) => A): A =
+      f(f(z, x0.asInstanceOf[E]), x1.asInstanceOf[E])
+    def toList = x0.asInstanceOf[Elem] :: x1.asInstanceOf[Elem] :: Nil
+    def iterator = Iterator.tabulate(2) {
+      case 0 => x0.asInstanceOf[Elem]
+      case 1 => x1.asInstanceOf[Elem]
+    }
+  }
+
+  private class Set3[+Elem <: AnyRef](x0: AnyRef, x1: AnyRef, x2: AnyRef) extends SimpleIdentitySet[Elem] {
+    def size = 3
+    def + [E >: Elem <: AnyRef](x: E): SimpleIdentitySet[E] =
+      if (contains(x)) this
+      else {
+        val xs = new Array[AnyRef](4)
+        xs(0) = x0
+        xs(1) = x1
+        xs(2) = x2
+        xs(3) = x
+        new SetN[E](xs)
+      }
+    def - [E >: Elem <: AnyRef](x: E): SimpleIdentitySet[Elem] =
+      if (x `eq` x0) new Set2(x1, x2)
+      else if (x `eq` x1) new Set2(x0, x2)
+      else if (x `eq` x2) new Set2(x0, x1)
+      else this
+    def contains[E >: Elem <: AnyRef](x: E): Boolean = (x `eq` x0) || (x `eq` x1) || (x `eq` x2)
+    def foreach(f: Elem => Unit): Unit = {
+      f(x0.asInstanceOf[Elem]); f(x1.asInstanceOf[Elem]); f(x2.asInstanceOf[Elem])
+    }
+    def exists[E >: Elem <: AnyRef](p: E => Boolean): Boolean =
+      p(x0.asInstanceOf[E]) || p(x1.asInstanceOf[E]) || p(x2.asInstanceOf[E])
+    def map[B <: AnyRef](f: Elem => B): SimpleIdentitySet[B] =
+      Set3(f(x0.asInstanceOf[Elem]), f(x1.asInstanceOf[Elem]), f(x2.asInstanceOf[Elem]))
+    def /: [A, E >: Elem <: AnyRef](z: A)(f: (A, E) => A): A =
+      f(f(f(z, x0.asInstanceOf[E]), x1.asInstanceOf[E]), x2.asInstanceOf[E])
+    def toList = x0.asInstanceOf[Elem] :: x1.asInstanceOf[Elem] :: x2.asInstanceOf[Elem] :: Nil
+    def iterator = Iterator.tabulate(3) {
+      case 0 => x0.asInstanceOf[Elem]
+      case 1 => x1.asInstanceOf[Elem]
+      case 2 => x2.asInstanceOf[Elem]
+    }
+  }
+
+  private class SetN[+Elem <: AnyRef](val xs: Array[AnyRef]) extends SimpleIdentitySet[Elem] {
+    def size = xs.length
+    def + [E >: Elem <: AnyRef](x: E): SimpleIdentitySet[E] =
+      if (contains(x)) this
+      else {
+        val xs1 = new Array[AnyRef](size + 1)
+        System.arraycopy(xs, 0, xs1, 0, size)
+        xs1(size) = x
+        new SetN[E](xs1)
+      }
+    def - [E >: Elem <: AnyRef](x: E): SimpleIdentitySet[Elem] = {
+      var i = 0
+      while (i < size && (xs(i) `ne` x)) i += 1
+      if (i == size) this
+      else if (size == 4)
+        if (i == 0) new Set3(xs(1), xs(2), xs(3))
+        else if (i == 1) new Set3(xs(0), xs(2), xs(3))
+        else if (i == 2) new Set3(xs(0), xs(1), xs(3))
+        else new Set3(xs(0), xs(1), xs(2))
+      else {
+        val xs1 = new Array[AnyRef](size - 1)
+        System.arraycopy(xs, 0, xs1, 0, i)
+        System.arraycopy(xs, i + 1, xs1, i, size - (i + 1))
+        new SetN(xs1)
+      }
+    }
+    def contains[E >: Elem <: AnyRef](x: E): Boolean = {
+      var i = 0
+      while (i < size && (xs(i) `ne` x)) i += 1
+      i < size
+    }
+    def foreach(f: Elem => Unit): Unit = {
+      var i = 0
+      while (i < size) { f(xs(i).asInstanceOf[Elem]); i += 1 }
+    }
+    def exists[E >: Elem <: AnyRef](p: E => Boolean): Boolean =
+      xs.asInstanceOf[Array[E]].exists(p)
+    def map[B <: AnyRef](f: Elem => B): SimpleIdentitySet[B] =
+      SetN(xs.map(x => f(x.asInstanceOf[Elem]).asInstanceOf[AnyRef]))
+    def /: [A, E >: Elem <: AnyRef](z: A)(f: (A, E) => A): A =
+      xs.asInstanceOf[Array[E]].foldLeft(z)(f)
+    def toList: List[Elem] = {
+      val buf = new mutable.ListBuffer[Elem]
+      foreach(buf += _)
+      buf.toList
+    }
+    def iterator = xs.iterator.asInstanceOf[Iterator[Elem]]
+    override def ++ [E >: Elem <: AnyRef](that: SimpleIdentitySet[E]): SimpleIdentitySet[E] =
+      that match {
+        case that: SetN[?] =>
+          var toAdd: mutable.ArrayBuffer[AnyRef] = null
+          var i = 0
+          val limit = that.xs.length
+          while (i < limit) {
+            val elem = that.xs(i)
+            if (!contains(elem)) {
+              if (toAdd == null) toAdd = new mutable.ArrayBuffer
+              toAdd += elem
+            }
+            i += 1
+          }
+          if (toAdd == null) this
+          else {
+            val numAdded = toAdd.size
+            val xs1 = new Array[AnyRef](size + numAdded)
+            System.arraycopy(xs, 0, xs1, 0, size)
+            var i = 0
+            while (i < numAdded) {
+              xs1(i + size) = toAdd(i)
+              i += 1
+            }
+            new SetN[E](xs1)
+          }
+        case _ => super.++(that)
+      }
+    override def -- [E >: Elem <: AnyRef](that: SimpleIdentitySet[E]): SimpleIdentitySet[E] =
+      that match {
+        case that: SetN[?] =>
+          // both sets are large, optimize assuming they are similar
+          // by starting from empty set and adding elements
+          var toAdd: mutable.ArrayBuffer[AnyRef] = null
+          val thisSize = this.size
+          val thatSize = that.size
+          val thatElems = that.xs
+          var i = 0
+          var searchStart = 0
+          while (i < thisSize) {
+            val elem = this.xs(i)
+            var j = searchStart    // search thatElems in round robin fashion, starting one after latest hit
+            var missing = false
+            while (!missing && (elem ne thatElems(j))) {
+              j += 1
+              if (j == thatSize) j = 0
+              missing = j == searchStart
+            }
+            if (missing) {
+              if (toAdd == null) toAdd = new mutable.ArrayBuffer
+              toAdd += elem
+            }
+            else searchStart = (j + 1) % thatSize
+            i += 1
+          }
+          if (toAdd == null) empty
+          else toAdd.size match {
+            case 1 => new Set1[E](toAdd(0))
+            case 2 => new Set2[E](toAdd(0), toAdd(1))
+            case 3 => new Set3[E](toAdd(0), toAdd(1), toAdd(2))
+            case _ => new SetN[E](toAdd.toArray)
+          }
+        case _ => // this set is large, that set is small: reduce from above using `-`
+          ((this: SimpleIdentitySet[E]) /: that)(_ - _)
+      }
+  }
+}
diff --git a/tests/pos-with-compiler-cc/dotc/util/SixteenNibbles.scala b/tests/pos-with-compiler-cc/dotc/util/SixteenNibbles.scala
new file mode 100644
index 000000000000..42286aef5d31
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/util/SixteenNibbles.scala
@@ -0,0 +1,28 @@
+package dotty.tools.dotc.util
+
+/** An efficient implementation of sequences of 16 indexed elements with
+ *  values 0..15 in a single Long.
+ *
+ */
+class SixteenNibbles(val bits: Long) extends AnyVal {
+  import SixteenNibbles._
+
+  def apply(idx: Int): Int =
+    (bits >>> (idx * Width)).toInt & Mask
+
+  def updated(idx: Int, value: Int): SixteenNibbles =
+    new SixteenNibbles(
+      (bits & ~(LongMask << (idx * Width))) |
+      ((value & Mask).toLong << (idx * Width)))
+
+  def elements: IndexedSeq[Int] = (0 until 16) map apply
+
+  override def toString: String =
+    s"SixteenNibbles(${elements.mkString(", ")})"
+}
+
+object SixteenNibbles {
+  inline val Width = 4
+  inline val Mask = (1 << Width) - 1
+  final val LongMask: Long = Mask.toLong
+}
diff --git a/tests/pos-with-compiler-cc/dotc/util/SourceFile.scala b/tests/pos-with-compiler-cc/dotc/util/SourceFile.scala
new file mode 100644
index 000000000000..8a5a4828adfd
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/util/SourceFile.scala
@@ -0,0 +1,288 @@
+package dotty.tools
+package dotc
+package util
+
+import scala.language.unsafeNulls
+
+import dotty.tools.io._
+import Spans._
+import core.Contexts._
+
+import scala.io.Codec
+import Chars._
+import scala.annotation.internal.sharable
+import scala.collection.mutable
+import scala.collection.mutable.ArrayBuffer
+import scala.util.chaining.given
+
+import java.io.File.separator
+import java.nio.charset.StandardCharsets
+import java.nio.file.{FileSystemException, NoSuchFileException}
+import java.util.Optional
+import java.util.concurrent.atomic.AtomicInteger
+import java.util.regex.Pattern
+import language.experimental.pureFunctions
+
+object ScriptSourceFile {
+  @sharable private val headerPattern = Pattern.compile("""^(::)?!#.*(\r|\n|\r\n)""", Pattern.MULTILINE)
+  private val headerStarts  = List("#!", "::#!")
+
+  /** Return true if has a script header */
+  def hasScriptHeader(content: Array[Char]): Boolean =
+    headerStarts.exists(content.startsWith(_))
+
+  def apply(file: AbstractFile, content: Array[Char]): SourceFile = {
+    /** Length of the script header from the given content, if there is one.
+     *  The header begins with "#!" or "::#!" and is either a single line,
+     *  or it ends with a line starting with "!#" or "::!#", if present.
+     */
+    val headerLength =
+      if (headerStarts exists (content startsWith _)) {
+        val matcher = headerPattern matcher content.mkString
+        if (matcher.find) matcher.end
+        else content.indexOf('\n') // end of first line
+      }
+      else 0
+
+    // overwrite hash-bang lines with all spaces to preserve line numbers
+    val hashBangLines = content.take(headerLength).mkString.split("\\r?\\n")
+    if hashBangLines.nonEmpty then
+      for i <- 0 until headerLength do
+        content(i) match {
+          case '\r' | '\n' =>
+          case _ =>
+            content(i) = ' '
+        }
+
+    new SourceFile(file, content) {
+      override val underlying = new SourceFile(this.file, this.content)
+    }
+  }
+}
+
+class SourceFile(val file: AbstractFile, computeContent: -> Array[Char]) extends interfaces.SourceFile, caps.Pure {
+  import SourceFile._
+
+  private var myContent: Array[Char] | Null = null
+
+  /** The contents of the original source file. Note that this can be empty, for example when
+   * the source is read from Tasty. */
+  def content(): Array[Char] = {
+    if (myContent == null) myContent = computeContent
+    myContent
+  }
+
+  private var _maybeInComplete: Boolean = false
+
+  def maybeIncomplete: Boolean = _maybeInComplete
+
+  override def name: String = file.name
+  override def path: String = file.path
+  override def jfile: Optional[JFile] = Optional.ofNullable(file.file)
+
+  override def equals(that: Any): Boolean =
+    (this `eq` that.asInstanceOf[AnyRef]) || {
+      that match {
+        case that : SourceFile => file == that.file && start == that.start
+        case _ => false
+      }
+    }
+
+  override def hashCode: Int = file.hashCode * 41 + start.hashCode
+
+  def apply(idx: Int): Char = content().apply(idx)
+
+  /** length of the original source file
+   * Note that when the source is from Tasty, content() could be empty even though length > 0.
+   * Use content().length to determine the length of content(). */
+  def length: Int =
+    if lineIndicesCache ne null then lineIndicesCache.last
+    else content().length
+
+  /** true for all source files except `NoSource` */
+  def exists: Boolean = true
+
+  /** The underlying source file */
+  def underlying: SourceFile = this
+
+  /** The start of this file in the underlying source file */
+  def start: Int = 0
+
+  def atSpan(span: Span): SourcePosition =
+    if (span.exists) SourcePosition(underlying, span)
+    else NoSourcePosition
+
+  def isSelfContained: Boolean = underlying eq this
+
+  /** Map a position to a position in the underlying source file.
+   *  For regular source files, simply return the argument.
+   */
+  def positionInUltimateSource(position: SourcePosition): SourcePosition =
+    SourcePosition(underlying, position.span shift start)
+
+  private def calculateLineIndicesFromContents() = {
+    val cs = content()
+    val buf = new ArrayBuffer[Int]
+    buf += 0
+    var i = 0
+    while i < cs.length do
+      val isLineBreak =
+        val ch = cs(i)
+        // don't identify the CR in CR LF as a line break, since LF will do.
+        if ch == CR then i + 1 == cs.length || cs(i + 1) != LF
+        else isLineBreakChar(ch)
+      if isLineBreak then buf += i + 1
+      i += 1
+    buf += cs.length // sentinel, so that findLine below works smoother
+    buf.toArray
+  }
+
+  private var lineIndicesCache: Array[Int] = _
+  private def lineIndices: Array[Int] =
+    if lineIndicesCache eq null then
+      lineIndicesCache = calculateLineIndicesFromContents()
+    lineIndicesCache
+
+  def initialized = lineIndicesCache != null
+
+  def setLineIndicesFromLineSizes(sizes: Array[Int]): Unit =
+    val lines = sizes.length
+    val indices = new Array[Int](lines + 1)
+    var i = 0
+    val penultimate = lines - 1
+    while i < penultimate do
+      indices(i + 1) = indices(i) + sizes(i) + 1 // `+1` for the '\n' at the end of the line
+      i += 1
+    indices(lines) = indices(penultimate) + sizes(penultimate) // last line does not end with '\n'
+    lineIndicesCache = indices
+
+  /** Map line to offset of first character in line */
+  def lineToOffset(index: Int): Int = lineIndices(index)
+
+  /** Like `lineToOffset`, but doesn't crash if the index is out of bounds. */
+  def lineToOffsetOpt(index: Int): Option[Int] =
+    if (index < 0 || index >= lineIndices.length)
+      None
+    else
+      Some(lineToOffset(index))
+
+  /** A cache to speed up offsetToLine searches to similar lines */
+  private var lastLine = 0
+
+  /** Convert offset to line in this source file
+   *  Lines are numbered from 0
+   */
+  def offsetToLine(offset: Int): Int = {
+    lastLine = Util.bestFit(lineIndices, lineIndices.length, offset, lastLine)
+    if (offset >= length) lastLine -= 1 // compensate for the sentinel
+    lastLine
+  }
+
+  /** The index of the first character of the line containing position `offset` */
+  def startOfLine(offset: Int): Int = {
+    require(offset >= 0)
+    lineToOffset(offsetToLine(offset))
+  }
+
+  /** The start index of the line following the one containing position `offset` */
+  def nextLine(offset: Int): Int =
+    lineToOffset(offsetToLine(offset) + 1 min lineIndices.length - 1)
+
+  /** The content of the line containing position `offset` */
+  def lineContent(offset: Int): String =
+    content.slice(startOfLine(offset), nextLine(offset)).mkString
+
+  /** The column corresponding to `offset`, starting at 0 */
+  def column(offset: Int): Int = {
+    var idx = startOfLine(offset)
+    offset - idx
+  }
+
+  /** The padding of the column corresponding to `offset`, includes tabs */
+  def startColumnPadding(offset: Int): String = {
+    var idx = startOfLine(offset)
+    val pad = new StringBuilder
+    while (idx != offset) {
+      pad.append(if (idx < content().length && content()(idx) == '\t') '\t' else ' ')
+      idx += 1
+    }
+    pad.result()
+  }
+
+  override def toString: String = file.toString
+}
+object SourceFile {
+  implicit def eqSource: CanEqual[SourceFile, SourceFile] = CanEqual.derived
+
+  implicit def fromContext(using Context): SourceFile = ctx.source
+
+  /** A source file with an underlying virtual file. The name is taken as a file system path
+   *  with the local separator converted to "/". The last element of the path will be the simple name of the file.
+   */
+  def virtual(name: String, content: String, maybeIncomplete: Boolean = false) =
+    SourceFile(new VirtualFile(name.replace(separator, "/"), content.getBytes(StandardCharsets.UTF_8)), content.toCharArray)
+      .tap(_._maybeInComplete = maybeIncomplete)
+
+  /** Returns the relative path of `source` within the `reference` path
+   *
+   *  It returns the absolute path of `source` if it is not contained in `reference`.
+   */
+  def relativePath(source: SourceFile, reference: String): String = {
+    val file = source.file
+    val jpath = file.jpath
+    if jpath eq null then
+      file.path // repl and other custom tests use abstract files with no path
+    else
+      val sourcePath = jpath.toAbsolutePath.normalize
+      val refPath = java.nio.file.Paths.get(reference).toAbsolutePath.normalize
+
+      if sourcePath.startsWith(refPath) then
+        // On Windows we can only relativize paths if root component matches
+        // (see implementation of sun.nio.fs.WindowsPath#relativize)
+        //
+        //     try refPath.relativize(sourcePath).toString
+        //     catch case _: IllegalArgumentException => sourcePath.toString
+        //
+        // As we already check that the prefix matches, the special handling for
+        // Windows is not needed.
+
+        // We also consistently use forward slashes as path element separators
+        // for relative paths. If we didn't do that, it'd be impossible to parse
+        // them back, as one would need to know whether they were created on Windows
+        // and use both slashes as separators, or on other OS and use forward slash
+        // as separator, backslash as file name character.
+
+        import scala.jdk.CollectionConverters._
+        val path = refPath.relativize(sourcePath)
+        path.iterator.asScala.mkString("/")
+      else
+        sourcePath.toString
+  }
+
+  /** Return true if file is a script:
+   *  if filename extension is not .scala and has a script header.
+   */
+  def isScript(file: AbstractFile | Null, content: Array[Char]): Boolean =
+    ScriptSourceFile.hasScriptHeader(content)
+
+  def apply(file: AbstractFile | Null, codec: Codec): SourceFile =
+    // Files.exists is slow on Java 8 (https://rules.sonarsource.com/java/tag/performance/RSPEC-3725),
+    // so cope with failure; also deal with path prefix "Not a directory".
+    val chars =
+      try new String(file.toByteArray, codec.charSet).toCharArray
+      catch
+        case _: NoSuchFileException => Array.empty[Char]
+        case fse: FileSystemException if fse.getMessage.endsWith("Not a directory") => Array.empty[Char]
+
+    if isScript(file, chars) then
+      ScriptSourceFile(file, chars)
+    else
+      SourceFile(file, chars)
+
+  def apply(file: AbstractFile | Null, computeContent: -> Array[Char]): SourceFile = new SourceFile(file, computeContent)
+}
+
+@sharable object NoSource extends SourceFile(NoAbstractFile, Array[Char]()) {
+  override def exists: Boolean = false
+  override def atSpan(span: Span): SourcePosition = NoSourcePosition
+}
diff --git a/tests/pos-with-compiler-cc/dotc/util/SourcePosition.scala b/tests/pos-with-compiler-cc/dotc/util/SourcePosition.scala
new file mode 100644
index 000000000000..ef4350741036
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/util/SourcePosition.scala
@@ -0,0 +1,104 @@
+package dotty.tools
+package dotc
+package util
+
+import scala.language.unsafeNulls
+
+import printing.{Showable, Printer}
+import printing.Texts._
+import core.Contexts.Context
+import Spans.{Span, NoSpan}
+import scala.annotation.internal.sharable
+
+/** A source position is comprised of a span and a source file */
+case class SourcePosition(source: SourceFile, span: Span, outer: SourcePosition = NoSourcePosition)
+extends SrcPos, interfaces.SourcePosition, Showable, caps.Pure {
+
+  def sourcePos(using Context) = this
+
+  /** Is `that` a source position contained in this source position ?
+   *  `outer` is not taken into account. */
+  def contains(that: SourcePosition): Boolean =
+    this.source == that.source && this.span.contains(that.span)
+
+  def exists: Boolean = span.exists
+
+  def lineContent: String = source.lineContent(point)
+
+  def point: Int = span.point
+
+  def line: Int = source.offsetToLine(point)
+
+  /** Extracts the lines from the underlying source file as `Array[Char]`*/
+  def linesSlice: Array[Char] =
+    source.content.slice(source.startOfLine(start), source.nextLine(end))
+
+  /** The lines of the position */
+  def lines: Range = {
+    val startOffset = source.offsetToLine(start)
+    val endOffset = source.offsetToLine(end - 1) // -1 to drop a line if no chars in it form part of the position
+    if (startOffset >= endOffset) line to line
+    else startOffset to endOffset
+  }
+
+  def lineOffsets: List[Int] =
+    lines.toList.map(source.lineToOffset(_))
+
+  def beforeAndAfterPoint: (List[Int], List[Int]) =
+    lineOffsets.partition(_ <= point)
+
+  def column: Int = source.column(point)
+
+  def start: Int = span.start
+  def startLine: Int = source.offsetToLine(start)
+  def startColumn: Int = source.column(start)
+  def startColumnPadding: String = source.startColumnPadding(start)
+
+  def end: Int = span.end
+  def endLine: Int = source.offsetToLine(end)
+  def endColumn: Int = source.column(end)
+
+  def withOuter(outer: SourcePosition): SourcePosition = SourcePosition(source, span, outer)
+  def withSpan(range: Span) = SourcePosition(source, range, outer)
+
+  def startPos: SourcePosition = withSpan(span.startPos)
+  def endPos  : SourcePosition = withSpan(span.endPos)
+  def focus   : SourcePosition = withSpan(span.focus)
+  def toSynthetic: SourcePosition = withSpan(span.toSynthetic)
+
+  def outermost: SourcePosition =
+    if outer == null || outer == NoSourcePosition then this else outer.outermost
+
+  /** Inner most position that is contained within the `outermost` position.
+   *  Most precise position that comes from the call site.
+   */
+  def nonInlined: SourcePosition = {
+    val om = outermost
+    def rec(self: SourcePosition): SourcePosition =
+      if om.contains(self) then self else rec(self.outer)
+    rec(this)
+  }
+
+
+  override def toString: String =
+    s"${if (source.exists) source.file.toString else "(no source)"}:$span"
+
+  def toText(printer: Printer): Text = printer.toText(this)
+}
+
+/** A sentinel for a non-existing source position */
+@sharable object NoSourcePosition extends SourcePosition(NoSource, NoSpan, null) {
+  override def line: Int = -1
+  override def column: Int = -1
+  override def toString: String = "?"
+  override def withOuter(outer: SourcePosition): SourcePosition = outer
+}
+
+/** Things that can produce a source position and a span */
+trait SrcPos:
+  def sourcePos(using ctx: Context): SourcePosition
+  def span: Span
+  def startPos(using ctx: Context): SourcePosition = sourcePos.startPos
+  def endPos(using ctx: Context): SourcePosition = sourcePos.endPos
+  def focus(using ctx: Context): SourcePosition = sourcePos.focus
+  def line(using ctx: Context): Int = sourcePos.line
diff --git a/tests/pos-with-compiler-cc/dotc/util/Spans.scala b/tests/pos-with-compiler-cc/dotc/util/Spans.scala
new file mode 100644
index 000000000000..baf2cfa121b0
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/util/Spans.scala
@@ -0,0 +1,195 @@
+package dotty.tools.dotc
+package util
+
+import language.implicitConversions
+
+/** The offsets part of a full position, consisting of 2 or 3 entries:
+ *    - start:  the start offset of the span, in characters from start of file
+ *    - end  :  the end offset of the span
+ *    - point:  if given, the offset where a single `^` would be logically placed
+ *
+ *  Spans are encoded according to the following format in little endian:
+ *  Start: unsigned 26 Bits (works for source files up to 64M)
+ *  End: unsigned 26 Bits
+ *  Point: unsigned 12 Bits relative to start
+ *  NoSpan encoded as -1L (this is a normally invalid span because point would lie beyond end).
+ */
+object Spans {
+
+  private inline val StartEndBits = 26
+  private inline val StartEndMask = (1L << StartEndBits) - 1
+  private inline val SyntheticPointDelta = (1 << (64 - StartEndBits * 2)) - 1
+
+  /** The maximal representable offset in a span */
+  final val MaxOffset = StartEndMask.toInt
+
+  /** Convert offset `x` to an integer by sign extending the original
+   *  field of `StartEndBits` width.
+   */
+  def offsetToInt(x: Int): Int =
+    x << (32 - StartEndBits) >> (32 - StartEndBits)
+
+  /** A span indicates a range between a start offset and an end offset.
+   *  Spans can be synthetic or source-derived. A source-derived span
+   *  has in addition a point. The point lies somewhere between start and end. The point
+   *  is roughly where the `^` would go if an error was diagnosed at that position.
+   *  All quantities are encoded opaquely in a Long.
+   */
+  class Span(val coords: Long) extends AnyVal {
+
+    /** Is this span different from NoSpan? */
+    def exists: Boolean = this != NoSpan
+
+    /** The start of this span. */
+    def start: Int = {
+      assert(exists)
+      (coords & StartEndMask).toInt
+    }
+
+    /** The end of this span */
+    def end: Int = {
+      assert(exists)
+      ((coords >>> StartEndBits) & StartEndMask).toInt
+    }
+
+    /** The point of this span, returns start for synthetic spans */
+    def point: Int = {
+      assert(exists)
+      val poff = pointDelta
+      if (poff == SyntheticPointDelta) start else start + poff
+    }
+
+    /** The difference between point and start in this span */
+    def pointDelta: Int =
+      (coords >>> (StartEndBits * 2)).toInt
+
+    def orElse(that: Span): Span =
+      if (this.exists) this else that
+
+    /** The union of two spans. This is the least range that encloses
+     *  both spans. It is always a synthetic span.
+     */
+    def union(that: Span): Span =
+      if (!this.exists) that
+      else if (!that.exists) this
+      else Span(this.start min that.start, this.end max that.end, this.point)
+
+    /** Does the range of this span contain the one of that span? */
+    def contains(that: Span): Boolean =
+      !that.exists || exists && (start <= that.start && end >= that.end)
+
+    /** Does the range of this span overlap with the range of that span at more than a single point? */
+    def overlaps(that: Span): Boolean = {
+      def containsInner(span: Span, offset: Int) = span.start < offset && offset < span.end
+      exists && that.exists && (
+         containsInner(this, that.start)
+      || containsInner(this, that.end)
+      || containsInner(that, this.start)
+      || containsInner(that, this.end)
+      || this.start == that.start && this.end == that.end   // exact match in one point
+      )
+    }
+
+    /** Is this span synthetic? */
+    def isSynthetic: Boolean = pointDelta == SyntheticPointDelta
+
+    /** Is this span source-derived? */
+    def isSourceDerived: Boolean = !isSynthetic
+
+    /** Is this a zero-extent span? */
+    def isZeroExtent: Boolean = exists && start == end
+
+     /** A span where all components are shifted by a given `offset`
+     *  relative to this span.
+     */
+    def shift(offset: Int): Span =
+      if (exists) fromOffsets(start + offset, end + offset, pointDelta)
+      else this
+
+    /** The zero-extent span with start and end at the point of this span */
+    def focus: Span = if (exists) Span(point) else NoSpan
+
+    /** The zero-extent span with start and end at the start of this span */
+    def startPos: Span = if (exists) Span(start) else NoSpan
+
+    /** The zero-extent span with start and end at the end of this span */
+    def endPos: Span = if (exists) Span(end) else NoSpan
+
+    /** A copy of this span with a different start */
+    def withStart(start: Int): Span =
+      if (exists) fromOffsets(start, this.end, if (isSynthetic) SyntheticPointDelta else this.point - start)
+      else this
+
+    /** A copy of this span with a different end */
+    def withEnd(end: Int): Span =
+      if (exists) fromOffsets(this.start, end, pointDelta)
+      else this
+
+    /** A copy of this span with a different point */
+    def withPoint(point: Int): Span =
+      if (exists) fromOffsets(this.start, this.end, point - this.start)
+      else this
+
+    /** A synthetic copy of this span */
+    def toSynthetic: Span = if (isSynthetic) this else Span(start, end)
+
+    override def toString: String = {
+      val (left, right) = if (isSynthetic) ("<", ">") else ("[", "]")
+      if (exists)
+        s"$left$start..${if (point == start) "" else s"$point.."}$end$right"
+      else
+        s"${left}no position${right}"
+    }
+
+    def ==(that: Span): Boolean = this.coords == that.coords
+    def !=(that: Span): Boolean = this.coords != that.coords
+  }
+
+  private def fromOffsets(start: Int, end: Int, pointDelta: Int) =
+    //assert(start <= end || start == 1 && end == 0, s"$start..$end")
+    new Span(
+      (start & StartEndMask).toLong |
+      ((end & StartEndMask).toLong << StartEndBits) |
+      (pointDelta.toLong << (StartEndBits * 2)))
+
+  /** A synthetic span with given start and end */
+  def Span(start: Int, end: Int): Span =
+    fromOffsets(start, end, SyntheticPointDelta)
+
+  /** A source-derived span with given start, end, and point delta */
+  def Span(start: Int, end: Int, point: Int): Span = {
+    val pointDelta = (point - start) max 0
+    fromOffsets(start, end, if (pointDelta >= SyntheticPointDelta) 0 else pointDelta)
+  }
+
+  /** A synthetic zero-extent span that starts and ends at given `start`. */
+  def Span(start: Int): Span = Span(start, start)
+
+  /** A sentinel for a non-existing span */
+  val NoSpan: Span = Span(1, 0)
+
+  /** The coordinate of a symbol. This is either an index or
+   *  a zero-range span.
+   */
+  class Coord(val encoding: Int) extends AnyVal {
+    def isIndex: Boolean = encoding > 0
+    def isSpan: Boolean = encoding <= 0
+    def toIndex: Int = {
+      assert(isIndex)
+      encoding - 1
+    }
+    def toSpan: Span = {
+      assert(isSpan)
+      if (this == NoCoord) NoSpan else Span(-1 - encoding)
+    }
+  }
+
+  /** An index coordinate */
+  implicit def indexCoord(n: Int): Coord = new Coord(n + 1)
+  implicit def spanCoord(span: Span): Coord =
+    if (span.exists) new Coord(-(span.point + 1))
+    else NoCoord
+
+  /** A sentinel for a missing coordinate */
+  val NoCoord: Coord = new Coord(0)
+}
diff --git a/tests/pos-with-compiler-cc/dotc/util/StackTraceOps.scala b/tests/pos-with-compiler-cc/dotc/util/StackTraceOps.scala
new file mode 100644
index 000000000000..7fa54606c572
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/util/StackTraceOps.scala
@@ -0,0 +1,78 @@
+/*
+ * Scala (https://www.scala-lang.org)
+ *
+ * Copyright EPFL and Lightbend, Inc.
+ *
+ * Licensed under Apache License 2.0
+ * (http://www.apache.org/licenses/LICENSE-2.0).
+ *
+ * See the NOTICE file distributed with this work for
+ * additional information regarding copyright ownership.
+ */
+
+package dotty.tools.dotc.util
+
+import scala.language.unsafeNulls
+
+import collection.mutable, mutable.ListBuffer
+import scala.util.chaining.given
+import java.lang.System.lineSeparator
+
+object StackTraceOps:
+
+  extension (t: Throwable)
+
+    /** Format a stack trace, taking the prefix span satisfying a predicate.
+     *
+     *  The format is similar to the typical case described in the Javadoc
+     *  for [[java.lang.Throwable#printStackTrace()*]].
+     *  If a stack trace is truncated, it will be followed by a line of the form
+     *  `... 3 elided`, by analogy to the lines `... 3 more` which indicate
+     *  shared stack trace segments.
+     *  @param e the exception
+     *  @param p the predicate to select the prefix
+     */
+    def formatStackTracePrefix(p: StackTraceElement => Boolean): String =
+
+      type TraceRelation = String
+      val Self       = new TraceRelation("")
+      val CausedBy   = new TraceRelation("Caused by: ")
+      val Suppressed = new TraceRelation("Suppressed: ")
+
+      def header(e: Throwable): String =
+        def because = e.getCause   match { case null => null    ; case c => header(c) }
+        def msg     = e.getMessage match { case null => because ; case s => s         }
+        def txt     = msg          match { case null => ""      ; case s => s": $s"   }
+        s"${e.getClass.getName}$txt"
+
+      val seen = mutable.Set.empty[Throwable]
+      def unseen(e: Throwable): Boolean = (e != null && !seen(e)).tap(if _ then seen += e)
+
+      val lines = ListBuffer.empty[String]
+
+      // format the stack trace, skipping the shared trace
+      def print(e: Throwable, r: TraceRelation, share: Array[StackTraceElement], indents: Int): Unit = if unseen(e) then
+        val trace  = e.getStackTrace
+        val frames = if share.isEmpty then trace else
+          val spare   = share.reverseIterator
+          val trimmed = trace.reverse.dropWhile(spare.hasNext && spare.next() == _)
+          trimmed.reverse
+        val prefix = frames.takeWhile(p)
+        val margin = "  " * indents
+        lines += s"${margin}${r}${header(e)}"
+        prefix.foreach(frame => lines += s"$margin  at $frame")
+
+        val traceFramesLenDiff  = trace.length - frames.length
+        val framesPrefixLenDiff = frames.length - prefix.length
+        if traceFramesLenDiff > 0 then
+          if framesPrefixLenDiff > 0 then lines += s"$margin  ... $framesPrefixLenDiff elided and $traceFramesLenDiff more"
+          else lines += s"$margin  ... $traceFramesLenDiff more"
+        else if framesPrefixLenDiff > 0 then lines += s"$margin  ... $framesPrefixLenDiff elided"
+
+        print(e.getCause, CausedBy, trace, indents)
+        e.getSuppressed.foreach(print(_, Suppressed, frames, indents + 1))
+      end print
+
+      print(t, Self, share = Array.empty, indents = 0)
+      lines.mkString(lineSeparator)
+    end formatStackTracePrefix
diff --git a/tests/pos-with-compiler-cc/dotc/util/Stats.scala b/tests/pos-with-compiler-cc/dotc/util/Stats.scala
new file mode 100644
index 000000000000..f04957f26400
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/util/Stats.scala
@@ -0,0 +1,69 @@
+package dotty.tools
+package dotc
+package util
+
+import scala.annotation.internal.sharable
+
+import core.Contexts._
+import collection.mutable
+
+@sharable object Stats {
+
+  inline val enabled = false
+
+  var monitored: Boolean = false
+
+  @volatile private var stack: List[String] = Nil
+
+  val hits: mutable.HashMap[String, Int] = new mutable.HashMap[String, Int] {
+    override def default(key: String): Int = 0
+  }
+
+  inline def record(inline fn: String, inline n: Int = 1): Unit =
+    if (enabled) doRecord(fn, n)
+
+  def doRecord(fn: String, n: Int) =
+    if (monitored) {
+      val name = if (fn.startsWith("member-")) "member" else fn
+      hits(name) += n
+    }
+
+  def doRecordSize(fn: String, coll: scala.collection.Iterable[_]): coll.type =
+    doRecord(fn, coll.size)
+    coll
+
+  inline def trackTime[T](fn: String)(inline op: T): T =
+    if (enabled) doTrackTime(fn)(op) else op
+
+  def doTrackTime[T](fn: String)(op: => T): T = {
+    if (monitored) {
+      val start = System.nanoTime
+      try op finally record(fn, ((System.nanoTime - start) / 1000).toInt)
+    }
+    else op
+  }
+
+  inline val GroupChar = '/'
+
+  /** Aggregate all counts of all keys with a common prefix, followed by `:` */
+  private def aggregate(): Unit = {
+    val groups = hits.keys
+      .filter(_.contains(GroupChar))
+      .groupBy(_.takeWhile(_ != GroupChar))
+    for ((prefix, names) <- groups; name <- names)
+      hits(s"Total $prefix") += hits(name)
+  }
+
+  def maybeMonitored[T](op: => T)(using Context): T =
+    if (ctx.settings.YdetailedStats.value && hits.nonEmpty) {
+      monitored = true
+      try op
+      finally {
+        aggregate()
+        println()
+        println(hits.toList.sortBy(_._2).map{ case (x, y) => s"$x -> $y" } mkString "\n")
+        hits.clear()
+      }
+    }
+    else op
+}
diff --git a/tests/pos-with-compiler-cc/dotc/util/Store.scala b/tests/pos-with-compiler-cc/dotc/util/Store.scala
new file mode 100644
index 000000000000..d8c9230b9272
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/util/Store.scala
@@ -0,0 +1,33 @@
+package dotty.tools.dotc.util
+
+object Store {
+
+  class Location[T](private[Store] val idx: Int) extends AnyVal
+
+  val empty: Store = new Store(Array())
+}
+
+class Store(private val elems: Array[AnyRef | Null]) extends AnyVal {
+  import Store._
+
+  def newLocation[T](): (Location[T], Store) = {
+    val elems1 = new Array[AnyRef | Null](elems.length + 1)
+    System.arraycopy(elems, 0, elems1, 0, elems.length)
+    (new Location(elems.length), new Store(elems1))
+  }
+
+  def newLocation[T](initial: T): (Location[T], Store) = {
+    val (loc, store) = newLocation[T]()
+    store.elems(loc.idx) = initial.asInstanceOf[AnyRef | Null]
+    (loc, store)
+  }
+
+  def updated[T](loc: Location[T], value: T): Store = {
+    val elems1 = elems.clone
+    elems1(loc.idx) = value.asInstanceOf[AnyRef | Null]
+    new Store(elems1)
+  }
+
+  def apply[T](loc: Location[T]): T =
+    elems(loc.idx).asInstanceOf[T]
+}
diff --git a/tests/pos-with-compiler-cc/dotc/util/Util.scala b/tests/pos-with-compiler-cc/dotc/util/Util.scala
new file mode 100644
index 000000000000..7b6e3b1136ff
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/util/Util.scala
@@ -0,0 +1,25 @@
+package dotty.tools.dotc.util
+
+object Util {
+
+  /** The index `i` in `candidates.indices` such that `candidates(i) <= x` and
+   *  `candidates(i)` is closest to `x`, determined by binary search, or -1
+   *  if `x < candidates(0)`.
+   *  @param  hint   If between 0 and `candidates.length` use this
+   *                 as the first search point, otherwise use
+   *                 `candidates.length/2`.
+   *  @pre   candidates is sorted
+   */
+  def bestFit(candidates: Array[Int], length: Int, x: Int, hint: Int = -1): Int = {
+    def recur(lo: Int, hi: Int, mid: Int): Int =
+      if (x < candidates(mid))
+        recur(lo, mid - 1, (lo + mid - 1) / 2)
+      else if (mid + 1 < length && x >= candidates(mid + 1))
+        recur(mid + 1, hi, (mid + 1 + hi) / 2)
+      else mid
+    val initMid = if (0 <= hint && hint < length) hint else length / 2
+    if (length == 0 || x < candidates(0)) -1
+    else recur(0, length, initMid)
+  }
+
+}
diff --git a/tests/pos-with-compiler-cc/dotc/util/WeakHashSet.scala b/tests/pos-with-compiler-cc/dotc/util/WeakHashSet.scala
new file mode 100644
index 000000000000..3c23b181a041
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/util/WeakHashSet.scala
@@ -0,0 +1,349 @@
+/** Adapted from the original implementation of WeakHashSet in scala-reflect
+ */
+package dotty.tools.dotc.util
+
+import java.lang.ref.{ReferenceQueue, WeakReference}
+
+import scala.annotation.{ constructorOnly, tailrec }
+
+import dotty.tools._
+
+/**
+ * A HashSet where the elements are stored weakly. Elements in this set are eligible for GC if no other
+ * hard references are associated with them. Its primary use case is as a canonical reference
+ * identity holder (aka "hash-consing") via findEntryOrUpdate
+ *
+ * This Set implementation cannot hold null. Any attempt to put a null in it will result in a NullPointerException
+ *
+ * This set implementation is not in general thread safe without external concurrency control. However it behaves
+ * properly when GC concurrently collects elements in this set.
+ */
+abstract class WeakHashSet[A <: AnyRef](initialCapacity: Int = 8, loadFactor: Double = 0.5) extends MutableSet[A] {
+
+  import WeakHashSet._
+
+  type This = WeakHashSet[A]
+
+  /**
+   * queue of Entries that hold elements scheduled for GC
+   * the removeStaleEntries() method works through the queue to remove
+   * stale entries from the table
+   */
+  protected val queue = new ReferenceQueue[A]
+
+  /**
+   * the number of elements in this set
+   */
+  protected var count = 0
+
+  /**
+   * from a specified initial capacity compute the capacity we'll use as being the next
+   * power of two equal to or greater than the specified initial capacity
+   */
+  private def computeCapacity = {
+    if (initialCapacity < 0) throw new IllegalArgumentException("initial capacity cannot be less than 0")
+    var candidate = 1
+    while (candidate < initialCapacity)
+      candidate  *= 2
+    candidate
+  }
+
+  /**
+   * the underlying table of entries which is an array of Entry linked lists
+   */
+  protected var table = new Array[Entry[A] | Null](computeCapacity)
+
+  /**
+   * the limit at which we'll increase the size of the hash table
+   */
+  protected var threshold = computeThreshold
+
+  private def computeThreshold: Int = (table.size * loadFactor).ceil.toInt
+
+  protected def hash(key: A): Int
+  protected def isEqual(x: A, y: A): Boolean = x.equals(y)
+
+  /** Turn hashcode `x` into a table index */
+  protected def index(x: Int): Int = x & (table.length - 1)
+
+  /**
+   * remove a single entry from a linked list in a given bucket
+   */
+  private def remove(bucket: Int, prevEntry: Entry[A] | Null, entry: Entry[A]): Unit = {
+    Stats.record(statsItem("remove"))
+    prevEntry match {
+      case null => table(bucket) = entry.tail
+      case _ => prevEntry.tail = entry.tail
+    }
+    count -= 1
+  }
+
+  /**
+   * remove entries associated with elements that have been gc'ed
+   */
+  protected def removeStaleEntries(): Unit = {
+    def poll(): Entry[A] | Null = queue.poll().asInstanceOf
+
+    @tailrec
+    def queueLoop(): Unit = {
+      val stale = poll()
+      if (stale != null) {
+        val bucket = index(stale.hash)
+
+        @tailrec
+        def linkedListLoop(prevEntry: Entry[A] | Null, entry: Entry[A] | Null): Unit =
+          if entry != null then
+            if stale eq entry then remove(bucket, prevEntry, entry)
+            else linkedListLoop(entry, entry.tail)
+
+        linkedListLoop(null, table(bucket))
+
+        queueLoop()
+      }
+    }
+
+    queueLoop()
+  }
+
+  /**
+   * Double the size of the internal table
+   */
+  protected def resize(): Unit = {
+    Stats.record(statsItem("resize"))
+    val oldTable = table
+    table = new Array[Entry[A] | Null](oldTable.size * 2)
+    threshold = computeThreshold
+
+    @tailrec
+    def tableLoop(oldBucket: Int): Unit = if (oldBucket < oldTable.size) {
+      @tailrec
+      def linkedListLoop(entry: Entry[A] | Null): Unit = entry match {
+        case null => ()
+        case _ =>
+          val bucket = index(entry.hash)
+          val oldNext = entry.tail
+          entry.tail = table(bucket)
+          table(bucket) = entry
+          linkedListLoop(oldNext)
+      }
+      linkedListLoop(oldTable(oldBucket))
+
+      tableLoop(oldBucket + 1)
+    }
+    tableLoop(0)
+  }
+
+  // TODO: remove the `case null` when we can enable explicit nulls in regular compiling,
+  // since the type `A <: AnyRef` of `elem` can ensure the value is not null.
+  def lookup(elem: A): A | Null = (elem: A | Null) match {
+    case null => throw new NullPointerException("WeakHashSet cannot hold nulls")
+    case _ =>
+      Stats.record(statsItem("lookup"))
+      removeStaleEntries()
+      val bucket = index(hash(elem))
+
+      @tailrec
+      def linkedListLoop(entry: Entry[A] | Null): A | Null = entry match {
+        case null                    => null
+        case _                       =>
+          val entryElem = entry.get
+          if entryElem != null && isEqual(elem, entryElem) then entryElem
+          else linkedListLoop(entry.tail)
+      }
+
+      linkedListLoop(table(bucket))
+  }
+
+  protected def addEntryAt(bucket: Int, elem: A, elemHash: Int, oldHead: Entry[A] | Null): A = {
+    Stats.record(statsItem("addEntryAt"))
+    table(bucket) = new Entry(elem, elemHash, oldHead, queue)
+    count += 1
+    if (count > threshold) resize()
+    elem
+  }
+
+  // TODO: remove the `case null` when we can enable explicit nulls in regular compiling,
+  // since the type `A <: AnyRef` of `elem` can ensure the value is not null.
+  def put(elem: A): A = (elem: A | Null) match {
+    case null => throw new NullPointerException("WeakHashSet cannot hold nulls")
+    case _    =>
+      Stats.record(statsItem("put"))
+      removeStaleEntries()
+      val h = hash(elem)
+      val bucket = index(h)
+      val oldHead = table(bucket)
+
+      @tailrec
+      def linkedListLoop(entry: Entry[A] | Null): A = entry match {
+        case null                    => addEntryAt(bucket, elem, h, oldHead)
+        case _                       =>
+          val entryElem = entry.get
+          if entryElem != null && isEqual(elem, entryElem) then entryElem.uncheckedNN
+          else linkedListLoop(entry.tail)
+      }
+
+      linkedListLoop(oldHead)
+  }
+
+  def +=(elem: A): Unit = put(elem)
+
+  def -=(elem: A): Unit = (elem: A | Null) match {
+    case null =>
+    case _ =>
+      Stats.record(statsItem("-="))
+      removeStaleEntries()
+      val bucket = index(hash(elem))
+
+      @tailrec
+      def linkedListLoop(prevEntry: Entry[A] | Null, entry: Entry[A] | Null): Unit =
+        if entry != null then
+          val entryElem = entry.get
+          if entryElem != null && isEqual(elem, entryElem) then remove(bucket, prevEntry, entry)
+          else linkedListLoop(entry, entry.tail)
+
+      linkedListLoop(null, table(bucket))
+  }
+
+  def clear(): Unit = {
+    table = new Array[Entry[A] | Null](table.size)
+    threshold = computeThreshold
+    count = 0
+
+    // drain the queue - doesn't do anything because we're throwing away all the values anyway
+    @tailrec def queueLoop(): Unit = if (queue.poll() != null) queueLoop()
+    queueLoop()
+  }
+
+  def size: Int = {
+    removeStaleEntries()
+    count
+  }
+
+  // Iterator over all the elements in this set in no particular order
+  override def iterator: Iterator[A] = {
+    removeStaleEntries()
+
+    new collection.AbstractIterator[A] {
+
+      /**
+       * the bucket currently being examined. Initially it's set past the last bucket and will be decremented
+       */
+      private var currentBucket: Int = table.size
+
+      /**
+       * the entry that was last examined
+       */
+      private var entry: Entry[A] | Null = null
+
+      /**
+       * the element that will be the result of the next call to next()
+       */
+      private var lookaheadelement: A | Null = null
+
+      @tailrec
+      def hasNext: Boolean = {
+        while (entry == null && currentBucket > 0) {
+          currentBucket -= 1
+          entry = table(currentBucket)
+        }
+
+        val e = entry
+        if (e == null) false
+        else {
+          lookaheadelement = e.get
+          if lookaheadelement == null then
+            // element null means the weakref has been cleared since we last did a removeStaleEntries(), move to the next entry
+            entry = e.tail
+            hasNext
+          else true
+        }
+      }
+
+      def next(): A =
+        if lookaheadelement == null then
+          throw new IndexOutOfBoundsException("next on an empty iterator")
+        else
+          val result = lookaheadelement.nn
+          lookaheadelement = null
+          entry = entry.nn.tail
+          result
+    }
+  }
+
+  protected def statsItem(op: String): String = {
+    val prefix = "WeakHashSet."
+    val suffix = getClass.getSimpleName
+    s"$prefix$op $suffix"
+  }
+
+  /**
+   * Diagnostic information about the internals of this set. Not normally
+   * needed by ordinary code, but may be useful for diagnosing performance problems
+   */
+  private[util] class Diagnostics {
+    /**
+     * Verify that the internal structure of this hash set is fully consistent.
+     * Throws an assertion error on any problem. In order for it to be reliable
+     * the entries must be stable. If any are garbage collected during validation
+     * then an assertion may inappropriately fire.
+     */
+    def fullyValidate(): Unit = {
+      var computedCount = 0
+      var bucket = 0
+      while (bucket < table.size) {
+        var entry = table(bucket)
+        while (entry != null) {
+          assert(entry.get != null, s"$entry had a null value indicated that gc activity was happening during diagnostic validation or that a null value was inserted")
+          computedCount += 1
+          val cachedHash = entry.hash
+          val realHash = hash(entry.get.uncheckedNN)
+          assert(cachedHash == realHash, s"for $entry cached hash was $cachedHash but should have been $realHash")
+          val computedBucket = index(realHash)
+          assert(computedBucket == bucket, s"for $entry the computed bucket was $computedBucket but should have been $bucket")
+
+          entry = entry.tail
+        }
+
+        bucket += 1
+      }
+
+      assert(computedCount == count, s"The computed count was $computedCount but should have been $count")
+    }
+
+    /**
+     *  Produces a diagnostic dump of the table that underlies this hash set.
+     */
+    def dump: String = java.util.Arrays.toString(table.asInstanceOf[Array[AnyRef | Null]])
+
+    /**
+     * Number of buckets that hold collisions. Useful for diagnosing performance issues.
+     */
+    def collisionBucketsCount: Int =
+      (table count (entry => entry != null && entry.tail != null))
+
+    /**
+     * Number of buckets that are occupied in this hash table.
+     */
+    def fullBucketsCount: Int =
+      (table count (entry => entry != null))
+
+    /**
+     *  Number of buckets in the table
+     */
+    def bucketsCount: Int = table.size
+  }
+
+  private[util] def diagnostics: Diagnostics = new Diagnostics
+}
+
+/**
+ * Companion object for WeakHashSet
+ */
+object WeakHashSet {
+  /**
+   * A single entry in a WeakHashSet. It's a WeakReference plus a cached hash code and
+   * a link to the next Entry in the same bucket
+   */
+  class Entry[A](@constructorOnly element: A, val hash:Int, var tail: Entry[A] | Null, @constructorOnly queue: ReferenceQueue[A]) extends WeakReference[A](element, queue)
+
+}
diff --git a/tests/pos-with-compiler-cc/dotc/util/common.scala b/tests/pos-with-compiler-cc/dotc/util/common.scala
new file mode 100644
index 000000000000..70e0e82a7d50
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/util/common.scala
@@ -0,0 +1,14 @@
+package dotty.tools.dotc
+package util
+
+import core.Types.WildcardType
+import language.experimental.pureFunctions
+
+/** Common values hoisted out for performance */
+object common {
+
+  val alwaysTrue: Any -> Boolean = Function.const(true)
+  val alwaysFalse: Any -> Boolean = Function.const(false)
+  val alwaysZero: Any -> Int = Function.const(0)
+  val alwaysWildcardType: Any -> WildcardType.type = Function.const(WildcardType)
+}
diff --git a/tests/pos-with-compiler-cc/dotc/util/kwords.sc b/tests/pos-with-compiler-cc/dotc/util/kwords.sc
new file mode 100644
index 000000000000..961be3b0aa23
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/util/kwords.sc
@@ -0,0 +1,18 @@
+package dotty.tools.dotc.util
+
+import dotty.tools.dotc.parsing._
+import Scanners._
+import Tokens._
+
+object kwords {
+  println("Welcome to the Scala worksheet")       //> Welcome to the Scala worksheet
+  keywords.toList.map(tokenString)                //> res0: List[String] = List(if, for, else, this, null, new, with, super, case,
+                                                  //|  case class, case object, val, abstract, final, private, protected, override
+                                                  //| , implicit, var, def, type, extends, true, false, object, class, import, pac
+                                                  //| kage, yield, do, trait, sealed, throw, try, catch, finally, while, return, m
+                                                  //| atch, lazy, then, forSome, _, :, =, <-, =>, ';', ';', <:, >:, #, @, <%)
+  keywords.toList.filter(kw => tokenString(kw) == null)
+                                                  //> res1: List[Int] = List()
+  canStartStatTokens3 contains CASE               //> res2: Boolean = false
+
+}
\ No newline at end of file
diff --git a/tests/pos-with-compiler-cc/dotc/util/lrutest.sc b/tests/pos-with-compiler-cc/dotc/util/lrutest.sc
new file mode 100644
index 000000000000..6e6328b248e3
--- /dev/null
+++ b/tests/pos-with-compiler-cc/dotc/util/lrutest.sc
@@ -0,0 +1,40 @@
+package dotty.tools.dotc.util
+
+object lrutest {
+  println("Welcome to the Scala worksheet")       //> Welcome to the Scala worksheet
+  val bits = new SixteenNibbles(0L)               //> bits  : dotty.tools.dotc.util.SixteenNibbles = SixteenNibbles(0, 0, 0, 0, 0,
+                                                  //|  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0)
+  bits.updated(1, 3)                              //> res0: dotty.tools.dotc.util.SixteenNibbles = SixteenNibbles(0, 3, 0, 0, 0, 0
+                                                  //| , 0, 0, 0, 0, 0, 0, 0, 0, 0, 0)
+  LRUCache.initialRing                            //> res1: dotty.tools.dotc.util.SixteenNibbles = SixteenNibbles(1, 2, 3, 4, 5, 6
+                                                  //| , 7, 0, 0, 0, 0, 0, 0, 0, 0, 0)
+  val cache = new LRUCache[String, String]        //> cache  : dotty.tools.dotc.util.LRUCache[String,String] = LRUCache()
+  cache lookup "hi"                               //> res2: String = null
+  cache enter ("hi", "x")
+	cache.indices.take(10).toList             //> res3: List[Int] = List(7, 0, 1, 2, 3, 4, 5, 6, 7, 0)
+	cache.last                                //> res4: Int = 6
+	cache lookup "hi"                         //> res5: String = x
+	cache.indices.take(10).toList             //> res6: List[Int] = List(7, 0, 1, 2, 3, 4, 5, 6, 7, 0)
+	
+	for (i <- 1 to 10) {
+	  if (cache.lookup(i.toString) == null)
+		  cache.enter(i.toString, i.toString)
+	}
+	  
+  cache.indices.take(10).toList                   //> res7: List[Int] = List(5, 6, 7, 0, 1, 2, 3, 4, 5, 6)
+	cache                                     //> res8: dotty.tools.dotc.util.LRUCache[String,String] = LRUCache(10 -> 10, 9 -
+                                                  //| > 9, 8 -> 8, 7 -> 7, 6 -> 6, 5 -> 5, 4 -> 4, 3 -> 3)
+  cache                                           //> res9: dotty.tools.dotc.util.LRUCache[String,String] = LRUCache(10 -> 10, 9 -
+                                                  //| > 9, 8 -> 8, 7 -> 7, 6 -> 6, 5 -> 5, 4 -> 4, 3 -> 3)
+  cache.lookup("7")                               //> res10: String = 7
+  cache.indices.take(10).toList                   //> res11: List[Int] = List(0, 5, 6, 7, 1, 2, 3, 4, 0, 5)
+	cache.keysIterator.toList                 //> res12: List[String] = List(7, 10, 9, 8, 6, 5, 4, 3)
+  cache.lookup("10")                              //> res13: String = 10
+  cache.lookup("5")                               //> res14: String = 5
+  cache                                           //> res15: dotty.tools.dotc.util.LRUCache[String,String] = LRUCache(5 -> 5, 10 -
+                                                  //| > 10, 7 -> 7, 9 -> 9, 8 -> 8, 6 -> 6, 4 -> 4, 3 -> 3)
+  cache.lookup("11")                              //> res16: String = null
+  cache.enter("11", "!!")
+  cache                                           //> res17: dotty.tools.dotc.util.LRUCache[String,String] = LRUCache(11 -> !!, 5 
+                                                  //| -> 5, 10 -> 10, 7 -> 7, 9 -> 9, 8 -> 8, 6 -> 6, 4 -> 4)
+}
\ No newline at end of file
diff --git a/tests/pos-with-compiler-cc/package.scala b/tests/pos-with-compiler-cc/package.scala
new file mode 100644
index 000000000000..1c6bb2310d80
--- /dev/null
+++ b/tests/pos-with-compiler-cc/package.scala
@@ -0,0 +1,53 @@
+package dotty
+
+package object tools {
+  // Ensure this object is already classloaded, since it's only actually used
+  // when handling stack overflows and every operation (including class loading)
+  // risks failing.
+  dotty.tools.dotc.core.handleRecursive
+
+  val ListOfNil: List[Nil.type] = Nil :: Nil
+
+  /** Throws an `UnsupportedOperationException` with the given method name. */
+  def unsupported(methodName: String): Nothing =
+    throw new UnsupportedOperationException(methodName)
+
+  /** Forward-ported from the explicit-nulls branch. */
+  extension [T](x: T | Null)
+    /** Should be used when we know from the context that `x` is not null.
+     *  Flow-typing under explicit nulls will automatically insert many necessary
+     *  occurrences of uncheckedNN.
+     */
+    transparent inline def uncheckedNN: T = // !cc! needs to be transparent, or calls with give errors
+      x.asInstanceOf[T]
+
+    inline def toOption: Option[T] =
+      if x == null then None else Some(x.asInstanceOf[T])
+  end extension
+
+  /** Nullable eq and ne. */
+  extension [T <: AnyRef](x: T | Null)
+    inline def eqn (y: T | Null) =
+      x.asInstanceOf[AnyRef] eq y.asInstanceOf[AnyRef]
+
+    inline def nen(y: T | Null): Boolean = !eqn(y)
+
+  object resultWrapper {
+    opaque type WrappedResult[T] = T
+    private[tools] def unwrap[T](x: WrappedResult[T]): T = x
+    private[tools] def wrap[T](x: T): WrappedResult[T] = x
+  }
+  type WrappedResult[T] = resultWrapper.WrappedResult[T]
+  def WrappedResult[T](x: T) = resultWrapper.wrap(x)
+  def result[T](using x: WrappedResult[T]): T = resultWrapper.unwrap(x)
+
+  def unreachable(x: Any = "<< this case was declared unreachable >>"): Nothing =
+    throw new MatchError(x)
+
+  transparent inline def assertShort(inline assertion: Boolean, inline message: Any = null): Unit =
+    if !assertion then
+      val msg = message
+      val e = if msg == null then AssertionError() else AssertionError("assertion failed: " + msg)
+      e.setStackTrace(Array())
+      throw e
+}
diff --git a/tests/pos/byname-purefuns-adapt/A_1.scala b/tests/pos/byname-purefuns-adapt/A_1.scala
index c98664a91a71..441dc24a8ef0 100644
--- a/tests/pos/byname-purefuns-adapt/A_1.scala
+++ b/tests/pos/byname-purefuns-adapt/A_1.scala
@@ -1,3 +1,4 @@
+class Ctx
 object A:
   def f(x: => Int) = ()
-
+  def g(op: Ctx ?=> Int) = op(using Ctx())
diff --git a/tests/pos/byname-purefuns-adapt/B_2.scala b/tests/pos/byname-purefuns-adapt/B_2.scala
index 4bcaa2e6c69b..842161c0fcbd 100644
--- a/tests/pos/byname-purefuns-adapt/B_2.scala
+++ b/tests/pos/byname-purefuns-adapt/B_2.scala
@@ -1,5 +1,8 @@
 import language.experimental.captureChecking
 object B:
   def test(x: => Int) = A.f(x)
+  def opp(using Ctx) = 0
+  A.g(opp)
+
 
 
diff --git a/tests/pos/experimental-inheritance.scala b/tests/pos/experimental-inheritance.scala
new file mode 100644
index 000000000000..78681caa3929
--- /dev/null
+++ b/tests/pos/experimental-inheritance.scala
@@ -0,0 +1,4 @@
+import annotation.experimental
+@experimental class A
+@experimental object o:
+  class B extends A
\ No newline at end of file
diff --git a/tests/run-custom-args/captures/colltest5/Test_2.scala b/tests/run-custom-args/captures/colltest5/Test_2.scala
index 934223a9840b..8c070439db80 100644
--- a/tests/run-custom-args/captures/colltest5/Test_2.scala
+++ b/tests/run-custom-args/captures/colltest5/Test_2.scala
@@ -76,7 +76,7 @@ object Test {
     val x4 = xs.head
     val y4: Int = x4
     val x5 = xs.to(List)
-    val y5: {x5} List[Int] = x5
+    val y5: List[Int] = x5
     val (xs6, xs7) = xs.partition(isEven)
     val ys6: {xs6, isEven} View[Int] = xs6
     val ys7: {xs7, isEven} View[Int] = xs7